/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-19 17:47:22 UTC
  • Revision ID: jelmer@canonical.com-20111219174722-hm8wjmwfoov2vyt4
Fix a relative import.

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
try:
 
33
    from bzrlib import bencode
 
34
except ImportError:
 
35
    from bzrlib.util import bencode
28
36
 
29
 
from bzrlib.plugins.gtk import commit
 
37
from bzrlib.plugins.gtk import (
 
38
    commit,
 
39
    commitmsgs,
 
40
    )
30
41
 
31
42
 
32
43
# TODO: All we need is basic ancestry code to test this, we shouldn't need a
38
49
        tree = self.make_branch_and_tree('.')
39
50
        tree.commit('one')
40
51
 
 
52
        self.addCleanup(tree.lock_read().unlock)
41
53
        self.assertIs(None, commit.pending_revisions(tree))
42
54
 
43
55
    def test_pending_revisions_simple(self):
48
60
        tree.merge_from_branch(tree2.branch)
49
61
        self.assertEqual([rev_id1, rev_id2], tree.get_parent_ids())
50
62
 
 
63
        self.addCleanup(tree.lock_read().unlock)
51
64
        pending_revisions = commit.pending_revisions(tree)
52
65
        # One primary merge
53
66
        self.assertEqual(1, len(pending_revisions))
66
79
        tree.merge_from_branch(tree2.branch)
67
80
        self.assertEqual([rev_id1, rev_id4], tree.get_parent_ids())
68
81
 
 
82
        self.addCleanup(tree.lock_read().unlock)
69
83
        pending_revisions = commit.pending_revisions(tree)
70
84
        # One primary merge
71
85
        self.assertEqual(1, len(pending_revisions))
86
100
        rev_id4 = tree3.commit('four')
87
101
        rev_id5 = tree3.commit('five')
88
102
        tree.merge_from_branch(tree2.branch)
89
 
        tree.merge_from_branch(tree3.branch)
 
103
        tree.merge_from_branch(tree3.branch, force=True)
90
104
        self.assertEqual([rev_id1, rev_id3, rev_id5], tree.get_parent_ids())
91
105
 
 
106
        self.addCleanup(tree.lock_read().unlock)
92
107
        pending_revisions = commit.pending_revisions(tree)
93
108
        # Two primary merges
94
109
        self.assertEqual(2, len(pending_revisions))
207
222
 
208
223
        commit_col = dlg._treeview_files.get_column(0)
209
224
        self.assertEqual('Commit', commit_col.get_title())
210
 
        renderer = commit_col.get_cell_renderers()[0]
 
225
        renderer = commit_col.get_cells()[0]
211
226
        self.assertTrue(renderer.get_property('activatable'))
212
227
 
213
228
        self.assertEqual('Commit all changes',
232
247
 
233
248
        commit_col = dlg._treeview_files.get_column(0)
234
249
        self.assertEqual('Commit*', commit_col.get_title())
235
 
        renderer = commit_col.get_cell_renderers()[0]
 
250
        renderer = commit_col.get_cells()[0]
236
251
        self.assertFalse(renderer.get_property('activatable'))
237
252
 
238
253
        values = [(r[0], r[1], r[2], r[3]) for r in dlg._pending_store]
266
281
                               committer='Jerry Foo <jerry@foo.com>',
267
282
                               timestamp=1191372278.05,
268
283
                               timezone=+7200)
269
 
        tree.merge_from_branch(tree3.branch)
 
284
        tree.merge_from_branch(tree3.branch, force=True)
270
285
 
271
286
        dlg = commit.CommitDialog(tree)
272
287
        # TODO: assert that the pending box is set to show
380
395
                          ('b-id', 'b', True, 'b/', 'removed'),
381
396
                         ], values)
382
397
        # All Files should be selected
383
 
        self.assertEqual(((0,), None), dlg._treeview_files.get_cursor())
 
398
        self.assertEqual(
 
399
            (Gtk.TreePath(path=0), None), dlg._treeview_files.get_cursor())
384
400
 
385
401
    def test_filelist_with_selected(self):
386
402
        tree = self.make_branch_and_tree('tree')
395
411
                         ], values)
396
412
        # This file should also be selected in the file list, rather than the
397
413
        # 'All Files' selection
398
 
        self.assertEqual(((1,), None), dlg._treeview_files.get_cursor())
 
414
        self.assertEqual(
 
415
            (Gtk.TreePath(path=1), None), dlg._treeview_files.get_cursor())
399
416
 
400
417
    def test_diff_view(self):
401
418
        tree = self.make_branch_and_tree('tree')
409
426
        dlg = commit.CommitDialog(tree)
410
427
        diff_buffer = dlg._diff_view.buffer
411
428
        text = diff_buffer.get_text(diff_buffer.get_start_iter(),
412
 
                                    diff_buffer.get_end_iter()).splitlines(True)
 
429
                                    diff_buffer.get_end_iter(),
 
430
                                    True).splitlines(True)
413
431
 
414
432
        self.assertEqual("=== modified file 'a'\n", text[0])
415
433
        self.assertContainsRe(text[1],
460
478
        self.assertFalse(dlg._file_message_expander.get_expanded())
461
479
        self.assertFalse(dlg._file_message_expander.get_property('sensitive'))
462
480
 
463
 
        dlg._treeview_files.set_cursor((1,))
 
481
        dlg._treeview_files.set_cursor(
 
482
            Gtk.TreePath(path=1), None, False)
464
483
        self.assertEqual('Diff for a', dlg._diff_label.get_text())
465
484
        text = diff_buffer.get_text(diff_buffer.get_start_iter(),
466
 
                                    diff_buffer.get_end_iter()).splitlines(True)
 
485
                                    diff_buffer.get_end_iter(),
 
486
                                    True).splitlines(True)
467
487
        self.assertEqual("=== added file 'a'\n", text[0])
468
488
        self.assertContainsRe(text[1],
469
489
            r"--- a\t\d\d\d\d-\d\d-\d\d \d\d:\d\d:\d\d [+-]\d\d\d\d")
477
497
        self.assertTrue(dlg._file_message_expander.get_expanded())
478
498
        self.assertTrue(dlg._file_message_expander.get_property('sensitive'))
479
499
 
480
 
        dlg._treeview_files.set_cursor((2,))
 
500
        dlg._treeview_files.set_cursor(
 
501
            Gtk.TreePath(path=2), None, False)
481
502
        self.assertEqual('Diff for b', dlg._diff_label.get_text())
482
503
        text = diff_buffer.get_text(diff_buffer.get_start_iter(),
483
 
                                    diff_buffer.get_end_iter()).splitlines(True)
 
504
                                    diff_buffer.get_end_iter(),
 
505
                                    True).splitlines(True)
484
506
        self.assertEqual("=== added file 'b'\n", text[0])
485
507
        self.assertContainsRe(text[1],
486
508
            r"--- b\t\d\d\d\d-\d\d-\d\d \d\d:\d\d:\d\d [+-]\d\d\d\d")
494
516
        self.assertTrue(dlg._file_message_expander.get_expanded())
495
517
        self.assertTrue(dlg._file_message_expander.get_property('sensitive'))
496
518
 
497
 
        dlg._treeview_files.set_cursor((0,))
 
519
        dlg._treeview_files.set_cursor(
 
520
            Gtk.TreePath(path=0), None, False)
498
521
        self.assertEqual('Diff for All Files', dlg._diff_label.get_text())
499
522
        self.assertEqual('File commit message',
500
523
                         dlg._file_message_expander.get_label())
510
533
 
511
534
        def get_file_text():
512
535
            buf = dlg._file_message_text_view.get_buffer()
513
 
            return buf.get_text(buf.get_start_iter(), buf.get_end_iter())
 
536
            return buf.get_text(
 
537
                buf.get_start_iter(), buf.get_end_iter(), True)
514
538
 
515
539
        def get_saved_text(path):
516
540
            """Get the saved text for a given record."""
523
547
        self.assertFalse(dlg._file_message_expander.get_property('sensitive'))
524
548
        self.assertEqual('', get_file_text())
525
549
 
526
 
        dlg._treeview_files.set_cursor((1,))
 
550
        dlg._treeview_files.set_cursor(
 
551
            Gtk.TreePath(path=1), None, False)
527
552
        self.assertEqual('Commit message for a',
528
553
                         dlg._file_message_expander.get_label())
529
554
        self.assertTrue(dlg._file_message_expander.get_expanded())
536
561
        # We should have updated the ListStore with the new file commit info
537
562
        self.assertEqual('Some text\nfor a\n', get_saved_text(1))
538
563
 
539
 
        dlg._treeview_files.set_cursor((2,))
 
564
        dlg._treeview_files.set_cursor(
 
565
            Gtk.TreePath(path=2), None, False)
540
566
        self.assertEqual('Commit message for b/',
541
567
                         dlg._file_message_expander.get_label())
542
568
        self.assertTrue(dlg._file_message_expander.get_expanded())
547
573
        dlg._set_file_commit_message('More text\nfor b\n')
548
574
        # Now switch back to 'a'. The message should be saved, and the buffer
549
575
        # should be updated with the other text
550
 
        dlg._treeview_files.set_cursor((1,))
 
576
        dlg._treeview_files.set_cursor(
 
577
            Gtk.TreePath(path=1), None, False)
551
578
        self.assertEqual('More text\nfor b\n', get_saved_text(2))
552
579
        self.assertEqual('Commit message for a',
553
580
                         dlg._file_message_expander.get_label())
573
600
        #       do with. So instead, we just call toggle directly, and assume
574
601
        #       that toggle is hooked in correctly
575
602
        # column = dlg._treeview_files.get_column(0)
576
 
        # renderer = column.get_cell_renderers()[0]
 
603
        # renderer = column.get_cells()[0]
577
604
 
578
605
        # Toggle a single entry should set just that entry to False
579
606
        dlg._toggle_commit(None, 1, dlg._files_store)
626
653
        dlg._commit_selected_radio.set_active(True)
627
654
        self.assertEqual((['a_file', 'b_dir'], []), dlg._get_specific_files())
628
655
 
629
 
        dlg._treeview_files.set_cursor((1,))
 
656
        dlg._treeview_files.set_cursor(
 
657
            Gtk.TreePath(path=1), None, False)
630
658
        dlg._set_file_commit_message('Test\nmessage\nfor a_file\n')
631
 
        dlg._treeview_files.set_cursor((2,))
 
659
        dlg._treeview_files.set_cursor(
 
660
            Gtk.TreePath(path=2), None, False)
632
661
        dlg._set_file_commit_message('message\nfor b_dir\n')
633
662
 
634
663
        self.assertEqual((['a_file', 'b_dir'],
644
673
                            'message':'message\nfor b_dir\n'},
645
674
                          ]), dlg._get_specific_files())
646
675
 
647
 
 
648
 
class TestCommitDialog_Commit(tests.TestCaseWithTransport):
649
 
    """Tests on the actual 'commit' button being pushed."""
 
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):
650
702
 
651
703
    def _set_question_yes(self, dlg):
652
704
        """Set the dialog to answer YES to any questions."""
653
705
        self.questions = []
654
 
        def _question_yes(*args):
 
706
        def _question_yes(*args, **kwargs):
655
707
            self.questions.append(args)
656
708
            self.questions.append('YES')
657
 
            return gtk.RESPONSE_YES
 
709
            return Gtk.ResponseType.YES
658
710
        dlg._question_dialog = _question_yes
659
711
 
660
712
    def _set_question_no(self, dlg):
661
713
        """Set the dialog to answer NO to any questions."""
662
714
        self.questions = []
663
 
        def _question_no(*args):
 
715
        def _question_no(*args, **kwargs):
664
716
            self.questions.append(args)
665
717
            self.questions.append('NO')
666
 
            return gtk.RESPONSE_NO
 
718
            return Gtk.ResponseType.NO
667
719
        dlg._question_dialog = _question_no
668
720
 
 
721
 
 
722
class TestCommitDialog_Commit(tests.TestCaseWithTransport, QuestionHelpers):
 
723
    """Tests on the actual 'commit' button being pushed."""
 
724
 
669
725
    def test_bound_commit_local(self):
670
726
        tree = self.make_branch_and_tree('tree')
671
727
        self.build_tree(['tree/a'])
687
743
        self.assertEqual(last_rev, dlg.committed_revision_id)
688
744
        self.assertEqual(rev_id1, tree.branch.last_revision())
689
745
 
 
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
 
690
761
    def test_bound_commit_both(self):
691
762
        tree = self.make_branch_and_tree('tree')
692
763
        self.build_tree(['tree/a'])
708
779
        self.assertEqual(last_rev, dlg.committed_revision_id)
709
780
        self.assertEqual(last_rev, tree.branch.last_revision())
710
781
 
711
 
    def test_commit_no_message(self):
 
782
    def test_commit_empty_message(self):
712
783
        tree = self.make_branch_and_tree('tree')
713
784
        self.build_tree(['tree/a', 'tree/b'])
714
785
        tree.add(['a'], ['a-id'])
929
1000
 
930
1001
        dlg = commit.CommitDialog(tree)
931
1002
        dlg._commit_selected_radio.set_active(True) # enable partial
932
 
        dlg._treeview_files.set_cursor((1,))
 
1003
        dlg._treeview_files.set_cursor(
 
1004
            Gtk.TreePath(path=1), None, False)
933
1005
        dlg._set_file_commit_message('Message for A\n')
934
 
        dlg._treeview_files.set_cursor((2,))
 
1006
        dlg._treeview_files.set_cursor(
 
1007
            Gtk.TreePath(path=2), None, False)
935
1008
        dlg._set_file_commit_message('Message for B\n')
936
1009
        dlg._toggle_commit(None, 2, dlg._files_store) # unset 'b'
937
1010
        dlg._set_global_commit_message('Commit just "a"')
943
1016
        rev = tree.branch.repository.get_revision(rev_id2)
944
1017
        self.assertEqual('Commit just "a"', rev.message)
945
1018
        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)
 
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)
950
1024
        self.assertEqual([{'path':'a', 'file_id':'a-id',
951
 
                           'message':'Message for A\n'},
952
 
                         ], bencode.bdecode(file_info))
 
1025
                           'message':'Message for A\n'},],
 
1026
                         bencode.bdecode(file_info.encode('UTF-8')))
953
1027
 
954
1028
    def test_commit_messages_after_merge(self):
955
1029
        tree = self.make_branch_and_tree('tree')
963
1037
        tree.merge_from_branch(tree2.branch)
964
1038
 
965
1039
        dlg = commit.CommitDialog(tree)
966
 
        dlg._treeview_files.set_cursor((1,)) # 'a'
 
1040
        dlg._treeview_files.set_cursor(
 
1041
            Gtk.TreePath(path=1), None, False) # 'a'
967
1042
        dlg._set_file_commit_message('Message for A\n')
968
1043
        # No message for 'B'
969
1044
        dlg._set_global_commit_message('Merging from "tree2"\n')
976
1051
        self.assertEqual('Merging from "tree2"\n', rev.message)
977
1052
        self.assertEqual([rev_id1, rev_id2], rev.parent_ids)
978
1053
        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)
 
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)
983
1059
        self.assertEqual([{'path':'a', 'file_id':'a-id',
984
 
                           'message':'Message for A\n'},
985
 
                         ], bencode.bdecode(file_info))
 
1060
                           'message':'Message for A\n'},],
 
1061
                         bencode.bdecode(file_info.encode('UTF-8')))
986
1062
 
987
1063
    def test_commit_unicode_messages(self):
988
 
        self.requireFeature(tests.UnicodeFilenameFeature)
 
1064
        self.requireFeature(UnicodeFilenameFeature)
989
1065
 
990
1066
        tree = self.make_branch_and_tree('tree')
991
1067
        tree.branch.get_config().set_user_option('per_file_commits', 'true')
993
1069
        tree.add(['a', u'\u03a9'], ['a-id', 'omega-id'])
994
1070
 
995
1071
        dlg = commit.CommitDialog(tree)
996
 
        dlg._treeview_files.set_cursor((1,)) # 'a'
 
1072
        dlg._treeview_files.set_cursor(
 
1073
            Gtk.TreePath(path=1), None, False) # 'a'
997
1074
        dlg._set_file_commit_message(u'Test \xfan\xecc\xf6de\n')
998
 
        dlg._treeview_files.set_cursor((2,)) # omega
 
1075
        dlg._treeview_files.set_cursor(
 
1076
            Gtk.TreePath(path=2), None, False) # omega
999
1077
        dlg._set_file_commit_message(u'\u03a9 is the end of all things.\n')
1000
1078
        dlg._set_global_commit_message(u'\u03a9 and \xfan\xecc\xf6de\n')
1001
1079
 
1030
1108
                          {'path':u'\u03a9', 'file_id':'omega-id',
1031
1109
                           'message':u'\u03a9 is the end of all things.\n'},
1032
1110
                         ], 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())