/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 15:47:30 UTC
  • mto: This revision was merged to the branch mainline in revision 519.
  • Revision ID: jelmer@samba.org-20080629154730-xfsotoxwkiytf0ph
Pass graph object rather than full repository to linegraph.

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