/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-06-29 16:11:12 UTC
  • mfrom: (475.2.2 gtk)
  • mto: This revision was merged to the branch mainline in revision 519.
  • Revision ID: jelmer@samba.org-20080629161112-3j4zp0r0e7cv6cds
Merge Chad's progress bar in viz patch.

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/test_commit.py
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
18
18
 
19
19
import os
20
20
 
21
 
from gi.repository import Gtk
 
21
import gtk
22
22
 
23
23
from bzrlib import (
24
 
    branch,
25
24
    tests,
26
 
    uncommit,
 
25
    revision,
27
26
    )
28
 
try:
29
 
    from bzrlib.tests.features import UnicodeFilenameFeature
30
 
except ImportError: # bzr < 2.5
31
 
    from bzrlib.tests import UnicodeFilenameFeature
32
 
try:
33
 
    from bzrlib import bencode
34
 
except ImportError:
35
 
    from bzrlib.util import bencode
 
27
from bzrlib.util import bencode
36
28
 
37
 
from bzrlib.plugins.gtk import (
38
 
    commit,
39
 
    commitmsgs,
40
 
    )
 
29
from bzrlib.plugins.gtk import commit
41
30
 
42
31
 
43
32
# TODO: All we need is basic ancestry code to test this, we shouldn't need a
49
38
        tree = self.make_branch_and_tree('.')
50
39
        tree.commit('one')
51
40
 
52
 
        self.addCleanup(tree.lock_read().unlock)
53
41
        self.assertIs(None, commit.pending_revisions(tree))
54
42
 
55
43
    def test_pending_revisions_simple(self):
60
48
        tree.merge_from_branch(tree2.branch)
61
49
        self.assertEqual([rev_id1, rev_id2], tree.get_parent_ids())
62
50
 
63
 
        self.addCleanup(tree.lock_read().unlock)
64
51
        pending_revisions = commit.pending_revisions(tree)
65
52
        # One primary merge
66
53
        self.assertEqual(1, len(pending_revisions))
79
66
        tree.merge_from_branch(tree2.branch)
80
67
        self.assertEqual([rev_id1, rev_id4], tree.get_parent_ids())
81
68
 
82
 
        self.addCleanup(tree.lock_read().unlock)
83
69
        pending_revisions = commit.pending_revisions(tree)
84
70
        # One primary merge
85
71
        self.assertEqual(1, len(pending_revisions))
100
86
        rev_id4 = tree3.commit('four')
101
87
        rev_id5 = tree3.commit('five')
102
88
        tree.merge_from_branch(tree2.branch)
103
 
        tree.merge_from_branch(tree3.branch, force=True)
 
89
        tree.merge_from_branch(tree3.branch)
104
90
        self.assertEqual([rev_id1, rev_id3, rev_id5], tree.get_parent_ids())
105
91
 
106
 
        self.addCleanup(tree.lock_read().unlock)
107
92
        pending_revisions = commit.pending_revisions(tree)
108
93
        # Two primary merges
109
94
        self.assertEqual(2, len(pending_revisions))
222
207
 
223
208
        commit_col = dlg._treeview_files.get_column(0)
224
209
        self.assertEqual('Commit', commit_col.get_title())
225
 
        renderer = commit_col.get_cells()[0]
 
210
        renderer = commit_col.get_cell_renderers()[0]
226
211
        self.assertTrue(renderer.get_property('activatable'))
227
212
 
228
213
        self.assertEqual('Commit all changes',
247
232
 
248
233
        commit_col = dlg._treeview_files.get_column(0)
249
234
        self.assertEqual('Commit*', commit_col.get_title())
250
 
        renderer = commit_col.get_cells()[0]
 
235
        renderer = commit_col.get_cell_renderers()[0]
251
236
        self.assertFalse(renderer.get_property('activatable'))
252
237
 
253
238
        values = [(r[0], r[1], r[2], r[3]) for r in dlg._pending_store]
281
266
                               committer='Jerry Foo <jerry@foo.com>',
282
267
                               timestamp=1191372278.05,
283
268
                               timezone=+7200)
284
 
        tree.merge_from_branch(tree3.branch, force=True)
 
269
        tree.merge_from_branch(tree3.branch)
285
270
 
286
271
        dlg = commit.CommitDialog(tree)
287
272
        # TODO: assert that the pending box is set to show
395
380
                          ('b-id', 'b', True, 'b/', 'removed'),
396
381
                         ], values)
397
382
        # All Files should be selected
398
 
        self.assertEqual(
399
 
            (Gtk.TreePath(path=0), None), dlg._treeview_files.get_cursor())
 
383
        self.assertEqual(((0,), None), dlg._treeview_files.get_cursor())
400
384
 
401
385
    def test_filelist_with_selected(self):
402
386
        tree = self.make_branch_and_tree('tree')
411
395
                         ], values)
412
396
        # This file should also be selected in the file list, rather than the
413
397
        # 'All Files' selection
414
 
        self.assertEqual(
415
 
            (Gtk.TreePath(path=1), None), dlg._treeview_files.get_cursor())
 
398
        self.assertEqual(((1,), None), dlg._treeview_files.get_cursor())
416
399
 
417
400
    def test_diff_view(self):
418
401
        tree = self.make_branch_and_tree('tree')
426
409
        dlg = commit.CommitDialog(tree)
427
410
        diff_buffer = dlg._diff_view.buffer
428
411
        text = diff_buffer.get_text(diff_buffer.get_start_iter(),
429
 
                                    diff_buffer.get_end_iter(),
430
 
                                    True).splitlines(True)
 
412
                                    diff_buffer.get_end_iter()).splitlines(True)
431
413
 
432
414
        self.assertEqual("=== modified file 'a'\n", text[0])
433
415
        self.assertContainsRe(text[1],
478
460
        self.assertFalse(dlg._file_message_expander.get_expanded())
479
461
        self.assertFalse(dlg._file_message_expander.get_property('sensitive'))
480
462
 
481
 
        dlg._treeview_files.set_cursor(
482
 
            Gtk.TreePath(path=1), None, False)
 
463
        dlg._treeview_files.set_cursor((1,))
483
464
        self.assertEqual('Diff for a', dlg._diff_label.get_text())
484
465
        text = diff_buffer.get_text(diff_buffer.get_start_iter(),
485
 
                                    diff_buffer.get_end_iter(),
486
 
                                    True).splitlines(True)
 
466
                                    diff_buffer.get_end_iter()).splitlines(True)
487
467
        self.assertEqual("=== added file 'a'\n", text[0])
488
468
        self.assertContainsRe(text[1],
489
469
            r"--- a\t\d\d\d\d-\d\d-\d\d \d\d:\d\d:\d\d [+-]\d\d\d\d")
497
477
        self.assertTrue(dlg._file_message_expander.get_expanded())
498
478
        self.assertTrue(dlg._file_message_expander.get_property('sensitive'))
499
479
 
500
 
        dlg._treeview_files.set_cursor(
501
 
            Gtk.TreePath(path=2), None, False)
 
480
        dlg._treeview_files.set_cursor((2,))
502
481
        self.assertEqual('Diff for b', dlg._diff_label.get_text())
503
482
        text = diff_buffer.get_text(diff_buffer.get_start_iter(),
504
 
                                    diff_buffer.get_end_iter(),
505
 
                                    True).splitlines(True)
 
483
                                    diff_buffer.get_end_iter()).splitlines(True)
506
484
        self.assertEqual("=== added file 'b'\n", text[0])
507
485
        self.assertContainsRe(text[1],
508
486
            r"--- b\t\d\d\d\d-\d\d-\d\d \d\d:\d\d:\d\d [+-]\d\d\d\d")
516
494
        self.assertTrue(dlg._file_message_expander.get_expanded())
517
495
        self.assertTrue(dlg._file_message_expander.get_property('sensitive'))
518
496
 
519
 
        dlg._treeview_files.set_cursor(
520
 
            Gtk.TreePath(path=0), None, False)
 
497
        dlg._treeview_files.set_cursor((0,))
521
498
        self.assertEqual('Diff for All Files', dlg._diff_label.get_text())
522
499
        self.assertEqual('File commit message',
523
500
                         dlg._file_message_expander.get_label())
533
510
 
534
511
        def get_file_text():
535
512
            buf = dlg._file_message_text_view.get_buffer()
536
 
            return buf.get_text(
537
 
                buf.get_start_iter(), buf.get_end_iter(), True)
 
513
            return buf.get_text(buf.get_start_iter(), buf.get_end_iter())
538
514
 
539
515
        def get_saved_text(path):
540
516
            """Get the saved text for a given record."""
547
523
        self.assertFalse(dlg._file_message_expander.get_property('sensitive'))
548
524
        self.assertEqual('', get_file_text())
549
525
 
550
 
        dlg._treeview_files.set_cursor(
551
 
            Gtk.TreePath(path=1), None, False)
 
526
        dlg._treeview_files.set_cursor((1,))
552
527
        self.assertEqual('Commit message for a',
553
528
                         dlg._file_message_expander.get_label())
554
529
        self.assertTrue(dlg._file_message_expander.get_expanded())
561
536
        # We should have updated the ListStore with the new file commit info
562
537
        self.assertEqual('Some text\nfor a\n', get_saved_text(1))
563
538
 
564
 
        dlg._treeview_files.set_cursor(
565
 
            Gtk.TreePath(path=2), None, False)
 
539
        dlg._treeview_files.set_cursor((2,))
566
540
        self.assertEqual('Commit message for b/',
567
541
                         dlg._file_message_expander.get_label())
568
542
        self.assertTrue(dlg._file_message_expander.get_expanded())
573
547
        dlg._set_file_commit_message('More text\nfor b\n')
574
548
        # Now switch back to 'a'. The message should be saved, and the buffer
575
549
        # should be updated with the other text
576
 
        dlg._treeview_files.set_cursor(
577
 
            Gtk.TreePath(path=1), None, False)
 
550
        dlg._treeview_files.set_cursor((1,))
578
551
        self.assertEqual('More text\nfor b\n', get_saved_text(2))
579
552
        self.assertEqual('Commit message for a',
580
553
                         dlg._file_message_expander.get_label())
600
573
        #       do with. So instead, we just call toggle directly, and assume
601
574
        #       that toggle is hooked in correctly
602
575
        # column = dlg._treeview_files.get_column(0)
603
 
        # renderer = column.get_cells()[0]
 
576
        # renderer = column.get_cell_renderers()[0]
604
577
 
605
578
        # Toggle a single entry should set just that entry to False
606
579
        dlg._toggle_commit(None, 1, dlg._files_store)
653
626
        dlg._commit_selected_radio.set_active(True)
654
627
        self.assertEqual((['a_file', 'b_dir'], []), dlg._get_specific_files())
655
628
 
656
 
        dlg._treeview_files.set_cursor(
657
 
            Gtk.TreePath(path=1), None, False)
 
629
        dlg._treeview_files.set_cursor((1,))
658
630
        dlg._set_file_commit_message('Test\nmessage\nfor a_file\n')
659
 
        dlg._treeview_files.set_cursor(
660
 
            Gtk.TreePath(path=2), None, False)
 
631
        dlg._treeview_files.set_cursor((2,))
661
632
        dlg._set_file_commit_message('message\nfor b_dir\n')
662
633
 
663
634
        self.assertEqual((['a_file', 'b_dir'],
673
644
                            'message':'message\nfor b_dir\n'},
674
645
                          ]), dlg._get_specific_files())
675
646
 
676
 
    def test_specific_files_sanitizes_messages(self):
677
 
        tree = self.make_branch_and_tree('tree')
678
 
        tree.branch.get_config().set_user_option('per_file_commits', 'true')
679
 
        self.build_tree(['tree/a_file', 'tree/b_dir/'])
680
 
        tree.add(['a_file', 'b_dir'], ['1a-id', '0b-id'])
681
 
 
682
 
        dlg = commit.CommitDialog(tree)
683
 
        dlg._commit_selected_radio.set_active(True)
684
 
        self.assertEqual((['a_file', 'b_dir'], []), dlg._get_specific_files())
685
 
 
686
 
        dlg._treeview_files.set_cursor(
687
 
            Gtk.TreePath(path=1), None, False)
688
 
        dlg._set_file_commit_message('Test\r\nmessage\rfor a_file\n')
689
 
        dlg._treeview_files.set_cursor(
690
 
            Gtk.TreePath(path=2), None, False)
691
 
        dlg._set_file_commit_message('message\r\nfor\nb_dir\r')
692
 
 
693
 
        self.assertEqual((['a_file', 'b_dir'],
694
 
                          [{'path':'a_file', 'file_id':'1a-id',
695
 
                            'message':'Test\nmessage\nfor a_file\n'},
696
 
                           {'path':'b_dir', 'file_id':'0b-id',
697
 
                            'message':'message\nfor\nb_dir\n'},
698
 
                          ]), dlg._get_specific_files())
699
 
 
700
 
 
701
 
class QuestionHelpers(object):
 
647
 
 
648
class TestCommitDialog_Commit(tests.TestCaseWithTransport):
 
649
    """Tests on the actual 'commit' button being pushed."""
702
650
 
703
651
    def _set_question_yes(self, dlg):
704
652
        """Set the dialog to answer YES to any questions."""
705
653
        self.questions = []
706
 
        def _question_yes(*args, **kwargs):
 
654
        def _question_yes(*args):
707
655
            self.questions.append(args)
708
656
            self.questions.append('YES')
709
 
            return Gtk.ResponseType.YES
 
657
            return gtk.RESPONSE_YES
710
658
        dlg._question_dialog = _question_yes
711
659
 
712
660
    def _set_question_no(self, dlg):
713
661
        """Set the dialog to answer NO to any questions."""
714
662
        self.questions = []
715
 
        def _question_no(*args, **kwargs):
 
663
        def _question_no(*args):
716
664
            self.questions.append(args)
717
665
            self.questions.append('NO')
718
 
            return Gtk.ResponseType.NO
 
666
            return gtk.RESPONSE_NO
719
667
        dlg._question_dialog = _question_no
720
668
 
721
 
 
722
 
class TestCommitDialog_Commit(tests.TestCaseWithTransport, QuestionHelpers):
723
 
    """Tests on the actual 'commit' button being pushed."""
724
 
 
725
669
    def test_bound_commit_local(self):
726
670
        tree = self.make_branch_and_tree('tree')
727
671
        self.build_tree(['tree/a'])
743
687
        self.assertEqual(last_rev, dlg.committed_revision_id)
744
688
        self.assertEqual(rev_id1, tree.branch.last_revision())
745
689
 
746
 
    def test_commit_global_sanitizes_message(self):
747
 
        tree = self.make_branch_and_tree('tree')
748
 
        self.build_tree(['tree/a'])
749
 
        tree.add(['a'], ['a-id'])
750
 
        rev_id1 = tree.commit('one')
751
 
 
752
 
        self.build_tree(['tree/b'])
753
 
        tree.add(['b'], ['b-id'])
754
 
        dlg = commit.CommitDialog(tree)
755
 
        # With the check box set, it should only effect the local branch
756
 
        dlg._set_global_commit_message('Commit\r\nmessage\rfoo\n')
757
 
        dlg._do_commit()
758
 
        rev = tree.branch.repository.get_revision(tree.last_revision())
759
 
        self.assertEqual('Commit\nmessage\nfoo\n', rev.message)
760
 
 
761
690
    def test_bound_commit_both(self):
762
691
        tree = self.make_branch_and_tree('tree')
763
692
        self.build_tree(['tree/a'])
779
708
        self.assertEqual(last_rev, dlg.committed_revision_id)
780
709
        self.assertEqual(last_rev, tree.branch.last_revision())
781
710
 
782
 
    def test_commit_empty_message(self):
 
711
    def test_commit_no_message(self):
783
712
        tree = self.make_branch_and_tree('tree')
784
713
        self.build_tree(['tree/a', 'tree/b'])
785
714
        tree.add(['a'], ['a-id'])
1000
929
 
1001
930
        dlg = commit.CommitDialog(tree)
1002
931
        dlg._commit_selected_radio.set_active(True) # enable partial
1003
 
        dlg._treeview_files.set_cursor(
1004
 
            Gtk.TreePath(path=1), None, False)
 
932
        dlg._treeview_files.set_cursor((1,))
1005
933
        dlg._set_file_commit_message('Message for A\n')
1006
 
        dlg._treeview_files.set_cursor(
1007
 
            Gtk.TreePath(path=2), None, False)
 
934
        dlg._treeview_files.set_cursor((2,))
1008
935
        dlg._set_file_commit_message('Message for B\n')
1009
936
        dlg._toggle_commit(None, 2, dlg._files_store) # unset 'b'
1010
937
        dlg._set_global_commit_message('Commit just "a"')
1016
943
        rev = tree.branch.repository.get_revision(rev_id2)
1017
944
        self.assertEqual('Commit just "a"', rev.message)
1018
945
        file_info = rev.properties['file-info']
1019
 
        self.assertEqual(u'ld7:file_id4:a-id'
1020
 
                         '7:message14:Message for A\n'
1021
 
                         '4:path1:a'
1022
 
                         'ee',
1023
 
                         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)
1024
950
        self.assertEqual([{'path':'a', 'file_id':'a-id',
1025
 
                           'message':'Message for A\n'},],
1026
 
                         bencode.bdecode(file_info.encode('UTF-8')))
 
951
                           'message':'Message for A\n'},
 
952
                         ], bencode.bdecode(file_info))
1027
953
 
1028
954
    def test_commit_messages_after_merge(self):
1029
955
        tree = self.make_branch_and_tree('tree')
1037
963
        tree.merge_from_branch(tree2.branch)
1038
964
 
1039
965
        dlg = commit.CommitDialog(tree)
1040
 
        dlg._treeview_files.set_cursor(
1041
 
            Gtk.TreePath(path=1), None, False) # 'a'
 
966
        dlg._treeview_files.set_cursor((1,)) # 'a'
1042
967
        dlg._set_file_commit_message('Message for A\n')
1043
968
        # No message for 'B'
1044
969
        dlg._set_global_commit_message('Merging from "tree2"\n')
1051
976
        self.assertEqual('Merging from "tree2"\n', rev.message)
1052
977
        self.assertEqual([rev_id1, rev_id2], rev.parent_ids)
1053
978
        file_info = rev.properties['file-info']
1054
 
        self.assertEqual(u'ld7:file_id4:a-id'
1055
 
                         '7:message14:Message for A\n'
1056
 
                         '4:path1:a'
1057
 
                         'ee',
1058
 
                         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)
1059
983
        self.assertEqual([{'path':'a', 'file_id':'a-id',
1060
 
                           'message':'Message for A\n'},],
1061
 
                         bencode.bdecode(file_info.encode('UTF-8')))
 
984
                           'message':'Message for A\n'},
 
985
                         ], bencode.bdecode(file_info))
1062
986
 
1063
987
    def test_commit_unicode_messages(self):
1064
 
        self.requireFeature(UnicodeFilenameFeature)
 
988
        self.requireFeature(tests.UnicodeFilenameFeature)
1065
989
 
1066
990
        tree = self.make_branch_and_tree('tree')
1067
991
        tree.branch.get_config().set_user_option('per_file_commits', 'true')
1069
993
        tree.add(['a', u'\u03a9'], ['a-id', 'omega-id'])
1070
994
 
1071
995
        dlg = commit.CommitDialog(tree)
1072
 
        dlg._treeview_files.set_cursor(
1073
 
            Gtk.TreePath(path=1), None, False) # 'a'
 
996
        dlg._treeview_files.set_cursor((1,)) # 'a'
1074
997
        dlg._set_file_commit_message(u'Test \xfan\xecc\xf6de\n')
1075
 
        dlg._treeview_files.set_cursor(
1076
 
            Gtk.TreePath(path=2), None, False) # omega
 
998
        dlg._treeview_files.set_cursor((2,)) # omega
1077
999
        dlg._set_file_commit_message(u'\u03a9 is the end of all things.\n')
1078
1000
        dlg._set_global_commit_message(u'\u03a9 and \xfan\xecc\xf6de\n')
1079
1001
 
1108
1030
                          {'path':u'\u03a9', 'file_id':'omega-id',
1109
1031
                           'message':u'\u03a9 is the end of all things.\n'},
1110
1032
                         ], file_info_decoded)
1111
 
 
1112
 
 
1113
 
class TestSanitizeMessage(tests.TestCase):
1114
 
 
1115
 
    def assertSanitize(self, expected, original):
1116
 
        self.assertEqual(expected,
1117
 
                         commit._sanitize_and_decode_message(original))
1118
 
 
1119
 
    def test_untouched(self):
1120
 
        self.assertSanitize('foo\nbar\nbaz\n', 'foo\nbar\nbaz\n')
1121
 
 
1122
 
    def test_converts_cr_to_lf(self):
1123
 
        self.assertSanitize('foo\nbar\nbaz\n', 'foo\rbar\rbaz\r')
1124
 
 
1125
 
    def test_converts_crlf_to_lf(self):
1126
 
        self.assertSanitize('foo\nbar\nbaz\n', 'foo\r\nbar\r\nbaz\r\n')
1127
 
 
1128
 
    def test_converts_mixed_to_lf(self):
1129
 
        self.assertSanitize('foo\nbar\nbaz\n', 'foo\r\nbar\rbaz\n')
1130
 
 
1131
 
 
1132
 
class TestSavedCommitMessages(tests.TestCaseWithTransport):
1133
 
 
1134
 
    def setUp(self):
1135
 
        super(TestSavedCommitMessages, self).setUp()
1136
 
        # Install our hook
1137
 
        branch.Branch.hooks.install_named_hook(
1138
 
            'post_uncommit', commitmsgs.save_commit_messages, None)
1139
 
 
1140
 
    def _get_file_info_dict(self, rank):
1141
 
        file_info = [dict(path='a', file_id='a-id', message='a msg %d' % rank),
1142
 
                     dict(path='b', file_id='b-id', message='b msg %d' % rank)]
1143
 
        return file_info
1144
 
 
1145
 
    def _get_file_info_revprops(self, rank):
1146
 
        file_info_prop = self._get_file_info_dict(rank)
1147
 
        return {'file-info': bencode.bencode(file_info_prop).decode('UTF-8')}
1148
 
 
1149
 
    def _get_commit_message(self):
1150
 
        return self.config.get_user_option('gtk_global_commit_message')
1151
 
 
1152
 
    def _get_file_commit_messages(self):
1153
 
        return self.config.get_user_option('gtk_file_commit_messages')
1154
 
 
1155
 
 
1156
 
class TestUncommitHook(TestSavedCommitMessages):
1157
 
 
1158
 
    def setUp(self):
1159
 
        super(TestUncommitHook, self).setUp()
1160
 
        self.tree = self.make_branch_and_tree('tree')
1161
 
        self.config = self.tree.branch.get_config()
1162
 
        self.build_tree(['tree/a', 'tree/b'])
1163
 
        self.tree.add(['a'], ['a-id'])
1164
 
        self.tree.add(['b'], ['b-id'])
1165
 
        rev1 = self.tree.commit('one', rev_id='one-id',
1166
 
                                revprops=self._get_file_info_revprops(1))
1167
 
        rev2 = self.tree.commit('two', rev_id='two-id',
1168
 
                                revprops=self._get_file_info_revprops(2))
1169
 
        rev3 = self.tree.commit('three', rev_id='three-id',
1170
 
                                revprops=self._get_file_info_revprops(3))
1171
 
 
1172
 
    def test_uncommit_one_by_one(self):
1173
 
        uncommit.uncommit(self.tree.branch, tree=self.tree)
1174
 
        self.assertEquals(u'three', self._get_commit_message())
1175
 
        self.assertEquals(u'd4:a-id7:a msg 34:b-id7:b msg 3e',
1176
 
                          self._get_file_commit_messages())
1177
 
 
1178
 
        uncommit.uncommit(self.tree.branch, tree=self.tree)
1179
 
        self.assertEquals(u'two\n******\nthree', self._get_commit_message())
1180
 
        self.assertEquals(u'd4:a-id22:a msg 2\n******\na msg 3'
1181
 
                          '4:b-id22:b msg 2\n******\nb msg 3e',
1182
 
                          self._get_file_commit_messages())
1183
 
 
1184
 
        uncommit.uncommit(self.tree.branch, tree=self.tree)
1185
 
        self.assertEquals(u'one\n******\ntwo\n******\nthree',
1186
 
                          self._get_commit_message())
1187
 
        self.assertEquals(u'd4:a-id37:a msg 1\n******\na msg 2\n******\na msg 3'
1188
 
                          '4:b-id37:b msg 1\n******\nb msg 2\n******\nb msg 3e',
1189
 
                          self._get_file_commit_messages())
1190
 
 
1191
 
    def test_uncommit_all_at_once(self):
1192
 
        uncommit.uncommit(self.tree.branch, tree=self.tree, revno=1)
1193
 
        self.assertEquals(u'one\n******\ntwo\n******\nthree',
1194
 
                          self._get_commit_message())
1195
 
        self.assertEquals(u'd4:a-id37:a msg 1\n******\na msg 2\n******\na msg 3'
1196
 
                          '4:b-id37:b msg 1\n******\nb msg 2\n******\nb msg 3e',
1197
 
                          self._get_file_commit_messages())
1198
 
 
1199
 
 
1200
 
class TestReusingSavedCommitMessages(TestSavedCommitMessages, QuestionHelpers):
1201
 
 
1202
 
    def setUp(self):
1203
 
        super(TestReusingSavedCommitMessages, self).setUp()
1204
 
        self.tree = self.make_branch_and_tree('tree')
1205
 
        self.config = self.tree.branch.get_config()
1206
 
        self.config.set_user_option('per_file_commits', 'true')
1207
 
        self.build_tree(['tree/a', 'tree/b'])
1208
 
        self.tree.add(['a'], ['a-id'])
1209
 
        self.tree.add(['b'], ['b-id'])
1210
 
        rev1 = self.tree.commit('one', revprops=self._get_file_info_revprops(1))
1211
 
        rev2 = self.tree.commit('two', revprops=self._get_file_info_revprops(2))
1212
 
        uncommit.uncommit(self.tree.branch, tree=self.tree)
1213
 
        self.build_tree_contents([('tree/a', 'new a content\n'),
1214
 
                                  ('tree/b', 'new b content'),])
1215
 
 
1216
 
    def _get_commit_dialog(self, tree):
1217
 
        # Ensure we will never use a dialog that can actually prompt the user
1218
 
        # during the test suite. Test *can* and *should* override with the
1219
 
        # correct question dialog type.
1220
 
        dlg = commit.CommitDialog(tree)
1221
 
        self._set_question_no(dlg)
1222
 
        return dlg
1223
 
 
1224
 
    def test_setup_saved_messages(self):
1225
 
        # Check the initial setup
1226
 
        self.assertEquals(u'two', self._get_commit_message())
1227
 
        self.assertEquals(u'd4:a-id7:a msg 24:b-id7:b msg 2e',
1228
 
                          self._get_file_commit_messages())
1229
 
 
1230
 
    def test_messages_are_reloaded(self):
1231
 
        dlg = self._get_commit_dialog(self.tree)
1232
 
        self.assertEquals(u'two', dlg._get_global_commit_message())
1233
 
        self.assertEquals(([u'a', u'b'],
1234
 
                           [{ 'path': 'a',
1235
 
                             'file_id': 'a-id', 'message': 'a msg 2',},
1236
 
                           {'path': 'b',
1237
 
                            'file_id': 'b-id', 'message': 'b msg 2',}],),
1238
 
                          dlg._get_specific_files())
1239
 
 
1240
 
    def test_messages_are_consumed(self):
1241
 
        dlg = self._get_commit_dialog(self.tree)
1242
 
        dlg._do_commit()
1243
 
        self.assertEquals(u'', self._get_commit_message())
1244
 
        self.assertEquals(u'de', self._get_file_commit_messages())
1245
 
 
1246
 
    def test_messages_are_saved_on_cancel_if_required(self):
1247
 
        dlg = self._get_commit_dialog(self.tree)
1248
 
        self._set_question_yes(dlg) # Save messages
1249
 
        dlg._do_cancel()
1250
 
        self.assertEquals(u'two', self._get_commit_message())
1251
 
        self.assertEquals(u'd4:a-id7:a msg 24:b-id7:b msg 2e',
1252
 
                          self._get_file_commit_messages())
1253
 
 
1254
 
    def test_messages_are_cleared_on_cancel_if_required(self):
1255
 
        dlg = self._get_commit_dialog(self.tree)
1256
 
        self._set_question_no(dlg) # Don't save messages
1257
 
        dlg._do_cancel()
1258
 
        self.assertEquals(u'', self._get_commit_message())
1259
 
        self.assertEquals(u'de',
1260
 
                          self._get_file_commit_messages())