/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

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

  • Committer: Robert Collins
  • Date: 2007-07-15 15:40:37 UTC
  • mto: (2592.3.33 repository)
  • mto: This revision was merged to the branch mainline in revision 2624.
  • Revision ID: robertc@robertcollins.net-20070715154037-3ar8g89decddc9su
Make GraphIndex accept nodes as key, value, references, so that the method
signature is closer to what a simple key->value index delivers. Also
change the behaviour when the reference list count is zero to accept
key, value as nodes, and emit key, value to make it identical in that case
to a simple key->value index. This may not be a good idea, but for now it
seems ok.

Show diffs side-by-side

added added

removed removed

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