/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 18:12:29 UTC
  • mto: This revision was merged to the branch mainline in revision 519.
  • Revision ID: jelmer@samba.org-20080629181229-1l2m4cf7vvbyh8qg
Simplify progress bar code, use embedded progress bar inside viz window.

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