/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: Markus Korn
  • Date: 2009-03-05 16:50:39 UTC
  • mto: (635.2.4 trunk)
  • mto: This revision was merged to the branch mainline in revision 639.
  • Revision ID: thekorn@gmx.de-20090305165039-h6xh48wr9lwe1661
https://launchpad.net/bugs/294396
* register BranchSelectionBox() as a gobject type to fix (LP: #294396)

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/test_commit.py
17
17
"""Test the Commit functionality."""
18
18
 
19
19
import os
20
 
import subprocess
21
 
from tempfile import NamedTemporaryFile
22
20
 
23
 
from gi.repository import Gtk
 
21
import gtk
24
22
 
25
23
from bzrlib import (
26
 
    branch,
27
24
    tests,
28
 
    uncommit,
 
25
    revision,
29
26
    )
30
 
try:
31
 
    from bzrlib.tests.features import UnicodeFilenameFeature
32
 
except ImportError: # bzr < 2.5
33
 
    from bzrlib.tests import UnicodeFilenameFeature
34
 
from bzrlib import bencode
 
27
from bzrlib.util import bencode
35
28
 
36
 
from bzrlib.plugins.gtk import (
37
 
    commit,
38
 
    commitmsgs,
39
 
    )
40
 
from bzrlib.plugins.gtk.commitmsgs import SavedCommitMessagesManager
41
 
from bzrlib.plugins.gtk.tests import MockMethod
 
29
from bzrlib.plugins.gtk import commit
42
30
 
43
31
 
44
32
# TODO: All we need is basic ancestry code to test this, we shouldn't need a
50
38
        tree = self.make_branch_and_tree('.')
51
39
        tree.commit('one')
52
40
 
53
 
        self.addCleanup(tree.lock_read().unlock)
54
 
        self.assertEquals([], list(commit.pending_revisions(tree)))
 
41
        self.assertIs(None, commit.pending_revisions(tree))
55
42
 
56
43
    def test_pending_revisions_simple(self):
57
44
        tree = self.make_branch_and_tree('tree')
61
48
        tree.merge_from_branch(tree2.branch)
62
49
        self.assertEqual([rev_id1, rev_id2], tree.get_parent_ids())
63
50
 
64
 
        self.addCleanup(tree.lock_read().unlock)
65
 
        pending_revisions = list(commit.pending_revisions(tree))
 
51
        pending_revisions = commit.pending_revisions(tree)
66
52
        # One primary merge
67
53
        self.assertEqual(1, len(pending_revisions))
68
54
        # Revision == rev_id2
80
66
        tree.merge_from_branch(tree2.branch)
81
67
        self.assertEqual([rev_id1, rev_id4], tree.get_parent_ids())
82
68
 
83
 
        self.addCleanup(tree.lock_read().unlock)
84
 
        pending_revisions = list(commit.pending_revisions(tree))
 
69
        pending_revisions = commit.pending_revisions(tree)
85
70
        # One primary merge
86
71
        self.assertEqual(1, len(pending_revisions))
87
72
        # Revision == rev_id2
101
86
        rev_id4 = tree3.commit('four')
102
87
        rev_id5 = tree3.commit('five')
103
88
        tree.merge_from_branch(tree2.branch)
104
 
        tree.merge_from_branch(tree3.branch, force=True)
 
89
        tree.merge_from_branch(tree3.branch)
105
90
        self.assertEqual([rev_id1, rev_id3, rev_id5], tree.get_parent_ids())
106
91
 
107
 
        self.addCleanup(tree.lock_read().unlock)
108
 
        pending_revisions = list(commit.pending_revisions(tree))
 
92
        pending_revisions = commit.pending_revisions(tree)
109
93
        # Two primary merges
110
94
        self.assertEqual(2, len(pending_revisions))
111
95
        # Revision == rev_id2
148
132
 
149
133
class TestCommitDialogSimple(tests.TestCaseWithTransport):
150
134
 
151
 
    def test_init(self):
152
 
        MockMethod.bind(self, CommitDialogNoWidgets, 'setup_params')
153
 
        MockMethod.bind(self, CommitDialogNoWidgets, 'construct')
154
 
        MockMethod.bind(self, CommitDialogNoWidgets, 'fill_in_data')
155
 
 
156
 
        tree = self.make_branch_and_tree('tree')
157
 
        rev_id = tree.commit('first')
158
 
        dlg = CommitDialogNoWidgets(tree)
159
 
        self.assertIs(tree, dlg._wt)
160
 
        self.assertIs(None, dlg._selected)
161
 
        self.assertTrue(dlg._enable_per_file_commits)
162
 
        self.assertTrue(dlg._commit_all_changes)
163
 
        self.assertIs(None, dlg.committed_revision_id)
164
 
        self.assertIs(None, dlg._last_selected_file)
165
 
        self.assertIsInstance(
166
 
            dlg._saved_commit_messages_manager, SavedCommitMessagesManager)
167
 
        self.assertTrue(CommitDialogNoWidgets.setup_params.called)
168
 
        self.assertTrue(CommitDialogNoWidgets.construct.called)
169
 
        self.assertTrue(CommitDialogNoWidgets.fill_in_data.called)
170
 
 
171
135
    def test_setup_parameters_no_pending(self):
172
136
        tree = self.make_branch_and_tree('tree')
173
137
        rev_id = tree.commit('first')
174
138
 
175
139
        dlg = CommitDialogNoWidgets(tree)
176
140
        self.assertEqual(rev_id, dlg._basis_tree.get_revision_id())
177
 
        self.assertEquals([], dlg._pending)
 
141
        self.assertIs(None, dlg._pending)
178
142
        self.assertFalse(dlg._is_checkout)
179
143
 
180
144
    def test_setup_parameters_checkout(self):
185
149
 
186
150
        dlg = CommitDialogNoWidgets(tree2)
187
151
        self.assertEqual(rev_id, dlg._basis_tree.get_revision_id())
188
 
        self.assertEquals([], dlg._pending)
 
152
        self.assertIs(None, dlg._pending)
189
153
        self.assertTrue(dlg._is_checkout)
190
154
 
191
155
    def test_setup_parameters_pending(self):
216
180
        self.assertEqual([], delta.removed)
217
181
        self.assertEqual([(u'a', 'a-id', 'file')], delta.added)
218
182
 
219
 
    def test_on_treeview_files_cursor_changed_no_selection(self):
220
 
        MockMethod.bind(self, CommitDialogNoWidgets, '_update_per_file_info')
221
 
        tree = self.make_branch_and_tree('tree')
222
 
        rev_id = tree.commit('first')
223
 
        dlg = CommitDialogNoWidgets(tree)
224
 
        treeview = Gtk.TreeView()
225
 
        dlg._on_treeview_files_cursor_changed(treeview)
226
 
        self.assertFalse(CommitDialogNoWidgets._update_per_file_info.called)
227
 
 
228
 
    def test_on_treeview_files_cursor_changed_with_destroyed_treeview(self):
229
 
        MockMethod.bind(self, CommitDialogNoWidgets, '_update_per_file_info')
230
 
        tree = self.make_branch_and_tree('tree')
231
 
        rev_id = tree.commit('first')
232
 
        dlg = CommitDialogNoWidgets(tree)
233
 
        treeview = Gtk.TreeView()
234
 
        treeview.destroy()
235
 
        dlg._on_treeview_files_cursor_changed(treeview)
236
 
        self.assertFalse(CommitDialogNoWidgets._update_per_file_info.called)
237
 
 
238
 
    def test_get_line_height(self):
239
 
        tree = self.make_branch_and_tree('tree')
240
 
        dlg = CommitDialogNoWidgets(tree)
241
 
        textview = Gtk.TextView()
242
 
        line_height = dlg.get_line_height(textview)
243
 
        self.assertIsInstance(line_height, int)
244
 
 
245
183
 
246
184
class TestCommitDialog(tests.TestCaseWithTransport):
247
185
 
269
207
 
270
208
        commit_col = dlg._treeview_files.get_column(0)
271
209
        self.assertEqual('Commit', commit_col.get_title())
272
 
        renderer = commit_col.get_cells()[0]
 
210
        renderer = commit_col.get_cell_renderers()[0]
273
211
        self.assertTrue(renderer.get_property('activatable'))
274
212
 
275
213
        self.assertEqual('Commit all changes',
294
232
 
295
233
        commit_col = dlg._treeview_files.get_column(0)
296
234
        self.assertEqual('Commit*', commit_col.get_title())
297
 
        renderer = commit_col.get_cells()[0]
 
235
        renderer = commit_col.get_cell_renderers()[0]
298
236
        self.assertFalse(renderer.get_property('activatable'))
299
237
 
300
238
        values = [(r[0], r[1], r[2], r[3]) for r in dlg._pending_store]
328
266
                               committer='Jerry Foo <jerry@foo.com>',
329
267
                               timestamp=1191372278.05,
330
268
                               timezone=+7200)
331
 
        tree.merge_from_branch(tree3.branch, force=True)
 
269
        tree.merge_from_branch(tree3.branch)
332
270
 
333
271
        dlg = commit.CommitDialog(tree)
334
272
        # TODO: assert that the pending box is set to show
346
284
 
347
285
        dlg = commit.CommitDialog(tree)
348
286
        values = [(r[0], r[1], r[2], r[3], r[4]) for r in dlg._files_store]
349
 
        self.assertEqual([("", "", True, 'All Files', ''),
 
287
        self.assertEqual([(None, None, True, 'All Files', ''),
350
288
                          ('a-id', 'a', True, 'a', 'added'),
351
289
                          ('b-id', 'b', True, 'b/', 'added'),
352
290
                          ('c-id', 'b/c', True, 'b/c', 'added'),
363
301
 
364
302
        dlg = commit.CommitDialog(tree)
365
303
        values = [(r[0], r[1], r[2], r[3], r[4]) for r in dlg._files_store]
366
 
        self.assertEqual([("", "", True, 'All Files', ''),
 
304
        self.assertEqual([(None, None, True, 'All Files', ''),
367
305
                          ('b-id', 'd', True, 'b/ => d/', 'renamed'),
368
306
                          ('a-id', 'd/a', True, 'a => d/a', 'renamed'),
369
307
                         ], values)
378
316
 
379
317
        dlg = commit.CommitDialog(tree)
380
318
        values = [(r[0], r[1], r[2], r[3], r[4]) for r in dlg._files_store]
381
 
        self.assertEqual([("", "", True, 'All Files', ''),
 
319
        self.assertEqual([(None, None, True, 'All Files', ''),
382
320
                          ('a-id', 'a', True, 'a', 'modified'),
383
321
                         ], values)
384
322
 
398
336
 
399
337
        dlg = commit.CommitDialog(tree)
400
338
        values = [(r[0], r[1], r[2], r[3], r[4]) for r in dlg._files_store]
401
 
        self.assertEqual([("", "", True, 'All Files', ''),
 
339
        self.assertEqual([(None, None, True, 'All Files', ''),
402
340
                          ('b-id', 'd', True, 'b/ => d/', 'renamed'),
403
341
                          ('a-id', 'd/a', True, 'a => d/a', 'renamed and modified'),
404
342
                          ('c-id', 'd/c', True, 'd/c', 'modified'),
421
359
 
422
360
        dlg = commit.CommitDialog(tree)
423
361
        values = [(r[0], r[1], r[2], r[3], r[4]) for r in dlg._files_store]
424
 
        self.assertEqual([("", "", True, 'All Files', ''),
 
362
        self.assertEqual([(None, None, True, 'All Files', ''),
425
363
                          ('a-id', 'a', True, 'a => a/', 'kind changed'),
426
364
                          # ('b-id', 'c', True, 'b => c/', 'renamed and modified'),
427
365
                         ], values)
437
375
 
438
376
        dlg = commit.CommitDialog(tree)
439
377
        values = [(r[0], r[1], r[2], r[3], r[4]) for r in dlg._files_store]
440
 
        self.assertEqual([("", "", True, 'All Files', ''),
 
378
        self.assertEqual([(None, None, True, 'All Files', ''),
441
379
                          ('a-id', 'a', True, 'a', 'removed'),
442
380
                          ('b-id', 'b', True, 'b/', 'removed'),
443
381
                         ], values)
444
382
        # All Files should be selected
445
 
        self.assertEqual(
446
 
            (Gtk.TreePath(path=0), None), dlg._treeview_files.get_cursor())
 
383
        self.assertEqual(((0,), None), dlg._treeview_files.get_cursor())
447
384
 
448
385
    def test_filelist_with_selected(self):
449
386
        tree = self.make_branch_and_tree('tree')
452
389
 
453
390
        dlg = commit.CommitDialog(tree, selected='a')
454
391
        values = [(r[0], r[1], r[2], r[3], r[4]) for r in dlg._files_store]
455
 
        self.assertEqual([("", "", False, 'All Files', ''),
 
392
        self.assertEqual([(None, None, False, 'All Files', ''),
456
393
                          ('a-id', 'a', True, 'a', 'added'),
457
394
                          ('b-id', 'b', False, 'b/', 'added'),
458
395
                         ], values)
459
396
        # This file should also be selected in the file list, rather than the
460
397
        # 'All Files' selection
461
 
        self.assertEqual(
462
 
            (Gtk.TreePath(path=1), None), dlg._treeview_files.get_cursor())
 
398
        self.assertEqual(((1,), None), dlg._treeview_files.get_cursor())
463
399
 
464
400
    def test_diff_view(self):
465
401
        tree = self.make_branch_and_tree('tree')
473
409
        dlg = commit.CommitDialog(tree)
474
410
        diff_buffer = dlg._diff_view.buffer
475
411
        text = diff_buffer.get_text(diff_buffer.get_start_iter(),
476
 
                                    diff_buffer.get_end_iter(),
477
 
                                    True).splitlines(True)
 
412
                                    diff_buffer.get_end_iter()).splitlines(True)
478
413
 
479
414
        self.assertEqual("=== modified file 'a'\n", text[0])
480
415
        self.assertContainsRe(text[1],
525
460
        self.assertFalse(dlg._file_message_expander.get_expanded())
526
461
        self.assertFalse(dlg._file_message_expander.get_property('sensitive'))
527
462
 
528
 
        dlg._treeview_files.set_cursor(
529
 
            Gtk.TreePath(path=1), None, False)
 
463
        dlg._treeview_files.set_cursor((1,))
530
464
        self.assertEqual('Diff for a', dlg._diff_label.get_text())
531
465
        text = diff_buffer.get_text(diff_buffer.get_start_iter(),
532
 
                                    diff_buffer.get_end_iter(),
533
 
                                    True).splitlines(True)
 
466
                                    diff_buffer.get_end_iter()).splitlines(True)
534
467
        self.assertEqual("=== added file 'a'\n", text[0])
535
468
        self.assertContainsRe(text[1],
536
469
            r"--- a\t\d\d\d\d-\d\d-\d\d \d\d:\d\d:\d\d [+-]\d\d\d\d")
544
477
        self.assertTrue(dlg._file_message_expander.get_expanded())
545
478
        self.assertTrue(dlg._file_message_expander.get_property('sensitive'))
546
479
 
547
 
        dlg._treeview_files.set_cursor(
548
 
            Gtk.TreePath(path=2), None, False)
 
480
        dlg._treeview_files.set_cursor((2,))
549
481
        self.assertEqual('Diff for b', dlg._diff_label.get_text())
550
482
        text = diff_buffer.get_text(diff_buffer.get_start_iter(),
551
 
                                    diff_buffer.get_end_iter(),
552
 
                                    True).splitlines(True)
 
483
                                    diff_buffer.get_end_iter()).splitlines(True)
553
484
        self.assertEqual("=== added file 'b'\n", text[0])
554
485
        self.assertContainsRe(text[1],
555
486
            r"--- b\t\d\d\d\d-\d\d-\d\d \d\d:\d\d:\d\d [+-]\d\d\d\d")
563
494
        self.assertTrue(dlg._file_message_expander.get_expanded())
564
495
        self.assertTrue(dlg._file_message_expander.get_property('sensitive'))
565
496
 
566
 
        dlg._treeview_files.set_cursor(
567
 
            Gtk.TreePath(path=0), None, False)
 
497
        dlg._treeview_files.set_cursor((0,))
568
498
        self.assertEqual('Diff for All Files', dlg._diff_label.get_text())
569
499
        self.assertEqual('File commit message',
570
500
                         dlg._file_message_expander.get_label())
580
510
 
581
511
        def get_file_text():
582
512
            buf = dlg._file_message_text_view.get_buffer()
583
 
            return buf.get_text(
584
 
                buf.get_start_iter(), buf.get_end_iter(), True)
 
513
            return buf.get_text(buf.get_start_iter(), buf.get_end_iter())
585
514
 
586
515
        def get_saved_text(path):
587
516
            """Get the saved text for a given record."""
594
523
        self.assertFalse(dlg._file_message_expander.get_property('sensitive'))
595
524
        self.assertEqual('', get_file_text())
596
525
 
597
 
        dlg._treeview_files.set_cursor(
598
 
            Gtk.TreePath(path=1), None, False)
 
526
        dlg._treeview_files.set_cursor((1,))
599
527
        self.assertEqual('Commit message for a',
600
528
                         dlg._file_message_expander.get_label())
601
529
        self.assertTrue(dlg._file_message_expander.get_expanded())
608
536
        # We should have updated the ListStore with the new file commit info
609
537
        self.assertEqual('Some text\nfor a\n', get_saved_text(1))
610
538
 
611
 
        dlg._treeview_files.set_cursor(
612
 
            Gtk.TreePath(path=2), None, False)
 
539
        dlg._treeview_files.set_cursor((2,))
613
540
        self.assertEqual('Commit message for b/',
614
541
                         dlg._file_message_expander.get_label())
615
542
        self.assertTrue(dlg._file_message_expander.get_expanded())
620
547
        dlg._set_file_commit_message('More text\nfor b\n')
621
548
        # Now switch back to 'a'. The message should be saved, and the buffer
622
549
        # should be updated with the other text
623
 
        dlg._treeview_files.set_cursor(
624
 
            Gtk.TreePath(path=1), None, False)
 
550
        dlg._treeview_files.set_cursor((1,))
625
551
        self.assertEqual('More text\nfor b\n', get_saved_text(2))
626
552
        self.assertEqual('Commit message for a',
627
553
                         dlg._file_message_expander.get_label())
636
562
        tree.add(['a', 'b'], ['a-id', 'b-id'])
637
563
 
638
564
        dlg = commit.CommitDialog(tree)
639
 
        self.assertEqual([("", "", True),
 
565
        self.assertEqual([(None, None, True),
640
566
                          ('a-id', 'a', True),
641
567
                          ('b-id', 'b', True),
642
568
                         ], [(r[0], r[1], r[2]) for r in dlg._files_store])
647
573
        #       do with. So instead, we just call toggle directly, and assume
648
574
        #       that toggle is hooked in correctly
649
575
        # column = dlg._treeview_files.get_column(0)
650
 
        # renderer = column.get_cells()[0]
 
576
        # renderer = column.get_cell_renderers()[0]
651
577
 
652
578
        # Toggle a single entry should set just that entry to False
653
579
        dlg._toggle_commit(None, 1, dlg._files_store)
654
 
        self.assertEqual([("", "", True),
 
580
        self.assertEqual([(None, None, True),
655
581
                          ('a-id', 'a', False),
656
582
                          ('b-id', 'b', True),
657
583
                         ], [(r[0], r[1], r[2]) for r in dlg._files_store])
658
584
 
659
585
        # Toggling the main entry should set all entries
660
586
        dlg._toggle_commit(None, 0, dlg._files_store)
661
 
        self.assertEqual([("", "", False),
 
587
        self.assertEqual([(None, None, False),
662
588
                          ('a-id', 'a', False),
663
589
                          ('b-id', 'b', False),
664
590
                         ], [(r[0], r[1], r[2]) for r in dlg._files_store])
665
591
 
666
592
        dlg._toggle_commit(None, 2, dlg._files_store)
667
 
        self.assertEqual([("", "", False),
 
593
        self.assertEqual([(None, None, False),
668
594
                          ('a-id', 'a', False),
669
595
                          ('b-id', 'b', True),
670
596
                         ], [(r[0], r[1], r[2]) for r in dlg._files_store])
671
597
 
672
598
        dlg._toggle_commit(None, 0, dlg._files_store)
673
 
        self.assertEqual([("", "", True),
 
599
        self.assertEqual([(None, None, True),
674
600
                          ('a-id', 'a', True),
675
601
                          ('b-id', 'b', True),
676
602
                         ], [(r[0], r[1], r[2]) for r in dlg._files_store])
700
626
        dlg._commit_selected_radio.set_active(True)
701
627
        self.assertEqual((['a_file', 'b_dir'], []), dlg._get_specific_files())
702
628
 
703
 
        dlg._treeview_files.set_cursor(
704
 
            Gtk.TreePath(path=1), None, False)
 
629
        dlg._treeview_files.set_cursor((1,))
705
630
        dlg._set_file_commit_message('Test\nmessage\nfor a_file\n')
706
 
        dlg._treeview_files.set_cursor(
707
 
            Gtk.TreePath(path=2), None, False)
 
631
        dlg._treeview_files.set_cursor((2,))
708
632
        dlg._set_file_commit_message('message\nfor b_dir\n')
709
633
 
710
634
        self.assertEqual((['a_file', 'b_dir'],
730
654
        dlg._commit_selected_radio.set_active(True)
731
655
        self.assertEqual((['a_file', 'b_dir'], []), dlg._get_specific_files())
732
656
 
733
 
        dlg._treeview_files.set_cursor(
734
 
            Gtk.TreePath(path=1), None, False)
 
657
        dlg._treeview_files.set_cursor((1,))
735
658
        dlg._set_file_commit_message('Test\r\nmessage\rfor a_file\n')
736
 
        dlg._treeview_files.set_cursor(
737
 
            Gtk.TreePath(path=2), None, False)
 
659
        dlg._treeview_files.set_cursor((2,))
738
660
        dlg._set_file_commit_message('message\r\nfor\nb_dir\r')
739
661
 
740
662
        self.assertEqual((['a_file', 'b_dir'],
745
667
                          ]), dlg._get_specific_files())
746
668
 
747
669
 
748
 
class QuestionHelpers(object):
 
670
class TestCommitDialog_Commit(tests.TestCaseWithTransport):
 
671
    """Tests on the actual 'commit' button being pushed."""
749
672
 
750
673
    def _set_question_yes(self, dlg):
751
674
        """Set the dialog to answer YES to any questions."""
753
676
        def _question_yes(*args, **kwargs):
754
677
            self.questions.append(args)
755
678
            self.questions.append('YES')
756
 
            return Gtk.ResponseType.YES
 
679
            return gtk.RESPONSE_YES
757
680
        dlg._question_dialog = _question_yes
758
681
 
759
682
    def _set_question_no(self, dlg):
762
685
        def _question_no(*args, **kwargs):
763
686
            self.questions.append(args)
764
687
            self.questions.append('NO')
765
 
            return Gtk.ResponseType.NO
 
688
            return gtk.RESPONSE_NO
766
689
        dlg._question_dialog = _question_no
767
690
 
768
 
 
769
 
class TestCommitDialog_Commit(tests.TestCaseWithTransport, QuestionHelpers):
770
 
    """Tests on the actual 'commit' button being pushed."""
771
 
 
772
691
    def test_bound_commit_local(self):
773
692
        tree = self.make_branch_and_tree('tree')
774
693
        self.build_tree(['tree/a'])
1047
966
 
1048
967
        dlg = commit.CommitDialog(tree)
1049
968
        dlg._commit_selected_radio.set_active(True) # enable partial
1050
 
        dlg._treeview_files.set_cursor(
1051
 
            Gtk.TreePath(path=1), None, False)
 
969
        dlg._treeview_files.set_cursor((1,))
1052
970
        dlg._set_file_commit_message('Message for A\n')
1053
 
        dlg._treeview_files.set_cursor(
1054
 
            Gtk.TreePath(path=2), None, False)
 
971
        dlg._treeview_files.set_cursor((2,))
1055
972
        dlg._set_file_commit_message('Message for B\n')
1056
973
        dlg._toggle_commit(None, 2, dlg._files_store) # unset 'b'
1057
974
        dlg._set_global_commit_message('Commit just "a"')
1063
980
        rev = tree.branch.repository.get_revision(rev_id2)
1064
981
        self.assertEqual('Commit just "a"', rev.message)
1065
982
        file_info = rev.properties['file-info']
1066
 
        self.assertEqual(u'ld7:file_id4:a-id'
1067
 
                         '7:message14:Message for A\n'
1068
 
                         '4:path1:a'
1069
 
                         'ee',
1070
 
                         file_info)
 
983
        self.assertEqual('ld7:file_id4:a-id'
 
984
                           '7:message14:Message for A\n'
 
985
                           '4:path1:a'
 
986
                         'ee', file_info)
1071
987
        self.assertEqual([{'path':'a', 'file_id':'a-id',
1072
 
                           'message':'Message for A\n'},],
1073
 
                         bencode.bdecode(file_info.encode('UTF-8')))
 
988
                           'message':'Message for A\n'},
 
989
                         ], bencode.bdecode(file_info))
1074
990
 
1075
991
    def test_commit_messages_after_merge(self):
1076
992
        tree = self.make_branch_and_tree('tree')
1084
1000
        tree.merge_from_branch(tree2.branch)
1085
1001
 
1086
1002
        dlg = commit.CommitDialog(tree)
1087
 
        dlg._treeview_files.set_cursor(
1088
 
            Gtk.TreePath(path=1), None, False) # 'a'
 
1003
        dlg._treeview_files.set_cursor((1,)) # 'a'
1089
1004
        dlg._set_file_commit_message('Message for A\n')
1090
1005
        # No message for 'B'
1091
1006
        dlg._set_global_commit_message('Merging from "tree2"\n')
1098
1013
        self.assertEqual('Merging from "tree2"\n', rev.message)
1099
1014
        self.assertEqual([rev_id1, rev_id2], rev.parent_ids)
1100
1015
        file_info = rev.properties['file-info']
1101
 
        self.assertEqual(u'ld7:file_id4:a-id'
1102
 
                         '7:message14:Message for A\n'
1103
 
                         '4:path1:a'
1104
 
                         'ee',
1105
 
                         file_info)
 
1016
        self.assertEqual('ld7:file_id4:a-id'
 
1017
                           '7:message14:Message for A\n'
 
1018
                           '4:path1:a'
 
1019
                         'ee', file_info)
1106
1020
        self.assertEqual([{'path':'a', 'file_id':'a-id',
1107
 
                           'message':'Message for A\n'},],
1108
 
                         bencode.bdecode(file_info.encode('UTF-8')))
 
1021
                           'message':'Message for A\n'},
 
1022
                         ], bencode.bdecode(file_info))
1109
1023
 
1110
1024
    def test_commit_unicode_messages(self):
1111
 
        self.requireFeature(UnicodeFilenameFeature)
 
1025
        self.requireFeature(tests.UnicodeFilenameFeature)
1112
1026
 
1113
1027
        tree = self.make_branch_and_tree('tree')
1114
1028
        tree.branch.get_config().set_user_option('per_file_commits', 'true')
1116
1030
        tree.add(['a', u'\u03a9'], ['a-id', 'omega-id'])
1117
1031
 
1118
1032
        dlg = commit.CommitDialog(tree)
1119
 
        dlg._treeview_files.set_cursor(
1120
 
            Gtk.TreePath(path=1), None, False) # 'a'
 
1033
        dlg._treeview_files.set_cursor((1,)) # 'a'
1121
1034
        dlg._set_file_commit_message(u'Test \xfan\xecc\xf6de\n')
1122
 
        dlg._treeview_files.set_cursor(
1123
 
            Gtk.TreePath(path=2), None, False) # omega
 
1035
        dlg._treeview_files.set_cursor((2,)) # omega
1124
1036
        dlg._set_file_commit_message(u'\u03a9 is the end of all things.\n')
1125
1037
        dlg._set_global_commit_message(u'\u03a9 and \xfan\xecc\xf6de\n')
1126
1038
 
1174
1086
 
1175
1087
    def test_converts_mixed_to_lf(self):
1176
1088
        self.assertSanitize('foo\nbar\nbaz\n', 'foo\r\nbar\rbaz\n')
1177
 
 
1178
 
 
1179
 
class TestSavedCommitMessages(tests.TestCaseWithTransport):
1180
 
 
1181
 
    def setUp(self):
1182
 
        super(TestSavedCommitMessages, self).setUp()
1183
 
        # Install our hook
1184
 
        branch.Branch.hooks.install_named_hook(
1185
 
            'post_uncommit', commitmsgs.save_commit_messages, None)
1186
 
 
1187
 
    def _get_file_info_dict(self, rank):
1188
 
        file_info = [dict(path='a', file_id='a-id', message='a msg %d' % rank),
1189
 
                     dict(path='b', file_id='b-id', message='b msg %d' % rank)]
1190
 
        return file_info
1191
 
 
1192
 
    def _get_file_info_revprops(self, rank):
1193
 
        file_info_prop = self._get_file_info_dict(rank)
1194
 
        return {'file-info': bencode.bencode(file_info_prop).decode('UTF-8')}
1195
 
 
1196
 
    def _get_commit_message(self):
1197
 
        return self.config.get_user_option('gtk_global_commit_message')
1198
 
 
1199
 
    def _get_file_commit_messages(self):
1200
 
        return self.config.get_user_option('gtk_file_commit_messages')
1201
 
 
1202
 
 
1203
 
class TestUncommitHook(TestSavedCommitMessages):
1204
 
 
1205
 
    def setUp(self):
1206
 
        super(TestUncommitHook, self).setUp()
1207
 
        self.tree = self.make_branch_and_tree('tree')
1208
 
        self.config = self.tree.branch.get_config()
1209
 
        self.build_tree(['tree/a', 'tree/b'])
1210
 
        self.tree.add(['a'], ['a-id'])
1211
 
        self.tree.add(['b'], ['b-id'])
1212
 
        rev1 = self.tree.commit('one', rev_id='one-id',
1213
 
                                revprops=self._get_file_info_revprops(1))
1214
 
        rev2 = self.tree.commit('two', rev_id='two-id',
1215
 
                                revprops=self._get_file_info_revprops(2))
1216
 
        rev3 = self.tree.commit('three', rev_id='three-id',
1217
 
                                revprops=self._get_file_info_revprops(3))
1218
 
 
1219
 
    def test_uncommit_one_by_one(self):
1220
 
        uncommit.uncommit(self.tree.branch, tree=self.tree)
1221
 
        self.assertEquals(u'three', self._get_commit_message())
1222
 
        self.assertEquals(u'd4:a-id7:a msg 34:b-id7:b msg 3e',
1223
 
                          self._get_file_commit_messages())
1224
 
 
1225
 
        uncommit.uncommit(self.tree.branch, tree=self.tree)
1226
 
        self.assertEquals(u'two\n******\nthree', self._get_commit_message())
1227
 
        self.assertEquals(u'd4:a-id22:a msg 2\n******\na msg 3'
1228
 
                          '4:b-id22:b msg 2\n******\nb msg 3e',
1229
 
                          self._get_file_commit_messages())
1230
 
 
1231
 
        uncommit.uncommit(self.tree.branch, tree=self.tree)
1232
 
        self.assertEquals(u'one\n******\ntwo\n******\nthree',
1233
 
                          self._get_commit_message())
1234
 
        self.assertEquals(u'd4:a-id37:a msg 1\n******\na msg 2\n******\na msg 3'
1235
 
                          '4:b-id37:b msg 1\n******\nb msg 2\n******\nb msg 3e',
1236
 
                          self._get_file_commit_messages())
1237
 
 
1238
 
    def test_uncommit_all_at_once(self):
1239
 
        uncommit.uncommit(self.tree.branch, tree=self.tree, revno=1)
1240
 
        self.assertEquals(u'one\n******\ntwo\n******\nthree',
1241
 
                          self._get_commit_message())
1242
 
        self.assertEquals(u'd4:a-id37:a msg 1\n******\na msg 2\n******\na msg 3'
1243
 
                          '4:b-id37:b msg 1\n******\nb msg 2\n******\nb msg 3e',
1244
 
                          self._get_file_commit_messages())
1245
 
 
1246
 
 
1247
 
class TestReusingSavedCommitMessages(TestSavedCommitMessages, QuestionHelpers):
1248
 
 
1249
 
    def setUp(self):
1250
 
        super(TestReusingSavedCommitMessages, self).setUp()
1251
 
        self.tree = self.make_branch_and_tree('tree')
1252
 
        self.config = self.tree.branch.get_config()
1253
 
        self.config.set_user_option('per_file_commits', 'true')
1254
 
        self.build_tree(['tree/a', 'tree/b'])
1255
 
        self.tree.add(['a'], ['a-id'])
1256
 
        self.tree.add(['b'], ['b-id'])
1257
 
        rev1 = self.tree.commit('one', revprops=self._get_file_info_revprops(1))
1258
 
        rev2 = self.tree.commit('two', revprops=self._get_file_info_revprops(2))
1259
 
        uncommit.uncommit(self.tree.branch, tree=self.tree)
1260
 
        self.build_tree_contents([('tree/a', 'new a content\n'),
1261
 
                                  ('tree/b', 'new b content'),])
1262
 
 
1263
 
    def _get_commit_dialog(self, tree):
1264
 
        # Ensure we will never use a dialog that can actually prompt the user
1265
 
        # during the test suite. Test *can* and *should* override with the
1266
 
        # correct question dialog type.
1267
 
        dlg = commit.CommitDialog(tree)
1268
 
        self._set_question_no(dlg)
1269
 
        return dlg
1270
 
 
1271
 
    def test_setup_saved_messages(self):
1272
 
        # Check the initial setup
1273
 
        self.assertEquals(u'two', self._get_commit_message())
1274
 
        self.assertEquals(u'd4:a-id7:a msg 24:b-id7:b msg 2e',
1275
 
                          self._get_file_commit_messages())
1276
 
 
1277
 
    def test_messages_are_reloaded(self):
1278
 
        dlg = self._get_commit_dialog(self.tree)
1279
 
        self.assertEquals(u'two', dlg._get_global_commit_message())
1280
 
        self.assertEquals(([u'a', u'b'],
1281
 
                           [{ 'path': 'a',
1282
 
                             'file_id': 'a-id', 'message': 'a msg 2',},
1283
 
                           {'path': 'b',
1284
 
                            'file_id': 'b-id', 'message': 'b msg 2',}],),
1285
 
                          dlg._get_specific_files())
1286
 
 
1287
 
    def test_messages_are_consumed(self):
1288
 
        dlg = self._get_commit_dialog(self.tree)
1289
 
        dlg._do_commit()
1290
 
        self.assertEquals(u'', self._get_commit_message())
1291
 
        self.assertEquals(u'de', self._get_file_commit_messages())
1292
 
 
1293
 
    def test_messages_are_saved_on_cancel_if_required(self):
1294
 
        dlg = self._get_commit_dialog(self.tree)
1295
 
        self._set_question_yes(dlg) # Save messages
1296
 
        dlg._do_cancel()
1297
 
        self.assertEquals(u'two', self._get_commit_message())
1298
 
        self.assertEquals(u'd4:a-id7:a msg 24:b-id7:b msg 2e',
1299
 
                          self._get_file_commit_messages())
1300
 
 
1301
 
    def test_messages_are_cleared_on_cancel_if_required(self):
1302
 
        dlg = self._get_commit_dialog(self.tree)
1303
 
        self._set_question_no(dlg) # Don't save messages
1304
 
        dlg._do_cancel()
1305
 
        self.assertEquals(u'', self._get_commit_message())
1306
 
        self.assertEquals(u'de',
1307
 
                          self._get_file_commit_messages())
1308
 
 
1309
 
 
1310
 
class BzrHandlePatchTestCase(tests.TestCase):
1311
 
 
1312
 
    def setUp(self):
1313
 
        top = os.path.abspath(os.path.join(
1314
 
            os.path.dirname(__file__), os.pardir))
1315
 
        self.script = os.path.join(top, 'bzr-handle-patch')
1316
 
        self.env = dict(os.environ)
1317
 
        self.env['BZR_PLUGINS_AT'] = 'gtk@%s' % top
1318
 
        self.patch = NamedTemporaryFile()
1319
 
        self.patch.write('\n'.join([
1320
 
            "=== added file '_test.txt'",
1321
 
            "--- _test.txt      1970-01-01 00:00:00 +0000",
1322
 
            "+++ _test.txt      2012-02-03 20:00:34 +0000",
1323
 
            "@@ -0,0 +1,1 @@",
1324
 
            "+hello",
1325
 
            ]))
1326
 
        self.patch.flush()
1327
 
        super(BzrHandlePatchTestCase, self).setUp()
1328
 
 
1329
 
    def test_smoketest(self):
1330
 
        # This is a smoke test to verify the process starts.
1331
 
        bzr_notify = subprocess.Popen(
1332
 
            [self.script, self.patch.name, 'test'],
1333
 
            stdout=subprocess.PIPE, stderr=subprocess.PIPE, env=self.env)
1334
 
        stdout, stderr = bzr_notify.communicate()
1335
 
        self.assertEqual('', stdout)
1336
 
        self.assertEqual('', stderr)