/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

Commit messages never contain config options

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/test_commit.py
 
1
# Copyright (C) 2007, 2008, 2009, 2011, 2012, 2013 John Arbash Meinel <john@arbash-meinel.com>
 
2
#
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
#
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
#
 
13
# You should have received a copy of the GNU General Public License
 
14
# along with this program; if not, write to the Free Software
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
16
 
 
17
"""Test the Commit functionality."""
 
18
 
 
19
import os
 
20
import subprocess
 
21
from tempfile import NamedTemporaryFile
 
22
 
 
23
from gi.repository import Gtk
 
24
 
 
25
from bzrlib import (
 
26
    branch,
 
27
    tests,
 
28
    uncommit,
 
29
    )
 
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
 
35
 
 
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
 
42
 
 
43
 
 
44
# TODO: All we need is basic ancestry code to test this, we shouldn't need a
 
45
# TestCaseWithTransport, just a TestCaseWithMemoryTransport or somesuch.
 
46
 
 
47
class TestPendingRevisions(tests.TestCaseWithTransport):
 
48
 
 
49
    def test_pending_revisions_none(self):
 
50
        tree = self.make_branch_and_tree('.')
 
51
        tree.commit('one')
 
52
 
 
53
        self.addCleanup(tree.lock_read().unlock)
 
54
        self.assertEquals([], list(commit.pending_revisions(tree)))
 
55
 
 
56
    def test_pending_revisions_simple(self):
 
57
        tree = self.make_branch_and_tree('tree')
 
58
        rev_id1 = tree.commit('one')
 
59
        tree2 = tree.bzrdir.sprout('tree2').open_workingtree()
 
60
        rev_id2 = tree2.commit('two')
 
61
        tree.merge_from_branch(tree2.branch)
 
62
        self.assertEqual([rev_id1, rev_id2], tree.get_parent_ids())
 
63
 
 
64
        self.addCleanup(tree.lock_read().unlock)
 
65
        pending_revisions = list(commit.pending_revisions(tree))
 
66
        # One primary merge
 
67
        self.assertEqual(1, len(pending_revisions))
 
68
        # Revision == rev_id2
 
69
        self.assertEqual(rev_id2, pending_revisions[0][0].revision_id)
 
70
        # No children of this revision.
 
71
        self.assertEqual([], pending_revisions[0][1])
 
72
 
 
73
    def test_pending_revisions_with_children(self):
 
74
        tree = self.make_branch_and_tree('tree')
 
75
        rev_id1 = tree.commit('one')
 
76
        tree2 = tree.bzrdir.sprout('tree2').open_workingtree()
 
77
        rev_id2 = tree2.commit('two')
 
78
        rev_id3 = tree2.commit('three')
 
79
        rev_id4 = tree2.commit('four')
 
80
        tree.merge_from_branch(tree2.branch)
 
81
        self.assertEqual([rev_id1, rev_id4], tree.get_parent_ids())
 
82
 
 
83
        self.addCleanup(tree.lock_read().unlock)
 
84
        pending_revisions = list(commit.pending_revisions(tree))
 
85
        # One primary merge
 
86
        self.assertEqual(1, len(pending_revisions))
 
87
        # Revision == rev_id2
 
88
        self.assertEqual(rev_id4, pending_revisions[0][0].revision_id)
 
89
        # Two children for this revision
 
90
        self.assertEqual(2, len(pending_revisions[0][1]))
 
91
        self.assertEqual(rev_id3, pending_revisions[0][1][0].revision_id)
 
92
        self.assertEqual(rev_id2, pending_revisions[0][1][1].revision_id)
 
93
 
 
94
    def test_pending_revisions_multi_merge(self):
 
95
        tree = self.make_branch_and_tree('tree')
 
96
        rev_id1 = tree.commit('one')
 
97
        tree2 = tree.bzrdir.sprout('tree2').open_workingtree()
 
98
        rev_id2 = tree2.commit('two')
 
99
        tree3 = tree2.bzrdir.sprout('tree3').open_workingtree()
 
100
        rev_id3 = tree2.commit('three')
 
101
        rev_id4 = tree3.commit('four')
 
102
        rev_id5 = tree3.commit('five')
 
103
        tree.merge_from_branch(tree2.branch)
 
104
        tree.merge_from_branch(tree3.branch, force=True)
 
105
        self.assertEqual([rev_id1, rev_id3, rev_id5], tree.get_parent_ids())
 
106
 
 
107
        self.addCleanup(tree.lock_read().unlock)
 
108
        pending_revisions = list(commit.pending_revisions(tree))
 
109
        # Two primary merges
 
110
        self.assertEqual(2, len(pending_revisions))
 
111
        # Revision == rev_id2
 
112
        self.assertEqual(rev_id3, pending_revisions[0][0].revision_id)
 
113
        self.assertEqual(rev_id5, pending_revisions[1][0].revision_id)
 
114
        # One child for the first merge
 
115
        self.assertEqual(1, len(pending_revisions[0][1]))
 
116
        self.assertEqual(rev_id2, pending_revisions[0][1][0].revision_id)
 
117
        # One child for the second merge
 
118
        self.assertEqual(1, len(pending_revisions[1][1]))
 
119
        self.assertEqual(rev_id4, pending_revisions[1][1][0].revision_id)
 
120
 
 
121
 
 
122
class Test_RevToPendingInfo(tests.TestCaseWithTransport):
 
123
 
 
124
    def test_basic_info(self):
 
125
        tree = self.make_branch_and_tree('tree')
 
126
        rev_id = tree.commit('Multiline\ncommit\nmessage',
 
127
                             committer='Joe Foo <joe@foo.com>',
 
128
                             timestamp=1191012408.674,
 
129
                             timezone=-18000
 
130
                             )
 
131
        rev = tree.branch.repository.get_revision(rev_id)
 
132
        rev_dict = commit.CommitDialog._rev_to_pending_info(rev)
 
133
        self.assertEqual({'committer':'Joe Foo',
 
134
                          'summary':'Multiline',
 
135
                          'date':'2007-09-28',
 
136
                          'revision_id':rev_id,
 
137
                         }, rev_dict)
 
138
 
 
139
 
 
140
class CommitDialogNoWidgets(commit.CommitDialog):
 
141
 
 
142
    def construct(self):
 
143
        pass # Don't create any widgets here
 
144
 
 
145
    def fill_in_data(self):
 
146
        pass # With no widgets, there are no widgets to fill out
 
147
 
 
148
 
 
149
class TestCommitDialogSimple(tests.TestCaseWithTransport):
 
150
 
 
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
    def test_setup_parameters_no_pending(self):
 
172
        tree = self.make_branch_and_tree('tree')
 
173
        rev_id = tree.commit('first')
 
174
 
 
175
        dlg = CommitDialogNoWidgets(tree)
 
176
        self.assertEqual(rev_id, dlg._basis_tree.get_revision_id())
 
177
        self.assertEquals([], dlg._pending)
 
178
        self.assertFalse(dlg._is_checkout)
 
179
 
 
180
    def test_setup_parameters_checkout(self):
 
181
        tree = self.make_branch_and_tree('tree')
 
182
        rev_id = tree.commit('first')
 
183
        tree2 = tree.bzrdir.sprout('tree2').open_workingtree()
 
184
        tree2.branch.bind(tree.branch)
 
185
 
 
186
        dlg = CommitDialogNoWidgets(tree2)
 
187
        self.assertEqual(rev_id, dlg._basis_tree.get_revision_id())
 
188
        self.assertEquals([], dlg._pending)
 
189
        self.assertTrue(dlg._is_checkout)
 
190
 
 
191
    def test_setup_parameters_pending(self):
 
192
        tree = self.make_branch_and_tree('tree')
 
193
        rev_id1 = tree.commit('one')
 
194
        tree2 = tree.bzrdir.sprout('tree2').open_workingtree()
 
195
        rev_id2 = tree2.commit('two')
 
196
        tree.merge_from_branch(tree2.branch)
 
197
 
 
198
        dlg = CommitDialogNoWidgets(tree)
 
199
        self.assertEqual(rev_id1, dlg._basis_tree.get_revision_id())
 
200
        self.assertIsNot(None, dlg._pending)
 
201
        self.assertEqual(1, len(dlg._pending))
 
202
        self.assertEqual(rev_id2, dlg._pending[0][0].revision_id)
 
203
 
 
204
    def test_setup_parameters_delta(self):
 
205
        tree = self.make_branch_and_tree('tree')
 
206
        self.build_tree(['tree/a'])
 
207
        tree.add(['a'], ['a-id'])
 
208
 
 
209
        dlg = CommitDialogNoWidgets(tree)
 
210
        self.assertIs(None, dlg._delta)
 
211
        dlg._compute_delta()
 
212
 
 
213
        delta = dlg._delta
 
214
        self.assertEqual([], delta.modified)
 
215
        self.assertEqual([], delta.renamed)
 
216
        self.assertEqual([], delta.removed)
 
217
        self.assertEqual([(u'a', 'a-id', 'file')], delta.added)
 
218
 
 
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
 
 
246
class TestCommitDialog(tests.TestCaseWithTransport):
 
247
 
 
248
    def test_bound(self):
 
249
        tree = self.make_branch_and_tree('tree')
 
250
        rev_id = tree.commit('first')
 
251
        tree2 = tree.bzrdir.sprout('tree2').open_workingtree()
 
252
        tree2.branch.bind(tree.branch)
 
253
 
 
254
        # tree is not a checkout
 
255
        dlg = commit.CommitDialog(tree)
 
256
        self.assertFalse(dlg._check_local.get_property('visible'))
 
257
 
 
258
        # tree2 is a checkout
 
259
        dlg2 = commit.CommitDialog(tree2)
 
260
        self.assertTrue(dlg2._check_local.get_property('visible'))
 
261
 
 
262
    def test_no_pending(self):
 
263
        tree = self.make_branch_and_tree('tree')
 
264
        rev_id1 = tree.commit('one')
 
265
 
 
266
        dlg = commit.CommitDialog(tree)
 
267
 
 
268
        self.assertFalse(dlg._pending_box.get_property('visible'))
 
269
 
 
270
        commit_col = dlg._treeview_files.get_column(0)
 
271
        self.assertEqual('Commit', commit_col.get_title())
 
272
        renderer = commit_col.get_cells()[0]
 
273
        self.assertTrue(renderer.get_property('activatable'))
 
274
 
 
275
        self.assertEqual('Commit all changes',
 
276
                         dlg._commit_all_files_radio.get_label())
 
277
        self.assertTrue(dlg._commit_all_files_radio.get_property('sensitive'))
 
278
        self.assertTrue(dlg._commit_selected_radio.get_property('sensitive'))
 
279
 
 
280
    def test_pending(self):
 
281
        tree = self.make_branch_and_tree('tree')
 
282
        rev_id1 = tree.commit('one')
 
283
 
 
284
        tree2 = tree.bzrdir.sprout('tree2').open_workingtree()
 
285
        rev_id2 = tree2.commit('two',
 
286
                               committer='Joe Foo <joe@foo.com>',
 
287
                               timestamp=1191264271.05,
 
288
                               timezone=+7200)
 
289
        tree.merge_from_branch(tree2.branch)
 
290
 
 
291
        dlg = commit.CommitDialog(tree)
 
292
 
 
293
        self.assertTrue(dlg._pending_box.get_property('visible'))
 
294
 
 
295
        commit_col = dlg._treeview_files.get_column(0)
 
296
        self.assertEqual('Commit*', commit_col.get_title())
 
297
        renderer = commit_col.get_cells()[0]
 
298
        self.assertFalse(renderer.get_property('activatable'))
 
299
 
 
300
        values = [(r[0], r[1], r[2], r[3]) for r in dlg._pending_store]
 
301
        self.assertEqual([(rev_id2, '2007-10-01', 'Joe Foo', 'two')], values)
 
302
 
 
303
        self.assertEqual('Commit all changes*',
 
304
                         dlg._commit_all_files_radio.get_label())
 
305
        self.assertFalse(dlg._commit_all_files_radio.get_property('sensitive'))
 
306
        self.assertFalse(dlg._commit_selected_radio.get_property('sensitive'))
 
307
 
 
308
    def test_pending_multiple(self):
 
309
        tree = self.make_branch_and_tree('tree')
 
310
        rev_id1 = tree.commit('one')
 
311
 
 
312
        tree2 = tree.bzrdir.sprout('tree2').open_workingtree()
 
313
        rev_id2 = tree2.commit('two',
 
314
                               committer='Joe Foo <joe@foo.com>',
 
315
                               timestamp=1191264271.05,
 
316
                               timezone=+7200)
 
317
        rev_id3 = tree2.commit('three',
 
318
                               committer='Jerry Foo <jerry@foo.com>',
 
319
                               timestamp=1191264278.05,
 
320
                               timezone=+7200)
 
321
        tree.merge_from_branch(tree2.branch)
 
322
        tree3 = tree.bzrdir.sprout('tree3').open_workingtree()
 
323
        rev_id4 = tree3.commit('four',
 
324
                               committer='Joe Foo <joe@foo.com>',
 
325
                               timestamp=1191264279.05,
 
326
                               timezone=+7200)
 
327
        rev_id5 = tree3.commit('five',
 
328
                               committer='Jerry Foo <jerry@foo.com>',
 
329
                               timestamp=1191372278.05,
 
330
                               timezone=+7200)
 
331
        tree.merge_from_branch(tree3.branch, force=True)
 
332
 
 
333
        dlg = commit.CommitDialog(tree)
 
334
        # TODO: assert that the pending box is set to show
 
335
        values = [(r[0], r[1], r[2], r[3]) for r in dlg._pending_store]
 
336
        self.assertEqual([(rev_id3, '2007-10-01', 'Jerry Foo', 'three'),
 
337
                          (rev_id2, '2007-10-01', 'Joe Foo', 'two'),
 
338
                          (rev_id5, '2007-10-03', 'Jerry Foo', 'five'),
 
339
                          (rev_id4, '2007-10-01', 'Joe Foo', 'four'),
 
340
                         ], values)
 
341
 
 
342
    def test_filelist_added(self):
 
343
        tree = self.make_branch_and_tree('tree')
 
344
        self.build_tree(['tree/a', 'tree/b/', 'tree/b/c'])
 
345
        tree.add(['a', 'b', 'b/c'], ['a-id', 'b-id', 'c-id'])
 
346
 
 
347
        dlg = commit.CommitDialog(tree)
 
348
        values = [(r[0], r[1], r[2], r[3], r[4]) for r in dlg._files_store]
 
349
        self.assertEqual([("", "", True, 'All Files', ''),
 
350
                          ('a-id', 'a', True, 'a', 'added'),
 
351
                          ('b-id', 'b', True, 'b/', 'added'),
 
352
                          ('c-id', 'b/c', True, 'b/c', 'added'),
 
353
                         ], values)
 
354
 
 
355
    def test_filelist_renamed(self):
 
356
        tree = self.make_branch_and_tree('tree')
 
357
        self.build_tree(['tree/a', 'tree/b/', 'tree/b/c'])
 
358
        tree.add(['a', 'b', 'b/c'], ['a-id', 'b-id', 'c-id'])
 
359
        rev_id1 = tree.commit('one')
 
360
 
 
361
        tree.rename_one('b', 'd')
 
362
        tree.rename_one('a', 'd/a')
 
363
 
 
364
        dlg = commit.CommitDialog(tree)
 
365
        values = [(r[0], r[1], r[2], r[3], r[4]) for r in dlg._files_store]
 
366
        self.assertEqual([("", "", True, 'All Files', ''),
 
367
                          ('b-id', 'd', True, 'b/ => d/', 'renamed'),
 
368
                          ('a-id', 'd/a', True, 'a => d/a', 'renamed'),
 
369
                         ], values)
 
370
 
 
371
    def test_filelist_modified(self):
 
372
        tree = self.make_branch_and_tree('tree')
 
373
        self.build_tree(['tree/a'])
 
374
        tree.add(['a'], ['a-id'])
 
375
        rev_id1 = tree.commit('one')
 
376
 
 
377
        self.build_tree_contents([('tree/a', 'new contents for a\n')])
 
378
 
 
379
        dlg = commit.CommitDialog(tree)
 
380
        values = [(r[0], r[1], r[2], r[3], r[4]) for r in dlg._files_store]
 
381
        self.assertEqual([("", "", True, 'All Files', ''),
 
382
                          ('a-id', 'a', True, 'a', 'modified'),
 
383
                         ], values)
 
384
 
 
385
    def test_filelist_renamed_and_modified(self):
 
386
        tree = self.make_branch_and_tree('tree')
 
387
        self.build_tree(['tree/a', 'tree/b/', 'tree/b/c'])
 
388
        tree.add(['a', 'b', 'b/c'], ['a-id', 'b-id', 'c-id'])
 
389
        rev_id1 = tree.commit('one')
 
390
 
 
391
        tree.rename_one('b', 'd')
 
392
        tree.rename_one('a', 'd/a')
 
393
        self.build_tree_contents([('tree/d/a', 'new contents for a\n'),
 
394
                                  ('tree/d/c', 'new contents for c\n'),
 
395
                                 ])
 
396
        # 'c' is not considered renamed, because only its parent was moved, it
 
397
        # stayed in the same directory
 
398
 
 
399
        dlg = commit.CommitDialog(tree)
 
400
        values = [(r[0], r[1], r[2], r[3], r[4]) for r in dlg._files_store]
 
401
        self.assertEqual([("", "", True, 'All Files', ''),
 
402
                          ('b-id', 'd', True, 'b/ => d/', 'renamed'),
 
403
                          ('a-id', 'd/a', True, 'a => d/a', 'renamed and modified'),
 
404
                          ('c-id', 'd/c', True, 'd/c', 'modified'),
 
405
                         ], values)
 
406
 
 
407
    def test_filelist_kind_changed(self):
 
408
        tree = self.make_branch_and_tree('tree')
 
409
        self.build_tree(['tree/a', 'tree/b'])
 
410
        tree.add(['a', 'b'], ['a-id', 'b-id'])
 
411
        tree.commit('one')
 
412
 
 
413
        os.remove('tree/a')
 
414
        self.build_tree(['tree/a/'])
 
415
        # XXX:  This is technically valid, and the file list handles it fine,
 
416
        #       but 'show_diff_trees()' does not, so we skip this part of the
 
417
        #       test for now.
 
418
        # tree.rename_one('b', 'c')
 
419
        # os.remove('tree/c')
 
420
        # self.build_tree(['tree/c/'])
 
421
 
 
422
        dlg = commit.CommitDialog(tree)
 
423
        values = [(r[0], r[1], r[2], r[3], r[4]) for r in dlg._files_store]
 
424
        self.assertEqual([("", "", True, 'All Files', ''),
 
425
                          ('a-id', 'a', True, 'a => a/', 'kind changed'),
 
426
                          # ('b-id', 'c', True, 'b => c/', 'renamed and modified'),
 
427
                         ], values)
 
428
 
 
429
    def test_filelist_removed(self):
 
430
        tree = self.make_branch_and_tree('tree')
 
431
        self.build_tree(['tree/a', 'tree/b/'])
 
432
        tree.add(['a', 'b'], ['a-id', 'b-id'])
 
433
        tree.commit('one')
 
434
 
 
435
        os.remove('tree/a')
 
436
        tree.remove('b', force=True)
 
437
 
 
438
        dlg = commit.CommitDialog(tree)
 
439
        values = [(r[0], r[1], r[2], r[3], r[4]) for r in dlg._files_store]
 
440
        self.assertEqual([("", "", True, 'All Files', ''),
 
441
                          ('a-id', 'a', True, 'a', 'removed'),
 
442
                          ('b-id', 'b', True, 'b/', 'removed'),
 
443
                         ], values)
 
444
        # All Files should be selected
 
445
        self.assertEqual(
 
446
            (Gtk.TreePath(path=0), None), dlg._treeview_files.get_cursor())
 
447
 
 
448
    def test_filelist_with_selected(self):
 
449
        tree = self.make_branch_and_tree('tree')
 
450
        self.build_tree(['tree/a', 'tree/b/'])
 
451
        tree.add(['a', 'b'], ['a-id', 'b-id'])
 
452
 
 
453
        dlg = commit.CommitDialog(tree, selected='a')
 
454
        values = [(r[0], r[1], r[2], r[3], r[4]) for r in dlg._files_store]
 
455
        self.assertEqual([("", "", False, 'All Files', ''),
 
456
                          ('a-id', 'a', True, 'a', 'added'),
 
457
                          ('b-id', 'b', False, 'b/', 'added'),
 
458
                         ], values)
 
459
        # This file should also be selected in the file list, rather than the
 
460
        # 'All Files' selection
 
461
        self.assertEqual(
 
462
            (Gtk.TreePath(path=1), None), dlg._treeview_files.get_cursor())
 
463
 
 
464
    def test_diff_view(self):
 
465
        tree = self.make_branch_and_tree('tree')
 
466
        self.build_tree(['tree/a', 'tree/b'])
 
467
        tree.add(['a', 'b'], ['a-id', 'b-id'])
 
468
        tree.commit('one')
 
469
 
 
470
        self.build_tree_contents([('tree/a', 'new contents for a\n')])
 
471
        tree.remove('b')
 
472
 
 
473
        dlg = commit.CommitDialog(tree)
 
474
        diff_buffer = dlg._diff_view.buffer
 
475
        text = diff_buffer.get_text(diff_buffer.get_start_iter(),
 
476
                                    diff_buffer.get_end_iter(),
 
477
                                    True).splitlines(True)
 
478
 
 
479
        self.assertEqual("=== modified file 'a'\n", text[0])
 
480
        self.assertContainsRe(text[1],
 
481
            r"--- a\t\d\d\d\d-\d\d-\d\d \d\d:\d\d:\d\d [+-]\d\d\d\d")
 
482
        self.assertContainsRe(text[2],
 
483
            r"\+\+\+ a\t\d\d\d\d-\d\d-\d\d \d\d:\d\d:\d\d [+-]\d\d\d\d")
 
484
        self.assertEqual('@@ -1,1 +1,1 @@\n', text[3])
 
485
        self.assertEqual('-contents of tree/a\n', text[4])
 
486
        self.assertEqual('+new contents for a\n', text[5])
 
487
        self.assertEqual('\n', text[6])
 
488
 
 
489
        self.assertEqual("=== removed file 'b'\n", text[7])
 
490
        self.assertContainsRe(text[8],
 
491
            r"--- b\t\d\d\d\d-\d\d-\d\d \d\d:\d\d:\d\d [+-]\d\d\d\d")
 
492
        self.assertEqual('+++ b\t1970-01-01 00:00:00 +0000\n', text[9])
 
493
        self.assertEqual('@@ -1,1 +0,0 @@\n', text[10])
 
494
        self.assertEqual('-contents of tree/b\n', text[11])
 
495
        self.assertEqual('\n', text[12])
 
496
 
 
497
        self.assertEqual('Diff for All Files', dlg._diff_label.get_text())
 
498
 
 
499
    def test_commit_partial_toggle(self):
 
500
        tree = self.make_branch_and_tree('tree')
 
501
        self.build_tree(['tree/a', 'tree/b'])
 
502
        tree.add(['a', 'b'], ['a-id', 'b-id'])
 
503
 
 
504
        dlg = commit.CommitDialog(tree)
 
505
        checked_col = dlg._treeview_files.get_column(0)
 
506
        self.assertFalse(checked_col.get_property('visible'))
 
507
        self.assertTrue(dlg._commit_all_changes)
 
508
 
 
509
        dlg._commit_selected_radio.set_active(True)
 
510
        self.assertTrue(checked_col.get_property('visible'))
 
511
        self.assertFalse(dlg._commit_all_changes)
 
512
 
 
513
    def test_file_selection(self):
 
514
        """Several things should happen when a file has been selected."""
 
515
        tree = self.make_branch_and_tree('tree')
 
516
        tree.branch.get_config().set_user_option('per_file_commits', 'true')
 
517
        self.build_tree(['tree/a', 'tree/b'])
 
518
        tree.add(['a', 'b'], ['a-id', 'b-id'])
 
519
 
 
520
        dlg = commit.CommitDialog(tree)
 
521
        diff_buffer = dlg._diff_view.buffer
 
522
        self.assertEqual('Diff for All Files', dlg._diff_label.get_text())
 
523
        self.assertEqual('File commit message',
 
524
                         dlg._file_message_expander.get_label())
 
525
        self.assertFalse(dlg._file_message_expander.get_expanded())
 
526
        self.assertFalse(dlg._file_message_expander.get_property('sensitive'))
 
527
 
 
528
        dlg._treeview_files.set_cursor(
 
529
            Gtk.TreePath(path=1), None, False)
 
530
        self.assertEqual('Diff for a', dlg._diff_label.get_text())
 
531
        text = diff_buffer.get_text(diff_buffer.get_start_iter(),
 
532
                                    diff_buffer.get_end_iter(),
 
533
                                    True).splitlines(True)
 
534
        self.assertEqual("=== added file 'a'\n", text[0])
 
535
        self.assertContainsRe(text[1],
 
536
            r"--- a\t\d\d\d\d-\d\d-\d\d \d\d:\d\d:\d\d [+-]\d\d\d\d")
 
537
        self.assertContainsRe(text[2],
 
538
            r"\+\+\+ a\t\d\d\d\d-\d\d-\d\d \d\d:\d\d:\d\d [+-]\d\d\d\d")
 
539
        self.assertEqual('@@ -0,0 +1,1 @@\n', text[3])
 
540
        self.assertEqual('+contents of tree/a\n', text[4])
 
541
        self.assertEqual('\n', text[5])
 
542
        self.assertEqual('Commit message for a',
 
543
                         dlg._file_message_expander.get_label())
 
544
        self.assertTrue(dlg._file_message_expander.get_expanded())
 
545
        self.assertTrue(dlg._file_message_expander.get_property('sensitive'))
 
546
 
 
547
        dlg._treeview_files.set_cursor(
 
548
            Gtk.TreePath(path=2), None, False)
 
549
        self.assertEqual('Diff for b', dlg._diff_label.get_text())
 
550
        text = diff_buffer.get_text(diff_buffer.get_start_iter(),
 
551
                                    diff_buffer.get_end_iter(),
 
552
                                    True).splitlines(True)
 
553
        self.assertEqual("=== added file 'b'\n", text[0])
 
554
        self.assertContainsRe(text[1],
 
555
            r"--- b\t\d\d\d\d-\d\d-\d\d \d\d:\d\d:\d\d [+-]\d\d\d\d")
 
556
        self.assertContainsRe(text[2],
 
557
            r"\+\+\+ b\t\d\d\d\d-\d\d-\d\d \d\d:\d\d:\d\d [+-]\d\d\d\d")
 
558
        self.assertEqual('@@ -0,0 +1,1 @@\n', text[3])
 
559
        self.assertEqual('+contents of tree/b\n', text[4])
 
560
        self.assertEqual('\n', text[5])
 
561
        self.assertEqual('Commit message for b',
 
562
                         dlg._file_message_expander.get_label())
 
563
        self.assertTrue(dlg._file_message_expander.get_expanded())
 
564
        self.assertTrue(dlg._file_message_expander.get_property('sensitive'))
 
565
 
 
566
        dlg._treeview_files.set_cursor(
 
567
            Gtk.TreePath(path=0), None, False)
 
568
        self.assertEqual('Diff for All Files', dlg._diff_label.get_text())
 
569
        self.assertEqual('File commit message',
 
570
                         dlg._file_message_expander.get_label())
 
571
        self.assertFalse(dlg._file_message_expander.get_expanded())
 
572
        self.assertFalse(dlg._file_message_expander.get_property('sensitive'))
 
573
 
 
574
    def test_file_selection_message(self):
 
575
        """Selecting a file should bring up its commit message."""
 
576
        tree = self.make_branch_and_tree('tree')
 
577
        tree.branch.get_config().set_user_option('per_file_commits', 'true')
 
578
        self.build_tree(['tree/a', 'tree/b/'])
 
579
        tree.add(['a', 'b'], ['a-id', 'b-id'])
 
580
 
 
581
        def get_file_text():
 
582
            buf = dlg._file_message_text_view.get_buffer()
 
583
            return buf.get_text(
 
584
                buf.get_start_iter(), buf.get_end_iter(), True)
 
585
 
 
586
        def get_saved_text(path):
 
587
            """Get the saved text for a given record."""
 
588
            return dlg._files_store.get_value(dlg._files_store.get_iter(path), 5)
 
589
 
 
590
        dlg = commit.CommitDialog(tree)
 
591
        self.assertEqual('File commit message',
 
592
                         dlg._file_message_expander.get_label())
 
593
        self.assertFalse(dlg._file_message_expander.get_expanded())
 
594
        self.assertFalse(dlg._file_message_expander.get_property('sensitive'))
 
595
        self.assertEqual('', get_file_text())
 
596
 
 
597
        dlg._treeview_files.set_cursor(
 
598
            Gtk.TreePath(path=1), None, False)
 
599
        self.assertEqual('Commit message for a',
 
600
                         dlg._file_message_expander.get_label())
 
601
        self.assertTrue(dlg._file_message_expander.get_expanded())
 
602
        self.assertTrue(dlg._file_message_expander.get_property('sensitive'))
 
603
        self.assertEqual('', get_file_text())
 
604
 
 
605
        self.assertEqual('', get_saved_text(1))
 
606
        dlg._set_file_commit_message('Some text\nfor a\n')
 
607
        dlg._save_current_file_message()
 
608
        # We should have updated the ListStore with the new file commit info
 
609
        self.assertEqual('Some text\nfor a\n', get_saved_text(1))
 
610
 
 
611
        dlg._treeview_files.set_cursor(
 
612
            Gtk.TreePath(path=2), None, False)
 
613
        self.assertEqual('Commit message for b/',
 
614
                         dlg._file_message_expander.get_label())
 
615
        self.assertTrue(dlg._file_message_expander.get_expanded())
 
616
        self.assertTrue(dlg._file_message_expander.get_property('sensitive'))
 
617
        self.assertEqual('', get_file_text())
 
618
 
 
619
        self.assertEqual('', get_saved_text(2))
 
620
        dlg._set_file_commit_message('More text\nfor b\n')
 
621
        # Now switch back to 'a'. The message should be saved, and the buffer
 
622
        # should be updated with the other text
 
623
        dlg._treeview_files.set_cursor(
 
624
            Gtk.TreePath(path=1), None, False)
 
625
        self.assertEqual('More text\nfor b\n', get_saved_text(2))
 
626
        self.assertEqual('Commit message for a',
 
627
                         dlg._file_message_expander.get_label())
 
628
        self.assertTrue(dlg._file_message_expander.get_expanded())
 
629
        self.assertTrue(dlg._file_message_expander.get_property('sensitive'))
 
630
        self.assertEqual('Some text\nfor a\n', get_file_text())
 
631
 
 
632
    def test_toggle_all_files(self):
 
633
        """When checking the All Files entry, it should toggle all fields"""
 
634
        tree = self.make_branch_and_tree('tree')
 
635
        self.build_tree(['tree/a', 'tree/b/'])
 
636
        tree.add(['a', 'b'], ['a-id', 'b-id'])
 
637
 
 
638
        dlg = commit.CommitDialog(tree)
 
639
        self.assertEqual([("", "", True),
 
640
                          ('a-id', 'a', True),
 
641
                          ('b-id', 'b', True),
 
642
                         ], [(r[0], r[1], r[2]) for r in dlg._files_store])
 
643
 
 
644
        # TODO: jam 20071002 I'm not sure how to exactly trigger a toggle, it
 
645
        #       looks like we need to call renderer.activate() and pass an
 
646
        #       event and widget, and lots of other stuff I'm not sure what to
 
647
        #       do with. So instead, we just call toggle directly, and assume
 
648
        #       that toggle is hooked in correctly
 
649
        # column = dlg._treeview_files.get_column(0)
 
650
        # renderer = column.get_cells()[0]
 
651
 
 
652
        # Toggle a single entry should set just that entry to False
 
653
        dlg._toggle_commit(None, 1, dlg._files_store)
 
654
        self.assertEqual([("", "", True),
 
655
                          ('a-id', 'a', False),
 
656
                          ('b-id', 'b', True),
 
657
                         ], [(r[0], r[1], r[2]) for r in dlg._files_store])
 
658
 
 
659
        # Toggling the main entry should set all entries
 
660
        dlg._toggle_commit(None, 0, dlg._files_store)
 
661
        self.assertEqual([("", "", False),
 
662
                          ('a-id', 'a', False),
 
663
                          ('b-id', 'b', False),
 
664
                         ], [(r[0], r[1], r[2]) for r in dlg._files_store])
 
665
 
 
666
        dlg._toggle_commit(None, 2, dlg._files_store)
 
667
        self.assertEqual([("", "", False),
 
668
                          ('a-id', 'a', False),
 
669
                          ('b-id', 'b', True),
 
670
                         ], [(r[0], r[1], r[2]) for r in dlg._files_store])
 
671
 
 
672
        dlg._toggle_commit(None, 0, dlg._files_store)
 
673
        self.assertEqual([("", "", True),
 
674
                          ('a-id', 'a', True),
 
675
                          ('b-id', 'b', True),
 
676
                         ], [(r[0], r[1], r[2]) for r in dlg._files_store])
 
677
 
 
678
    def test_specific_files(self):
 
679
        tree = self.make_branch_and_tree('tree')
 
680
        self.build_tree(['tree/a', 'tree/b/'])
 
681
        tree.add(['a', 'b'], ['a-id', 'b-id'])
 
682
 
 
683
        dlg = commit.CommitDialog(tree)
 
684
        self.assertEqual((['a', 'b'], []), dlg._get_specific_files())
 
685
 
 
686
        dlg._commit_selected_radio.set_active(True)
 
687
        dlg._toggle_commit(None, 0, dlg._files_store)
 
688
        self.assertEqual(([], []), dlg._get_specific_files())
 
689
 
 
690
        dlg._toggle_commit(None, 1, dlg._files_store)
 
691
        self.assertEqual((['a'], []), dlg._get_specific_files())
 
692
 
 
693
    def test_specific_files_with_messages(self):
 
694
        tree = self.make_branch_and_tree('tree')
 
695
        tree.branch.get_config().set_user_option('per_file_commits', 'true')
 
696
        self.build_tree(['tree/a_file', 'tree/b_dir/'])
 
697
        tree.add(['a_file', 'b_dir'], ['1a-id', '0b-id'])
 
698
 
 
699
        dlg = commit.CommitDialog(tree)
 
700
        dlg._commit_selected_radio.set_active(True)
 
701
        self.assertEqual((['a_file', 'b_dir'], []), dlg._get_specific_files())
 
702
 
 
703
        dlg._treeview_files.set_cursor(
 
704
            Gtk.TreePath(path=1), None, False)
 
705
        dlg._set_file_commit_message('Test\nmessage\nfor a_file\n')
 
706
        dlg._treeview_files.set_cursor(
 
707
            Gtk.TreePath(path=2), None, False)
 
708
        dlg._set_file_commit_message('message\nfor b_dir\n')
 
709
 
 
710
        self.assertEqual((['a_file', 'b_dir'],
 
711
                          [{'path':'a_file', 'file_id':'1a-id',
 
712
                            'message':'Test\nmessage\nfor a_file\n'},
 
713
                           {'path':'b_dir', 'file_id':'0b-id',
 
714
                            'message':'message\nfor b_dir\n'},
 
715
                          ]), dlg._get_specific_files())
 
716
 
 
717
        dlg._toggle_commit(None, 1, dlg._files_store)
 
718
        self.assertEqual((['b_dir'],
 
719
                          [{'path':'b_dir', 'file_id':'0b-id',
 
720
                            'message':'message\nfor b_dir\n'},
 
721
                          ]), dlg._get_specific_files())
 
722
 
 
723
    def test_specific_files_sanitizes_messages(self):
 
724
        tree = self.make_branch_and_tree('tree')
 
725
        tree.branch.get_config().set_user_option('per_file_commits', 'true')
 
726
        self.build_tree(['tree/a_file', 'tree/b_dir/'])
 
727
        tree.add(['a_file', 'b_dir'], ['1a-id', '0b-id'])
 
728
 
 
729
        dlg = commit.CommitDialog(tree)
 
730
        dlg._commit_selected_radio.set_active(True)
 
731
        self.assertEqual((['a_file', 'b_dir'], []), dlg._get_specific_files())
 
732
 
 
733
        dlg._treeview_files.set_cursor(
 
734
            Gtk.TreePath(path=1), None, False)
 
735
        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)
 
738
        dlg._set_file_commit_message('message\r\nfor\nb_dir\r')
 
739
 
 
740
        self.assertEqual((['a_file', 'b_dir'],
 
741
                          [{'path':'a_file', 'file_id':'1a-id',
 
742
                            'message':'Test\nmessage\nfor a_file\n'},
 
743
                           {'path':'b_dir', 'file_id':'0b-id',
 
744
                            'message':'message\nfor\nb_dir\n'},
 
745
                          ]), dlg._get_specific_files())
 
746
 
 
747
 
 
748
class QuestionHelpers(object):
 
749
 
 
750
    def _set_question_yes(self, dlg):
 
751
        """Set the dialog to answer YES to any questions."""
 
752
        self.questions = []
 
753
        def _question_yes(*args, **kwargs):
 
754
            self.questions.append(args)
 
755
            self.questions.append('YES')
 
756
            return Gtk.ResponseType.YES
 
757
        dlg._question_dialog = _question_yes
 
758
 
 
759
    def _set_question_no(self, dlg):
 
760
        """Set the dialog to answer NO to any questions."""
 
761
        self.questions = []
 
762
        def _question_no(*args, **kwargs):
 
763
            self.questions.append(args)
 
764
            self.questions.append('NO')
 
765
            return Gtk.ResponseType.NO
 
766
        dlg._question_dialog = _question_no
 
767
 
 
768
 
 
769
class TestCommitDialog_Commit(tests.TestCaseWithTransport, QuestionHelpers):
 
770
    """Tests on the actual 'commit' button being pushed."""
 
771
 
 
772
    def test_bound_commit_local(self):
 
773
        tree = self.make_branch_and_tree('tree')
 
774
        self.build_tree(['tree/a'])
 
775
        tree.add(['a'], ['a-id'])
 
776
        rev_id1 = tree.commit('one')
 
777
 
 
778
        tree2 = tree.bzrdir.sprout('tree2').open_workingtree()
 
779
        self.build_tree(['tree2/b'])
 
780
        tree2.add(['b'], ['b-id'])
 
781
        tree2.branch.bind(tree.branch)
 
782
 
 
783
        dlg = commit.CommitDialog(tree2)
 
784
        # With the check box set, it should only effect the local branch
 
785
        dlg._check_local.set_active(True)
 
786
        dlg._set_global_commit_message('Commit message\n')
 
787
        dlg._do_commit()
 
788
 
 
789
        last_rev = tree2.last_revision()
 
790
        self.assertEqual(last_rev, dlg.committed_revision_id)
 
791
        self.assertEqual(rev_id1, tree.branch.last_revision())
 
792
 
 
793
    def test_commit_global_sanitizes_message(self):
 
794
        tree = self.make_branch_and_tree('tree')
 
795
        self.build_tree(['tree/a'])
 
796
        tree.add(['a'], ['a-id'])
 
797
        rev_id1 = tree.commit('one')
 
798
 
 
799
        self.build_tree(['tree/b'])
 
800
        tree.add(['b'], ['b-id'])
 
801
        dlg = commit.CommitDialog(tree)
 
802
        # With the check box set, it should only effect the local branch
 
803
        dlg._set_global_commit_message('Commit\r\nmessage\rfoo\n')
 
804
        dlg._do_commit()
 
805
        rev = tree.branch.repository.get_revision(tree.last_revision())
 
806
        self.assertEqual('Commit\nmessage\nfoo\n', rev.message)
 
807
 
 
808
    def test_bound_commit_both(self):
 
809
        tree = self.make_branch_and_tree('tree')
 
810
        self.build_tree(['tree/a'])
 
811
        tree.add(['a'], ['a-id'])
 
812
        rev_id1 = tree.commit('one')
 
813
 
 
814
        tree2 = tree.bzrdir.sprout('tree2').open_workingtree()
 
815
        self.build_tree(['tree2/b'])
 
816
        tree2.add(['b'], ['b-id'])
 
817
        tree2.branch.bind(tree.branch)
 
818
 
 
819
        dlg = commit.CommitDialog(tree2)
 
820
        # With the check box set, it should only effect the local branch
 
821
        dlg._check_local.set_active(False)
 
822
        dlg._set_global_commit_message('Commit message\n')
 
823
        dlg._do_commit()
 
824
 
 
825
        last_rev = tree2.last_revision()
 
826
        self.assertEqual(last_rev, dlg.committed_revision_id)
 
827
        self.assertEqual(last_rev, tree.branch.last_revision())
 
828
 
 
829
    def test_commit_empty_message(self):
 
830
        tree = self.make_branch_and_tree('tree')
 
831
        self.build_tree(['tree/a', 'tree/b'])
 
832
        tree.add(['a'], ['a-id'])
 
833
        rev_id = tree.commit('one')
 
834
 
 
835
        tree.add(['b'], ['b-id'])
 
836
 
 
837
        dlg = commit.CommitDialog(tree)
 
838
        self._set_question_no(dlg)
 
839
        dlg._do_commit()
 
840
        self.assertEqual(
 
841
            [('Commit with an empty message?',
 
842
              'You can describe your commit intent in the message.'),
 
843
              'NO',
 
844
            ], self.questions)
 
845
        # By saying NO, nothing should be committed.
 
846
        self.assertEqual(rev_id, tree.last_revision())
 
847
        self.assertIs(None, dlg.committed_revision_id)
 
848
        self.assertTrue(dlg._global_message_text_view.get_property('is-focus'))
 
849
 
 
850
        self._set_question_yes(dlg)
 
851
 
 
852
        dlg._do_commit()
 
853
        self.assertEqual(
 
854
            [('Commit with an empty message?',
 
855
              'You can describe your commit intent in the message.'),
 
856
              'YES',
 
857
            ], self.questions)
 
858
        committed = tree.last_revision()
 
859
        self.assertNotEqual(rev_id, committed)
 
860
        self.assertEqual(committed, dlg.committed_revision_id)
 
861
 
 
862
    def test_initial_commit(self):
 
863
        tree = self.make_branch_and_tree('tree')
 
864
        self.build_tree(['tree/a'])
 
865
        tree.add(['a'], ['a-id'])
 
866
 
 
867
        dlg = commit.CommitDialog(tree)
 
868
        dlg._set_global_commit_message('Some text\n')
 
869
        dlg._do_commit()
 
870
 
 
871
        last_rev = tree.last_revision()
 
872
        self.assertEqual(last_rev, dlg.committed_revision_id)
 
873
        rev = tree.branch.repository.get_revision(last_rev)
 
874
        self.assertEqual(last_rev, rev.revision_id)
 
875
        self.assertEqual('Some text\n', rev.message)
 
876
 
 
877
    def test_pointless_commit(self):
 
878
        tree = self.make_branch_and_tree('tree')
 
879
        self.build_tree(['tree/a'])
 
880
        tree.add(['a'], ['a-id'])
 
881
        rev_id1 = tree.commit('one')
 
882
 
 
883
        dlg = commit.CommitDialog(tree)
 
884
        dlg._set_global_commit_message('Some text\n')
 
885
 
 
886
        self._set_question_no(dlg)
 
887
        dlg._do_commit()
 
888
 
 
889
        self.assertIs(None, dlg.committed_revision_id)
 
890
        self.assertEqual(rev_id1, tree.last_revision())
 
891
        self.assertEqual(
 
892
            [('Commit with no changes?',
 
893
              'There are no changes in the working tree.'
 
894
              ' Do you want to commit anyway?'),
 
895
              'NO',
 
896
            ], self.questions)
 
897
 
 
898
        self._set_question_yes(dlg)
 
899
        dlg._do_commit()
 
900
 
 
901
        rev_id2 = tree.last_revision()
 
902
        self.assertEqual(rev_id2, dlg.committed_revision_id)
 
903
        self.assertNotEqual(rev_id1, rev_id2)
 
904
        self.assertEqual(
 
905
            [('Commit with no changes?',
 
906
              'There are no changes in the working tree.'
 
907
              ' Do you want to commit anyway?'),
 
908
              'YES',
 
909
            ], self.questions)
 
910
 
 
911
    def test_unknowns(self):
 
912
        """We should check if there are unknown files."""
 
913
        tree = self.make_branch_and_tree('tree')
 
914
        rev_id1 = tree.commit('one')
 
915
        self.build_tree(['tree/a', 'tree/b'])
 
916
        tree.add(['a'], ['a-id'])
 
917
 
 
918
        dlg = commit.CommitDialog(tree)
 
919
        dlg._set_global_commit_message('Some text\n')
 
920
        self._set_question_no(dlg)
 
921
 
 
922
        dlg._do_commit()
 
923
 
 
924
        self.assertIs(None, dlg.committed_revision_id)
 
925
        self.assertEqual(rev_id1, tree.last_revision())
 
926
        self.assertEqual(
 
927
            [("Commit with unknowns?",
 
928
              "Unknown files exist in the working tree. Commit anyway?"),
 
929
              "NO",
 
930
            ], self.questions)
 
931
 
 
932
        self._set_question_yes(dlg)
 
933
        dlg._do_commit()
 
934
 
 
935
        rev_id2 = tree.last_revision()
 
936
        self.assertNotEqual(rev_id1, rev_id2)
 
937
        self.assertEqual(rev_id2, dlg.committed_revision_id)
 
938
        self.assertEqual(
 
939
            [("Commit with unknowns?",
 
940
              "Unknown files exist in the working tree. Commit anyway?"),
 
941
              "YES",
 
942
            ], self.questions)
 
943
 
 
944
    def test_commit_specific_files(self):
 
945
        tree = self.make_branch_and_tree('tree')
 
946
        rev_id1 = tree.commit('one')
 
947
        self.build_tree(['tree/a', 'tree/b'])
 
948
        tree.add(['a', 'b'], ['a-id', 'b-id'])
 
949
 
 
950
        dlg = commit.CommitDialog(tree)
 
951
        dlg._commit_selected_radio.set_active(True) # enable partial
 
952
        dlg._toggle_commit(None, 2, dlg._files_store) # unset 'b'
 
953
 
 
954
        dlg._set_global_commit_message('Committing just "a"\n')
 
955
        dlg._do_commit()
 
956
 
 
957
        rev_id2 = dlg.committed_revision_id
 
958
        self.assertIsNot(None, rev_id2)
 
959
        self.assertEqual(rev_id2, tree.last_revision())
 
960
 
 
961
        rt = tree.branch.repository.revision_tree(rev_id2)
 
962
        entries = [(path, ie.file_id) for path, ie in rt.iter_entries_by_dir()
 
963
                                       if path] # Ignore the root entry
 
964
        self.assertEqual([('a', 'a-id')], entries)
 
965
 
 
966
    def test_commit_partial_no_partial(self):
 
967
        """Ignore the checkboxes if committing all files."""
 
968
        tree = self.make_branch_and_tree('tree')
 
969
        rev_id1 = tree.commit('one')
 
970
        self.build_tree(['tree/a', 'tree/b'])
 
971
        tree.add(['a', 'b'], ['a-id', 'b-id'])
 
972
 
 
973
        dlg = commit.CommitDialog(tree)
 
974
        dlg._commit_selected_radio.set_active(True) # enable partial
 
975
        dlg._toggle_commit(None, 2, dlg._files_store) # unset 'b'
 
976
 
 
977
        # Switch back to committing all changes
 
978
        dlg._commit_all_files_radio.set_active(True)
 
979
 
 
980
        dlg._set_global_commit_message('Committing everything\n')
 
981
        dlg._do_commit()
 
982
 
 
983
        rev_id2 = dlg.committed_revision_id
 
984
        self.assertIsNot(None, rev_id2)
 
985
        self.assertEqual(rev_id2, tree.last_revision())
 
986
 
 
987
        rt = tree.branch.repository.revision_tree(rev_id2)
 
988
        entries = [(path, ie.file_id) for path, ie in rt.iter_entries_by_dir()
 
989
                                       if path] # Ignore the root entry
 
990
        self.assertEqual([('a', 'a-id'), ('b', 'b-id')], entries)
 
991
 
 
992
    def test_commit_no_messages(self):
 
993
        tree = self.make_branch_and_tree('tree')
 
994
        rev_id1 = tree.commit('one')
 
995
        self.build_tree(['tree/a', 'tree/b'])
 
996
        tree.add(['a', 'b'], ['a-id', 'b-id'])
 
997
 
 
998
        dlg = commit.CommitDialog(tree)
 
999
        dlg._set_global_commit_message('Simple commit\n')
 
1000
        dlg._do_commit()
 
1001
 
 
1002
        rev = tree.branch.repository.get_revision(dlg.committed_revision_id)
 
1003
        self.failIf('file-info' in rev.properties)
 
1004
 
 
1005
    def test_commit_disabled_messages(self):
 
1006
        tree = self.make_branch_and_tree('tree')
 
1007
        rev_id1 = tree.commit('one')
 
1008
 
 
1009
        self.build_tree(['tree/a', 'tree/b'])
 
1010
        tree.add(['a', 'b'], ['a-id', 'b-id'])
 
1011
 
 
1012
        dlg = commit.CommitDialog(tree)
 
1013
        self.assertFalse(dlg._file_message_expander.get_property('visible'))
 
1014
        self.assertEqual('Commit Message',
 
1015
                         dlg._global_message_label.get_text())
 
1016
 
 
1017
        tree.branch.get_config().set_user_option('per_file_commits', 'true')
 
1018
        dlg = commit.CommitDialog(tree)
 
1019
        self.assertTrue(dlg._file_message_expander.get_property('visible'))
 
1020
        self.assertEqual('Global Commit Message',
 
1021
                         dlg._global_message_label.get_text())
 
1022
 
 
1023
        tree.branch.get_config().set_user_option('per_file_commits', 'on')
 
1024
        dlg = commit.CommitDialog(tree)
 
1025
        self.assertTrue(dlg._file_message_expander.get_property('visible'))
 
1026
        self.assertEqual('Global Commit Message',
 
1027
                         dlg._global_message_label.get_text())
 
1028
 
 
1029
        tree.branch.get_config().set_user_option('per_file_commits', 'y')
 
1030
        dlg = commit.CommitDialog(tree)
 
1031
        self.assertTrue(dlg._file_message_expander.get_property('visible'))
 
1032
        self.assertEqual('Global Commit Message',
 
1033
                         dlg._global_message_label.get_text())
 
1034
 
 
1035
        tree.branch.get_config().set_user_option('per_file_commits', 'n')
 
1036
        dlg = commit.CommitDialog(tree)
 
1037
        self.assertFalse(dlg._file_message_expander.get_property('visible'))
 
1038
        self.assertEqual('Commit Message',
 
1039
                         dlg._global_message_label.get_text())
 
1040
 
 
1041
    def test_commit_specific_files_with_messages(self):
 
1042
        tree = self.make_branch_and_tree('tree')
 
1043
        tree.branch.get_config().set_user_option('per_file_commits', 'true')
 
1044
        rev_id1 = tree.commit('one')
 
1045
        self.build_tree(['tree/a', 'tree/b'])
 
1046
        tree.add(['a', 'b'], ['a-id', 'b-id'])
 
1047
 
 
1048
        dlg = commit.CommitDialog(tree)
 
1049
        dlg._commit_selected_radio.set_active(True) # enable partial
 
1050
        dlg._treeview_files.set_cursor(
 
1051
            Gtk.TreePath(path=1), None, False)
 
1052
        dlg._set_file_commit_message('Message for A\n')
 
1053
        dlg._treeview_files.set_cursor(
 
1054
            Gtk.TreePath(path=2), None, False)
 
1055
        dlg._set_file_commit_message('Message for B\n')
 
1056
        dlg._toggle_commit(None, 2, dlg._files_store) # unset 'b'
 
1057
        dlg._set_global_commit_message('Commit just "a"')
 
1058
 
 
1059
        dlg._do_commit()
 
1060
 
 
1061
        rev_id2 = dlg.committed_revision_id
 
1062
        self.assertEqual(rev_id2, tree.last_revision())
 
1063
        rev = tree.branch.repository.get_revision(rev_id2)
 
1064
        self.assertEqual('Commit just "a"', rev.message)
 
1065
        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)
 
1071
        self.assertEqual([{'path':'a', 'file_id':'a-id',
 
1072
                           'message':'Message for A\n'},],
 
1073
                         bencode.bdecode(file_info.encode('UTF-8')))
 
1074
 
 
1075
    def test_commit_messages_after_merge(self):
 
1076
        tree = self.make_branch_and_tree('tree')
 
1077
        tree.branch.get_config().set_user_option('per_file_commits', 'true')
 
1078
        rev_id1 = tree.commit('one')
 
1079
        tree2 = tree.bzrdir.sprout('tree2').open_workingtree()
 
1080
        self.build_tree(['tree2/a', 'tree2/b'])
 
1081
        tree2.add(['a', 'b'], ['a-id', 'b-id'])
 
1082
        rev_id2 = tree2.commit('two')
 
1083
 
 
1084
        tree.merge_from_branch(tree2.branch)
 
1085
 
 
1086
        dlg = commit.CommitDialog(tree)
 
1087
        dlg._treeview_files.set_cursor(
 
1088
            Gtk.TreePath(path=1), None, False) # 'a'
 
1089
        dlg._set_file_commit_message('Message for A\n')
 
1090
        # No message for 'B'
 
1091
        dlg._set_global_commit_message('Merging from "tree2"\n')
 
1092
 
 
1093
        dlg._do_commit()
 
1094
 
 
1095
        rev_id3 = dlg.committed_revision_id
 
1096
        self.assertEqual(rev_id3, tree.last_revision())
 
1097
        rev = tree.branch.repository.get_revision(rev_id3)
 
1098
        self.assertEqual('Merging from "tree2"\n', rev.message)
 
1099
        self.assertEqual([rev_id1, rev_id2], rev.parent_ids)
 
1100
        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)
 
1106
        self.assertEqual([{'path':'a', 'file_id':'a-id',
 
1107
                           'message':'Message for A\n'},],
 
1108
                         bencode.bdecode(file_info.encode('UTF-8')))
 
1109
 
 
1110
    def test_commit_unicode_messages(self):
 
1111
        self.requireFeature(UnicodeFilenameFeature)
 
1112
 
 
1113
        tree = self.make_branch_and_tree('tree')
 
1114
        tree.branch.get_config().set_user_option('per_file_commits', 'true')
 
1115
        self.build_tree(['tree/a', u'tree/\u03a9'])
 
1116
        tree.add(['a', u'\u03a9'], ['a-id', 'omega-id'])
 
1117
 
 
1118
        dlg = commit.CommitDialog(tree)
 
1119
        dlg._treeview_files.set_cursor(
 
1120
            Gtk.TreePath(path=1), None, False) # 'a'
 
1121
        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
 
1124
        dlg._set_file_commit_message(u'\u03a9 is the end of all things.\n')
 
1125
        dlg._set_global_commit_message(u'\u03a9 and \xfan\xecc\xf6de\n')
 
1126
 
 
1127
        self.assertEqual(([u'a', u'\u03a9'],
 
1128
                          [{'path':'a', 'file_id':'a-id',
 
1129
                            'message':'Test \xc3\xban\xc3\xacc\xc3\xb6de\n'},
 
1130
                           {'path':'\xce\xa9', 'file_id':'omega-id',
 
1131
                            'message':'\xce\xa9 is the end of all things.\n'},
 
1132
                          ]), dlg._get_specific_files())
 
1133
 
 
1134
        dlg._do_commit()
 
1135
 
 
1136
        rev = tree.branch.repository.get_revision(dlg.committed_revision_id)
 
1137
        file_info = rev.properties['file-info'].encode('UTF-8')
 
1138
        value = ('ld7:file_id4:a-id'
 
1139
                   '7:message16:Test \xc3\xban\xc3\xacc\xc3\xb6de\n'
 
1140
                   '4:path1:a'
 
1141
                  'e'
 
1142
                  'd7:file_id8:omega-id'
 
1143
                   '7:message29:\xce\xa9 is the end of all things.\n'
 
1144
                   '4:path2:\xce\xa9'
 
1145
                  'e'
 
1146
                 'e')
 
1147
        self.assertEqual(value, file_info)
 
1148
        file_info_decoded = bencode.bdecode(file_info)
 
1149
        for d in file_info_decoded:
 
1150
            d['path'] = d['path'].decode('UTF-8')
 
1151
            d['message'] = d['message'].decode('UTF-8')
 
1152
 
 
1153
        self.assertEqual([{'path':u'a', 'file_id':'a-id',
 
1154
                           'message':u'Test \xfan\xecc\xf6de\n'},
 
1155
                          {'path':u'\u03a9', 'file_id':'omega-id',
 
1156
                           'message':u'\u03a9 is the end of all things.\n'},
 
1157
                         ], file_info_decoded)
 
1158
 
 
1159
 
 
1160
class TestSanitizeMessage(tests.TestCase):
 
1161
 
 
1162
    def assertSanitize(self, expected, original):
 
1163
        self.assertEqual(expected,
 
1164
                         commit._sanitize_and_decode_message(original))
 
1165
 
 
1166
    def test_untouched(self):
 
1167
        self.assertSanitize('foo\nbar\nbaz\n', 'foo\nbar\nbaz\n')
 
1168
 
 
1169
    def test_converts_cr_to_lf(self):
 
1170
        self.assertSanitize('foo\nbar\nbaz\n', 'foo\rbar\rbaz\r')
 
1171
 
 
1172
    def test_converts_crlf_to_lf(self):
 
1173
        self.assertSanitize('foo\nbar\nbaz\n', 'foo\r\nbar\r\nbaz\r\n')
 
1174
 
 
1175
    def test_converts_mixed_to_lf(self):
 
1176
        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',
 
1189
                          message='a {msg} %d' % rank),
 
1190
                     dict(path='b', file_id='b-id',
 
1191
                          message='b msg %d' % rank)]
 
1192
        return file_info
 
1193
 
 
1194
    def _get_file_info_revprops(self, rank):
 
1195
        file_info_prop = self._get_file_info_dict(rank)
 
1196
        return {'file-info': bencode.bencode(file_info_prop).decode('UTF-8')}
 
1197
 
 
1198
    def _get_commit_message(self):
 
1199
        return self.config.get_user_option(
 
1200
            'gtk_global_commit_message', expand=False)
 
1201
 
 
1202
    def _get_file_commit_messages(self):
 
1203
        return self.config.get_user_option(
 
1204
            'gtk_file_commit_messages', expand=False)
 
1205
 
 
1206
 
 
1207
class TestUncommitHook(TestSavedCommitMessages):
 
1208
 
 
1209
    def setUp(self):
 
1210
        super(TestUncommitHook, self).setUp()
 
1211
        self.tree = self.make_branch_and_tree('tree')
 
1212
        self.config = self.tree.branch.get_config()
 
1213
        self.build_tree(['tree/a', 'tree/b'])
 
1214
        self.tree.add(['a'], ['a-id'])
 
1215
        self.tree.add(['b'], ['b-id'])
 
1216
        rev1 = self.tree.commit('one', rev_id='one-id',
 
1217
                                revprops=self._get_file_info_revprops(1))
 
1218
        rev2 = self.tree.commit('two', rev_id='two-id',
 
1219
                                revprops=self._get_file_info_revprops(2))
 
1220
        rev3 = self.tree.commit('three', rev_id='three-id',
 
1221
                                revprops=self._get_file_info_revprops(3))
 
1222
 
 
1223
    def test_uncommit_one_by_one(self):
 
1224
        uncommit.uncommit(self.tree.branch, tree=self.tree)
 
1225
        self.assertEquals(u'three', self._get_commit_message())
 
1226
        self.assertEquals(u'd4:a-id9:a {msg} 34:b-id7:b msg 3e',
 
1227
                          self._get_file_commit_messages())
 
1228
 
 
1229
        uncommit.uncommit(self.tree.branch, tree=self.tree)
 
1230
        self.assertEquals(u'two\n******\nthree', self._get_commit_message())
 
1231
        self.assertEquals(u'd4:a-id26:a {msg} 2\n******\na {msg} 3'
 
1232
                          '4:b-id22:b msg 2\n******\nb msg 3e',
 
1233
                          self._get_file_commit_messages())
 
1234
 
 
1235
        uncommit.uncommit(self.tree.branch, tree=self.tree)
 
1236
        self.assertEquals(u'one\n******\ntwo\n******\nthree',
 
1237
                          self._get_commit_message())
 
1238
        self.assertEquals(
 
1239
            u'd4:a-id43:a {msg} 1\n******\na {msg} 2\n******\na {msg} 3'
 
1240
            '4:b-id37:b msg 1\n******\nb msg 2\n******\nb msg 3e',
 
1241
            self._get_file_commit_messages())
 
1242
 
 
1243
    def test_uncommit_all_at_once(self):
 
1244
        uncommit.uncommit(self.tree.branch, tree=self.tree, revno=1)
 
1245
        self.assertEquals(u'one\n******\ntwo\n******\nthree',
 
1246
                          self._get_commit_message())
 
1247
        self.assertEquals(
 
1248
            u'd4:a-id43:a {msg} 1\n******\na {msg} 2\n******\na {msg} 3'
 
1249
            '4:b-id37:b msg 1\n******\nb msg 2\n******\nb msg 3e',
 
1250
            self._get_file_commit_messages())
 
1251
 
 
1252
 
 
1253
class TestReusingSavedCommitMessages(TestSavedCommitMessages, QuestionHelpers):
 
1254
 
 
1255
    def setUp(self):
 
1256
        super(TestReusingSavedCommitMessages, self).setUp()
 
1257
        self.tree = self.make_branch_and_tree('tree')
 
1258
        self.config = self.tree.branch.get_config()
 
1259
        self.config.set_user_option('per_file_commits', 'true')
 
1260
        self.build_tree(['tree/a', 'tree/b'])
 
1261
        self.tree.add(['a'], ['a-id'])
 
1262
        self.tree.add(['b'], ['b-id'])
 
1263
        rev1 = self.tree.commit('one', revprops=self._get_file_info_revprops(1))
 
1264
        rev2 = self.tree.commit('two{x}',
 
1265
                                revprops=self._get_file_info_revprops(2))
 
1266
        uncommit.uncommit(self.tree.branch, tree=self.tree)
 
1267
        self.build_tree_contents([('tree/a', 'new a content\n'),
 
1268
                                  ('tree/b', 'new b content'),])
 
1269
 
 
1270
    def _get_commit_dialog(self, tree):
 
1271
        # Ensure we will never use a dialog that can actually prompt the user
 
1272
        # during the test suite. Test *can* and *should* override with the
 
1273
        # correct question dialog type.
 
1274
        dlg = commit.CommitDialog(tree)
 
1275
        self._set_question_no(dlg)
 
1276
        return dlg
 
1277
 
 
1278
    def test_setup_saved_messages(self):
 
1279
        # Check the initial setup
 
1280
        self.assertEquals(u'two{x}', self._get_commit_message())
 
1281
        self.assertEquals(u'd4:a-id9:a {msg} 24:b-id7:b msg 2e',
 
1282
                          self._get_file_commit_messages())
 
1283
 
 
1284
    def test_messages_are_reloaded(self):
 
1285
        dlg = self._get_commit_dialog(self.tree)
 
1286
        self.assertEquals(u'two{x}', dlg._get_global_commit_message())
 
1287
        self.assertEquals(([u'a', u'b'],
 
1288
                           [{ 'path': 'a',
 
1289
                             'file_id': 'a-id', 'message': 'a {msg} 2',},
 
1290
                           {'path': 'b',
 
1291
                            'file_id': 'b-id', 'message': 'b msg 2',}],),
 
1292
                          dlg._get_specific_files())
 
1293
 
 
1294
    def test_messages_are_consumed(self):
 
1295
        dlg = self._get_commit_dialog(self.tree)
 
1296
        dlg._do_commit()
 
1297
        self.assertEquals(u'', self._get_commit_message())
 
1298
        self.assertEquals(u'de', self._get_file_commit_messages())
 
1299
 
 
1300
    def test_messages_are_saved_on_cancel_if_required(self):
 
1301
        dlg = self._get_commit_dialog(self.tree)
 
1302
        self._set_question_yes(dlg) # Save messages
 
1303
        dlg._do_cancel()
 
1304
        self.assertEquals(u'two{x}', self._get_commit_message())
 
1305
        self.assertEquals(u'd4:a-id9:a {msg} 24:b-id7:b msg 2e',
 
1306
                          self._get_file_commit_messages())
 
1307
 
 
1308
    def test_messages_are_cleared_on_cancel_if_required(self):
 
1309
        dlg = self._get_commit_dialog(self.tree)
 
1310
        self._set_question_no(dlg) # Don't save messages
 
1311
        dlg._do_cancel()
 
1312
        self.assertEquals(u'', self._get_commit_message())
 
1313
        self.assertEquals(u'de',
 
1314
                          self._get_file_commit_messages())
 
1315
 
 
1316
 
 
1317
class BzrHandlePatchTestCase(tests.TestCase):
 
1318
 
 
1319
    def setUp(self):
 
1320
        top = os.path.abspath(os.path.join(
 
1321
            os.path.dirname(__file__), os.pardir))
 
1322
        self.script = os.path.join(top, 'bzr-handle-patch')
 
1323
        self.env = dict(os.environ)
 
1324
        self.env['BZR_PLUGINS_AT'] = 'gtk@%s' % top
 
1325
        self.patch = NamedTemporaryFile()
 
1326
        self.patch.write('\n'.join([
 
1327
            "=== added file '_test.txt'",
 
1328
            "--- _test.txt      1970-01-01 00:00:00 +0000",
 
1329
            "+++ _test.txt      2012-02-03 20:00:34 +0000",
 
1330
            "@@ -0,0 +1,1 @@",
 
1331
            "+hello",
 
1332
            ]))
 
1333
        self.patch.flush()
 
1334
        super(BzrHandlePatchTestCase, self).setUp()
 
1335
 
 
1336
    def test_smoketest(self):
 
1337
        # This is a smoke test to verify the process starts.
 
1338
        bzr_notify = subprocess.Popen(
 
1339
            [self.script, self.patch.name, 'test'],
 
1340
            stdout=subprocess.PIPE, stderr=subprocess.PIPE, env=self.env)
 
1341
        stdout, stderr = bzr_notify.communicate()
 
1342
        self.assertEqual('', stdout)
 
1343
        self.assertEqual('', stderr)