/b-gtk/fix-viz

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/b-gtk/fix-viz

« back to all changes in this revision

Viewing changes to tests/test_commit.py

  • Committer: Jelmer Vernooij
  • Date: 2008-06-29 16:20:15 UTC
  • mto: This revision was merged to the branch mainline in revision 519.
  • Revision ID: jelmer@samba.org-20080629162015-amhe7xj4cdmup4id
Rename GtkProgressBarStack to GtkWindowProgressBarStack

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
 
    )
38
 
from bzrlib.plugins.gtk.commitmsgs import SavedCommitMessagesManager
39
 
from bzrlib.plugins.gtk.tests import MockMethod
 
29
from bzrlib.plugins.gtk import commit
40
30
 
41
31
 
42
32
# TODO: All we need is basic ancestry code to test this, we shouldn't need a
48
38
        tree = self.make_branch_and_tree('.')
49
39
        tree.commit('one')
50
40
 
51
 
        self.addCleanup(tree.lock_read().unlock)
52
41
        self.assertIs(None, commit.pending_revisions(tree))
53
42
 
54
43
    def test_pending_revisions_simple(self):
59
48
        tree.merge_from_branch(tree2.branch)
60
49
        self.assertEqual([rev_id1, rev_id2], tree.get_parent_ids())
61
50
 
62
 
        self.addCleanup(tree.lock_read().unlock)
63
51
        pending_revisions = commit.pending_revisions(tree)
64
52
        # One primary merge
65
53
        self.assertEqual(1, len(pending_revisions))
78
66
        tree.merge_from_branch(tree2.branch)
79
67
        self.assertEqual([rev_id1, rev_id4], tree.get_parent_ids())
80
68
 
81
 
        self.addCleanup(tree.lock_read().unlock)
82
69
        pending_revisions = commit.pending_revisions(tree)
83
70
        # One primary merge
84
71
        self.assertEqual(1, len(pending_revisions))
99
86
        rev_id4 = tree3.commit('four')
100
87
        rev_id5 = tree3.commit('five')
101
88
        tree.merge_from_branch(tree2.branch)
102
 
        tree.merge_from_branch(tree3.branch, force=True)
 
89
        tree.merge_from_branch(tree3.branch)
103
90
        self.assertEqual([rev_id1, rev_id3, rev_id5], tree.get_parent_ids())
104
91
 
105
 
        self.addCleanup(tree.lock_read().unlock)
106
92
        pending_revisions = commit.pending_revisions(tree)
107
93
        # Two primary merges
108
94
        self.assertEqual(2, len(pending_revisions))
146
132
 
147
133
class TestCommitDialogSimple(tests.TestCaseWithTransport):
148
134
 
149
 
    def test_init(self):
150
 
        MockMethod.bind(self, CommitDialogNoWidgets, 'setup_params')
151
 
        MockMethod.bind(self, CommitDialogNoWidgets, 'construct')
152
 
        MockMethod.bind(self, CommitDialogNoWidgets, 'fill_in_data')
153
 
 
154
 
        tree = self.make_branch_and_tree('tree')
155
 
        rev_id = tree.commit('first')
156
 
        dlg = CommitDialogNoWidgets(tree)
157
 
        self.assertIs(tree, dlg._wt)
158
 
        self.assertIs(None, dlg._selected)
159
 
        self.assertTrue(dlg._enable_per_file_commits)
160
 
        self.assertTrue(dlg._commit_all_changes)
161
 
        self.assertIs(None, dlg.committed_revision_id)
162
 
        self.assertIs(None, dlg._last_selected_file)
163
 
        self.assertIsInstance(
164
 
            dlg._saved_commit_messages_manager, SavedCommitMessagesManager)
165
 
        self.assertTrue(CommitDialogNoWidgets.setup_params.called)
166
 
        self.assertTrue(CommitDialogNoWidgets.construct.called)
167
 
        self.assertTrue(CommitDialogNoWidgets.fill_in_data.called)
168
 
 
169
135
    def test_setup_parameters_no_pending(self):
170
136
        tree = self.make_branch_and_tree('tree')
171
137
        rev_id = tree.commit('first')
214
180
        self.assertEqual([], delta.removed)
215
181
        self.assertEqual([(u'a', 'a-id', 'file')], delta.added)
216
182
 
217
 
    def test_on_treeview_files_cursor_changed_no_selection(self):
218
 
        MockMethod.bind(self, CommitDialogNoWidgets, '_update_per_file_info')
219
 
        tree = self.make_branch_and_tree('tree')
220
 
        rev_id = tree.commit('first')
221
 
        dlg = CommitDialogNoWidgets(tree)
222
 
        treeview = Gtk.TreeView()
223
 
        dlg._on_treeview_files_cursor_changed(treeview)
224
 
        self.assertFalse(CommitDialogNoWidgets._update_per_file_info.called)
225
 
 
226
 
    def test_on_treeview_files_cursor_changed_with_destroyed_treeview(self):
227
 
        MockMethod.bind(self, CommitDialogNoWidgets, '_update_per_file_info')
228
 
        tree = self.make_branch_and_tree('tree')
229
 
        rev_id = tree.commit('first')
230
 
        dlg = CommitDialogNoWidgets(tree)
231
 
        treeview = Gtk.TreeView()
232
 
        treeview.destroy()
233
 
        dlg._on_treeview_files_cursor_changed(treeview)
234
 
        self.assertFalse(CommitDialogNoWidgets._update_per_file_info.called)
235
 
 
236
183
 
237
184
class TestCommitDialog(tests.TestCaseWithTransport):
238
185
 
260
207
 
261
208
        commit_col = dlg._treeview_files.get_column(0)
262
209
        self.assertEqual('Commit', commit_col.get_title())
263
 
        renderer = commit_col.get_cells()[0]
 
210
        renderer = commit_col.get_cell_renderers()[0]
264
211
        self.assertTrue(renderer.get_property('activatable'))
265
212
 
266
213
        self.assertEqual('Commit all changes',
285
232
 
286
233
        commit_col = dlg._treeview_files.get_column(0)
287
234
        self.assertEqual('Commit*', commit_col.get_title())
288
 
        renderer = commit_col.get_cells()[0]
 
235
        renderer = commit_col.get_cell_renderers()[0]
289
236
        self.assertFalse(renderer.get_property('activatable'))
290
237
 
291
238
        values = [(r[0], r[1], r[2], r[3]) for r in dlg._pending_store]
319
266
                               committer='Jerry Foo <jerry@foo.com>',
320
267
                               timestamp=1191372278.05,
321
268
                               timezone=+7200)
322
 
        tree.merge_from_branch(tree3.branch, force=True)
 
269
        tree.merge_from_branch(tree3.branch)
323
270
 
324
271
        dlg = commit.CommitDialog(tree)
325
272
        # TODO: assert that the pending box is set to show
337
284
 
338
285
        dlg = commit.CommitDialog(tree)
339
286
        values = [(r[0], r[1], r[2], r[3], r[4]) for r in dlg._files_store]
340
 
        self.assertEqual([("", "", True, 'All Files', ''),
 
287
        self.assertEqual([(None, None, True, 'All Files', ''),
341
288
                          ('a-id', 'a', True, 'a', 'added'),
342
289
                          ('b-id', 'b', True, 'b/', 'added'),
343
290
                          ('c-id', 'b/c', True, 'b/c', 'added'),
354
301
 
355
302
        dlg = commit.CommitDialog(tree)
356
303
        values = [(r[0], r[1], r[2], r[3], r[4]) for r in dlg._files_store]
357
 
        self.assertEqual([("", "", True, 'All Files', ''),
 
304
        self.assertEqual([(None, None, True, 'All Files', ''),
358
305
                          ('b-id', 'd', True, 'b/ => d/', 'renamed'),
359
306
                          ('a-id', 'd/a', True, 'a => d/a', 'renamed'),
360
307
                         ], values)
369
316
 
370
317
        dlg = commit.CommitDialog(tree)
371
318
        values = [(r[0], r[1], r[2], r[3], r[4]) for r in dlg._files_store]
372
 
        self.assertEqual([("", "", True, 'All Files', ''),
 
319
        self.assertEqual([(None, None, True, 'All Files', ''),
373
320
                          ('a-id', 'a', True, 'a', 'modified'),
374
321
                         ], values)
375
322
 
389
336
 
390
337
        dlg = commit.CommitDialog(tree)
391
338
        values = [(r[0], r[1], r[2], r[3], r[4]) for r in dlg._files_store]
392
 
        self.assertEqual([("", "", True, 'All Files', ''),
 
339
        self.assertEqual([(None, None, True, 'All Files', ''),
393
340
                          ('b-id', 'd', True, 'b/ => d/', 'renamed'),
394
341
                          ('a-id', 'd/a', True, 'a => d/a', 'renamed and modified'),
395
342
                          ('c-id', 'd/c', True, 'd/c', 'modified'),
412
359
 
413
360
        dlg = commit.CommitDialog(tree)
414
361
        values = [(r[0], r[1], r[2], r[3], r[4]) for r in dlg._files_store]
415
 
        self.assertEqual([("", "", True, 'All Files', ''),
 
362
        self.assertEqual([(None, None, True, 'All Files', ''),
416
363
                          ('a-id', 'a', True, 'a => a/', 'kind changed'),
417
364
                          # ('b-id', 'c', True, 'b => c/', 'renamed and modified'),
418
365
                         ], values)
428
375
 
429
376
        dlg = commit.CommitDialog(tree)
430
377
        values = [(r[0], r[1], r[2], r[3], r[4]) for r in dlg._files_store]
431
 
        self.assertEqual([("", "", True, 'All Files', ''),
 
378
        self.assertEqual([(None, None, True, 'All Files', ''),
432
379
                          ('a-id', 'a', True, 'a', 'removed'),
433
380
                          ('b-id', 'b', True, 'b/', 'removed'),
434
381
                         ], values)
435
382
        # All Files should be selected
436
 
        self.assertEqual(
437
 
            (Gtk.TreePath(path=0), None), dlg._treeview_files.get_cursor())
 
383
        self.assertEqual(((0,), None), dlg._treeview_files.get_cursor())
438
384
 
439
385
    def test_filelist_with_selected(self):
440
386
        tree = self.make_branch_and_tree('tree')
443
389
 
444
390
        dlg = commit.CommitDialog(tree, selected='a')
445
391
        values = [(r[0], r[1], r[2], r[3], r[4]) for r in dlg._files_store]
446
 
        self.assertEqual([("", "", False, 'All Files', ''),
 
392
        self.assertEqual([(None, None, False, 'All Files', ''),
447
393
                          ('a-id', 'a', True, 'a', 'added'),
448
394
                          ('b-id', 'b', False, 'b/', 'added'),
449
395
                         ], values)
450
396
        # This file should also be selected in the file list, rather than the
451
397
        # 'All Files' selection
452
 
        self.assertEqual(
453
 
            (Gtk.TreePath(path=1), None), dlg._treeview_files.get_cursor())
 
398
        self.assertEqual(((1,), None), dlg._treeview_files.get_cursor())
454
399
 
455
400
    def test_diff_view(self):
456
401
        tree = self.make_branch_and_tree('tree')
464
409
        dlg = commit.CommitDialog(tree)
465
410
        diff_buffer = dlg._diff_view.buffer
466
411
        text = diff_buffer.get_text(diff_buffer.get_start_iter(),
467
 
                                    diff_buffer.get_end_iter(),
468
 
                                    True).splitlines(True)
 
412
                                    diff_buffer.get_end_iter()).splitlines(True)
469
413
 
470
414
        self.assertEqual("=== modified file 'a'\n", text[0])
471
415
        self.assertContainsRe(text[1],
516
460
        self.assertFalse(dlg._file_message_expander.get_expanded())
517
461
        self.assertFalse(dlg._file_message_expander.get_property('sensitive'))
518
462
 
519
 
        dlg._treeview_files.set_cursor(
520
 
            Gtk.TreePath(path=1), None, False)
 
463
        dlg._treeview_files.set_cursor((1,))
521
464
        self.assertEqual('Diff for a', dlg._diff_label.get_text())
522
465
        text = diff_buffer.get_text(diff_buffer.get_start_iter(),
523
 
                                    diff_buffer.get_end_iter(),
524
 
                                    True).splitlines(True)
 
466
                                    diff_buffer.get_end_iter()).splitlines(True)
525
467
        self.assertEqual("=== added file 'a'\n", text[0])
526
468
        self.assertContainsRe(text[1],
527
469
            r"--- a\t\d\d\d\d-\d\d-\d\d \d\d:\d\d:\d\d [+-]\d\d\d\d")
535
477
        self.assertTrue(dlg._file_message_expander.get_expanded())
536
478
        self.assertTrue(dlg._file_message_expander.get_property('sensitive'))
537
479
 
538
 
        dlg._treeview_files.set_cursor(
539
 
            Gtk.TreePath(path=2), None, False)
 
480
        dlg._treeview_files.set_cursor((2,))
540
481
        self.assertEqual('Diff for b', dlg._diff_label.get_text())
541
482
        text = diff_buffer.get_text(diff_buffer.get_start_iter(),
542
 
                                    diff_buffer.get_end_iter(),
543
 
                                    True).splitlines(True)
 
483
                                    diff_buffer.get_end_iter()).splitlines(True)
544
484
        self.assertEqual("=== added file 'b'\n", text[0])
545
485
        self.assertContainsRe(text[1],
546
486
            r"--- b\t\d\d\d\d-\d\d-\d\d \d\d:\d\d:\d\d [+-]\d\d\d\d")
554
494
        self.assertTrue(dlg._file_message_expander.get_expanded())
555
495
        self.assertTrue(dlg._file_message_expander.get_property('sensitive'))
556
496
 
557
 
        dlg._treeview_files.set_cursor(
558
 
            Gtk.TreePath(path=0), None, False)
 
497
        dlg._treeview_files.set_cursor((0,))
559
498
        self.assertEqual('Diff for All Files', dlg._diff_label.get_text())
560
499
        self.assertEqual('File commit message',
561
500
                         dlg._file_message_expander.get_label())
571
510
 
572
511
        def get_file_text():
573
512
            buf = dlg._file_message_text_view.get_buffer()
574
 
            return buf.get_text(
575
 
                buf.get_start_iter(), buf.get_end_iter(), True)
 
513
            return buf.get_text(buf.get_start_iter(), buf.get_end_iter())
576
514
 
577
515
        def get_saved_text(path):
578
516
            """Get the saved text for a given record."""
585
523
        self.assertFalse(dlg._file_message_expander.get_property('sensitive'))
586
524
        self.assertEqual('', get_file_text())
587
525
 
588
 
        dlg._treeview_files.set_cursor(
589
 
            Gtk.TreePath(path=1), None, False)
 
526
        dlg._treeview_files.set_cursor((1,))
590
527
        self.assertEqual('Commit message for a',
591
528
                         dlg._file_message_expander.get_label())
592
529
        self.assertTrue(dlg._file_message_expander.get_expanded())
599
536
        # We should have updated the ListStore with the new file commit info
600
537
        self.assertEqual('Some text\nfor a\n', get_saved_text(1))
601
538
 
602
 
        dlg._treeview_files.set_cursor(
603
 
            Gtk.TreePath(path=2), None, False)
 
539
        dlg._treeview_files.set_cursor((2,))
604
540
        self.assertEqual('Commit message for b/',
605
541
                         dlg._file_message_expander.get_label())
606
542
        self.assertTrue(dlg._file_message_expander.get_expanded())
611
547
        dlg._set_file_commit_message('More text\nfor b\n')
612
548
        # Now switch back to 'a'. The message should be saved, and the buffer
613
549
        # should be updated with the other text
614
 
        dlg._treeview_files.set_cursor(
615
 
            Gtk.TreePath(path=1), None, False)
 
550
        dlg._treeview_files.set_cursor((1,))
616
551
        self.assertEqual('More text\nfor b\n', get_saved_text(2))
617
552
        self.assertEqual('Commit message for a',
618
553
                         dlg._file_message_expander.get_label())
627
562
        tree.add(['a', 'b'], ['a-id', 'b-id'])
628
563
 
629
564
        dlg = commit.CommitDialog(tree)
630
 
        self.assertEqual([("", "", True),
 
565
        self.assertEqual([(None, None, True),
631
566
                          ('a-id', 'a', True),
632
567
                          ('b-id', 'b', True),
633
568
                         ], [(r[0], r[1], r[2]) for r in dlg._files_store])
638
573
        #       do with. So instead, we just call toggle directly, and assume
639
574
        #       that toggle is hooked in correctly
640
575
        # column = dlg._treeview_files.get_column(0)
641
 
        # renderer = column.get_cells()[0]
 
576
        # renderer = column.get_cell_renderers()[0]
642
577
 
643
578
        # Toggle a single entry should set just that entry to False
644
579
        dlg._toggle_commit(None, 1, dlg._files_store)
645
 
        self.assertEqual([("", "", True),
 
580
        self.assertEqual([(None, None, True),
646
581
                          ('a-id', 'a', False),
647
582
                          ('b-id', 'b', True),
648
583
                         ], [(r[0], r[1], r[2]) for r in dlg._files_store])
649
584
 
650
585
        # Toggling the main entry should set all entries
651
586
        dlg._toggle_commit(None, 0, dlg._files_store)
652
 
        self.assertEqual([("", "", False),
 
587
        self.assertEqual([(None, None, False),
653
588
                          ('a-id', 'a', False),
654
589
                          ('b-id', 'b', False),
655
590
                         ], [(r[0], r[1], r[2]) for r in dlg._files_store])
656
591
 
657
592
        dlg._toggle_commit(None, 2, dlg._files_store)
658
 
        self.assertEqual([("", "", False),
 
593
        self.assertEqual([(None, None, False),
659
594
                          ('a-id', 'a', False),
660
595
                          ('b-id', 'b', True),
661
596
                         ], [(r[0], r[1], r[2]) for r in dlg._files_store])
662
597
 
663
598
        dlg._toggle_commit(None, 0, dlg._files_store)
664
 
        self.assertEqual([("", "", True),
 
599
        self.assertEqual([(None, None, True),
665
600
                          ('a-id', 'a', True),
666
601
                          ('b-id', 'b', True),
667
602
                         ], [(r[0], r[1], r[2]) for r in dlg._files_store])
691
626
        dlg._commit_selected_radio.set_active(True)
692
627
        self.assertEqual((['a_file', 'b_dir'], []), dlg._get_specific_files())
693
628
 
694
 
        dlg._treeview_files.set_cursor(
695
 
            Gtk.TreePath(path=1), None, False)
 
629
        dlg._treeview_files.set_cursor((1,))
696
630
        dlg._set_file_commit_message('Test\nmessage\nfor a_file\n')
697
 
        dlg._treeview_files.set_cursor(
698
 
            Gtk.TreePath(path=2), None, False)
 
631
        dlg._treeview_files.set_cursor((2,))
699
632
        dlg._set_file_commit_message('message\nfor b_dir\n')
700
633
 
701
634
        self.assertEqual((['a_file', 'b_dir'],
711
644
                            'message':'message\nfor b_dir\n'},
712
645
                          ]), dlg._get_specific_files())
713
646
 
714
 
    def test_specific_files_sanitizes_messages(self):
715
 
        tree = self.make_branch_and_tree('tree')
716
 
        tree.branch.get_config().set_user_option('per_file_commits', 'true')
717
 
        self.build_tree(['tree/a_file', 'tree/b_dir/'])
718
 
        tree.add(['a_file', 'b_dir'], ['1a-id', '0b-id'])
719
 
 
720
 
        dlg = commit.CommitDialog(tree)
721
 
        dlg._commit_selected_radio.set_active(True)
722
 
        self.assertEqual((['a_file', 'b_dir'], []), dlg._get_specific_files())
723
 
 
724
 
        dlg._treeview_files.set_cursor(
725
 
            Gtk.TreePath(path=1), None, False)
726
 
        dlg._set_file_commit_message('Test\r\nmessage\rfor a_file\n')
727
 
        dlg._treeview_files.set_cursor(
728
 
            Gtk.TreePath(path=2), None, False)
729
 
        dlg._set_file_commit_message('message\r\nfor\nb_dir\r')
730
 
 
731
 
        self.assertEqual((['a_file', 'b_dir'],
732
 
                          [{'path':'a_file', 'file_id':'1a-id',
733
 
                            'message':'Test\nmessage\nfor a_file\n'},
734
 
                           {'path':'b_dir', 'file_id':'0b-id',
735
 
                            'message':'message\nfor\nb_dir\n'},
736
 
                          ]), dlg._get_specific_files())
737
 
 
738
 
 
739
 
class QuestionHelpers(object):
 
647
 
 
648
class TestCommitDialog_Commit(tests.TestCaseWithTransport):
 
649
    """Tests on the actual 'commit' button being pushed."""
740
650
 
741
651
    def _set_question_yes(self, dlg):
742
652
        """Set the dialog to answer YES to any questions."""
743
653
        self.questions = []
744
 
        def _question_yes(*args, **kwargs):
 
654
        def _question_yes(*args):
745
655
            self.questions.append(args)
746
656
            self.questions.append('YES')
747
 
            return Gtk.ResponseType.YES
 
657
            return gtk.RESPONSE_YES
748
658
        dlg._question_dialog = _question_yes
749
659
 
750
660
    def _set_question_no(self, dlg):
751
661
        """Set the dialog to answer NO to any questions."""
752
662
        self.questions = []
753
 
        def _question_no(*args, **kwargs):
 
663
        def _question_no(*args):
754
664
            self.questions.append(args)
755
665
            self.questions.append('NO')
756
 
            return Gtk.ResponseType.NO
 
666
            return gtk.RESPONSE_NO
757
667
        dlg._question_dialog = _question_no
758
668
 
759
 
 
760
 
class TestCommitDialog_Commit(tests.TestCaseWithTransport, QuestionHelpers):
761
 
    """Tests on the actual 'commit' button being pushed."""
762
 
 
763
669
    def test_bound_commit_local(self):
764
670
        tree = self.make_branch_and_tree('tree')
765
671
        self.build_tree(['tree/a'])
781
687
        self.assertEqual(last_rev, dlg.committed_revision_id)
782
688
        self.assertEqual(rev_id1, tree.branch.last_revision())
783
689
 
784
 
    def test_commit_global_sanitizes_message(self):
785
 
        tree = self.make_branch_and_tree('tree')
786
 
        self.build_tree(['tree/a'])
787
 
        tree.add(['a'], ['a-id'])
788
 
        rev_id1 = tree.commit('one')
789
 
 
790
 
        self.build_tree(['tree/b'])
791
 
        tree.add(['b'], ['b-id'])
792
 
        dlg = commit.CommitDialog(tree)
793
 
        # With the check box set, it should only effect the local branch
794
 
        dlg._set_global_commit_message('Commit\r\nmessage\rfoo\n')
795
 
        dlg._do_commit()
796
 
        rev = tree.branch.repository.get_revision(tree.last_revision())
797
 
        self.assertEqual('Commit\nmessage\nfoo\n', rev.message)
798
 
 
799
690
    def test_bound_commit_both(self):
800
691
        tree = self.make_branch_and_tree('tree')
801
692
        self.build_tree(['tree/a'])
817
708
        self.assertEqual(last_rev, dlg.committed_revision_id)
818
709
        self.assertEqual(last_rev, tree.branch.last_revision())
819
710
 
820
 
    def test_commit_empty_message(self):
 
711
    def test_commit_no_message(self):
821
712
        tree = self.make_branch_and_tree('tree')
822
713
        self.build_tree(['tree/a', 'tree/b'])
823
714
        tree.add(['a'], ['a-id'])
1038
929
 
1039
930
        dlg = commit.CommitDialog(tree)
1040
931
        dlg._commit_selected_radio.set_active(True) # enable partial
1041
 
        dlg._treeview_files.set_cursor(
1042
 
            Gtk.TreePath(path=1), None, False)
 
932
        dlg._treeview_files.set_cursor((1,))
1043
933
        dlg._set_file_commit_message('Message for A\n')
1044
 
        dlg._treeview_files.set_cursor(
1045
 
            Gtk.TreePath(path=2), None, False)
 
934
        dlg._treeview_files.set_cursor((2,))
1046
935
        dlg._set_file_commit_message('Message for B\n')
1047
936
        dlg._toggle_commit(None, 2, dlg._files_store) # unset 'b'
1048
937
        dlg._set_global_commit_message('Commit just "a"')
1054
943
        rev = tree.branch.repository.get_revision(rev_id2)
1055
944
        self.assertEqual('Commit just "a"', rev.message)
1056
945
        file_info = rev.properties['file-info']
1057
 
        self.assertEqual(u'ld7:file_id4:a-id'
1058
 
                         '7:message14:Message for A\n'
1059
 
                         '4:path1:a'
1060
 
                         'ee',
1061
 
                         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)
1062
950
        self.assertEqual([{'path':'a', 'file_id':'a-id',
1063
 
                           'message':'Message for A\n'},],
1064
 
                         bencode.bdecode(file_info.encode('UTF-8')))
 
951
                           'message':'Message for A\n'},
 
952
                         ], bencode.bdecode(file_info))
1065
953
 
1066
954
    def test_commit_messages_after_merge(self):
1067
955
        tree = self.make_branch_and_tree('tree')
1075
963
        tree.merge_from_branch(tree2.branch)
1076
964
 
1077
965
        dlg = commit.CommitDialog(tree)
1078
 
        dlg._treeview_files.set_cursor(
1079
 
            Gtk.TreePath(path=1), None, False) # 'a'
 
966
        dlg._treeview_files.set_cursor((1,)) # 'a'
1080
967
        dlg._set_file_commit_message('Message for A\n')
1081
968
        # No message for 'B'
1082
969
        dlg._set_global_commit_message('Merging from "tree2"\n')
1089
976
        self.assertEqual('Merging from "tree2"\n', rev.message)
1090
977
        self.assertEqual([rev_id1, rev_id2], rev.parent_ids)
1091
978
        file_info = rev.properties['file-info']
1092
 
        self.assertEqual(u'ld7:file_id4:a-id'
1093
 
                         '7:message14:Message for A\n'
1094
 
                         '4:path1:a'
1095
 
                         'ee',
1096
 
                         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)
1097
983
        self.assertEqual([{'path':'a', 'file_id':'a-id',
1098
 
                           'message':'Message for A\n'},],
1099
 
                         bencode.bdecode(file_info.encode('UTF-8')))
 
984
                           'message':'Message for A\n'},
 
985
                         ], bencode.bdecode(file_info))
1100
986
 
1101
987
    def test_commit_unicode_messages(self):
1102
 
        self.requireFeature(UnicodeFilenameFeature)
 
988
        self.requireFeature(tests.UnicodeFilenameFeature)
1103
989
 
1104
990
        tree = self.make_branch_and_tree('tree')
1105
991
        tree.branch.get_config().set_user_option('per_file_commits', 'true')
1107
993
        tree.add(['a', u'\u03a9'], ['a-id', 'omega-id'])
1108
994
 
1109
995
        dlg = commit.CommitDialog(tree)
1110
 
        dlg._treeview_files.set_cursor(
1111
 
            Gtk.TreePath(path=1), None, False) # 'a'
 
996
        dlg._treeview_files.set_cursor((1,)) # 'a'
1112
997
        dlg._set_file_commit_message(u'Test \xfan\xecc\xf6de\n')
1113
 
        dlg._treeview_files.set_cursor(
1114
 
            Gtk.TreePath(path=2), None, False) # omega
 
998
        dlg._treeview_files.set_cursor((2,)) # omega
1115
999
        dlg._set_file_commit_message(u'\u03a9 is the end of all things.\n')
1116
1000
        dlg._set_global_commit_message(u'\u03a9 and \xfan\xecc\xf6de\n')
1117
1001
 
1146
1030
                          {'path':u'\u03a9', 'file_id':'omega-id',
1147
1031
                           'message':u'\u03a9 is the end of all things.\n'},
1148
1032
                         ], file_info_decoded)
1149
 
 
1150
 
 
1151
 
class TestSanitizeMessage(tests.TestCase):
1152
 
 
1153
 
    def assertSanitize(self, expected, original):
1154
 
        self.assertEqual(expected,
1155
 
                         commit._sanitize_and_decode_message(original))
1156
 
 
1157
 
    def test_untouched(self):
1158
 
        self.assertSanitize('foo\nbar\nbaz\n', 'foo\nbar\nbaz\n')
1159
 
 
1160
 
    def test_converts_cr_to_lf(self):
1161
 
        self.assertSanitize('foo\nbar\nbaz\n', 'foo\rbar\rbaz\r')
1162
 
 
1163
 
    def test_converts_crlf_to_lf(self):
1164
 
        self.assertSanitize('foo\nbar\nbaz\n', 'foo\r\nbar\r\nbaz\r\n')
1165
 
 
1166
 
    def test_converts_mixed_to_lf(self):
1167
 
        self.assertSanitize('foo\nbar\nbaz\n', 'foo\r\nbar\rbaz\n')
1168
 
 
1169
 
 
1170
 
class TestSavedCommitMessages(tests.TestCaseWithTransport):
1171
 
 
1172
 
    def setUp(self):
1173
 
        super(TestSavedCommitMessages, self).setUp()
1174
 
        # Install our hook
1175
 
        branch.Branch.hooks.install_named_hook(
1176
 
            'post_uncommit', commitmsgs.save_commit_messages, None)
1177
 
 
1178
 
    def _get_file_info_dict(self, rank):
1179
 
        file_info = [dict(path='a', file_id='a-id', message='a msg %d' % rank),
1180
 
                     dict(path='b', file_id='b-id', message='b msg %d' % rank)]
1181
 
        return file_info
1182
 
 
1183
 
    def _get_file_info_revprops(self, rank):
1184
 
        file_info_prop = self._get_file_info_dict(rank)
1185
 
        return {'file-info': bencode.bencode(file_info_prop).decode('UTF-8')}
1186
 
 
1187
 
    def _get_commit_message(self):
1188
 
        return self.config.get_user_option('gtk_global_commit_message')
1189
 
 
1190
 
    def _get_file_commit_messages(self):
1191
 
        return self.config.get_user_option('gtk_file_commit_messages')
1192
 
 
1193
 
 
1194
 
class TestUncommitHook(TestSavedCommitMessages):
1195
 
 
1196
 
    def setUp(self):
1197
 
        super(TestUncommitHook, self).setUp()
1198
 
        self.tree = self.make_branch_and_tree('tree')
1199
 
        self.config = self.tree.branch.get_config()
1200
 
        self.build_tree(['tree/a', 'tree/b'])
1201
 
        self.tree.add(['a'], ['a-id'])
1202
 
        self.tree.add(['b'], ['b-id'])
1203
 
        rev1 = self.tree.commit('one', rev_id='one-id',
1204
 
                                revprops=self._get_file_info_revprops(1))
1205
 
        rev2 = self.tree.commit('two', rev_id='two-id',
1206
 
                                revprops=self._get_file_info_revprops(2))
1207
 
        rev3 = self.tree.commit('three', rev_id='three-id',
1208
 
                                revprops=self._get_file_info_revprops(3))
1209
 
 
1210
 
    def test_uncommit_one_by_one(self):
1211
 
        uncommit.uncommit(self.tree.branch, tree=self.tree)
1212
 
        self.assertEquals(u'three', self._get_commit_message())
1213
 
        self.assertEquals(u'd4:a-id7:a msg 34:b-id7:b msg 3e',
1214
 
                          self._get_file_commit_messages())
1215
 
 
1216
 
        uncommit.uncommit(self.tree.branch, tree=self.tree)
1217
 
        self.assertEquals(u'two\n******\nthree', self._get_commit_message())
1218
 
        self.assertEquals(u'd4:a-id22:a msg 2\n******\na msg 3'
1219
 
                          '4:b-id22:b msg 2\n******\nb msg 3e',
1220
 
                          self._get_file_commit_messages())
1221
 
 
1222
 
        uncommit.uncommit(self.tree.branch, tree=self.tree)
1223
 
        self.assertEquals(u'one\n******\ntwo\n******\nthree',
1224
 
                          self._get_commit_message())
1225
 
        self.assertEquals(u'd4:a-id37:a msg 1\n******\na msg 2\n******\na msg 3'
1226
 
                          '4:b-id37:b msg 1\n******\nb msg 2\n******\nb msg 3e',
1227
 
                          self._get_file_commit_messages())
1228
 
 
1229
 
    def test_uncommit_all_at_once(self):
1230
 
        uncommit.uncommit(self.tree.branch, tree=self.tree, revno=1)
1231
 
        self.assertEquals(u'one\n******\ntwo\n******\nthree',
1232
 
                          self._get_commit_message())
1233
 
        self.assertEquals(u'd4:a-id37:a msg 1\n******\na msg 2\n******\na msg 3'
1234
 
                          '4:b-id37:b msg 1\n******\nb msg 2\n******\nb msg 3e',
1235
 
                          self._get_file_commit_messages())
1236
 
 
1237
 
 
1238
 
class TestReusingSavedCommitMessages(TestSavedCommitMessages, QuestionHelpers):
1239
 
 
1240
 
    def setUp(self):
1241
 
        super(TestReusingSavedCommitMessages, self).setUp()
1242
 
        self.tree = self.make_branch_and_tree('tree')
1243
 
        self.config = self.tree.branch.get_config()
1244
 
        self.config.set_user_option('per_file_commits', 'true')
1245
 
        self.build_tree(['tree/a', 'tree/b'])
1246
 
        self.tree.add(['a'], ['a-id'])
1247
 
        self.tree.add(['b'], ['b-id'])
1248
 
        rev1 = self.tree.commit('one', revprops=self._get_file_info_revprops(1))
1249
 
        rev2 = self.tree.commit('two', revprops=self._get_file_info_revprops(2))
1250
 
        uncommit.uncommit(self.tree.branch, tree=self.tree)
1251
 
        self.build_tree_contents([('tree/a', 'new a content\n'),
1252
 
                                  ('tree/b', 'new b content'),])
1253
 
 
1254
 
    def _get_commit_dialog(self, tree):
1255
 
        # Ensure we will never use a dialog that can actually prompt the user
1256
 
        # during the test suite. Test *can* and *should* override with the
1257
 
        # correct question dialog type.
1258
 
        dlg = commit.CommitDialog(tree)
1259
 
        self._set_question_no(dlg)
1260
 
        return dlg
1261
 
 
1262
 
    def test_setup_saved_messages(self):
1263
 
        # Check the initial setup
1264
 
        self.assertEquals(u'two', self._get_commit_message())
1265
 
        self.assertEquals(u'd4:a-id7:a msg 24:b-id7:b msg 2e',
1266
 
                          self._get_file_commit_messages())
1267
 
 
1268
 
    def test_messages_are_reloaded(self):
1269
 
        dlg = self._get_commit_dialog(self.tree)
1270
 
        self.assertEquals(u'two', dlg._get_global_commit_message())
1271
 
        self.assertEquals(([u'a', u'b'],
1272
 
                           [{ 'path': 'a',
1273
 
                             'file_id': 'a-id', 'message': 'a msg 2',},
1274
 
                           {'path': 'b',
1275
 
                            'file_id': 'b-id', 'message': 'b msg 2',}],),
1276
 
                          dlg._get_specific_files())
1277
 
 
1278
 
    def test_messages_are_consumed(self):
1279
 
        dlg = self._get_commit_dialog(self.tree)
1280
 
        dlg._do_commit()
1281
 
        self.assertEquals(u'', self._get_commit_message())
1282
 
        self.assertEquals(u'de', self._get_file_commit_messages())
1283
 
 
1284
 
    def test_messages_are_saved_on_cancel_if_required(self):
1285
 
        dlg = self._get_commit_dialog(self.tree)
1286
 
        self._set_question_yes(dlg) # Save messages
1287
 
        dlg._do_cancel()
1288
 
        self.assertEquals(u'two', self._get_commit_message())
1289
 
        self.assertEquals(u'd4:a-id7:a msg 24:b-id7:b msg 2e',
1290
 
                          self._get_file_commit_messages())
1291
 
 
1292
 
    def test_messages_are_cleared_on_cancel_if_required(self):
1293
 
        dlg = self._get_commit_dialog(self.tree)
1294
 
        self._set_question_no(dlg) # Don't save messages
1295
 
        dlg._do_cancel()
1296
 
        self.assertEquals(u'', self._get_commit_message())
1297
 
        self.assertEquals(u'de',
1298
 
                          self._get_file_commit_messages())