← 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: Aaron Bentley
  • Date: 2006-06-21 14:30:57 UTC
  • mfrom: (1801.1.1 bzr.dev)
  • mto: This revision was merged to the branch mainline in revision 1803.
  • Revision ID: abentley@panoramicfeedback.com-20060621143057-776e4b8d707e430e
Install benchmarks. (Jelmer Vernooij)

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
2
 
#
 
1
# Copyright (C) 2005, 2006 by Canonical Ltd
 
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
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
7
 
#
 
7
 
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
11
# GNU General Public License for more details.
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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
 
18
18
"""Black-box tests for bzr diff.
22
22
import re
23
23
 
24
24
import bzrlib
25
 
from bzrlib import workingtree
26
25
from bzrlib.branch import Branch
27
 
from bzrlib.tests import TestSkipped
28
26
from bzrlib.tests.blackbox import ExternalBase
29
27
 
30
28
 
34
32
                  'YYYY-MM-DD HH:MM:SS +ZZZZ', string)
35
33
 
36
34
 
37
 
class DiffBase(ExternalBase):
38
 
    """Base class with common setup method"""
39
 
 
40
 
    def make_example_branch(self):
41
 
        tree = self.make_branch_and_tree('.')
42
 
        self.build_tree_contents([
43
 
            ('hello', 'foo\n'),
44
 
            ('goodbye', 'baz\n')])
45
 
        tree.add(['hello'])
46
 
        tree.commit('setup')
47
 
        tree.add(['goodbye'])
48
 
        tree.commit('setup')
49
 
        return tree
50
 
 
51
 
 
52
 
class TestDiff(DiffBase):
 
35
class TestDiff(ExternalBase):
 
36
 
 
37
    def make_example_branch(test):
 
38
        # FIXME: copied from test_too_much -- share elsewhere?
 
39
        test.runbzr('init')
 
40
        file('hello', 'wt').write('foo\n')
 
41
        test.runbzr('add hello')
 
42
        test.runbzr('commit -m setup hello')
 
43
        file('goodbye', 'wt').write('baz\n')
 
44
        test.runbzr('add goodbye')
 
45
        test.runbzr('commit -m setup goodbye')
53
46
 
54
47
    def test_diff(self):
55
 
        tree = self.make_example_branch()
56
 
        self.build_tree_contents([('hello', 'hello world!')])
57
 
        tree.commit(message='fixing hello')
58
 
        output = self.run_bzr('diff -r 2..3', retcode=1)[0]
59
 
        self.assert_('\n+hello world!' in output)
60
 
        output = self.run_bzr('diff -c 3', retcode=1)[0]
61
 
        self.assert_('\n+hello world!' in output)
62
 
        output = self.run_bzr('diff -r last:3..last:1', retcode=1)[0]
63
 
        self.assert_('\n+baz' in output)
64
 
        output = self.run_bzr('diff -c last:2', retcode=1)[0]
65
 
        self.assert_('\n+baz' in output)
66
 
        self.build_tree(['moo'])
67
 
        tree.add('moo')
 
48
        self.make_example_branch()
 
49
        file('hello', 'wt').write('hello world!')
 
50
        self.runbzr('commit -m fixing hello')
 
51
        output = self.runbzr('diff -r 2..3', backtick=1, retcode=1)
 
52
        self.assert_('\n+hello world!' in output)
 
53
        output = self.runbzr('diff -r last:3..last:1', backtick=1, retcode=1)
 
54
        self.assert_('\n+baz' in output)
 
55
        file('moo', 'wb').write('moo')
 
56
        self.runbzr('add moo')
68
57
        os.unlink('moo')
69
 
        self.run_bzr('diff')
 
58
        self.runbzr('diff')
70
59
 
71
60
    def test_diff_prefix(self):
72
61
        """diff --prefix appends to filenames in output"""
73
62
        self.make_example_branch()
74
 
        self.build_tree_contents([('hello', 'hello world!\n')])
75
 
        out, err = self.run_bzr('diff --prefix old/:new/', retcode=1)
 
63
        file('hello', 'wt').write('hello world!\n')
 
64
        out, err = self.runbzr('diff --prefix old/:new/', retcode=1)
76
65
        self.assertEquals(err, '')
77
66
        self.assertEqualDiff(subst_dates(out), '''\
78
67
=== modified file 'hello'
84
73
 
85
74
''')
86
75
 
87
 
    def test_diff_illegal_prefix_value(self):
88
 
        # There was an error in error reporting for this option
89
 
        out, err = self.run_bzr('diff --prefix old/', retcode=3)
90
 
        self.assertContainsRe(err,
91
 
            '--prefix expects two values separated by a colon')
92
 
 
93
76
    def test_diff_p1(self):
94
77
        """diff -p1 produces lkml-style diffs"""
95
78
        self.make_example_branch()
96
 
        self.build_tree_contents([('hello', 'hello world!\n')])
97
 
        out, err = self.run_bzr('diff -p1', retcode=1)
 
79
        file('hello', 'wt').write('hello world!\n')
 
80
        out, err = self.runbzr('diff -p1', retcode=1)
98
81
        self.assertEquals(err, '')
99
82
        self.assertEqualDiff(subst_dates(out), '''\
100
83
=== modified file 'hello'
109
92
    def test_diff_p0(self):
110
93
        """diff -p0 produces diffs with no prefix"""
111
94
        self.make_example_branch()
112
 
        self.build_tree_contents([('hello', 'hello world!\n')])
113
 
        out, err = self.run_bzr('diff -p0', retcode=1)
 
95
        file('hello', 'wt').write('hello world!\n')
 
96
        out, err = self.runbzr('diff -p0', retcode=1)
114
97
        self.assertEquals(err, '')
115
98
        self.assertEqualDiff(subst_dates(out), '''\
116
99
=== modified file 'hello'
126
109
        # Get an error from a file that does not exist at all
127
110
        # (Malone #3619)
128
111
        self.make_example_branch()
129
 
        out, err = self.run_bzr('diff does-not-exist', retcode=3,
130
 
            error_regexes=('not versioned.*does-not-exist',))
131
 
 
132
 
    def test_diff_illegal_revision_specifiers(self):
133
 
        out, err = self.run_bzr('diff -r 1..23..123', retcode=3,
134
 
            error_regexes=('one or two revision specifiers',))
135
 
 
136
 
    def test_diff_nonexistent_revision(self):
137
 
        out, err = self.run_bzr('diff -r 123', retcode=3,
138
 
            error_regexes=("Requested revision: '123' does not "
139
 
                "exist in branch:",))
140
 
 
141
 
    def test_diff_nonexistent_dotted_revision(self):
142
 
        out, err = self.run_bzr('diff -r 1.1', retcode=3)
143
 
        self.assertContainsRe(err,
144
 
            "Requested revision: '1.1' does not exist in branch:")
145
 
 
146
 
    def test_diff_nonexistent_dotted_revision_change(self):
147
 
        out, err = self.run_bzr('diff -c 1.1', retcode=3)
148
 
        self.assertContainsRe(err,
149
 
            "Requested revision: '1.1' does not exist in branch:")
 
112
        out, err = self.runbzr('diff does-not-exist', retcode=3)
 
113
        self.assertContainsRe(err, 'not versioned.*does-not-exist')
150
114
 
151
115
    def test_diff_unversioned(self):
152
116
        # Get an error when diffing a non-versioned file.
153
117
        # (Malone #3619)
154
118
        self.make_example_branch()
155
119
        self.build_tree(['unversioned-file'])
156
 
        out, err = self.run_bzr('diff unversioned-file', retcode=3)
 
120
        out, err = self.runbzr('diff unversioned-file', retcode=3)
157
121
        self.assertContainsRe(err, 'not versioned.*unversioned-file')
158
122
 
159
123
    # TODO: What should diff say for a file deleted in working tree?
160
124
 
161
125
    def example_branches(self):
162
 
        branch1_tree = self.make_branch_and_tree('branch1')
163
 
        self.build_tree(['branch1/file'], line_endings='binary')
164
 
        self.build_tree(['branch1/file2'], line_endings='binary')
165
 
        branch1_tree.add('file')
166
 
        branch1_tree.add('file2')
167
 
        branch1_tree.commit(message='add file and file2')
168
 
        branch2_tree = branch1_tree.bzrdir.sprout('branch2').open_workingtree()
169
 
        self.build_tree_contents([('branch2/file', 'new content\n')])
170
 
        branch2_tree.commit(message='update file')
171
 
        return branch1_tree, branch2_tree
 
126
        self.build_tree(['branch1/', 'branch1/file'], line_endings='binary')
 
127
        self.capture('init branch1')
 
128
        self.capture('add branch1/file')
 
129
        self.run_bzr_captured(['commit', '-m', 'add file', 'branch1'])
 
130
        self.capture('branch branch1 branch2')
 
131
        print >> open('branch2/file', 'wb'), 'new content'
 
132
        self.run_bzr_captured(['commit', '-m', 'update file', 'branch2'])
172
133
 
173
 
    def check_b2_vs_b1(self, cmd):
174
 
        # Compare branch2 vs branch1 using cmd and check the result
175
 
        out, err = self.run_bzr(cmd, retcode=1)
 
134
    def test_diff_branches(self):
 
135
        self.example_branches()
 
136
        # should open branch1 and diff against branch2, 
 
137
        out, err = self.run_bzr_captured(['diff', '-r', 'branch:branch2', 
 
138
                                          'branch1'],
 
139
                                         retcode=1)
176
140
        self.assertEquals('', err)
177
141
        self.assertEquals("=== modified file 'file'\n"
178
142
                          "--- file\tYYYY-MM-DD HH:MM:SS +ZZZZ\n"
181
145
                          "-new content\n"
182
146
                          "+contents of branch1/file\n"
183
147
                          "\n", subst_dates(out))
184
 
 
185
 
    def check_b1_vs_b2(self, cmd):
186
 
        # Compare branch1 vs branch2 using cmd and check the result
187
 
        out, err = self.run_bzr(cmd, retcode=1)
188
 
        self.assertEquals('', err)
189
 
        self.assertEqualDiff("=== modified file 'file'\n"
190
 
                              "--- file\tYYYY-MM-DD HH:MM:SS +ZZZZ\n"
191
 
                              "+++ file\tYYYY-MM-DD HH:MM:SS +ZZZZ\n"
192
 
                              "@@ -1,1 +1,1 @@\n"
193
 
                              "-contents of branch1/file\n"
194
 
                              "+new content\n"
195
 
                              "\n", subst_dates(out))
196
 
 
197
 
    def check_no_diffs(self, cmd):
198
 
        # Check that running cmd returns an empty diff
199
 
        out, err = self.run_bzr(cmd, retcode=0)
200
 
        self.assertEquals('', err)
201
 
        self.assertEquals('', out)
202
 
 
203
 
    def test_diff_branches(self):
204
 
        self.example_branches()
205
 
        # should open branch1 and diff against branch2,
206
 
        self.check_b2_vs_b1('diff -r branch:branch2 branch1')
207
 
        # Compare two working trees using various syntax forms
208
 
        self.check_b2_vs_b1('diff --old branch2 --new branch1')
209
 
        self.check_b2_vs_b1('diff --old branch2 branch1')
210
 
        self.check_b2_vs_b1('diff branch2 --new branch1')
211
 
        # Test with a selected file that was changed
212
 
        self.check_b2_vs_b1('diff --old branch2 --new branch1 file')
213
 
        self.check_b2_vs_b1('diff --old branch2 branch1/file')
214
 
        self.check_b2_vs_b1('diff branch2/file --new branch1')
215
 
        # Test with a selected file that was not changed
216
 
        self.check_no_diffs('diff --old branch2 --new branch1 file2')
217
 
        self.check_no_diffs('diff --old branch2 branch1/file2')
218
 
        self.check_no_diffs('diff branch2/file2 --new branch1')
219
 
 
220
 
    def test_diff_branches_no_working_trees(self):
221
 
        branch1_tree, branch2_tree = self.example_branches()
222
 
        # Compare a working tree to a branch without a WT
223
 
        dir1 = branch1_tree.bzrdir
224
 
        dir1.destroy_workingtree()
225
 
        self.assertFalse(dir1.has_workingtree())
226
 
        self.check_b2_vs_b1('diff --old branch2 --new branch1')
227
 
        self.check_b2_vs_b1('diff --old branch2 branch1')
228
 
        self.check_b2_vs_b1('diff branch2 --new branch1')
229
 
        # Compare a branch without a WT to one with a WT
230
 
        self.check_b1_vs_b2('diff --old branch1 --new branch2')
231
 
        self.check_b1_vs_b2('diff --old branch1 branch2')
232
 
        self.check_b1_vs_b2('diff branch1 --new branch2')
233
 
        # Compare a branch with a WT against another without a WT
234
 
        dir2 = branch2_tree.bzrdir
235
 
        dir2.destroy_workingtree()
236
 
        self.assertFalse(dir2.has_workingtree())
237
 
        self.check_b1_vs_b2('diff --old branch1 --new branch2')
238
 
        self.check_b1_vs_b2('diff --old branch1 branch2')
239
 
        self.check_b1_vs_b2('diff branch1 --new branch2')
240
 
 
241
 
    def test_diff_revno_branches(self):
242
 
        self.example_branches()
243
 
        branch2_tree = workingtree.WorkingTree.open_containing('branch2')[0]
244
 
        self.build_tree_contents([('branch2/file', 'even newer content')])
245
 
        branch2_tree.commit(message='update file once more')
246
 
 
247
 
        out, err = self.run_bzr('diff -r revno:1:branch2..revno:1:branch1',
248
 
                                )
249
 
        self.assertEquals('', err)
250
 
        self.assertEquals('', out)
251
 
        out, err = self.run_bzr('diff -r revno:2:branch2..revno:1:branch1',
252
 
                                retcode=1)
 
148
        out, ett = self.run_bzr_captured(['diff', 'branch2', 'branch1'],
 
149
                                         retcode=1)
253
150
        self.assertEquals('', err)
254
151
        self.assertEqualDiff("=== modified file 'file'\n"
255
152
                              "--- file\tYYYY-MM-DD HH:MM:SS +ZZZZ\n"
260
157
                              "\n", subst_dates(out))
261
158
 
262
159
    def example_branch2(self):
263
 
        branch1_tree = self.make_branch_and_tree('branch1')
264
 
        self.build_tree_contents([('branch1/file1', 'original line\n')])
265
 
        branch1_tree.add('file1')
266
 
        branch1_tree.commit(message='first commit')
267
 
        self.build_tree_contents([('branch1/file1', 'repo line\n')])
268
 
        branch1_tree.commit(message='second commit')
269
 
        return branch1_tree
 
160
        self.build_tree(['branch1/', 'branch1/file1'], line_endings='binary')
 
161
        self.capture('init branch1')
 
162
        self.capture('add branch1/file1')
 
163
        print >> open('branch1/file1', 'wb'), 'original line'
 
164
        self.run_bzr_captured(['commit', '-m', 'first commit', 'branch1'])
 
165
        
 
166
        print >> open('branch1/file1', 'wb'), 'repo line'
 
167
        self.run_bzr_captured(['commit', '-m', 'second commit', 'branch1'])
270
168
 
271
169
    def test_diff_to_working_tree(self):
272
170
        self.example_branch2()
273
 
        self.build_tree_contents([('branch1/file1', 'new line')])
274
 
        output = self.run_bzr('diff -r 1.. branch1', retcode=1)
275
 
        self.assertContainsRe(output[0], '\n\\-original line\n\\+new line\n')
276
 
 
277
 
    def test_diff_to_working_tree_in_subdir(self):
278
 
        self.example_branch2()
279
 
        self.build_tree_contents([('branch1/file1', 'new line')])
280
 
        os.mkdir('branch1/dir1')
281
 
        os.chdir('branch1/dir1')
282
 
        output = self.run_bzr('diff -r 1..', retcode=1)
283
 
        self.assertContainsRe(output[0], '\n\\-original line\n\\+new line\n')
284
 
 
285
 
    def test_diff_across_rename(self):
286
 
        """The working tree path should always be considered for diffing"""
287
 
        tree = self.make_example_branch()
288
 
        self.run_bzr('diff -r 0..1 hello', retcode=1)
289
 
        tree.rename_one('hello', 'hello1')
290
 
        self.run_bzr('diff hello1', retcode=1)
291
 
        self.run_bzr('diff -r 0..1 hello1', retcode=1)
292
 
 
293
 
    def test_diff_to_branch_no_working_tree(self):
294
 
        branch1_tree = self.example_branch2()
295
 
        dir1 = branch1_tree.bzrdir
296
 
        dir1.destroy_workingtree()
297
 
        self.assertFalse(dir1.has_workingtree())
298
 
        output = self.run_bzr('diff -r 1.. branch1', retcode=1)
299
 
        self.assertContainsRe(output[0], '\n\\-original line\n\\+repo line\n')
 
171
        
 
172
        print >> open('branch1/file1', 'wb'), 'new line'
 
173
        output = self.run_bzr_captured(['diff', '-r', '1..', 'branch1'], retcode=1)
 
174
        self.assertTrue('\n-original line\n+new line\n' in output[0])
300
175
 
301
176
 
302
177
class TestCheckoutDiff(TestDiff):
303
178
 
304
179
    def make_example_branch(self):
305
 
        tree = super(TestCheckoutDiff, self).make_example_branch()
306
 
        tree = tree.branch.create_checkout('checkout')
 
180
        super(TestCheckoutDiff, self).make_example_branch()
 
181
        self.runbzr('checkout . checkout')
307
182
        os.chdir('checkout')
308
 
        return tree
309
183
 
310
184
    def example_branch2(self):
311
 
        tree = super(TestCheckoutDiff, self).example_branch2()
 
185
        super(TestCheckoutDiff, self).example_branch2()
312
186
        os.mkdir('checkouts')
313
 
        tree = tree.branch.create_checkout('checkouts/branch1')
 
187
        self.runbzr('checkout branch1 checkouts/branch1')
314
188
        os.chdir('checkouts')
315
 
        return tree
316
189
 
317
190
    def example_branches(self):
318
 
        branch1_tree, branch2_tree = super(TestCheckoutDiff, self).example_branches()
 
191
        super(TestCheckoutDiff, self).example_branches()
319
192
        os.mkdir('checkouts')
320
 
        branch1_tree = branch1_tree.branch.create_checkout('checkouts/branch1')
321
 
        branch2_tree = branch2_tree.branch.create_checkout('checkouts/branch2')
 
193
        self.runbzr('checkout branch1 checkouts/branch1')
 
194
        self.runbzr('checkout branch2 checkouts/branch2')
322
195
        os.chdir('checkouts')
323
 
        return branch1_tree, branch2_tree
324
 
 
325
 
 
326
 
class TestDiffLabels(DiffBase):
 
196
 
 
197
 
 
198
class TestDiffLabels(TestDiff):
327
199
 
328
200
    def test_diff_label_removed(self):
329
 
        tree = super(TestDiffLabels, self).make_example_branch()
330
 
        tree.remove('hello', keep_files=False)
331
 
        diff = self.run_bzr('diff', retcode=1)
 
201
        super(TestDiffLabels, self).make_example_branch()
 
202
        self.runbzr('remove hello')
 
203
        diff = self.run_bzr_captured(['diff'], retcode=1)
332
204
        self.assertTrue("=== removed file 'hello'" in diff[0])
333
205
 
334
206
    def test_diff_label_added(self):
335
 
        tree = super(TestDiffLabels, self).make_example_branch()
336
 
        self.build_tree_contents([('barbar', 'barbar')])
337
 
        tree.add('barbar')
338
 
        diff = self.run_bzr('diff', retcode=1)
 
207
        super(TestDiffLabels, self).make_example_branch()
 
208
        file('barbar', 'wt').write('barbar')
 
209
        self.runbzr('add barbar')
 
210
        diff = self.run_bzr_captured(['diff'], retcode=1)
339
211
        self.assertTrue("=== added file 'barbar'" in diff[0])
340
212
 
341
213
    def test_diff_label_modified(self):
342
214
        super(TestDiffLabels, self).make_example_branch()
343
 
        self.build_tree_contents([('hello', 'barbar')])
344
 
        diff = self.run_bzr('diff', retcode=1)
 
215
        file('hello', 'wt').write('barbar')
 
216
        diff = self.run_bzr_captured(['diff'], retcode=1)
345
217
        self.assertTrue("=== modified file 'hello'" in diff[0])
346
218
 
347
219
    def test_diff_label_renamed(self):
348
 
        tree = super(TestDiffLabels, self).make_example_branch()
349
 
        tree.rename_one('hello', 'gruezi')
350
 
        diff = self.run_bzr('diff', retcode=1)
 
220
        super(TestDiffLabels, self).make_example_branch()
 
221
        self.runbzr('rename hello gruezi')
 
222
        diff = self.run_bzr_captured(['diff'], retcode=1)
351
223
        self.assertTrue("=== renamed file 'hello' => 'gruezi'" in diff[0])
352
 
 
353
 
 
354
 
class TestExternalDiff(DiffBase):
355
 
 
356
 
    def test_external_diff(self):
357
 
        """Test that we can spawn an external diff process"""
358
 
        # We have to use run_bzr_subprocess, because we need to
359
 
        # test writing directly to stdout, (there was a bug in
360
 
        # subprocess.py that we had to workaround).
361
 
        # However, if 'diff' may not be available
362
 
        self.make_example_branch()
363
 
        # this will be automatically restored by the base bzr test class
364
 
        os.environ['BZR_PROGRESS_BAR'] = 'none'
365
 
        out, err = self.run_bzr_subprocess('diff -r 1 --diff-options -ub',
366
 
                                           universal_newlines=True,
367
 
                                           retcode=None)
368
 
        if 'Diff is not installed on this machine' in err:
369
 
            raise TestSkipped("No external 'diff' is available")
370
 
        self.assertEqual('', err)
371
 
        # We have to skip the stuff in the middle, because it depends
372
 
        # on time.time()
373
 
        self.assertStartsWith(out, "=== added file 'goodbye'\n"
374
 
                                   "--- goodbye\t1970-01-01 00:00:00 +0000\n"
375
 
                                   "+++ goodbye\t")
376
 
        self.assertEndsWith(out, "\n@@ -0,0 +1 @@\n"
377
 
                                 "+baz\n\n")
378
 
 
379
 
 
380
 
class TestDiffOutput(DiffBase):
381
 
 
382
 
    def test_diff_output(self):
383
 
        # check that output doesn't mangle line-endings
384
 
        self.make_example_branch()
385
 
        self.build_tree_contents([('hello', 'hello world!\n')])
386
 
        output = self.run_bzr_subprocess('diff', retcode=1)[0]
387
 
        self.assert_('\n+hello world!\n' in output)