/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: 2011-12-20 16:16:57 UTC
  • Revision ID: jelmer@canonical.com-20111220161657-zjn6rqjrw8ouehf8
Drop support for old bencode location.

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/test_commit.py
1
 
# Copyright (C) 2007 John Arbash Meinel <john@arbash-meinel.com>
 
1
# Copyright (C) 2007, 2008 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
 
import gtk
 
21
from gi.repository import Gtk
22
22
 
23
23
from bzrlib import (
 
24
    branch,
24
25
    tests,
25
 
    revision,
 
26
    uncommit,
26
27
    )
27
 
from bzrlib.util import bencode
 
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
28
33
 
29
 
from bzrlib.plugins.gtk import commit
 
34
from bzrlib.plugins.gtk import (
 
35
    commit,
 
36
    commitmsgs,
 
37
    )
30
38
 
31
39
 
32
40
# TODO: All we need is basic ancestry code to test this, we shouldn't need a
38
46
        tree = self.make_branch_and_tree('.')
39
47
        tree.commit('one')
40
48
 
 
49
        self.addCleanup(tree.lock_read().unlock)
41
50
        self.assertIs(None, commit.pending_revisions(tree))
42
51
 
43
52
    def test_pending_revisions_simple(self):
48
57
        tree.merge_from_branch(tree2.branch)
49
58
        self.assertEqual([rev_id1, rev_id2], tree.get_parent_ids())
50
59
 
 
60
        self.addCleanup(tree.lock_read().unlock)
51
61
        pending_revisions = commit.pending_revisions(tree)
52
62
        # One primary merge
53
63
        self.assertEqual(1, len(pending_revisions))
66
76
        tree.merge_from_branch(tree2.branch)
67
77
        self.assertEqual([rev_id1, rev_id4], tree.get_parent_ids())
68
78
 
 
79
        self.addCleanup(tree.lock_read().unlock)
69
80
        pending_revisions = commit.pending_revisions(tree)
70
81
        # One primary merge
71
82
        self.assertEqual(1, len(pending_revisions))
86
97
        rev_id4 = tree3.commit('four')
87
98
        rev_id5 = tree3.commit('five')
88
99
        tree.merge_from_branch(tree2.branch)
89
 
        tree.merge_from_branch(tree3.branch)
 
100
        tree.merge_from_branch(tree3.branch, force=True)
90
101
        self.assertEqual([rev_id1, rev_id3, rev_id5], tree.get_parent_ids())
91
102
 
 
103
        self.addCleanup(tree.lock_read().unlock)
92
104
        pending_revisions = commit.pending_revisions(tree)
93
105
        # Two primary merges
94
106
        self.assertEqual(2, len(pending_revisions))
207
219
 
208
220
        commit_col = dlg._treeview_files.get_column(0)
209
221
        self.assertEqual('Commit', commit_col.get_title())
210
 
        renderer = commit_col.get_cell_renderers()[0]
 
222
        renderer = commit_col.get_cells()[0]
211
223
        self.assertTrue(renderer.get_property('activatable'))
212
224
 
213
225
        self.assertEqual('Commit all changes',
232
244
 
233
245
        commit_col = dlg._treeview_files.get_column(0)
234
246
        self.assertEqual('Commit*', commit_col.get_title())
235
 
        renderer = commit_col.get_cell_renderers()[0]
 
247
        renderer = commit_col.get_cells()[0]
236
248
        self.assertFalse(renderer.get_property('activatable'))
237
249
 
238
250
        values = [(r[0], r[1], r[2], r[3]) for r in dlg._pending_store]
266
278
                               committer='Jerry Foo <jerry@foo.com>',
267
279
                               timestamp=1191372278.05,
268
280
                               timezone=+7200)
269
 
        tree.merge_from_branch(tree3.branch)
 
281
        tree.merge_from_branch(tree3.branch, force=True)
270
282
 
271
283
        dlg = commit.CommitDialog(tree)
272
284
        # TODO: assert that the pending box is set to show
380
392
                          ('b-id', 'b', True, 'b/', 'removed'),
381
393
                         ], values)
382
394
        # All Files should be selected
383
 
        self.assertEqual(((0,), None), dlg._treeview_files.get_cursor())
 
395
        self.assertEqual(
 
396
            (Gtk.TreePath(path=0), None), dlg._treeview_files.get_cursor())
384
397
 
385
398
    def test_filelist_with_selected(self):
386
399
        tree = self.make_branch_and_tree('tree')
395
408
                         ], values)
396
409
        # This file should also be selected in the file list, rather than the
397
410
        # 'All Files' selection
398
 
        self.assertEqual(((1,), None), dlg._treeview_files.get_cursor())
 
411
        self.assertEqual(
 
412
            (Gtk.TreePath(path=1), None), dlg._treeview_files.get_cursor())
399
413
 
400
414
    def test_diff_view(self):
401
415
        tree = self.make_branch_and_tree('tree')
409
423
        dlg = commit.CommitDialog(tree)
410
424
        diff_buffer = dlg._diff_view.buffer
411
425
        text = diff_buffer.get_text(diff_buffer.get_start_iter(),
412
 
                                    diff_buffer.get_end_iter()).splitlines(True)
 
426
                                    diff_buffer.get_end_iter(),
 
427
                                    True).splitlines(True)
413
428
 
414
429
        self.assertEqual("=== modified file 'a'\n", text[0])
415
430
        self.assertContainsRe(text[1],
460
475
        self.assertFalse(dlg._file_message_expander.get_expanded())
461
476
        self.assertFalse(dlg._file_message_expander.get_property('sensitive'))
462
477
 
463
 
        dlg._treeview_files.set_cursor((1,))
 
478
        dlg._treeview_files.set_cursor(
 
479
            Gtk.TreePath(path=1), None, False)
464
480
        self.assertEqual('Diff for a', dlg._diff_label.get_text())
465
481
        text = diff_buffer.get_text(diff_buffer.get_start_iter(),
466
 
                                    diff_buffer.get_end_iter()).splitlines(True)
 
482
                                    diff_buffer.get_end_iter(),
 
483
                                    True).splitlines(True)
467
484
        self.assertEqual("=== added file 'a'\n", text[0])
468
485
        self.assertContainsRe(text[1],
469
486
            r"--- a\t\d\d\d\d-\d\d-\d\d \d\d:\d\d:\d\d [+-]\d\d\d\d")
477
494
        self.assertTrue(dlg._file_message_expander.get_expanded())
478
495
        self.assertTrue(dlg._file_message_expander.get_property('sensitive'))
479
496
 
480
 
        dlg._treeview_files.set_cursor((2,))
 
497
        dlg._treeview_files.set_cursor(
 
498
            Gtk.TreePath(path=2), None, False)
481
499
        self.assertEqual('Diff for b', dlg._diff_label.get_text())
482
500
        text = diff_buffer.get_text(diff_buffer.get_start_iter(),
483
 
                                    diff_buffer.get_end_iter()).splitlines(True)
 
501
                                    diff_buffer.get_end_iter(),
 
502
                                    True).splitlines(True)
484
503
        self.assertEqual("=== added file 'b'\n", text[0])
485
504
        self.assertContainsRe(text[1],
486
505
            r"--- b\t\d\d\d\d-\d\d-\d\d \d\d:\d\d:\d\d [+-]\d\d\d\d")
494
513
        self.assertTrue(dlg._file_message_expander.get_expanded())
495
514
        self.assertTrue(dlg._file_message_expander.get_property('sensitive'))
496
515
 
497
 
        dlg._treeview_files.set_cursor((0,))
 
516
        dlg._treeview_files.set_cursor(
 
517
            Gtk.TreePath(path=0), None, False)
498
518
        self.assertEqual('Diff for All Files', dlg._diff_label.get_text())
499
519
        self.assertEqual('File commit message',
500
520
                         dlg._file_message_expander.get_label())
510
530
 
511
531
        def get_file_text():
512
532
            buf = dlg._file_message_text_view.get_buffer()
513
 
            return buf.get_text(buf.get_start_iter(), buf.get_end_iter())
 
533
            return buf.get_text(
 
534
                buf.get_start_iter(), buf.get_end_iter(), True)
514
535
 
515
536
        def get_saved_text(path):
516
537
            """Get the saved text for a given record."""
523
544
        self.assertFalse(dlg._file_message_expander.get_property('sensitive'))
524
545
        self.assertEqual('', get_file_text())
525
546
 
526
 
        dlg._treeview_files.set_cursor((1,))
 
547
        dlg._treeview_files.set_cursor(
 
548
            Gtk.TreePath(path=1), None, False)
527
549
        self.assertEqual('Commit message for a',
528
550
                         dlg._file_message_expander.get_label())
529
551
        self.assertTrue(dlg._file_message_expander.get_expanded())
536
558
        # We should have updated the ListStore with the new file commit info
537
559
        self.assertEqual('Some text\nfor a\n', get_saved_text(1))
538
560
 
539
 
        dlg._treeview_files.set_cursor((2,))
 
561
        dlg._treeview_files.set_cursor(
 
562
            Gtk.TreePath(path=2), None, False)
540
563
        self.assertEqual('Commit message for b/',
541
564
                         dlg._file_message_expander.get_label())
542
565
        self.assertTrue(dlg._file_message_expander.get_expanded())
547
570
        dlg._set_file_commit_message('More text\nfor b\n')
548
571
        # Now switch back to 'a'. The message should be saved, and the buffer
549
572
        # should be updated with the other text
550
 
        dlg._treeview_files.set_cursor((1,))
 
573
        dlg._treeview_files.set_cursor(
 
574
            Gtk.TreePath(path=1), None, False)
551
575
        self.assertEqual('More text\nfor b\n', get_saved_text(2))
552
576
        self.assertEqual('Commit message for a',
553
577
                         dlg._file_message_expander.get_label())
573
597
        #       do with. So instead, we just call toggle directly, and assume
574
598
        #       that toggle is hooked in correctly
575
599
        # column = dlg._treeview_files.get_column(0)
576
 
        # renderer = column.get_cell_renderers()[0]
 
600
        # renderer = column.get_cells()[0]
577
601
 
578
602
        # Toggle a single entry should set just that entry to False
579
603
        dlg._toggle_commit(None, 1, dlg._files_store)
626
650
        dlg._commit_selected_radio.set_active(True)
627
651
        self.assertEqual((['a_file', 'b_dir'], []), dlg._get_specific_files())
628
652
 
629
 
        dlg._treeview_files.set_cursor((1,))
 
653
        dlg._treeview_files.set_cursor(
 
654
            Gtk.TreePath(path=1), None, False)
630
655
        dlg._set_file_commit_message('Test\nmessage\nfor a_file\n')
631
 
        dlg._treeview_files.set_cursor((2,))
 
656
        dlg._treeview_files.set_cursor(
 
657
            Gtk.TreePath(path=2), None, False)
632
658
        dlg._set_file_commit_message('message\nfor b_dir\n')
633
659
 
634
660
        self.assertEqual((['a_file', 'b_dir'],
644
670
                            'message':'message\nfor b_dir\n'},
645
671
                          ]), dlg._get_specific_files())
646
672
 
647
 
 
648
 
class TestCommitDialog_Commit(tests.TestCaseWithTransport):
649
 
    """Tests on the actual 'commit' button being pushed."""
 
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):
650
699
 
651
700
    def _set_question_yes(self, dlg):
652
701
        """Set the dialog to answer YES to any questions."""
653
702
        self.questions = []
654
 
        def _question_yes(*args):
 
703
        def _question_yes(*args, **kwargs):
655
704
            self.questions.append(args)
656
705
            self.questions.append('YES')
657
 
            return gtk.RESPONSE_YES
 
706
            return Gtk.ResponseType.YES
658
707
        dlg._question_dialog = _question_yes
659
708
 
660
709
    def _set_question_no(self, dlg):
661
710
        """Set the dialog to answer NO to any questions."""
662
711
        self.questions = []
663
 
        def _question_no(*args):
 
712
        def _question_no(*args, **kwargs):
664
713
            self.questions.append(args)
665
714
            self.questions.append('NO')
666
 
            return gtk.RESPONSE_NO
 
715
            return Gtk.ResponseType.NO
667
716
        dlg._question_dialog = _question_no
668
717
 
 
718
 
 
719
class TestCommitDialog_Commit(tests.TestCaseWithTransport, QuestionHelpers):
 
720
    """Tests on the actual 'commit' button being pushed."""
 
721
 
669
722
    def test_bound_commit_local(self):
670
723
        tree = self.make_branch_and_tree('tree')
671
724
        self.build_tree(['tree/a'])
687
740
        self.assertEqual(last_rev, dlg.committed_revision_id)
688
741
        self.assertEqual(rev_id1, tree.branch.last_revision())
689
742
 
 
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
 
690
758
    def test_bound_commit_both(self):
691
759
        tree = self.make_branch_and_tree('tree')
692
760
        self.build_tree(['tree/a'])
708
776
        self.assertEqual(last_rev, dlg.committed_revision_id)
709
777
        self.assertEqual(last_rev, tree.branch.last_revision())
710
778
 
711
 
    def test_commit_no_message(self):
 
779
    def test_commit_empty_message(self):
712
780
        tree = self.make_branch_and_tree('tree')
713
781
        self.build_tree(['tree/a', 'tree/b'])
714
782
        tree.add(['a'], ['a-id'])
929
997
 
930
998
        dlg = commit.CommitDialog(tree)
931
999
        dlg._commit_selected_radio.set_active(True) # enable partial
932
 
        dlg._treeview_files.set_cursor((1,))
 
1000
        dlg._treeview_files.set_cursor(
 
1001
            Gtk.TreePath(path=1), None, False)
933
1002
        dlg._set_file_commit_message('Message for A\n')
934
 
        dlg._treeview_files.set_cursor((2,))
 
1003
        dlg._treeview_files.set_cursor(
 
1004
            Gtk.TreePath(path=2), None, False)
935
1005
        dlg._set_file_commit_message('Message for B\n')
936
1006
        dlg._toggle_commit(None, 2, dlg._files_store) # unset 'b'
937
1007
        dlg._set_global_commit_message('Commit just "a"')
943
1013
        rev = tree.branch.repository.get_revision(rev_id2)
944
1014
        self.assertEqual('Commit just "a"', rev.message)
945
1015
        file_info = rev.properties['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)
 
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)
950
1021
        self.assertEqual([{'path':'a', 'file_id':'a-id',
951
 
                           'message':'Message for A\n'},
952
 
                         ], bencode.bdecode(file_info))
 
1022
                           'message':'Message for A\n'},],
 
1023
                         bencode.bdecode(file_info.encode('UTF-8')))
953
1024
 
954
1025
    def test_commit_messages_after_merge(self):
955
1026
        tree = self.make_branch_and_tree('tree')
963
1034
        tree.merge_from_branch(tree2.branch)
964
1035
 
965
1036
        dlg = commit.CommitDialog(tree)
966
 
        dlg._treeview_files.set_cursor((1,)) # 'a'
 
1037
        dlg._treeview_files.set_cursor(
 
1038
            Gtk.TreePath(path=1), None, False) # 'a'
967
1039
        dlg._set_file_commit_message('Message for A\n')
968
1040
        # No message for 'B'
969
1041
        dlg._set_global_commit_message('Merging from "tree2"\n')
976
1048
        self.assertEqual('Merging from "tree2"\n', rev.message)
977
1049
        self.assertEqual([rev_id1, rev_id2], rev.parent_ids)
978
1050
        file_info = rev.properties['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)
 
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)
983
1056
        self.assertEqual([{'path':'a', 'file_id':'a-id',
984
 
                           'message':'Message for A\n'},
985
 
                         ], bencode.bdecode(file_info))
 
1057
                           'message':'Message for A\n'},],
 
1058
                         bencode.bdecode(file_info.encode('UTF-8')))
986
1059
 
987
1060
    def test_commit_unicode_messages(self):
988
 
        self.requireFeature(tests.UnicodeFilenameFeature)
 
1061
        self.requireFeature(UnicodeFilenameFeature)
989
1062
 
990
1063
        tree = self.make_branch_and_tree('tree')
991
1064
        tree.branch.get_config().set_user_option('per_file_commits', 'true')
993
1066
        tree.add(['a', u'\u03a9'], ['a-id', 'omega-id'])
994
1067
 
995
1068
        dlg = commit.CommitDialog(tree)
996
 
        dlg._treeview_files.set_cursor((1,)) # 'a'
 
1069
        dlg._treeview_files.set_cursor(
 
1070
            Gtk.TreePath(path=1), None, False) # 'a'
997
1071
        dlg._set_file_commit_message(u'Test \xfan\xecc\xf6de\n')
998
 
        dlg._treeview_files.set_cursor((2,)) # omega
 
1072
        dlg._treeview_files.set_cursor(
 
1073
            Gtk.TreePath(path=2), None, False) # omega
999
1074
        dlg._set_file_commit_message(u'\u03a9 is the end of all things.\n')
1000
1075
        dlg._set_global_commit_message(u'\u03a9 and \xfan\xecc\xf6de\n')
1001
1076
 
1030
1105
                          {'path':u'\u03a9', 'file_id':'omega-id',
1031
1106
                           'message':u'\u03a9 is the end of all things.\n'},
1032
1107
                         ], 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())