/b-gtk/fix-viz

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/b-gtk/fix-viz

« back to all changes in this revision

Viewing changes to tests/test_commit.py

  • Committer: Jelmer Vernooij
  • Date: 2008-03-28 19:26:53 UTC
  • mto: (450.1.13 trunk)
  • mto: This revision was merged to the branch mainline in revision 458.
  • Revision ID: jelmer@samba.org-20080328192653-trzptkwahx1tulz9
Add module for preferences code.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2007, 2008 John Arbash Meinel <john@arbash-meinel.com>
 
1
# Copyright (C) 2007 John Arbash Meinel <john@arbash-meinel.com>
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
17
17
"""Test the Commit functionality."""
18
18
 
19
19
import os
20
 
import subprocess
21
 
from tempfile import NamedTemporaryFile
22
20
 
23
 
from gi.repository import Gtk
 
21
import gtk
24
22
 
25
23
from bzrlib import (
26
 
    branch,
27
24
    tests,
28
 
    uncommit,
 
25
    revision,
29
26
    )
30
 
try:
31
 
    from bzrlib.tests.features import UnicodeFilenameFeature
32
 
except ImportError: # bzr < 2.5
33
 
    from bzrlib.tests import UnicodeFilenameFeature
34
 
from bzrlib import bencode
 
27
from bzrlib.util import bencode
35
28
 
36
 
from bzrlib.plugins.gtk import (
37
 
    commit,
38
 
    commitmsgs,
39
 
    )
40
 
from bzrlib.plugins.gtk.commitmsgs import SavedCommitMessagesManager
41
 
from bzrlib.plugins.gtk.tests import MockMethod
 
29
from bzrlib.plugins.gtk import commit
42
30
 
43
31
 
44
32
# TODO: All we need is basic ancestry code to test this, we shouldn't need a
50
38
        tree = self.make_branch_and_tree('.')
51
39
        tree.commit('one')
52
40
 
53
 
        self.addCleanup(tree.lock_read().unlock)
54
41
        self.assertIs(None, commit.pending_revisions(tree))
55
42
 
56
43
    def test_pending_revisions_simple(self):
61
48
        tree.merge_from_branch(tree2.branch)
62
49
        self.assertEqual([rev_id1, rev_id2], tree.get_parent_ids())
63
50
 
64
 
        self.addCleanup(tree.lock_read().unlock)
65
51
        pending_revisions = commit.pending_revisions(tree)
66
52
        # One primary merge
67
53
        self.assertEqual(1, len(pending_revisions))
80
66
        tree.merge_from_branch(tree2.branch)
81
67
        self.assertEqual([rev_id1, rev_id4], tree.get_parent_ids())
82
68
 
83
 
        self.addCleanup(tree.lock_read().unlock)
84
69
        pending_revisions = commit.pending_revisions(tree)
85
70
        # One primary merge
86
71
        self.assertEqual(1, len(pending_revisions))
96
81
        rev_id1 = tree.commit('one')
97
82
        tree2 = tree.bzrdir.sprout('tree2').open_workingtree()
98
83
        rev_id2 = tree2.commit('two')
 
84
        rev_id3 = tree2.commit('three')
99
85
        tree3 = tree2.bzrdir.sprout('tree3').open_workingtree()
100
 
        rev_id3 = tree2.commit('three')
101
86
        rev_id4 = tree3.commit('four')
102
87
        rev_id5 = tree3.commit('five')
103
88
        tree.merge_from_branch(tree2.branch)
104
 
        tree.merge_from_branch(tree3.branch, force=True)
 
89
        tree.merge_from_branch(tree3.branch)
105
90
        self.assertEqual([rev_id1, rev_id3, rev_id5], tree.get_parent_ids())
106
91
 
107
 
        self.addCleanup(tree.lock_read().unlock)
108
92
        pending_revisions = commit.pending_revisions(tree)
109
93
        # Two primary merges
110
94
        self.assertEqual(2, len(pending_revisions))
148
132
 
149
133
class TestCommitDialogSimple(tests.TestCaseWithTransport):
150
134
 
151
 
    def test_init(self):
152
 
        MockMethod.bind(self, CommitDialogNoWidgets, 'setup_params')
153
 
        MockMethod.bind(self, CommitDialogNoWidgets, 'construct')
154
 
        MockMethod.bind(self, CommitDialogNoWidgets, 'fill_in_data')
155
 
 
156
 
        tree = self.make_branch_and_tree('tree')
157
 
        rev_id = tree.commit('first')
158
 
        dlg = CommitDialogNoWidgets(tree)
159
 
        self.assertIs(tree, dlg._wt)
160
 
        self.assertIs(None, dlg._selected)
161
 
        self.assertTrue(dlg._enable_per_file_commits)
162
 
        self.assertTrue(dlg._commit_all_changes)
163
 
        self.assertIs(None, dlg.committed_revision_id)
164
 
        self.assertIs(None, dlg._last_selected_file)
165
 
        self.assertIsInstance(
166
 
            dlg._saved_commit_messages_manager, SavedCommitMessagesManager)
167
 
        self.assertTrue(CommitDialogNoWidgets.setup_params.called)
168
 
        self.assertTrue(CommitDialogNoWidgets.construct.called)
169
 
        self.assertTrue(CommitDialogNoWidgets.fill_in_data.called)
170
 
 
171
135
    def test_setup_parameters_no_pending(self):
172
136
        tree = self.make_branch_and_tree('tree')
173
137
        rev_id = tree.commit('first')
216
180
        self.assertEqual([], delta.removed)
217
181
        self.assertEqual([(u'a', 'a-id', 'file')], delta.added)
218
182
 
219
 
    def test_on_treeview_files_cursor_changed_no_selection(self):
220
 
        MockMethod.bind(self, CommitDialogNoWidgets, '_update_per_file_info')
221
 
        tree = self.make_branch_and_tree('tree')
222
 
        rev_id = tree.commit('first')
223
 
        dlg = CommitDialogNoWidgets(tree)
224
 
        treeview = Gtk.TreeView()
225
 
        dlg._on_treeview_files_cursor_changed(treeview)
226
 
        self.assertFalse(CommitDialogNoWidgets._update_per_file_info.called)
227
 
 
228
 
    def test_on_treeview_files_cursor_changed_with_destroyed_treeview(self):
229
 
        MockMethod.bind(self, CommitDialogNoWidgets, '_update_per_file_info')
230
 
        tree = self.make_branch_and_tree('tree')
231
 
        rev_id = tree.commit('first')
232
 
        dlg = CommitDialogNoWidgets(tree)
233
 
        treeview = Gtk.TreeView()
234
 
        treeview.destroy()
235
 
        dlg._on_treeview_files_cursor_changed(treeview)
236
 
        self.assertFalse(CommitDialogNoWidgets._update_per_file_info.called)
237
 
 
238
183
 
239
184
class TestCommitDialog(tests.TestCaseWithTransport):
240
185
 
262
207
 
263
208
        commit_col = dlg._treeview_files.get_column(0)
264
209
        self.assertEqual('Commit', commit_col.get_title())
265
 
        renderer = commit_col.get_cells()[0]
 
210
        renderer = commit_col.get_cell_renderers()[0]
266
211
        self.assertTrue(renderer.get_property('activatable'))
267
212
 
268
213
        self.assertEqual('Commit all changes',
287
232
 
288
233
        commit_col = dlg._treeview_files.get_column(0)
289
234
        self.assertEqual('Commit*', commit_col.get_title())
290
 
        renderer = commit_col.get_cells()[0]
 
235
        renderer = commit_col.get_cell_renderers()[0]
291
236
        self.assertFalse(renderer.get_property('activatable'))
292
237
 
293
238
        values = [(r[0], r[1], r[2], r[3]) for r in dlg._pending_store]
321
266
                               committer='Jerry Foo <jerry@foo.com>',
322
267
                               timestamp=1191372278.05,
323
268
                               timezone=+7200)
324
 
        tree.merge_from_branch(tree3.branch, force=True)
 
269
        tree.merge_from_branch(tree3.branch)
325
270
 
326
271
        dlg = commit.CommitDialog(tree)
327
272
        # TODO: assert that the pending box is set to show
339
284
 
340
285
        dlg = commit.CommitDialog(tree)
341
286
        values = [(r[0], r[1], r[2], r[3], r[4]) for r in dlg._files_store]
342
 
        self.assertEqual([("", "", True, 'All Files', ''),
 
287
        self.assertEqual([(None, None, True, 'All Files', ''),
343
288
                          ('a-id', 'a', True, 'a', 'added'),
344
289
                          ('b-id', 'b', True, 'b/', 'added'),
345
290
                          ('c-id', 'b/c', True, 'b/c', 'added'),
356
301
 
357
302
        dlg = commit.CommitDialog(tree)
358
303
        values = [(r[0], r[1], r[2], r[3], r[4]) for r in dlg._files_store]
359
 
        self.assertEqual([("", "", True, 'All Files', ''),
 
304
        self.assertEqual([(None, None, True, 'All Files', ''),
360
305
                          ('b-id', 'd', True, 'b/ => d/', 'renamed'),
361
306
                          ('a-id', 'd/a', True, 'a => d/a', 'renamed'),
362
307
                         ], values)
371
316
 
372
317
        dlg = commit.CommitDialog(tree)
373
318
        values = [(r[0], r[1], r[2], r[3], r[4]) for r in dlg._files_store]
374
 
        self.assertEqual([("", "", True, 'All Files', ''),
 
319
        self.assertEqual([(None, None, True, 'All Files', ''),
375
320
                          ('a-id', 'a', True, 'a', 'modified'),
376
321
                         ], values)
377
322
 
391
336
 
392
337
        dlg = commit.CommitDialog(tree)
393
338
        values = [(r[0], r[1], r[2], r[3], r[4]) for r in dlg._files_store]
394
 
        self.assertEqual([("", "", True, 'All Files', ''),
 
339
        self.assertEqual([(None, None, True, 'All Files', ''),
395
340
                          ('b-id', 'd', True, 'b/ => d/', 'renamed'),
396
341
                          ('a-id', 'd/a', True, 'a => d/a', 'renamed and modified'),
397
342
                          ('c-id', 'd/c', True, 'd/c', 'modified'),
414
359
 
415
360
        dlg = commit.CommitDialog(tree)
416
361
        values = [(r[0], r[1], r[2], r[3], r[4]) for r in dlg._files_store]
417
 
        self.assertEqual([("", "", True, 'All Files', ''),
 
362
        self.assertEqual([(None, None, True, 'All Files', ''),
418
363
                          ('a-id', 'a', True, 'a => a/', 'kind changed'),
419
364
                          # ('b-id', 'c', True, 'b => c/', 'renamed and modified'),
420
365
                         ], values)
430
375
 
431
376
        dlg = commit.CommitDialog(tree)
432
377
        values = [(r[0], r[1], r[2], r[3], r[4]) for r in dlg._files_store]
433
 
        self.assertEqual([("", "", True, 'All Files', ''),
 
378
        self.assertEqual([(None, None, True, 'All Files', ''),
434
379
                          ('a-id', 'a', True, 'a', 'removed'),
435
380
                          ('b-id', 'b', True, 'b/', 'removed'),
436
381
                         ], values)
437
382
        # All Files should be selected
438
 
        self.assertEqual(
439
 
            (Gtk.TreePath(path=0), None), dlg._treeview_files.get_cursor())
 
383
        self.assertEqual(((0,), None), dlg._treeview_files.get_cursor())
440
384
 
441
385
    def test_filelist_with_selected(self):
442
386
        tree = self.make_branch_and_tree('tree')
445
389
 
446
390
        dlg = commit.CommitDialog(tree, selected='a')
447
391
        values = [(r[0], r[1], r[2], r[3], r[4]) for r in dlg._files_store]
448
 
        self.assertEqual([("", "", False, 'All Files', ''),
 
392
        self.assertEqual([(None, None, False, 'All Files', ''),
449
393
                          ('a-id', 'a', True, 'a', 'added'),
450
394
                          ('b-id', 'b', False, 'b/', 'added'),
451
395
                         ], values)
452
396
        # This file should also be selected in the file list, rather than the
453
397
        # 'All Files' selection
454
 
        self.assertEqual(
455
 
            (Gtk.TreePath(path=1), None), dlg._treeview_files.get_cursor())
 
398
        self.assertEqual(((1,), None), dlg._treeview_files.get_cursor())
456
399
 
457
400
    def test_diff_view(self):
458
401
        tree = self.make_branch_and_tree('tree')
466
409
        dlg = commit.CommitDialog(tree)
467
410
        diff_buffer = dlg._diff_view.buffer
468
411
        text = diff_buffer.get_text(diff_buffer.get_start_iter(),
469
 
                                    diff_buffer.get_end_iter(),
470
 
                                    True).splitlines(True)
 
412
                                    diff_buffer.get_end_iter()).splitlines(True)
471
413
 
472
 
        self.assertEqual("=== modified file 'a'\n", text[0])
 
414
        self.assertEqual("=== removed file 'b'\n", text[0])
473
415
        self.assertContainsRe(text[1],
 
416
            r"--- b\t\d\d\d\d-\d\d-\d\d \d\d:\d\d:\d\d [+-]\d\d\d\d")
 
417
        self.assertEqual('+++ b\t1970-01-01 00:00:00 +0000\n', text[2])
 
418
        self.assertEqual('@@ -1,1 +0,0 @@\n', text[3])
 
419
        self.assertEqual('-contents of tree/b\n', text[4])
 
420
        self.assertEqual('\n', text[5])
 
421
 
 
422
        self.assertEqual("=== modified file 'a'\n", text[6])
 
423
        self.assertContainsRe(text[7],
474
424
            r"--- a\t\d\d\d\d-\d\d-\d\d \d\d:\d\d:\d\d [+-]\d\d\d\d")
475
 
        self.assertContainsRe(text[2],
476
 
            r"\+\+\+ a\t\d\d\d\d-\d\d-\d\d \d\d:\d\d:\d\d [+-]\d\d\d\d")
477
 
        self.assertEqual('@@ -1,1 +1,1 @@\n', text[3])
478
 
        self.assertEqual('-contents of tree/a\n', text[4])
479
 
        self.assertEqual('+new contents for a\n', text[5])
480
 
        self.assertEqual('\n', text[6])
481
 
 
482
 
        self.assertEqual("=== removed file 'b'\n", text[7])
483
425
        self.assertContainsRe(text[8],
484
 
            r"--- b\t\d\d\d\d-\d\d-\d\d \d\d:\d\d:\d\d [+-]\d\d\d\d")
485
 
        self.assertEqual('+++ b\t1970-01-01 00:00:00 +0000\n', text[9])
486
 
        self.assertEqual('@@ -1,1 +0,0 @@\n', text[10])
487
 
        self.assertEqual('-contents of tree/b\n', text[11])
 
426
            r"\+\+\+ a\t\d\d\d\d-\d\d-\d\d \d\d:\d\d:\d\d [+-]\d\d\d\d")
 
427
        self.assertEqual('@@ -1,1 +1,1 @@\n', text[9])
 
428
        self.assertEqual('-contents of tree/a\n', text[10])
 
429
        self.assertEqual('+new contents for a\n', text[11])
488
430
        self.assertEqual('\n', text[12])
489
431
 
490
432
        self.assertEqual('Diff for All Files', dlg._diff_label.get_text())
518
460
        self.assertFalse(dlg._file_message_expander.get_expanded())
519
461
        self.assertFalse(dlg._file_message_expander.get_property('sensitive'))
520
462
 
521
 
        dlg._treeview_files.set_cursor(
522
 
            Gtk.TreePath(path=1), None, False)
 
463
        dlg._treeview_files.set_cursor((1,))
523
464
        self.assertEqual('Diff for a', dlg._diff_label.get_text())
524
465
        text = diff_buffer.get_text(diff_buffer.get_start_iter(),
525
 
                                    diff_buffer.get_end_iter(),
526
 
                                    True).splitlines(True)
 
466
                                    diff_buffer.get_end_iter()).splitlines(True)
527
467
        self.assertEqual("=== added file 'a'\n", text[0])
528
468
        self.assertContainsRe(text[1],
529
469
            r"--- a\t\d\d\d\d-\d\d-\d\d \d\d:\d\d:\d\d [+-]\d\d\d\d")
537
477
        self.assertTrue(dlg._file_message_expander.get_expanded())
538
478
        self.assertTrue(dlg._file_message_expander.get_property('sensitive'))
539
479
 
540
 
        dlg._treeview_files.set_cursor(
541
 
            Gtk.TreePath(path=2), None, False)
 
480
        dlg._treeview_files.set_cursor((2,))
542
481
        self.assertEqual('Diff for b', dlg._diff_label.get_text())
543
482
        text = diff_buffer.get_text(diff_buffer.get_start_iter(),
544
 
                                    diff_buffer.get_end_iter(),
545
 
                                    True).splitlines(True)
 
483
                                    diff_buffer.get_end_iter()).splitlines(True)
546
484
        self.assertEqual("=== added file 'b'\n", text[0])
547
485
        self.assertContainsRe(text[1],
548
486
            r"--- b\t\d\d\d\d-\d\d-\d\d \d\d:\d\d:\d\d [+-]\d\d\d\d")
556
494
        self.assertTrue(dlg._file_message_expander.get_expanded())
557
495
        self.assertTrue(dlg._file_message_expander.get_property('sensitive'))
558
496
 
559
 
        dlg._treeview_files.set_cursor(
560
 
            Gtk.TreePath(path=0), None, False)
 
497
        dlg._treeview_files.set_cursor((0,))
561
498
        self.assertEqual('Diff for All Files', dlg._diff_label.get_text())
562
499
        self.assertEqual('File commit message',
563
500
                         dlg._file_message_expander.get_label())
573
510
 
574
511
        def get_file_text():
575
512
            buf = dlg._file_message_text_view.get_buffer()
576
 
            return buf.get_text(
577
 
                buf.get_start_iter(), buf.get_end_iter(), True)
 
513
            return buf.get_text(buf.get_start_iter(), buf.get_end_iter())
578
514
 
579
515
        def get_saved_text(path):
580
516
            """Get the saved text for a given record."""
587
523
        self.assertFalse(dlg._file_message_expander.get_property('sensitive'))
588
524
        self.assertEqual('', get_file_text())
589
525
 
590
 
        dlg._treeview_files.set_cursor(
591
 
            Gtk.TreePath(path=1), None, False)
 
526
        dlg._treeview_files.set_cursor((1,))
592
527
        self.assertEqual('Commit message for a',
593
528
                         dlg._file_message_expander.get_label())
594
529
        self.assertTrue(dlg._file_message_expander.get_expanded())
601
536
        # We should have updated the ListStore with the new file commit info
602
537
        self.assertEqual('Some text\nfor a\n', get_saved_text(1))
603
538
 
604
 
        dlg._treeview_files.set_cursor(
605
 
            Gtk.TreePath(path=2), None, False)
 
539
        dlg._treeview_files.set_cursor((2,))
606
540
        self.assertEqual('Commit message for b/',
607
541
                         dlg._file_message_expander.get_label())
608
542
        self.assertTrue(dlg._file_message_expander.get_expanded())
613
547
        dlg._set_file_commit_message('More text\nfor b\n')
614
548
        # Now switch back to 'a'. The message should be saved, and the buffer
615
549
        # should be updated with the other text
616
 
        dlg._treeview_files.set_cursor(
617
 
            Gtk.TreePath(path=1), None, False)
 
550
        dlg._treeview_files.set_cursor((1,))
618
551
        self.assertEqual('More text\nfor b\n', get_saved_text(2))
619
552
        self.assertEqual('Commit message for a',
620
553
                         dlg._file_message_expander.get_label())
629
562
        tree.add(['a', 'b'], ['a-id', 'b-id'])
630
563
 
631
564
        dlg = commit.CommitDialog(tree)
632
 
        self.assertEqual([("", "", True),
 
565
        self.assertEqual([(None, None, True),
633
566
                          ('a-id', 'a', True),
634
567
                          ('b-id', 'b', True),
635
568
                         ], [(r[0], r[1], r[2]) for r in dlg._files_store])
640
573
        #       do with. So instead, we just call toggle directly, and assume
641
574
        #       that toggle is hooked in correctly
642
575
        # column = dlg._treeview_files.get_column(0)
643
 
        # renderer = column.get_cells()[0]
 
576
        # renderer = column.get_cell_renderers()[0]
644
577
 
645
578
        # Toggle a single entry should set just that entry to False
646
579
        dlg._toggle_commit(None, 1, dlg._files_store)
647
 
        self.assertEqual([("", "", True),
 
580
        self.assertEqual([(None, None, True),
648
581
                          ('a-id', 'a', False),
649
582
                          ('b-id', 'b', True),
650
583
                         ], [(r[0], r[1], r[2]) for r in dlg._files_store])
651
584
 
652
585
        # Toggling the main entry should set all entries
653
586
        dlg._toggle_commit(None, 0, dlg._files_store)
654
 
        self.assertEqual([("", "", False),
 
587
        self.assertEqual([(None, None, False),
655
588
                          ('a-id', 'a', False),
656
589
                          ('b-id', 'b', False),
657
590
                         ], [(r[0], r[1], r[2]) for r in dlg._files_store])
658
591
 
659
592
        dlg._toggle_commit(None, 2, dlg._files_store)
660
 
        self.assertEqual([("", "", False),
 
593
        self.assertEqual([(None, None, False),
661
594
                          ('a-id', 'a', False),
662
595
                          ('b-id', 'b', True),
663
596
                         ], [(r[0], r[1], r[2]) for r in dlg._files_store])
664
597
 
665
598
        dlg._toggle_commit(None, 0, dlg._files_store)
666
 
        self.assertEqual([("", "", True),
 
599
        self.assertEqual([(None, None, True),
667
600
                          ('a-id', 'a', True),
668
601
                          ('b-id', 'b', True),
669
602
                         ], [(r[0], r[1], r[2]) for r in dlg._files_store])
693
626
        dlg._commit_selected_radio.set_active(True)
694
627
        self.assertEqual((['a_file', 'b_dir'], []), dlg._get_specific_files())
695
628
 
696
 
        dlg._treeview_files.set_cursor(
697
 
            Gtk.TreePath(path=1), None, False)
 
629
        dlg._treeview_files.set_cursor((1,))
698
630
        dlg._set_file_commit_message('Test\nmessage\nfor a_file\n')
699
 
        dlg._treeview_files.set_cursor(
700
 
            Gtk.TreePath(path=2), None, False)
 
631
        dlg._treeview_files.set_cursor((2,))
701
632
        dlg._set_file_commit_message('message\nfor b_dir\n')
702
633
 
703
634
        self.assertEqual((['a_file', 'b_dir'],
713
644
                            'message':'message\nfor b_dir\n'},
714
645
                          ]), dlg._get_specific_files())
715
646
 
716
 
    def test_specific_files_sanitizes_messages(self):
717
 
        tree = self.make_branch_and_tree('tree')
718
 
        tree.branch.get_config().set_user_option('per_file_commits', 'true')
719
 
        self.build_tree(['tree/a_file', 'tree/b_dir/'])
720
 
        tree.add(['a_file', 'b_dir'], ['1a-id', '0b-id'])
721
 
 
722
 
        dlg = commit.CommitDialog(tree)
723
 
        dlg._commit_selected_radio.set_active(True)
724
 
        self.assertEqual((['a_file', 'b_dir'], []), dlg._get_specific_files())
725
 
 
726
 
        dlg._treeview_files.set_cursor(
727
 
            Gtk.TreePath(path=1), None, False)
728
 
        dlg._set_file_commit_message('Test\r\nmessage\rfor a_file\n')
729
 
        dlg._treeview_files.set_cursor(
730
 
            Gtk.TreePath(path=2), None, False)
731
 
        dlg._set_file_commit_message('message\r\nfor\nb_dir\r')
732
 
 
733
 
        self.assertEqual((['a_file', 'b_dir'],
734
 
                          [{'path':'a_file', 'file_id':'1a-id',
735
 
                            'message':'Test\nmessage\nfor a_file\n'},
736
 
                           {'path':'b_dir', 'file_id':'0b-id',
737
 
                            'message':'message\nfor\nb_dir\n'},
738
 
                          ]), dlg._get_specific_files())
739
 
 
740
 
 
741
 
class QuestionHelpers(object):
 
647
 
 
648
class TestCommitDialog_Commit(tests.TestCaseWithTransport):
 
649
    """Tests on the actual 'commit' button being pushed."""
742
650
 
743
651
    def _set_question_yes(self, dlg):
744
652
        """Set the dialog to answer YES to any questions."""
745
653
        self.questions = []
746
 
        def _question_yes(*args, **kwargs):
 
654
        def _question_yes(*args):
747
655
            self.questions.append(args)
748
656
            self.questions.append('YES')
749
 
            return Gtk.ResponseType.YES
 
657
            return gtk.RESPONSE_YES
750
658
        dlg._question_dialog = _question_yes
751
659
 
752
660
    def _set_question_no(self, dlg):
753
661
        """Set the dialog to answer NO to any questions."""
754
662
        self.questions = []
755
 
        def _question_no(*args, **kwargs):
 
663
        def _question_no(*args):
756
664
            self.questions.append(args)
757
665
            self.questions.append('NO')
758
 
            return Gtk.ResponseType.NO
 
666
            return gtk.RESPONSE_NO
759
667
        dlg._question_dialog = _question_no
760
668
 
761
 
 
762
 
class TestCommitDialog_Commit(tests.TestCaseWithTransport, QuestionHelpers):
763
 
    """Tests on the actual 'commit' button being pushed."""
764
 
 
765
669
    def test_bound_commit_local(self):
766
670
        tree = self.make_branch_and_tree('tree')
767
671
        self.build_tree(['tree/a'])
783
687
        self.assertEqual(last_rev, dlg.committed_revision_id)
784
688
        self.assertEqual(rev_id1, tree.branch.last_revision())
785
689
 
786
 
    def test_commit_global_sanitizes_message(self):
787
 
        tree = self.make_branch_and_tree('tree')
788
 
        self.build_tree(['tree/a'])
789
 
        tree.add(['a'], ['a-id'])
790
 
        rev_id1 = tree.commit('one')
791
 
 
792
 
        self.build_tree(['tree/b'])
793
 
        tree.add(['b'], ['b-id'])
794
 
        dlg = commit.CommitDialog(tree)
795
 
        # With the check box set, it should only effect the local branch
796
 
        dlg._set_global_commit_message('Commit\r\nmessage\rfoo\n')
797
 
        dlg._do_commit()
798
 
        rev = tree.branch.repository.get_revision(tree.last_revision())
799
 
        self.assertEqual('Commit\nmessage\nfoo\n', rev.message)
800
 
 
801
690
    def test_bound_commit_both(self):
802
691
        tree = self.make_branch_and_tree('tree')
803
692
        self.build_tree(['tree/a'])
819
708
        self.assertEqual(last_rev, dlg.committed_revision_id)
820
709
        self.assertEqual(last_rev, tree.branch.last_revision())
821
710
 
822
 
    def test_commit_empty_message(self):
 
711
    def test_commit_no_message(self):
823
712
        tree = self.make_branch_and_tree('tree')
824
713
        self.build_tree(['tree/a', 'tree/b'])
825
714
        tree.add(['a'], ['a-id'])
1040
929
 
1041
930
        dlg = commit.CommitDialog(tree)
1042
931
        dlg._commit_selected_radio.set_active(True) # enable partial
1043
 
        dlg._treeview_files.set_cursor(
1044
 
            Gtk.TreePath(path=1), None, False)
 
932
        dlg._treeview_files.set_cursor((1,))
1045
933
        dlg._set_file_commit_message('Message for A\n')
1046
 
        dlg._treeview_files.set_cursor(
1047
 
            Gtk.TreePath(path=2), None, False)
 
934
        dlg._treeview_files.set_cursor((2,))
1048
935
        dlg._set_file_commit_message('Message for B\n')
1049
936
        dlg._toggle_commit(None, 2, dlg._files_store) # unset 'b'
1050
937
        dlg._set_global_commit_message('Commit just "a"')
1056
943
        rev = tree.branch.repository.get_revision(rev_id2)
1057
944
        self.assertEqual('Commit just "a"', rev.message)
1058
945
        file_info = rev.properties['file-info']
1059
 
        self.assertEqual(u'ld7:file_id4:a-id'
1060
 
                         '7:message14:Message for A\n'
1061
 
                         '4:path1:a'
1062
 
                         'ee',
1063
 
                         file_info)
 
946
        self.assertEqual('ld7:file_id4:a-id'
 
947
                           '7:message14:Message for A\n'
 
948
                           '4:path1:a'
 
949
                         'ee', file_info)
1064
950
        self.assertEqual([{'path':'a', 'file_id':'a-id',
1065
 
                           'message':'Message for A\n'},],
1066
 
                         bencode.bdecode(file_info.encode('UTF-8')))
 
951
                           'message':'Message for A\n'},
 
952
                         ], bencode.bdecode(file_info))
1067
953
 
1068
954
    def test_commit_messages_after_merge(self):
1069
955
        tree = self.make_branch_and_tree('tree')
1077
963
        tree.merge_from_branch(tree2.branch)
1078
964
 
1079
965
        dlg = commit.CommitDialog(tree)
1080
 
        dlg._treeview_files.set_cursor(
1081
 
            Gtk.TreePath(path=1), None, False) # 'a'
 
966
        dlg._treeview_files.set_cursor((1,)) # 'a'
1082
967
        dlg._set_file_commit_message('Message for A\n')
1083
968
        # No message for 'B'
1084
969
        dlg._set_global_commit_message('Merging from "tree2"\n')
1091
976
        self.assertEqual('Merging from "tree2"\n', rev.message)
1092
977
        self.assertEqual([rev_id1, rev_id2], rev.parent_ids)
1093
978
        file_info = rev.properties['file-info']
1094
 
        self.assertEqual(u'ld7:file_id4:a-id'
1095
 
                         '7:message14:Message for A\n'
1096
 
                         '4:path1:a'
1097
 
                         'ee',
1098
 
                         file_info)
 
979
        self.assertEqual('ld7:file_id4:a-id'
 
980
                           '7:message14:Message for A\n'
 
981
                           '4:path1:a'
 
982
                         'ee', file_info)
1099
983
        self.assertEqual([{'path':'a', 'file_id':'a-id',
1100
 
                           'message':'Message for A\n'},],
1101
 
                         bencode.bdecode(file_info.encode('UTF-8')))
 
984
                           'message':'Message for A\n'},
 
985
                         ], bencode.bdecode(file_info))
1102
986
 
1103
987
    def test_commit_unicode_messages(self):
1104
 
        self.requireFeature(UnicodeFilenameFeature)
 
988
        from bzrlib.tests.test_diff import UnicodeFilename
 
989
        self.requireFeature(UnicodeFilename)
1105
990
 
1106
991
        tree = self.make_branch_and_tree('tree')
1107
992
        tree.branch.get_config().set_user_option('per_file_commits', 'true')
1109
994
        tree.add(['a', u'\u03a9'], ['a-id', 'omega-id'])
1110
995
 
1111
996
        dlg = commit.CommitDialog(tree)
1112
 
        dlg._treeview_files.set_cursor(
1113
 
            Gtk.TreePath(path=1), None, False) # 'a'
 
997
        dlg._treeview_files.set_cursor((1,)) # 'a'
1114
998
        dlg._set_file_commit_message(u'Test \xfan\xecc\xf6de\n')
1115
 
        dlg._treeview_files.set_cursor(
1116
 
            Gtk.TreePath(path=2), None, False) # omega
 
999
        dlg._treeview_files.set_cursor((2,)) # omega
1117
1000
        dlg._set_file_commit_message(u'\u03a9 is the end of all things.\n')
1118
1001
        dlg._set_global_commit_message(u'\u03a9 and \xfan\xecc\xf6de\n')
1119
1002
 
1148
1031
                          {'path':u'\u03a9', 'file_id':'omega-id',
1149
1032
                           'message':u'\u03a9 is the end of all things.\n'},
1150
1033
                         ], file_info_decoded)
1151
 
 
1152
 
 
1153
 
class TestSanitizeMessage(tests.TestCase):
1154
 
 
1155
 
    def assertSanitize(self, expected, original):
1156
 
        self.assertEqual(expected,
1157
 
                         commit._sanitize_and_decode_message(original))
1158
 
 
1159
 
    def test_untouched(self):
1160
 
        self.assertSanitize('foo\nbar\nbaz\n', 'foo\nbar\nbaz\n')
1161
 
 
1162
 
    def test_converts_cr_to_lf(self):
1163
 
        self.assertSanitize('foo\nbar\nbaz\n', 'foo\rbar\rbaz\r')
1164
 
 
1165
 
    def test_converts_crlf_to_lf(self):
1166
 
        self.assertSanitize('foo\nbar\nbaz\n', 'foo\r\nbar\r\nbaz\r\n')
1167
 
 
1168
 
    def test_converts_mixed_to_lf(self):
1169
 
        self.assertSanitize('foo\nbar\nbaz\n', 'foo\r\nbar\rbaz\n')
1170
 
 
1171
 
 
1172
 
class TestSavedCommitMessages(tests.TestCaseWithTransport):
1173
 
 
1174
 
    def setUp(self):
1175
 
        super(TestSavedCommitMessages, self).setUp()
1176
 
        # Install our hook
1177
 
        branch.Branch.hooks.install_named_hook(
1178
 
            'post_uncommit', commitmsgs.save_commit_messages, None)
1179
 
 
1180
 
    def _get_file_info_dict(self, rank):
1181
 
        file_info = [dict(path='a', file_id='a-id', message='a msg %d' % rank),
1182
 
                     dict(path='b', file_id='b-id', message='b msg %d' % rank)]
1183
 
        return file_info
1184
 
 
1185
 
    def _get_file_info_revprops(self, rank):
1186
 
        file_info_prop = self._get_file_info_dict(rank)
1187
 
        return {'file-info': bencode.bencode(file_info_prop).decode('UTF-8')}
1188
 
 
1189
 
    def _get_commit_message(self):
1190
 
        return self.config.get_user_option('gtk_global_commit_message')
1191
 
 
1192
 
    def _get_file_commit_messages(self):
1193
 
        return self.config.get_user_option('gtk_file_commit_messages')
1194
 
 
1195
 
 
1196
 
class TestUncommitHook(TestSavedCommitMessages):
1197
 
 
1198
 
    def setUp(self):
1199
 
        super(TestUncommitHook, self).setUp()
1200
 
        self.tree = self.make_branch_and_tree('tree')
1201
 
        self.config = self.tree.branch.get_config()
1202
 
        self.build_tree(['tree/a', 'tree/b'])
1203
 
        self.tree.add(['a'], ['a-id'])
1204
 
        self.tree.add(['b'], ['b-id'])
1205
 
        rev1 = self.tree.commit('one', rev_id='one-id',
1206
 
                                revprops=self._get_file_info_revprops(1))
1207
 
        rev2 = self.tree.commit('two', rev_id='two-id',
1208
 
                                revprops=self._get_file_info_revprops(2))
1209
 
        rev3 = self.tree.commit('three', rev_id='three-id',
1210
 
                                revprops=self._get_file_info_revprops(3))
1211
 
 
1212
 
    def test_uncommit_one_by_one(self):
1213
 
        uncommit.uncommit(self.tree.branch, tree=self.tree)
1214
 
        self.assertEquals(u'three', self._get_commit_message())
1215
 
        self.assertEquals(u'd4:a-id7:a msg 34:b-id7:b msg 3e',
1216
 
                          self._get_file_commit_messages())
1217
 
 
1218
 
        uncommit.uncommit(self.tree.branch, tree=self.tree)
1219
 
        self.assertEquals(u'two\n******\nthree', self._get_commit_message())
1220
 
        self.assertEquals(u'd4:a-id22:a msg 2\n******\na msg 3'
1221
 
                          '4:b-id22:b msg 2\n******\nb msg 3e',
1222
 
                          self._get_file_commit_messages())
1223
 
 
1224
 
        uncommit.uncommit(self.tree.branch, tree=self.tree)
1225
 
        self.assertEquals(u'one\n******\ntwo\n******\nthree',
1226
 
                          self._get_commit_message())
1227
 
        self.assertEquals(u'd4:a-id37:a msg 1\n******\na msg 2\n******\na msg 3'
1228
 
                          '4:b-id37:b msg 1\n******\nb msg 2\n******\nb msg 3e',
1229
 
                          self._get_file_commit_messages())
1230
 
 
1231
 
    def test_uncommit_all_at_once(self):
1232
 
        uncommit.uncommit(self.tree.branch, tree=self.tree, revno=1)
1233
 
        self.assertEquals(u'one\n******\ntwo\n******\nthree',
1234
 
                          self._get_commit_message())
1235
 
        self.assertEquals(u'd4:a-id37:a msg 1\n******\na msg 2\n******\na msg 3'
1236
 
                          '4:b-id37:b msg 1\n******\nb msg 2\n******\nb msg 3e',
1237
 
                          self._get_file_commit_messages())
1238
 
 
1239
 
 
1240
 
class TestReusingSavedCommitMessages(TestSavedCommitMessages, QuestionHelpers):
1241
 
 
1242
 
    def setUp(self):
1243
 
        super(TestReusingSavedCommitMessages, self).setUp()
1244
 
        self.tree = self.make_branch_and_tree('tree')
1245
 
        self.config = self.tree.branch.get_config()
1246
 
        self.config.set_user_option('per_file_commits', 'true')
1247
 
        self.build_tree(['tree/a', 'tree/b'])
1248
 
        self.tree.add(['a'], ['a-id'])
1249
 
        self.tree.add(['b'], ['b-id'])
1250
 
        rev1 = self.tree.commit('one', revprops=self._get_file_info_revprops(1))
1251
 
        rev2 = self.tree.commit('two', revprops=self._get_file_info_revprops(2))
1252
 
        uncommit.uncommit(self.tree.branch, tree=self.tree)
1253
 
        self.build_tree_contents([('tree/a', 'new a content\n'),
1254
 
                                  ('tree/b', 'new b content'),])
1255
 
 
1256
 
    def _get_commit_dialog(self, tree):
1257
 
        # Ensure we will never use a dialog that can actually prompt the user
1258
 
        # during the test suite. Test *can* and *should* override with the
1259
 
        # correct question dialog type.
1260
 
        dlg = commit.CommitDialog(tree)
1261
 
        self._set_question_no(dlg)
1262
 
        return dlg
1263
 
 
1264
 
    def test_setup_saved_messages(self):
1265
 
        # Check the initial setup
1266
 
        self.assertEquals(u'two', self._get_commit_message())
1267
 
        self.assertEquals(u'd4:a-id7:a msg 24:b-id7:b msg 2e',
1268
 
                          self._get_file_commit_messages())
1269
 
 
1270
 
    def test_messages_are_reloaded(self):
1271
 
        dlg = self._get_commit_dialog(self.tree)
1272
 
        self.assertEquals(u'two', dlg._get_global_commit_message())
1273
 
        self.assertEquals(([u'a', u'b'],
1274
 
                           [{ 'path': 'a',
1275
 
                             'file_id': 'a-id', 'message': 'a msg 2',},
1276
 
                           {'path': 'b',
1277
 
                            'file_id': 'b-id', 'message': 'b msg 2',}],),
1278
 
                          dlg._get_specific_files())
1279
 
 
1280
 
    def test_messages_are_consumed(self):
1281
 
        dlg = self._get_commit_dialog(self.tree)
1282
 
        dlg._do_commit()
1283
 
        self.assertEquals(u'', self._get_commit_message())
1284
 
        self.assertEquals(u'de', self._get_file_commit_messages())
1285
 
 
1286
 
    def test_messages_are_saved_on_cancel_if_required(self):
1287
 
        dlg = self._get_commit_dialog(self.tree)
1288
 
        self._set_question_yes(dlg) # Save messages
1289
 
        dlg._do_cancel()
1290
 
        self.assertEquals(u'two', self._get_commit_message())
1291
 
        self.assertEquals(u'd4:a-id7:a msg 24:b-id7:b msg 2e',
1292
 
                          self._get_file_commit_messages())
1293
 
 
1294
 
    def test_messages_are_cleared_on_cancel_if_required(self):
1295
 
        dlg = self._get_commit_dialog(self.tree)
1296
 
        self._set_question_no(dlg) # Don't save messages
1297
 
        dlg._do_cancel()
1298
 
        self.assertEquals(u'', self._get_commit_message())
1299
 
        self.assertEquals(u'de',
1300
 
                          self._get_file_commit_messages())
1301
 
 
1302
 
 
1303
 
class BzrHandlePatchTestCase(tests.TestCase):
1304
 
 
1305
 
    def setUp(self):
1306
 
        top = os.path.abspath(os.path.join(
1307
 
            os.path.dirname(__file__), os.pardir))
1308
 
        self.script = os.path.join(top, 'bzr-handle-patch')
1309
 
        self.env = dict(os.environ)
1310
 
        self.env['BZR_PLUGINS_AT'] = 'gtk@%s' % top
1311
 
        self.patch = NamedTemporaryFile()
1312
 
        self.patch.write('\n'.join([
1313
 
            "=== added file '_test.txt'",
1314
 
            "--- _test.txt      1970-01-01 00:00:00 +0000",
1315
 
            "+++ _test.txt      2012-02-03 20:00:34 +0000",
1316
 
            "@@ -0,0 +1,1 @@",
1317
 
            "+hello",
1318
 
            ]))
1319
 
        self.patch.flush()
1320
 
        super(BzrHandlePatchTestCase, self).setUp()
1321
 
 
1322
 
    def test_smoketest(self):
1323
 
        # This is a smoke test to verify the process starts.
1324
 
        bzr_notify = subprocess.Popen(
1325
 
            [self.script, self.patch.name, 'test'],
1326
 
            stdout=subprocess.PIPE, stderr=subprocess.PIPE, env=self.env)
1327
 
        stdout, stderr = bzr_notify.communicate()
1328
 
        self.assertEqual('', stdout)
1329
 
        self.assertEqual('', stderr)