← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/blackbox/test_diff.py

  • Committer: Patch Queue Manager
  • Date: 2016-02-01 19:13:13 UTC
  • mfrom: (6614.2.2 trunk)
  • Revision ID: pqm@pqm.ubuntu.com-20160201191313-wdfvmfff1djde6oq
(vila) Release 2.7.0 (Vincent Ladeuil)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/blackbox/test_diff.py
1
 
# Copyright (C) 2005, 2006 Canonical Ltd
 
1
# Copyright (C) 2006-2012, 2016 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
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
 
 
18
 
"""Black-box tests for bzr diff.
19
 
"""
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
16
 
 
17
 
 
18
"""Black-box tests for bzr diff."""
20
19
 
21
20
import os
22
21
import re
23
22
 
24
 
import bzrlib
25
 
from bzrlib import workingtree
26
 
from bzrlib.branch import Branch
27
 
from bzrlib.tests import TestSkipped
28
 
from bzrlib.tests.blackbox import ExternalBase
 
23
from bzrlib import (
 
24
    tests,
 
25
    workingtree,
 
26
    )
 
27
from bzrlib.diff import (
 
28
    DiffTree,
 
29
    format_registry as diff_format_registry,
 
30
    )
 
31
from bzrlib.tests import (
 
32
    features,
 
33
    )
29
34
 
30
35
 
31
36
def subst_dates(string):
34
39
                  'YYYY-MM-DD HH:MM:SS +ZZZZ', string)
35
40
 
36
41
 
37
 
class DiffBase(ExternalBase):
 
42
class DiffBase(tests.TestCaseWithTransport):
38
43
    """Base class with common setup method"""
39
44
 
40
45
    def make_example_branch(self):
56
61
        self.build_tree_contents([('hello', 'hello world!')])
57
62
        tree.commit(message='fixing hello')
58
63
        output = self.run_bzr('diff -r 2..3', retcode=1)[0]
59
 
        self.assert_('\n+hello world!' in output)
 
64
        self.assertTrue('\n+hello world!' in output)
60
65
        output = self.run_bzr('diff -c 3', retcode=1)[0]
61
 
        self.assert_('\n+hello world!' in output)
 
66
        self.assertTrue('\n+hello world!' in output)
62
67
        output = self.run_bzr('diff -r last:3..last:1', retcode=1)[0]
63
 
        self.assert_('\n+baz' in output)
 
68
        self.assertTrue('\n+baz' in output)
64
69
        output = self.run_bzr('diff -c last:2', retcode=1)[0]
65
 
        self.assert_('\n+baz' in output)
 
70
        self.assertTrue('\n+baz' in output)
66
71
        self.build_tree(['moo'])
67
72
        tree.add('moo')
68
73
        os.unlink('moo')
73
78
        self.make_example_branch()
74
79
        self.build_tree_contents([('hello', 'hello world!\n')])
75
80
        out, err = self.run_bzr('diff --prefix old/:new/', retcode=1)
76
 
        self.assertEquals(err, '')
 
81
        self.assertEqual(err, '')
77
82
        self.assertEqualDiff(subst_dates(out), '''\
78
83
=== modified file 'hello'
79
84
--- old/hello\tYYYY-MM-DD HH:MM:SS +ZZZZ
95
100
        self.make_example_branch()
96
101
        self.build_tree_contents([('hello', 'hello world!\n')])
97
102
        out, err = self.run_bzr('diff -p1', retcode=1)
98
 
        self.assertEquals(err, '')
 
103
        self.assertEqual(err, '')
99
104
        self.assertEqualDiff(subst_dates(out), '''\
100
105
=== modified file 'hello'
101
106
--- old/hello\tYYYY-MM-DD HH:MM:SS +ZZZZ
111
116
        self.make_example_branch()
112
117
        self.build_tree_contents([('hello', 'hello world!\n')])
113
118
        out, err = self.run_bzr('diff -p0', retcode=1)
114
 
        self.assertEquals(err, '')
 
119
        self.assertEqual(err, '')
115
120
        self.assertEqualDiff(subst_dates(out), '''\
116
121
=== modified file 'hello'
117
122
--- hello\tYYYY-MM-DD HH:MM:SS +ZZZZ
126
131
        # Get an error from a file that does not exist at all
127
132
        # (Malone #3619)
128
133
        self.make_example_branch()
129
 
        out, err = self.run_bzr('diff does-not-exist', retcode=3)
130
 
        self.assertContainsRe(err, 'not versioned.*does-not-exist')
 
134
        out, err = self.run_bzr('diff does-not-exist', retcode=3,
 
135
            error_regexes=('not versioned.*does-not-exist',))
131
136
 
132
137
    def test_diff_illegal_revision_specifiers(self):
133
 
        out, err = self.run_bzr('diff -r 1..23..123', retcode=3)
134
 
        self.assertContainsRe(err, 'one or two revision specifiers')
 
138
        out, err = self.run_bzr('diff -r 1..23..123', retcode=3,
 
139
            error_regexes=('one or two revision specifiers',))
 
140
 
 
141
    def test_diff_using_and_format(self):
 
142
        out, err = self.run_bzr('diff --format=default --using=mydi', retcode=3,
 
143
            error_regexes=('are mutually exclusive',))
 
144
 
 
145
    def test_diff_nonexistent_revision(self):
 
146
        out, err = self.run_bzr('diff -r 123', retcode=3,
 
147
            error_regexes=("Requested revision: '123' does not "
 
148
                "exist in branch:",))
 
149
 
 
150
    def test_diff_nonexistent_dotted_revision(self):
 
151
        out, err = self.run_bzr('diff -r 1.1', retcode=3)
 
152
        self.assertContainsRe(err,
 
153
            "Requested revision: '1.1' does not exist in branch:")
 
154
 
 
155
    def test_diff_nonexistent_dotted_revision_change(self):
 
156
        out, err = self.run_bzr('diff -c 1.1', retcode=3)
 
157
        self.assertContainsRe(err,
 
158
            "Requested revision: '1.1' does not exist in branch:")
135
159
 
136
160
    def test_diff_unversioned(self):
137
161
        # Get an error when diffing a non-versioned file.
146
170
    def example_branches(self):
147
171
        branch1_tree = self.make_branch_and_tree('branch1')
148
172
        self.build_tree(['branch1/file'], line_endings='binary')
 
173
        self.build_tree(['branch1/file2'], line_endings='binary')
149
174
        branch1_tree.add('file')
150
 
        branch1_tree.commit(message='add file')
 
175
        branch1_tree.add('file2')
 
176
        branch1_tree.commit(message='add file and file2')
151
177
        branch2_tree = branch1_tree.bzrdir.sprout('branch2').open_workingtree()
152
178
        self.build_tree_contents([('branch2/file', 'new content\n')])
153
179
        branch2_tree.commit(message='update file')
154
180
        return branch1_tree, branch2_tree
155
181
 
156
 
    def test_diff_branches(self):
157
 
        self.example_branches()
158
 
        # should open branch1 and diff against branch2, 
159
 
        out, err = self.run_bzr('diff -r branch:branch2 branch1',
160
 
                                retcode=1)
161
 
        self.assertEquals('', err)
162
 
        self.assertEquals("=== modified file 'file'\n"
 
182
    def check_b2_vs_b1(self, cmd):
 
183
        # Compare branch2 vs branch1 using cmd and check the result
 
184
        out, err = self.run_bzr(cmd, retcode=1)
 
185
        self.assertEqual('', err)
 
186
        self.assertEqual("=== modified file 'file'\n"
163
187
                          "--- file\tYYYY-MM-DD HH:MM:SS +ZZZZ\n"
164
188
                          "+++ file\tYYYY-MM-DD HH:MM:SS +ZZZZ\n"
165
189
                          "@@ -1,1 +1,1 @@\n"
166
190
                          "-new content\n"
167
191
                          "+contents of branch1/file\n"
168
192
                          "\n", subst_dates(out))
169
 
        out, err = self.run_bzr('diff branch2 branch1',
170
 
                                         retcode=1)
171
 
        self.assertEquals('', err)
 
193
 
 
194
    def check_b1_vs_b2(self, cmd):
 
195
        # Compare branch1 vs branch2 using cmd and check the result
 
196
        out, err = self.run_bzr(cmd, retcode=1)
 
197
        self.assertEqual('', err)
172
198
        self.assertEqualDiff("=== modified file 'file'\n"
173
199
                              "--- file\tYYYY-MM-DD HH:MM:SS +ZZZZ\n"
174
200
                              "+++ file\tYYYY-MM-DD HH:MM:SS +ZZZZ\n"
175
201
                              "@@ -1,1 +1,1 @@\n"
176
 
                              "-new content\n"
177
 
                              "+contents of branch1/file\n"
 
202
                              "-contents of branch1/file\n"
 
203
                              "+new content\n"
178
204
                              "\n", subst_dates(out))
179
205
 
 
206
    def check_no_diffs(self, cmd):
 
207
        # Check that running cmd returns an empty diff
 
208
        out, err = self.run_bzr(cmd, retcode=0)
 
209
        self.assertEqual('', err)
 
210
        self.assertEqual('', out)
 
211
 
 
212
    def test_diff_branches(self):
 
213
        self.example_branches()
 
214
        # should open branch1 and diff against branch2,
 
215
        self.check_b2_vs_b1('diff -r branch:branch2 branch1')
 
216
        # Compare two working trees using various syntax forms
 
217
        self.check_b2_vs_b1('diff --old branch2 --new branch1')
 
218
        self.check_b2_vs_b1('diff --old branch2 branch1')
 
219
        self.check_b2_vs_b1('diff branch2 --new branch1')
 
220
        # Test with a selected file that was changed
 
221
        self.check_b2_vs_b1('diff --old branch2 --new branch1 file')
 
222
        self.check_b2_vs_b1('diff --old branch2 branch1/file')
 
223
        self.check_b2_vs_b1('diff branch2/file --new branch1')
 
224
        # Test with a selected file that was not changed
 
225
        self.check_no_diffs('diff --old branch2 --new branch1 file2')
 
226
        self.check_no_diffs('diff --old branch2 branch1/file2')
 
227
        self.check_no_diffs('diff branch2/file2 --new branch1')
 
228
 
 
229
    def test_diff_branches_no_working_trees(self):
 
230
        branch1_tree, branch2_tree = self.example_branches()
 
231
        # Compare a working tree to a branch without a WT
 
232
        dir1 = branch1_tree.bzrdir
 
233
        dir1.destroy_workingtree()
 
234
        self.assertFalse(dir1.has_workingtree())
 
235
        self.check_b2_vs_b1('diff --old branch2 --new branch1')
 
236
        self.check_b2_vs_b1('diff --old branch2 branch1')
 
237
        self.check_b2_vs_b1('diff branch2 --new branch1')
 
238
        # Compare a branch without a WT to one with a WT
 
239
        self.check_b1_vs_b2('diff --old branch1 --new branch2')
 
240
        self.check_b1_vs_b2('diff --old branch1 branch2')
 
241
        self.check_b1_vs_b2('diff branch1 --new branch2')
 
242
        # Compare a branch with a WT against another without a WT
 
243
        dir2 = branch2_tree.bzrdir
 
244
        dir2.destroy_workingtree()
 
245
        self.assertFalse(dir2.has_workingtree())
 
246
        self.check_b1_vs_b2('diff --old branch1 --new branch2')
 
247
        self.check_b1_vs_b2('diff --old branch1 branch2')
 
248
        self.check_b1_vs_b2('diff branch1 --new branch2')
 
249
 
180
250
    def test_diff_revno_branches(self):
181
251
        self.example_branches()
182
252
        branch2_tree = workingtree.WorkingTree.open_containing('branch2')[0]
185
255
 
186
256
        out, err = self.run_bzr('diff -r revno:1:branch2..revno:1:branch1',
187
257
                                )
188
 
        self.assertEquals('', err)
189
 
        self.assertEquals('', out)
 
258
        self.assertEqual('', err)
 
259
        self.assertEqual('', out)
190
260
        out, err = self.run_bzr('diff -r revno:2:branch2..revno:1:branch1',
191
261
                                retcode=1)
192
 
        self.assertEquals('', err)
 
262
        self.assertEqual('', err)
193
263
        self.assertEqualDiff("=== modified file 'file'\n"
194
264
                              "--- file\tYYYY-MM-DD HH:MM:SS +ZZZZ\n"
195
265
                              "+++ file\tYYYY-MM-DD HH:MM:SS +ZZZZ\n"
213
283
        output = self.run_bzr('diff -r 1.. branch1', retcode=1)
214
284
        self.assertContainsRe(output[0], '\n\\-original line\n\\+new line\n')
215
285
 
 
286
    def test_diff_to_working_tree_in_subdir(self):
 
287
        self.example_branch2()
 
288
        self.build_tree_contents([('branch1/file1', 'new line')])
 
289
        os.mkdir('branch1/dir1')
 
290
        output = self.run_bzr('diff -r 1..', retcode=1,
 
291
                              working_dir='branch1/dir1')
 
292
        self.assertContainsRe(output[0], '\n\\-original line\n\\+new line\n')
 
293
 
216
294
    def test_diff_across_rename(self):
217
295
        """The working tree path should always be considered for diffing"""
218
296
        tree = self.make_example_branch()
221
299
        self.run_bzr('diff hello1', retcode=1)
222
300
        self.run_bzr('diff -r 0..1 hello1', retcode=1)
223
301
 
 
302
    def test_diff_to_branch_no_working_tree(self):
 
303
        branch1_tree = self.example_branch2()
 
304
        dir1 = branch1_tree.bzrdir
 
305
        dir1.destroy_workingtree()
 
306
        self.assertFalse(dir1.has_workingtree())
 
307
        output = self.run_bzr('diff -r 1.. branch1', retcode=1)
 
308
        self.assertContainsRe(output[0], '\n\\-original line\n\\+repo line\n')
 
309
 
 
310
    def test_custom_format(self):
 
311
        class BooDiffTree(DiffTree):
 
312
 
 
313
            def show_diff(self, specific_files, extra_trees=None):
 
314
                self.to_file.write("BOO!\n")
 
315
                return super(BooDiffTree, self).show_diff(specific_files,
 
316
                    extra_trees)
 
317
 
 
318
        diff_format_registry.register("boo", BooDiffTree, "Scary diff format")
 
319
        self.addCleanup(diff_format_registry.remove, "boo")
 
320
        self.make_example_branch()
 
321
        self.build_tree_contents([('hello', 'hello world!\n')])
 
322
        output = self.run_bzr('diff --format=boo', retcode=1)
 
323
        self.assertTrue("BOO!" in output[0])
 
324
        output = self.run_bzr('diff -Fboo', retcode=1)
 
325
        self.assertTrue("BOO!" in output[0])
 
326
 
224
327
 
225
328
class TestCheckoutDiff(TestDiff):
226
329
 
238
341
        return tree
239
342
 
240
343
    def example_branches(self):
241
 
        branch1_tree, branch2_tree = super(TestCheckoutDiff, self).example_branches()
 
344
        branch1_tree, branch2_tree = super(TestCheckoutDiff,
 
345
                                           self).example_branches()
242
346
        os.mkdir('checkouts')
243
347
        branch1_tree = branch1_tree.branch.create_checkout('checkouts/branch1')
244
348
        branch2_tree = branch2_tree.branch.create_checkout('checkouts/branch2')
278
382
 
279
383
    def test_external_diff(self):
280
384
        """Test that we can spawn an external diff process"""
 
385
        self.disable_missing_extensions_warning()
281
386
        # We have to use run_bzr_subprocess, because we need to
282
387
        # test writing directly to stdout, (there was a bug in
283
388
        # subprocess.py that we had to workaround).
284
389
        # However, if 'diff' may not be available
285
390
        self.make_example_branch()
286
 
        orig_progress = os.environ.get('BZR_PROGRESS_BAR')
287
 
        try:
288
 
            os.environ['BZR_PROGRESS_BAR'] = 'none'
289
 
            out, err = self.run_bzr_subprocess('diff -r 1 --diff-options -ub',
290
 
                                               universal_newlines=True,
291
 
                                               retcode=None)
292
 
        finally:
293
 
            if orig_progress is None:
294
 
                del os.environ['BZR_PROGRESS_BAR']
295
 
            else:
296
 
                os.environ['BZR_PROGRESS_BAR'] = orig_progress
297
 
            
 
391
        out, err = self.run_bzr_subprocess(
 
392
            'diff -Oprogress_bar=none -r 1 --diff-options -ub',
 
393
            universal_newlines=True,
 
394
            retcode=None)
298
395
        if 'Diff is not installed on this machine' in err:
299
 
            raise TestSkipped("No external 'diff' is available")
 
396
            raise tests.TestSkipped("No external 'diff' is available")
300
397
        self.assertEqual('', err)
301
398
        # We have to skip the stuff in the middle, because it depends
302
399
        # on time.time()
306
403
        self.assertEndsWith(out, "\n@@ -0,0 +1 @@\n"
307
404
                                 "+baz\n\n")
308
405
 
 
406
    def test_external_diff_options_and_using(self):
 
407
        """Test that the options are passed correctly to an external diff process"""
 
408
        self.requireFeature(features.diff_feature)
 
409
        self.make_example_branch()
 
410
        self.build_tree_contents([('hello', 'Foo\n')])
 
411
        out, err = self.run_bzr('diff --diff-options -i --using diff',
 
412
                                    retcode=1)
 
413
        self.assertEqual("=== modified file 'hello'\n", out)
 
414
        self.assertEqual('', err)
 
415
 
309
416
 
310
417
class TestDiffOutput(DiffBase):
311
418
 
314
421
        self.make_example_branch()
315
422
        self.build_tree_contents([('hello', 'hello world!\n')])
316
423
        output = self.run_bzr_subprocess('diff', retcode=1)[0]
317
 
        self.assert_('\n+hello world!\n' in output)
 
424
        self.assertTrue('\n+hello world!\n' in output)