/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: 2010-02-08 13:28:34 UTC
  • Revision ID: jelmer@samba.org-20100208132834-443aedcu5hq4x5tj
use system configobj if bzrlib doesn't ship with one.

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