/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: Curtis Hovey
  • Date: 2011-09-03 22:00:09 UTC
  • mto: This revision was merged to the branch mainline in revision 738.
  • Revision ID: sinzui.is@verizon.net-20110903220009-rvrgi2q1npy27jsw
Added basic tests to verify __eq__ is fixed.

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
24
    branch,
31
29
    from bzrlib.tests.features import UnicodeFilenameFeature
32
30
except ImportError: # bzr < 2.5
33
31
    from bzrlib.tests import UnicodeFilenameFeature
34
 
from bzrlib import bencode
 
32
try:
 
33
    from bzrlib import bencode
 
34
except ImportError:
 
35
    from bzrlib.util import bencode
35
36
 
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
 
37
from bzrlib.plugins.gtk import commit
42
38
 
43
39
 
44
40
# TODO: All we need is basic ancestry code to test this, we shouldn't need a
50
46
        tree = self.make_branch_and_tree('.')
51
47
        tree.commit('one')
52
48
 
53
 
        self.addCleanup(tree.lock_read().unlock)
54
 
        self.assertEquals([], list(commit.pending_revisions(tree)))
 
49
        self.assertIs(None, commit.pending_revisions(tree))
55
50
 
56
51
    def test_pending_revisions_simple(self):
57
52
        tree = self.make_branch_and_tree('tree')
61
56
        tree.merge_from_branch(tree2.branch)
62
57
        self.assertEqual([rev_id1, rev_id2], tree.get_parent_ids())
63
58
 
64
 
        self.addCleanup(tree.lock_read().unlock)
65
 
        pending_revisions = list(commit.pending_revisions(tree))
 
59
        pending_revisions = commit.pending_revisions(tree)
66
60
        # One primary merge
67
61
        self.assertEqual(1, len(pending_revisions))
68
62
        # Revision == rev_id2
80
74
        tree.merge_from_branch(tree2.branch)
81
75
        self.assertEqual([rev_id1, rev_id4], tree.get_parent_ids())
82
76
 
83
 
        self.addCleanup(tree.lock_read().unlock)
84
 
        pending_revisions = list(commit.pending_revisions(tree))
 
77
        pending_revisions = commit.pending_revisions(tree)
85
78
        # One primary merge
86
79
        self.assertEqual(1, len(pending_revisions))
87
80
        # Revision == rev_id2
104
97
        tree.merge_from_branch(tree3.branch, force=True)
105
98
        self.assertEqual([rev_id1, rev_id3, rev_id5], tree.get_parent_ids())
106
99
 
107
 
        self.addCleanup(tree.lock_read().unlock)
108
 
        pending_revisions = list(commit.pending_revisions(tree))
 
100
        pending_revisions = commit.pending_revisions(tree)
109
101
        # Two primary merges
110
102
        self.assertEqual(2, len(pending_revisions))
111
103
        # Revision == rev_id2
148
140
 
149
141
class TestCommitDialogSimple(tests.TestCaseWithTransport):
150
142
 
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
143
    def test_setup_parameters_no_pending(self):
172
144
        tree = self.make_branch_and_tree('tree')
173
145
        rev_id = tree.commit('first')
174
146
 
175
147
        dlg = CommitDialogNoWidgets(tree)
176
148
        self.assertEqual(rev_id, dlg._basis_tree.get_revision_id())
177
 
        self.assertEquals([], dlg._pending)
 
149
        self.assertIs(None, dlg._pending)
178
150
        self.assertFalse(dlg._is_checkout)
179
151
 
180
152
    def test_setup_parameters_checkout(self):
185
157
 
186
158
        dlg = CommitDialogNoWidgets(tree2)
187
159
        self.assertEqual(rev_id, dlg._basis_tree.get_revision_id())
188
 
        self.assertEquals([], dlg._pending)
 
160
        self.assertIs(None, dlg._pending)
189
161
        self.assertTrue(dlg._is_checkout)
190
162
 
191
163
    def test_setup_parameters_pending(self):
216
188
        self.assertEqual([], delta.removed)
217
189
        self.assertEqual([(u'a', 'a-id', 'file')], delta.added)
218
190
 
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
191
 
246
192
class TestCommitDialog(tests.TestCaseWithTransport):
247
193
 
269
215
 
270
216
        commit_col = dlg._treeview_files.get_column(0)
271
217
        self.assertEqual('Commit', commit_col.get_title())
272
 
        renderer = commit_col.get_cells()[0]
 
218
        renderer = commit_col.get_cell_renderers()[0]
273
219
        self.assertTrue(renderer.get_property('activatable'))
274
220
 
275
221
        self.assertEqual('Commit all changes',
294
240
 
295
241
        commit_col = dlg._treeview_files.get_column(0)
296
242
        self.assertEqual('Commit*', commit_col.get_title())
297
 
        renderer = commit_col.get_cells()[0]
 
243
        renderer = commit_col.get_cell_renderers()[0]
298
244
        self.assertFalse(renderer.get_property('activatable'))
299
245
 
300
246
        values = [(r[0], r[1], r[2], r[3]) for r in dlg._pending_store]
346
292
 
347
293
        dlg = commit.CommitDialog(tree)
348
294
        values = [(r[0], r[1], r[2], r[3], r[4]) for r in dlg._files_store]
349
 
        self.assertEqual([("", "", True, 'All Files', ''),
 
295
        self.assertEqual([(None, None, True, 'All Files', ''),
350
296
                          ('a-id', 'a', True, 'a', 'added'),
351
297
                          ('b-id', 'b', True, 'b/', 'added'),
352
298
                          ('c-id', 'b/c', True, 'b/c', 'added'),
363
309
 
364
310
        dlg = commit.CommitDialog(tree)
365
311
        values = [(r[0], r[1], r[2], r[3], r[4]) for r in dlg._files_store]
366
 
        self.assertEqual([("", "", True, 'All Files', ''),
 
312
        self.assertEqual([(None, None, True, 'All Files', ''),
367
313
                          ('b-id', 'd', True, 'b/ => d/', 'renamed'),
368
314
                          ('a-id', 'd/a', True, 'a => d/a', 'renamed'),
369
315
                         ], values)
378
324
 
379
325
        dlg = commit.CommitDialog(tree)
380
326
        values = [(r[0], r[1], r[2], r[3], r[4]) for r in dlg._files_store]
381
 
        self.assertEqual([("", "", True, 'All Files', ''),
 
327
        self.assertEqual([(None, None, True, 'All Files', ''),
382
328
                          ('a-id', 'a', True, 'a', 'modified'),
383
329
                         ], values)
384
330
 
398
344
 
399
345
        dlg = commit.CommitDialog(tree)
400
346
        values = [(r[0], r[1], r[2], r[3], r[4]) for r in dlg._files_store]
401
 
        self.assertEqual([("", "", True, 'All Files', ''),
 
347
        self.assertEqual([(None, None, True, 'All Files', ''),
402
348
                          ('b-id', 'd', True, 'b/ => d/', 'renamed'),
403
349
                          ('a-id', 'd/a', True, 'a => d/a', 'renamed and modified'),
404
350
                          ('c-id', 'd/c', True, 'd/c', 'modified'),
421
367
 
422
368
        dlg = commit.CommitDialog(tree)
423
369
        values = [(r[0], r[1], r[2], r[3], r[4]) for r in dlg._files_store]
424
 
        self.assertEqual([("", "", True, 'All Files', ''),
 
370
        self.assertEqual([(None, None, True, 'All Files', ''),
425
371
                          ('a-id', 'a', True, 'a => a/', 'kind changed'),
426
372
                          # ('b-id', 'c', True, 'b => c/', 'renamed and modified'),
427
373
                         ], values)
437
383
 
438
384
        dlg = commit.CommitDialog(tree)
439
385
        values = [(r[0], r[1], r[2], r[3], r[4]) for r in dlg._files_store]
440
 
        self.assertEqual([("", "", True, 'All Files', ''),
 
386
        self.assertEqual([(None, None, True, 'All Files', ''),
441
387
                          ('a-id', 'a', True, 'a', 'removed'),
442
388
                          ('b-id', 'b', True, 'b/', 'removed'),
443
389
                         ], values)
444
390
        # All Files should be selected
445
 
        self.assertEqual(
446
 
            (Gtk.TreePath(path=0), None), dlg._treeview_files.get_cursor())
 
391
        self.assertEqual(((0,), None), dlg._treeview_files.get_cursor())
447
392
 
448
393
    def test_filelist_with_selected(self):
449
394
        tree = self.make_branch_and_tree('tree')
452
397
 
453
398
        dlg = commit.CommitDialog(tree, selected='a')
454
399
        values = [(r[0], r[1], r[2], r[3], r[4]) for r in dlg._files_store]
455
 
        self.assertEqual([("", "", False, 'All Files', ''),
 
400
        self.assertEqual([(None, None, False, 'All Files', ''),
456
401
                          ('a-id', 'a', True, 'a', 'added'),
457
402
                          ('b-id', 'b', False, 'b/', 'added'),
458
403
                         ], values)
459
404
        # This file should also be selected in the file list, rather than the
460
405
        # 'All Files' selection
461
 
        self.assertEqual(
462
 
            (Gtk.TreePath(path=1), None), dlg._treeview_files.get_cursor())
 
406
        self.assertEqual(((1,), None), dlg._treeview_files.get_cursor())
463
407
 
464
408
    def test_diff_view(self):
465
409
        tree = self.make_branch_and_tree('tree')
473
417
        dlg = commit.CommitDialog(tree)
474
418
        diff_buffer = dlg._diff_view.buffer
475
419
        text = diff_buffer.get_text(diff_buffer.get_start_iter(),
476
 
                                    diff_buffer.get_end_iter(),
477
 
                                    True).splitlines(True)
 
420
                                    diff_buffer.get_end_iter()).splitlines(True)
478
421
 
479
422
        self.assertEqual("=== modified file 'a'\n", text[0])
480
423
        self.assertContainsRe(text[1],
525
468
        self.assertFalse(dlg._file_message_expander.get_expanded())
526
469
        self.assertFalse(dlg._file_message_expander.get_property('sensitive'))
527
470
 
528
 
        dlg._treeview_files.set_cursor(
529
 
            Gtk.TreePath(path=1), None, False)
 
471
        dlg._treeview_files.set_cursor((1,))
530
472
        self.assertEqual('Diff for a', dlg._diff_label.get_text())
531
473
        text = diff_buffer.get_text(diff_buffer.get_start_iter(),
532
 
                                    diff_buffer.get_end_iter(),
533
 
                                    True).splitlines(True)
 
474
                                    diff_buffer.get_end_iter()).splitlines(True)
534
475
        self.assertEqual("=== added file 'a'\n", text[0])
535
476
        self.assertContainsRe(text[1],
536
477
            r"--- a\t\d\d\d\d-\d\d-\d\d \d\d:\d\d:\d\d [+-]\d\d\d\d")
544
485
        self.assertTrue(dlg._file_message_expander.get_expanded())
545
486
        self.assertTrue(dlg._file_message_expander.get_property('sensitive'))
546
487
 
547
 
        dlg._treeview_files.set_cursor(
548
 
            Gtk.TreePath(path=2), None, False)
 
488
        dlg._treeview_files.set_cursor((2,))
549
489
        self.assertEqual('Diff for b', dlg._diff_label.get_text())
550
490
        text = diff_buffer.get_text(diff_buffer.get_start_iter(),
551
 
                                    diff_buffer.get_end_iter(),
552
 
                                    True).splitlines(True)
 
491
                                    diff_buffer.get_end_iter()).splitlines(True)
553
492
        self.assertEqual("=== added file 'b'\n", text[0])
554
493
        self.assertContainsRe(text[1],
555
494
            r"--- b\t\d\d\d\d-\d\d-\d\d \d\d:\d\d:\d\d [+-]\d\d\d\d")
563
502
        self.assertTrue(dlg._file_message_expander.get_expanded())
564
503
        self.assertTrue(dlg._file_message_expander.get_property('sensitive'))
565
504
 
566
 
        dlg._treeview_files.set_cursor(
567
 
            Gtk.TreePath(path=0), None, False)
 
505
        dlg._treeview_files.set_cursor((0,))
568
506
        self.assertEqual('Diff for All Files', dlg._diff_label.get_text())
569
507
        self.assertEqual('File commit message',
570
508
                         dlg._file_message_expander.get_label())
580
518
 
581
519
        def get_file_text():
582
520
            buf = dlg._file_message_text_view.get_buffer()
583
 
            return buf.get_text(
584
 
                buf.get_start_iter(), buf.get_end_iter(), True)
 
521
            return buf.get_text(buf.get_start_iter(), buf.get_end_iter())
585
522
 
586
523
        def get_saved_text(path):
587
524
            """Get the saved text for a given record."""
594
531
        self.assertFalse(dlg._file_message_expander.get_property('sensitive'))
595
532
        self.assertEqual('', get_file_text())
596
533
 
597
 
        dlg._treeview_files.set_cursor(
598
 
            Gtk.TreePath(path=1), None, False)
 
534
        dlg._treeview_files.set_cursor((1,))
599
535
        self.assertEqual('Commit message for a',
600
536
                         dlg._file_message_expander.get_label())
601
537
        self.assertTrue(dlg._file_message_expander.get_expanded())
608
544
        # We should have updated the ListStore with the new file commit info
609
545
        self.assertEqual('Some text\nfor a\n', get_saved_text(1))
610
546
 
611
 
        dlg._treeview_files.set_cursor(
612
 
            Gtk.TreePath(path=2), None, False)
 
547
        dlg._treeview_files.set_cursor((2,))
613
548
        self.assertEqual('Commit message for b/',
614
549
                         dlg._file_message_expander.get_label())
615
550
        self.assertTrue(dlg._file_message_expander.get_expanded())
620
555
        dlg._set_file_commit_message('More text\nfor b\n')
621
556
        # Now switch back to 'a'. The message should be saved, and the buffer
622
557
        # should be updated with the other text
623
 
        dlg._treeview_files.set_cursor(
624
 
            Gtk.TreePath(path=1), None, False)
 
558
        dlg._treeview_files.set_cursor((1,))
625
559
        self.assertEqual('More text\nfor b\n', get_saved_text(2))
626
560
        self.assertEqual('Commit message for a',
627
561
                         dlg._file_message_expander.get_label())
636
570
        tree.add(['a', 'b'], ['a-id', 'b-id'])
637
571
 
638
572
        dlg = commit.CommitDialog(tree)
639
 
        self.assertEqual([("", "", True),
 
573
        self.assertEqual([(None, None, True),
640
574
                          ('a-id', 'a', True),
641
575
                          ('b-id', 'b', True),
642
576
                         ], [(r[0], r[1], r[2]) for r in dlg._files_store])
647
581
        #       do with. So instead, we just call toggle directly, and assume
648
582
        #       that toggle is hooked in correctly
649
583
        # column = dlg._treeview_files.get_column(0)
650
 
        # renderer = column.get_cells()[0]
 
584
        # renderer = column.get_cell_renderers()[0]
651
585
 
652
586
        # Toggle a single entry should set just that entry to False
653
587
        dlg._toggle_commit(None, 1, dlg._files_store)
654
 
        self.assertEqual([("", "", True),
 
588
        self.assertEqual([(None, None, True),
655
589
                          ('a-id', 'a', False),
656
590
                          ('b-id', 'b', True),
657
591
                         ], [(r[0], r[1], r[2]) for r in dlg._files_store])
658
592
 
659
593
        # Toggling the main entry should set all entries
660
594
        dlg._toggle_commit(None, 0, dlg._files_store)
661
 
        self.assertEqual([("", "", False),
 
595
        self.assertEqual([(None, None, False),
662
596
                          ('a-id', 'a', False),
663
597
                          ('b-id', 'b', False),
664
598
                         ], [(r[0], r[1], r[2]) for r in dlg._files_store])
665
599
 
666
600
        dlg._toggle_commit(None, 2, dlg._files_store)
667
 
        self.assertEqual([("", "", False),
 
601
        self.assertEqual([(None, None, False),
668
602
                          ('a-id', 'a', False),
669
603
                          ('b-id', 'b', True),
670
604
                         ], [(r[0], r[1], r[2]) for r in dlg._files_store])
671
605
 
672
606
        dlg._toggle_commit(None, 0, dlg._files_store)
673
 
        self.assertEqual([("", "", True),
 
607
        self.assertEqual([(None, None, True),
674
608
                          ('a-id', 'a', True),
675
609
                          ('b-id', 'b', True),
676
610
                         ], [(r[0], r[1], r[2]) for r in dlg._files_store])
700
634
        dlg._commit_selected_radio.set_active(True)
701
635
        self.assertEqual((['a_file', 'b_dir'], []), dlg._get_specific_files())
702
636
 
703
 
        dlg._treeview_files.set_cursor(
704
 
            Gtk.TreePath(path=1), None, False)
 
637
        dlg._treeview_files.set_cursor((1,))
705
638
        dlg._set_file_commit_message('Test\nmessage\nfor a_file\n')
706
 
        dlg._treeview_files.set_cursor(
707
 
            Gtk.TreePath(path=2), None, False)
 
639
        dlg._treeview_files.set_cursor((2,))
708
640
        dlg._set_file_commit_message('message\nfor b_dir\n')
709
641
 
710
642
        self.assertEqual((['a_file', 'b_dir'],
730
662
        dlg._commit_selected_radio.set_active(True)
731
663
        self.assertEqual((['a_file', 'b_dir'], []), dlg._get_specific_files())
732
664
 
733
 
        dlg._treeview_files.set_cursor(
734
 
            Gtk.TreePath(path=1), None, False)
 
665
        dlg._treeview_files.set_cursor((1,))
735
666
        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)
 
667
        dlg._treeview_files.set_cursor((2,))
738
668
        dlg._set_file_commit_message('message\r\nfor\nb_dir\r')
739
669
 
740
670
        self.assertEqual((['a_file', 'b_dir'],
753
683
        def _question_yes(*args, **kwargs):
754
684
            self.questions.append(args)
755
685
            self.questions.append('YES')
756
 
            return Gtk.ResponseType.YES
 
686
            return gtk.RESPONSE_YES
757
687
        dlg._question_dialog = _question_yes
758
688
 
759
689
    def _set_question_no(self, dlg):
762
692
        def _question_no(*args, **kwargs):
763
693
            self.questions.append(args)
764
694
            self.questions.append('NO')
765
 
            return Gtk.ResponseType.NO
 
695
            return gtk.RESPONSE_NO
766
696
        dlg._question_dialog = _question_no
767
697
 
768
698
 
1047
977
 
1048
978
        dlg = commit.CommitDialog(tree)
1049
979
        dlg._commit_selected_radio.set_active(True) # enable partial
1050
 
        dlg._treeview_files.set_cursor(
1051
 
            Gtk.TreePath(path=1), None, False)
 
980
        dlg._treeview_files.set_cursor((1,))
1052
981
        dlg._set_file_commit_message('Message for A\n')
1053
 
        dlg._treeview_files.set_cursor(
1054
 
            Gtk.TreePath(path=2), None, False)
 
982
        dlg._treeview_files.set_cursor((2,))
1055
983
        dlg._set_file_commit_message('Message for B\n')
1056
984
        dlg._toggle_commit(None, 2, dlg._files_store) # unset 'b'
1057
985
        dlg._set_global_commit_message('Commit just "a"')
1084
1012
        tree.merge_from_branch(tree2.branch)
1085
1013
 
1086
1014
        dlg = commit.CommitDialog(tree)
1087
 
        dlg._treeview_files.set_cursor(
1088
 
            Gtk.TreePath(path=1), None, False) # 'a'
 
1015
        dlg._treeview_files.set_cursor((1,)) # 'a'
1089
1016
        dlg._set_file_commit_message('Message for A\n')
1090
1017
        # No message for 'B'
1091
1018
        dlg._set_global_commit_message('Merging from "tree2"\n')
1116
1043
        tree.add(['a', u'\u03a9'], ['a-id', 'omega-id'])
1117
1044
 
1118
1045
        dlg = commit.CommitDialog(tree)
1119
 
        dlg._treeview_files.set_cursor(
1120
 
            Gtk.TreePath(path=1), None, False) # 'a'
 
1046
        dlg._treeview_files.set_cursor((1,)) # 'a'
1121
1047
        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
 
1048
        dlg._treeview_files.set_cursor((2,)) # omega
1124
1049
        dlg._set_file_commit_message(u'\u03a9 is the end of all things.\n')
1125
1050
        dlg._set_global_commit_message(u'\u03a9 and \xfan\xecc\xf6de\n')
1126
1051
 
1182
1107
        super(TestSavedCommitMessages, self).setUp()
1183
1108
        # Install our hook
1184
1109
        branch.Branch.hooks.install_named_hook(
1185
 
            'post_uncommit', commitmsgs.save_commit_messages, None)
 
1110
            'post_uncommit', commit.save_commit_messages, None)
1186
1111
 
1187
1112
    def _get_file_info_dict(self, rank):
1188
1113
        file_info = [dict(path='a', file_id='a-id', message='a msg %d' % rank),
1305
1230
        self.assertEquals(u'', self._get_commit_message())
1306
1231
        self.assertEquals(u'de',
1307
1232
                          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)