← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_diff.py

(vila) Fix test failures blocking package builds. (Vincent Ladeuil)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_diff.py
1
 
# Copyright (C) 2005, 2006 Canonical Ltd
 
1
# Copyright (C) 2005-2014 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
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
import os
18
 
import os.path
19
18
from cStringIO import StringIO
20
 
import errno
21
19
import subprocess
22
 
import sys
23
 
from tempfile import TemporaryFile
 
20
import tempfile
24
21
 
25
 
from bzrlib import tests
26
 
from bzrlib.diff import (
27
 
    DiffFromTool,
28
 
    DiffPath,
29
 
    DiffSymlink,
30
 
    DiffTree,
31
 
    DiffText,
32
 
    external_diff,
33
 
    internal_diff,
34
 
    show_diff_trees,
 
22
from bzrlib import (
 
23
    diff,
 
24
    errors,
 
25
    osutils,
 
26
    patiencediff,
 
27
    _patiencediff_py,
 
28
    revision as _mod_revision,
 
29
    revisionspec,
 
30
    revisiontree,
 
31
    tests,
 
32
    transform,
35
33
    )
36
 
from bzrlib.errors import BinaryFile, NoDiff, ExecutableMissing
37
 
import bzrlib.osutils as osutils
38
 
import bzrlib.revision as _mod_revision
39
 
import bzrlib.transform as transform
40
 
import bzrlib.patiencediff
41
 
import bzrlib._patiencediff_py
42
 
from bzrlib.tests import (Feature, TestCase, TestCaseWithTransport,
43
 
                          TestCaseInTempDir, TestSkipped)
44
 
 
45
 
 
46
 
class _AttribFeature(Feature):
47
 
 
48
 
    def _probe(self):
49
 
        if (sys.platform not in ('cygwin', 'win32')):
50
 
            return False
51
 
        try:
52
 
            proc = subprocess.Popen(['attrib', '.'], stdout=subprocess.PIPE)
53
 
        except OSError, e:
54
 
            return False
55
 
        return (0 == proc.wait())
56
 
 
57
 
    def feature_name(self):
58
 
        return 'attrib Windows command-line tool'
59
 
 
60
 
AttribFeature = _AttribFeature()
61
 
 
62
 
 
63
 
class _CompiledPatienceDiffFeature(Feature):
64
 
 
65
 
    def _probe(self):
66
 
        try:
67
 
            import bzrlib._patiencediff_c
68
 
        except ImportError:
69
 
            return False
70
 
        return True
71
 
 
72
 
    def feature_name(self):
73
 
        return 'bzrlib._patiencediff_c'
74
 
 
75
 
CompiledPatienceDiffFeature = _CompiledPatienceDiffFeature()
 
34
from bzrlib.tests import (
 
35
    features,
 
36
    EncodingAdapter,
 
37
)
 
38
from bzrlib.tests.blackbox.test_diff import subst_dates
 
39
from bzrlib.tests.scenarios import load_tests_apply_scenarios
 
40
 
 
41
 
 
42
load_tests = load_tests_apply_scenarios
76
43
 
77
44
 
78
45
def udiff_lines(old, new, allow_binary=False):
79
46
    output = StringIO()
80
 
    internal_diff('old', old, 'new', new, output, allow_binary)
 
47
    diff.internal_diff('old', old, 'new', new, output, allow_binary)
81
48
    output.seek(0, 0)
82
49
    return output.readlines()
83
50
 
87
54
        # StringIO has no fileno, so it tests a different codepath
88
55
        output = StringIO()
89
56
    else:
90
 
        output = TemporaryFile()
 
57
        output = tempfile.TemporaryFile()
91
58
    try:
92
 
        external_diff('old', old, 'new', new, output, diff_opts=['-u'])
93
 
    except NoDiff:
94
 
        raise TestSkipped('external "diff" not present to test')
 
59
        diff.external_diff('old', old, 'new', new, output, diff_opts=['-u'])
 
60
    except errors.NoDiff:
 
61
        raise tests.TestSkipped('external "diff" not present to test')
95
62
    output.seek(0, 0)
96
63
    lines = output.readlines()
97
64
    output.close()
98
65
    return lines
99
66
 
100
67
 
101
 
class TestDiff(TestCase):
 
68
class TestDiffOptions(tests.TestCase):
 
69
 
 
70
    def test_unified_added(self):
 
71
        """Check for default style '-u' only if no other style specified
 
72
        in 'diff-options'.
 
73
        """
 
74
        # Verify that style defaults to unified, id est '-u' appended
 
75
        # to option list, in the absence of an alternative style.
 
76
        self.assertEqual(['-a', '-u'], diff.default_style_unified(['-a']))
 
77
 
 
78
 
 
79
class TestDiffOptionsScenarios(tests.TestCase):
 
80
 
 
81
    scenarios = [(s, dict(style=s)) for s in diff.style_option_list]
 
82
    style = None # Set by load_tests_apply_scenarios from scenarios
 
83
 
 
84
    def test_unified_not_added(self):
 
85
        # Verify that for all valid style options, '-u' is not
 
86
        # appended to option list.
 
87
        ret_opts = diff.default_style_unified(diff_opts=["%s" % (self.style,)])
 
88
        self.assertEqual(["%s" % (self.style,)], ret_opts)
 
89
 
 
90
 
 
91
class TestDiff(tests.TestCase):
102
92
 
103
93
    def test_add_nl(self):
104
94
        """diff generates a valid diff for patches that add a newline"""
140
130
            ## "Unterminated hunk header for patch:\n%s" % "".join(lines)
141
131
 
142
132
    def test_binary_lines(self):
143
 
        self.assertRaises(BinaryFile, udiff_lines, [1023 * 'a' + '\x00'], [])
144
 
        self.assertRaises(BinaryFile, udiff_lines, [], [1023 * 'a' + '\x00'])
145
 
        udiff_lines([1023 * 'a' + '\x00'], [], allow_binary=True)
146
 
        udiff_lines([], [1023 * 'a' + '\x00'], allow_binary=True)
 
133
        empty = []
 
134
        uni_lines = [1023 * 'a' + '\x00']
 
135
        self.assertRaises(errors.BinaryFile, udiff_lines, uni_lines , empty)
 
136
        self.assertRaises(errors.BinaryFile, udiff_lines, empty, uni_lines)
 
137
        udiff_lines(uni_lines , empty, allow_binary=True)
 
138
        udiff_lines(empty, uni_lines, allow_binary=True)
147
139
 
148
140
    def test_external_diff(self):
149
141
        lines = external_udiff_lines(['boo\n'], ['goo\n'])
159
151
        self.check_patch(lines)
160
152
 
161
153
    def test_external_diff_binary_lang_c(self):
162
 
        old_env = {}
163
154
        for lang in ('LANG', 'LC_ALL', 'LANGUAGE'):
164
 
            old_env[lang] = osutils.set_or_unset_env(lang, 'C')
165
 
        try:
166
 
            lines = external_udiff_lines(['\x00foobar\n'], ['foo\x00bar\n'])
167
 
            # Older versions of diffutils say "Binary files", newer
168
 
            # versions just say "Files".
169
 
            self.assertContainsRe(lines[0],
170
 
                                  '(Binary f|F)iles old and new differ\n')
171
 
            self.assertEquals(lines[1:], ['\n'])
172
 
        finally:
173
 
            for lang, old_val in old_env.iteritems():
174
 
                osutils.set_or_unset_env(lang, old_val)
 
155
            self.overrideEnv(lang, 'C')
 
156
        lines = external_udiff_lines(['\x00foobar\n'], ['foo\x00bar\n'])
 
157
        # Older versions of diffutils say "Binary files", newer
 
158
        # versions just say "Files".
 
159
        self.assertContainsRe(lines[0], '(Binary f|F)iles old and new differ\n')
 
160
        self.assertEquals(lines[1:], ['\n'])
175
161
 
176
162
    def test_no_external_diff(self):
177
163
        """Check that NoDiff is raised when diff is not available"""
178
 
        # Use os.environ['PATH'] to make sure no 'diff' command is available
179
 
        orig_path = os.environ['PATH']
180
 
        try:
181
 
            os.environ['PATH'] = ''
182
 
            self.assertRaises(NoDiff, external_diff,
183
 
                              'old', ['boo\n'], 'new', ['goo\n'],
184
 
                              StringIO(), diff_opts=['-u'])
185
 
        finally:
186
 
            os.environ['PATH'] = orig_path
 
164
        # Make sure no 'diff' command is available
 
165
        # XXX: Weird, using None instead of '' breaks the test -- vila 20101216
 
166
        self.overrideEnv('PATH', '')
 
167
        self.assertRaises(errors.NoDiff, diff.external_diff,
 
168
                          'old', ['boo\n'], 'new', ['goo\n'],
 
169
                          StringIO(), diff_opts=['-u'])
187
170
 
188
171
    def test_internal_diff_default(self):
189
172
        # Default internal diff encoding is utf8
190
173
        output = StringIO()
191
 
        internal_diff(u'old_\xb5', ['old_text\n'],
192
 
                    u'new_\xe5', ['new_text\n'], output)
 
174
        diff.internal_diff(u'old_\xb5', ['old_text\n'],
 
175
                           u'new_\xe5', ['new_text\n'], output)
193
176
        lines = output.getvalue().splitlines(True)
194
177
        self.check_patch(lines)
195
178
        self.assertEquals(['--- old_\xc2\xb5\n',
203
186
 
204
187
    def test_internal_diff_utf8(self):
205
188
        output = StringIO()
206
 
        internal_diff(u'old_\xb5', ['old_text\n'],
207
 
                    u'new_\xe5', ['new_text\n'], output,
208
 
                    path_encoding='utf8')
 
189
        diff.internal_diff(u'old_\xb5', ['old_text\n'],
 
190
                           u'new_\xe5', ['new_text\n'], output,
 
191
                           path_encoding='utf8')
209
192
        lines = output.getvalue().splitlines(True)
210
193
        self.check_patch(lines)
211
194
        self.assertEquals(['--- old_\xc2\xb5\n',
219
202
 
220
203
    def test_internal_diff_iso_8859_1(self):
221
204
        output = StringIO()
222
 
        internal_diff(u'old_\xb5', ['old_text\n'],
223
 
                    u'new_\xe5', ['new_text\n'], output,
224
 
                    path_encoding='iso-8859-1')
 
205
        diff.internal_diff(u'old_\xb5', ['old_text\n'],
 
206
                           u'new_\xe5', ['new_text\n'], output,
 
207
                           path_encoding='iso-8859-1')
225
208
        lines = output.getvalue().splitlines(True)
226
209
        self.check_patch(lines)
227
210
        self.assertEquals(['--- old_\xb5\n',
235
218
 
236
219
    def test_internal_diff_no_content(self):
237
220
        output = StringIO()
238
 
        internal_diff(u'old', [], u'new', [], output)
 
221
        diff.internal_diff(u'old', [], u'new', [], output)
239
222
        self.assertEqual('', output.getvalue())
240
223
 
241
224
    def test_internal_diff_no_changes(self):
242
225
        output = StringIO()
243
 
        internal_diff(u'old', ['text\n', 'contents\n'],
244
 
                      u'new', ['text\n', 'contents\n'],
245
 
                      output)
 
226
        diff.internal_diff(u'old', ['text\n', 'contents\n'],
 
227
                           u'new', ['text\n', 'contents\n'],
 
228
                           output)
246
229
        self.assertEqual('', output.getvalue())
247
230
 
248
231
    def test_internal_diff_returns_bytes(self):
249
232
        import StringIO
250
233
        output = StringIO.StringIO()
251
 
        internal_diff(u'old_\xb5', ['old_text\n'],
252
 
                    u'new_\xe5', ['new_text\n'], output)
253
 
        self.failUnless(isinstance(output.getvalue(), str),
 
234
        diff.internal_diff(u'old_\xb5', ['old_text\n'],
 
235
                            u'new_\xe5', ['new_text\n'], output)
 
236
        self.assertIsInstance(output.getvalue(), str,
254
237
            'internal_diff should return bytestrings')
255
238
 
256
 
 
257
 
class TestDiffFiles(TestCaseInTempDir):
 
239
    def test_internal_diff_default_context(self):
 
240
        output = StringIO()
 
241
        diff.internal_diff('old', ['same_text\n','same_text\n','same_text\n',
 
242
                           'same_text\n','same_text\n','old_text\n'],
 
243
                           'new', ['same_text\n','same_text\n','same_text\n',
 
244
                           'same_text\n','same_text\n','new_text\n'], output)
 
245
        lines = output.getvalue().splitlines(True)
 
246
        self.check_patch(lines)
 
247
        self.assertEquals(['--- old\n',
 
248
                           '+++ new\n',
 
249
                           '@@ -3,4 +3,4 @@\n',
 
250
                           ' same_text\n',
 
251
                           ' same_text\n',
 
252
                           ' same_text\n',
 
253
                           '-old_text\n',
 
254
                           '+new_text\n',
 
255
                           '\n',
 
256
                          ]
 
257
                          , lines)
 
258
 
 
259
    def test_internal_diff_no_context(self):
 
260
        output = StringIO()
 
261
        diff.internal_diff('old', ['same_text\n','same_text\n','same_text\n',
 
262
                           'same_text\n','same_text\n','old_text\n'],
 
263
                           'new', ['same_text\n','same_text\n','same_text\n',
 
264
                           'same_text\n','same_text\n','new_text\n'], output,
 
265
                           context_lines=0)
 
266
        lines = output.getvalue().splitlines(True)
 
267
        self.check_patch(lines)
 
268
        self.assertEquals(['--- old\n',
 
269
                           '+++ new\n',
 
270
                           '@@ -6,1 +6,1 @@\n',
 
271
                           '-old_text\n',
 
272
                           '+new_text\n',
 
273
                           '\n',
 
274
                          ]
 
275
                          , lines)
 
276
 
 
277
    def test_internal_diff_more_context(self):
 
278
        output = StringIO()
 
279
        diff.internal_diff('old', ['same_text\n','same_text\n','same_text\n',
 
280
                           'same_text\n','same_text\n','old_text\n'],
 
281
                           'new', ['same_text\n','same_text\n','same_text\n',
 
282
                           'same_text\n','same_text\n','new_text\n'], output,
 
283
                           context_lines=4)
 
284
        lines = output.getvalue().splitlines(True)
 
285
        self.check_patch(lines)
 
286
        self.assertEquals(['--- old\n',
 
287
                           '+++ new\n',
 
288
                           '@@ -2,5 +2,5 @@\n',
 
289
                           ' same_text\n',
 
290
                           ' same_text\n',
 
291
                           ' same_text\n',
 
292
                           ' same_text\n',
 
293
                           '-old_text\n',
 
294
                           '+new_text\n',
 
295
                           '\n',
 
296
                          ]
 
297
                          , lines)
 
298
 
 
299
 
 
300
 
 
301
 
 
302
 
 
303
class TestDiffFiles(tests.TestCaseInTempDir):
258
304
 
259
305
    def test_external_diff_binary(self):
260
306
        """The output when using external diff should use diff's i18n error"""
262
308
        lines = external_udiff_lines(['\x00foobar\n'], ['foo\x00bar\n'])
263
309
 
264
310
        cmd = ['diff', '-u', '--binary', 'old', 'new']
265
 
        open('old', 'wb').write('\x00foobar\n')
266
 
        open('new', 'wb').write('foo\x00bar\n')
 
311
        with open('old', 'wb') as f: f.write('\x00foobar\n')
 
312
        with open('new', 'wb') as f: f.write('foo\x00bar\n')
267
313
        pipe = subprocess.Popen(cmd, stdout=subprocess.PIPE,
268
314
                                     stdin=subprocess.PIPE)
269
315
        out, err = pipe.communicate()
273
319
        self.assertEqual(out.splitlines(True) + ['\n'], lines)
274
320
 
275
321
 
276
 
class TestShowDiffTreesHelper(TestCaseWithTransport):
277
 
    """Has a helper for running show_diff_trees"""
278
 
 
279
 
    def get_diff(self, tree1, tree2, specific_files=None, working_tree=None):
280
 
        output = StringIO()
281
 
        if working_tree is not None:
282
 
            extra_trees = (working_tree,)
283
 
        else:
284
 
            extra_trees = ()
285
 
        show_diff_trees(tree1, tree2, output, specific_files=specific_files,
286
 
                        extra_trees=extra_trees, old_label='old/',
287
 
                        new_label='new/')
288
 
        return output.getvalue()
289
 
 
290
 
 
291
 
class TestDiffDates(TestShowDiffTreesHelper):
 
322
def get_diff_as_string(tree1, tree2, specific_files=None, working_tree=None):
 
323
    output = StringIO()
 
324
    if working_tree is not None:
 
325
        extra_trees = (working_tree,)
 
326
    else:
 
327
        extra_trees = ()
 
328
    diff.show_diff_trees(tree1, tree2, output,
 
329
        specific_files=specific_files,
 
330
        extra_trees=extra_trees, old_label='old/',
 
331
        new_label='new/')
 
332
    return output.getvalue()
 
333
 
 
334
 
 
335
class TestDiffDates(tests.TestCaseWithTransport):
292
336
 
293
337
    def setUp(self):
294
338
        super(TestDiffDates, self).setUp()
329
373
        os.utime('file1', (1144195200, 1144195200)) # 2006-04-05 00:00:00 UTC
330
374
 
331
375
    def test_diff_rev_tree_working_tree(self):
332
 
        output = self.get_diff(self.wt.basis_tree(), self.wt)
 
376
        output = get_diff_as_string(self.wt.basis_tree(), self.wt)
333
377
        # note that the date for old/file1 is from rev 2 rather than from
334
378
        # the basis revision (rev 4)
335
379
        self.assertEqualDiff(output, '''\
345
389
    def test_diff_rev_tree_rev_tree(self):
346
390
        tree1 = self.b.repository.revision_tree('rev-2')
347
391
        tree2 = self.b.repository.revision_tree('rev-3')
348
 
        output = self.get_diff(tree1, tree2)
 
392
        output = get_diff_as_string(tree1, tree2)
349
393
        self.assertEqualDiff(output, '''\
350
394
=== modified file 'file2'
351
395
--- old/file2\t2006-04-01 00:00:00 +0000
359
403
    def test_diff_add_files(self):
360
404
        tree1 = self.b.repository.revision_tree(_mod_revision.NULL_REVISION)
361
405
        tree2 = self.b.repository.revision_tree('rev-1')
362
 
        output = self.get_diff(tree1, tree2)
 
406
        output = get_diff_as_string(tree1, tree2)
363
407
        # the files have the epoch time stamp for the tree in which
364
408
        # they don't exist.
365
409
        self.assertEqualDiff(output, '''\
380
424
    def test_diff_remove_files(self):
381
425
        tree1 = self.b.repository.revision_tree('rev-3')
382
426
        tree2 = self.b.repository.revision_tree('rev-4')
383
 
        output = self.get_diff(tree1, tree2)
 
427
        output = get_diff_as_string(tree1, tree2)
384
428
        # the file has the epoch time stamp for the tree in which
385
429
        # it doesn't exist.
386
430
        self.assertEqualDiff(output, '''\
397
441
        self.wt.rename_one('file1', 'file1b')
398
442
        old_tree = self.b.repository.revision_tree('rev-1')
399
443
        new_tree = self.b.repository.revision_tree('rev-4')
400
 
        out = self.get_diff(old_tree, new_tree, specific_files=['file1b'],
 
444
        out = get_diff_as_string(old_tree, new_tree, specific_files=['file1b'],
401
445
                            working_tree=self.wt)
402
446
        self.assertContainsRe(out, 'file1\t')
403
447
 
409
453
        self.wt.rename_one('file1', 'dir1/file1')
410
454
        old_tree = self.b.repository.revision_tree('rev-1')
411
455
        new_tree = self.b.repository.revision_tree('rev-4')
412
 
        out = self.get_diff(old_tree, new_tree, specific_files=['dir1'],
 
456
        out = get_diff_as_string(old_tree, new_tree, specific_files=['dir1'],
413
457
                            working_tree=self.wt)
414
458
        self.assertContainsRe(out, 'file1\t')
415
 
        out = self.get_diff(old_tree, new_tree, specific_files=['dir2'],
 
459
        out = get_diff_as_string(old_tree, new_tree, specific_files=['dir2'],
416
460
                            working_tree=self.wt)
417
461
        self.assertNotContainsRe(out, 'file1\t')
418
462
 
419
463
 
420
 
 
421
 
class TestShowDiffTrees(TestShowDiffTreesHelper):
 
464
class TestShowDiffTrees(tests.TestCaseWithTransport):
422
465
    """Direct tests for show_diff_trees"""
423
466
 
424
467
    def test_modified_file(self):
429
472
        tree.commit('one', rev_id='rev-1')
430
473
 
431
474
        self.build_tree_contents([('tree/file', 'new contents\n')])
432
 
        diff = self.get_diff(tree.basis_tree(), tree)
433
 
        self.assertContainsRe(diff, "=== modified file 'file'\n")
434
 
        self.assertContainsRe(diff, '--- old/file\t')
435
 
        self.assertContainsRe(diff, '\\+\\+\\+ new/file\t')
436
 
        self.assertContainsRe(diff, '-contents\n'
437
 
                                    '\\+new contents\n')
 
475
        d = get_diff_as_string(tree.basis_tree(), tree)
 
476
        self.assertContainsRe(d, "=== modified file 'file'\n")
 
477
        self.assertContainsRe(d, '--- old/file\t')
 
478
        self.assertContainsRe(d, '\\+\\+\\+ new/file\t')
 
479
        self.assertContainsRe(d, '-contents\n'
 
480
                                 '\\+new contents\n')
438
481
 
439
482
    def test_modified_file_in_renamed_dir(self):
440
483
        """Test when a file is modified in a renamed directory."""
446
489
 
447
490
        tree.rename_one('dir', 'other')
448
491
        self.build_tree_contents([('tree/other/file', 'new contents\n')])
449
 
        diff = self.get_diff(tree.basis_tree(), tree)
450
 
        self.assertContainsRe(diff, "=== renamed directory 'dir' => 'other'\n")
451
 
        self.assertContainsRe(diff, "=== modified file 'other/file'\n")
 
492
        d = get_diff_as_string(tree.basis_tree(), tree)
 
493
        self.assertContainsRe(d, "=== renamed directory 'dir' => 'other'\n")
 
494
        self.assertContainsRe(d, "=== modified file 'other/file'\n")
452
495
        # XXX: This is technically incorrect, because it used to be at another
453
496
        # location. What to do?
454
 
        self.assertContainsRe(diff, '--- old/dir/file\t')
455
 
        self.assertContainsRe(diff, '\\+\\+\\+ new/other/file\t')
456
 
        self.assertContainsRe(diff, '-contents\n'
457
 
                                    '\\+new contents\n')
 
497
        self.assertContainsRe(d, '--- old/dir/file\t')
 
498
        self.assertContainsRe(d, '\\+\\+\\+ new/other/file\t')
 
499
        self.assertContainsRe(d, '-contents\n'
 
500
                                 '\\+new contents\n')
458
501
 
459
502
    def test_renamed_directory(self):
460
503
        """Test when only a directory is only renamed."""
465
508
        tree.commit('one', rev_id='rev-1')
466
509
 
467
510
        tree.rename_one('dir', 'newdir')
468
 
        diff = self.get_diff(tree.basis_tree(), tree)
 
511
        d = get_diff_as_string(tree.basis_tree(), tree)
469
512
        # Renaming a directory should be a single "you renamed this dir" even
470
513
        # when there are files inside.
471
 
        self.assertEqual("=== renamed directory 'dir' => 'newdir'\n", diff)
 
514
        self.assertEqual(d, "=== renamed directory 'dir' => 'newdir'\n")
472
515
 
473
516
    def test_renamed_file(self):
474
517
        """Test when a file is only renamed."""
478
521
        tree.commit('one', rev_id='rev-1')
479
522
 
480
523
        tree.rename_one('file', 'newname')
481
 
        diff = self.get_diff(tree.basis_tree(), tree)
482
 
        self.assertContainsRe(diff, "=== renamed file 'file' => 'newname'\n")
 
524
        d = get_diff_as_string(tree.basis_tree(), tree)
 
525
        self.assertContainsRe(d, "=== renamed file 'file' => 'newname'\n")
483
526
        # We shouldn't have a --- or +++ line, because there is no content
484
527
        # change
485
 
        self.assertNotContainsRe(diff, '---')
 
528
        self.assertNotContainsRe(d, '---')
486
529
 
487
530
    def test_renamed_and_modified_file(self):
488
531
        """Test when a file is only renamed."""
493
536
 
494
537
        tree.rename_one('file', 'newname')
495
538
        self.build_tree_contents([('tree/newname', 'new contents\n')])
496
 
        diff = self.get_diff(tree.basis_tree(), tree)
497
 
        self.assertContainsRe(diff, "=== renamed file 'file' => 'newname'\n")
498
 
        self.assertContainsRe(diff, '--- old/file\t')
499
 
        self.assertContainsRe(diff, '\\+\\+\\+ new/newname\t')
500
 
        self.assertContainsRe(diff, '-contents\n'
501
 
                                    '\\+new contents\n')
 
539
        d = get_diff_as_string(tree.basis_tree(), tree)
 
540
        self.assertContainsRe(d, "=== renamed file 'file' => 'newname'\n")
 
541
        self.assertContainsRe(d, '--- old/file\t')
 
542
        self.assertContainsRe(d, '\\+\\+\\+ new/newname\t')
 
543
        self.assertContainsRe(d, '-contents\n'
 
544
                                 '\\+new contents\n')
502
545
 
503
546
 
504
547
    def test_internal_diff_exec_property(self):
523
566
        tree.rename_one('c', 'new-c')
524
567
        tree.rename_one('d', 'new-d')
525
568
 
526
 
        diff = self.get_diff(tree.basis_tree(), tree)
527
 
 
528
 
        self.assertContainsRe(diff, r"file 'a'.*\(properties changed:.*\+x to -x.*\)")
529
 
        self.assertContainsRe(diff, r"file 'b'.*\(properties changed:.*-x to \+x.*\)")
530
 
        self.assertContainsRe(diff, r"file 'c'.*\(properties changed:.*\+x to -x.*\)")
531
 
        self.assertContainsRe(diff, r"file 'd'.*\(properties changed:.*-x to \+x.*\)")
532
 
        self.assertNotContainsRe(diff, r"file 'e'")
533
 
        self.assertNotContainsRe(diff, r"file 'f'")
534
 
 
 
569
        d = get_diff_as_string(tree.basis_tree(), tree)
 
570
 
 
571
        self.assertContainsRe(d, r"file 'a'.*\(properties changed:"
 
572
                                  ".*\+x to -x.*\)")
 
573
        self.assertContainsRe(d, r"file 'b'.*\(properties changed:"
 
574
                                  ".*-x to \+x.*\)")
 
575
        self.assertContainsRe(d, r"file 'c'.*\(properties changed:"
 
576
                                  ".*\+x to -x.*\)")
 
577
        self.assertContainsRe(d, r"file 'd'.*\(properties changed:"
 
578
                                  ".*-x to \+x.*\)")
 
579
        self.assertNotContainsRe(d, r"file 'e'")
 
580
        self.assertNotContainsRe(d, r"file 'f'")
535
581
 
536
582
    def test_binary_unicode_filenames(self):
537
583
        """Test that contents of files are *not* encoded in UTF-8 when there
538
584
        is a binary file in the diff.
539
585
        """
540
586
        # See https://bugs.launchpad.net/bugs/110092.
541
 
        self.requireFeature(tests.UnicodeFilenameFeature)
 
587
        self.requireFeature(features.UnicodeFilenameFeature)
542
588
 
543
589
        # This bug isn't triggered with cStringIO.
544
590
        from StringIO import StringIO
552
598
        tree.add([alpha], ['file-id'])
553
599
        tree.add([omega], ['file-id-2'])
554
600
        diff_content = StringIO()
555
 
        show_diff_trees(tree.basis_tree(), tree, diff_content)
556
 
        diff = diff_content.getvalue()
557
 
        self.assertContainsRe(diff, r"=== added file '%s'" % alpha_utf8)
558
 
        self.assertContainsRe(
559
 
            diff, "Binary files a/%s.*and b/%s.* differ\n" % (alpha_utf8, alpha_utf8))
560
 
        self.assertContainsRe(diff, r"=== added file '%s'" % omega_utf8)
561
 
        self.assertContainsRe(diff, r"--- a/%s" % (omega_utf8,))
562
 
        self.assertContainsRe(diff, r"\+\+\+ b/%s" % (omega_utf8,))
 
601
        diff.show_diff_trees(tree.basis_tree(), tree, diff_content)
 
602
        d = diff_content.getvalue()
 
603
        self.assertContainsRe(d, r"=== added file '%s'" % alpha_utf8)
 
604
        self.assertContainsRe(d, "Binary files a/%s.*and b/%s.* differ\n"
 
605
                              % (alpha_utf8, alpha_utf8))
 
606
        self.assertContainsRe(d, r"=== added file '%s'" % omega_utf8)
 
607
        self.assertContainsRe(d, r"--- a/%s" % (omega_utf8,))
 
608
        self.assertContainsRe(d, r"\+\+\+ b/%s" % (omega_utf8,))
563
609
 
564
610
    def test_unicode_filename(self):
565
611
        """Test when the filename are unicode."""
566
 
        self.requireFeature(tests.UnicodeFilenameFeature)
 
612
        self.requireFeature(features.UnicodeFilenameFeature)
567
613
 
568
614
        alpha, omega = u'\u03b1', u'\u03c9'
569
615
        autf8, outf8 = alpha.encode('utf8'), omega.encode('utf8')
584
630
        tree.add(['add_'+alpha], ['file-id'])
585
631
        self.build_tree_contents([('tree/mod_'+alpha, 'contents_mod\n')])
586
632
 
587
 
        diff = self.get_diff(tree.basis_tree(), tree)
588
 
        self.assertContainsRe(diff,
 
633
        d = get_diff_as_string(tree.basis_tree(), tree)
 
634
        self.assertContainsRe(d,
589
635
                "=== renamed file 'ren_%s' => 'ren_%s'\n"%(autf8, outf8))
590
 
        self.assertContainsRe(diff, "=== added file 'add_%s'"%autf8)
591
 
        self.assertContainsRe(diff, "=== modified file 'mod_%s'"%autf8)
592
 
        self.assertContainsRe(diff, "=== removed file 'del_%s'"%autf8)
593
 
 
594
 
 
595
 
class DiffWasIs(DiffPath):
 
636
        self.assertContainsRe(d, "=== added file 'add_%s'"%autf8)
 
637
        self.assertContainsRe(d, "=== modified file 'mod_%s'"%autf8)
 
638
        self.assertContainsRe(d, "=== removed file 'del_%s'"%autf8)
 
639
 
 
640
    def test_unicode_filename_path_encoding(self):
 
641
        """Test for bug #382699: unicode filenames on Windows should be shown
 
642
        in user encoding.
 
643
        """
 
644
        self.requireFeature(features.UnicodeFilenameFeature)
 
645
        # The word 'test' in Russian
 
646
        _russian_test = u'\u0422\u0435\u0441\u0442'
 
647
        directory = _russian_test + u'/'
 
648
        test_txt = _russian_test + u'.txt'
 
649
        u1234 = u'\u1234.txt'
 
650
 
 
651
        tree = self.make_branch_and_tree('.')
 
652
        self.build_tree_contents([
 
653
            (test_txt, 'foo\n'),
 
654
            (u1234, 'foo\n'),
 
655
            (directory, None),
 
656
            ])
 
657
        tree.add([test_txt, u1234, directory])
 
658
 
 
659
        sio = StringIO()
 
660
        diff.show_diff_trees(tree.basis_tree(), tree, sio,
 
661
            path_encoding='cp1251')
 
662
 
 
663
        output = subst_dates(sio.getvalue())
 
664
        shouldbe = ('''\
 
665
=== added directory '%(directory)s'
 
666
=== added file '%(test_txt)s'
 
667
--- a/%(test_txt)s\tYYYY-MM-DD HH:MM:SS +ZZZZ
 
668
+++ b/%(test_txt)s\tYYYY-MM-DD HH:MM:SS +ZZZZ
 
669
@@ -0,0 +1,1 @@
 
670
+foo
 
671
 
 
672
=== added file '?.txt'
 
673
--- a/?.txt\tYYYY-MM-DD HH:MM:SS +ZZZZ
 
674
+++ b/?.txt\tYYYY-MM-DD HH:MM:SS +ZZZZ
 
675
@@ -0,0 +1,1 @@
 
676
+foo
 
677
 
 
678
''' % {'directory': _russian_test.encode('cp1251'),
 
679
       'test_txt': test_txt.encode('cp1251'),
 
680
      })
 
681
        self.assertEqualDiff(output, shouldbe)
 
682
 
 
683
 
 
684
class DiffWasIs(diff.DiffPath):
596
685
 
597
686
    def diff(self, file_id, old_path, new_path, old_kind, new_kind):
598
687
        self.to_file.write('was: ')
602
691
        pass
603
692
 
604
693
 
605
 
class TestDiffTree(TestCaseWithTransport):
 
694
class TestDiffTree(tests.TestCaseWithTransport):
606
695
 
607
696
    def setUp(self):
608
 
        TestCaseWithTransport.setUp(self)
 
697
        super(TestDiffTree, self).setUp()
609
698
        self.old_tree = self.make_branch_and_tree('old-tree')
610
699
        self.old_tree.lock_write()
611
700
        self.addCleanup(self.old_tree.unlock)
612
701
        self.new_tree = self.make_branch_and_tree('new-tree')
613
702
        self.new_tree.lock_write()
614
703
        self.addCleanup(self.new_tree.unlock)
615
 
        self.differ = DiffTree(self.old_tree, self.new_tree, StringIO())
 
704
        self.differ = diff.DiffTree(self.old_tree, self.new_tree, StringIO())
616
705
 
617
706
    def test_diff_text(self):
618
707
        self.build_tree_contents([('old-tree/olddir/',),
623
712
                                  ('new-tree/newdir/newfile', 'new\n')])
624
713
        self.new_tree.add('newdir')
625
714
        self.new_tree.add('newdir/newfile', 'file-id')
626
 
        differ = DiffText(self.old_tree, self.new_tree, StringIO())
 
715
        differ = diff.DiffText(self.old_tree, self.new_tree, StringIO())
627
716
        differ.diff_text('file-id', None, 'old label', 'new label')
628
717
        self.assertEqual(
629
718
            '--- old label\n+++ new label\n@@ -1,1 +0,0 @@\n-old\n\n',
658
747
        self.assertContainsRe(self.differ.to_file.getvalue(), '\+contents')
659
748
 
660
749
    def test_diff_symlink(self):
661
 
        differ = DiffSymlink(self.old_tree, self.new_tree, StringIO())
 
750
        differ = diff.DiffSymlink(self.old_tree, self.new_tree, StringIO())
662
751
        differ.diff_symlink('old target', None)
663
752
        self.assertEqual("=== target was 'old target'\n",
664
753
                         differ.to_file.getvalue())
665
754
 
666
 
        differ = DiffSymlink(self.old_tree, self.new_tree, StringIO())
 
755
        differ = diff.DiffSymlink(self.old_tree, self.new_tree, StringIO())
667
756
        differ.diff_symlink(None, 'new target')
668
757
        self.assertEqual("=== target is 'new target'\n",
669
758
                         differ.to_file.getvalue())
670
759
 
671
 
        differ = DiffSymlink(self.old_tree, self.new_tree, StringIO())
 
760
        differ = diff.DiffSymlink(self.old_tree, self.new_tree, StringIO())
672
761
        differ.diff_symlink('old target', 'new target')
673
762
        self.assertEqual("=== target changed 'old target' => 'new target'\n",
674
763
                         differ.to_file.getvalue())
689
778
             ' \@\@\n-old\n\+new\n\n')
690
779
 
691
780
    def test_diff_kind_change(self):
692
 
        self.requireFeature(tests.SymlinkFeature)
 
781
        self.requireFeature(features.SymlinkFeature)
693
782
        self.build_tree_contents([('old-tree/olddir/',),
694
783
                                  ('old-tree/olddir/oldfile', 'old\n')])
695
784
        self.old_tree.add('olddir')
724
813
 
725
814
    def test_register_diff(self):
726
815
        self.create_old_new()
727
 
        old_diff_factories = DiffTree.diff_factories
728
 
        DiffTree.diff_factories=old_diff_factories[:]
729
 
        DiffTree.diff_factories.insert(0, DiffWasIs.from_diff_tree)
 
816
        old_diff_factories = diff.DiffTree.diff_factories
 
817
        diff.DiffTree.diff_factories=old_diff_factories[:]
 
818
        diff.DiffTree.diff_factories.insert(0, DiffWasIs.from_diff_tree)
730
819
        try:
731
 
            differ = DiffTree(self.old_tree, self.new_tree, StringIO())
 
820
            differ = diff.DiffTree(self.old_tree, self.new_tree, StringIO())
732
821
        finally:
733
 
            DiffTree.diff_factories = old_diff_factories
 
822
            diff.DiffTree.diff_factories = old_diff_factories
734
823
        differ.diff('file-id', 'olddir/oldfile', 'newdir/newfile')
735
824
        self.assertNotContainsRe(
736
825
            differ.to_file.getvalue(),
741
830
 
742
831
    def test_extra_factories(self):
743
832
        self.create_old_new()
744
 
        differ = DiffTree(self.old_tree, self.new_tree, StringIO(),
745
 
                            extra_factories=[DiffWasIs.from_diff_tree])
 
833
        differ = diff.DiffTree(self.old_tree, self.new_tree, StringIO(),
 
834
                               extra_factories=[DiffWasIs.from_diff_tree])
746
835
        differ.diff('file-id', 'olddir/oldfile', 'newdir/newfile')
747
836
        self.assertNotContainsRe(
748
837
            differ.to_file.getvalue(),
761
850
            '.*a-file(.|\n)*b-file')
762
851
 
763
852
 
764
 
class TestPatienceDiffLib(TestCase):
 
853
class TestPatienceDiffLib(tests.TestCase):
765
854
 
766
855
    def setUp(self):
767
856
        super(TestPatienceDiffLib, self).setUp()
768
 
        self._unique_lcs = bzrlib._patiencediff_py.unique_lcs_py
769
 
        self._recurse_matches = bzrlib._patiencediff_py.recurse_matches_py
 
857
        self._unique_lcs = _patiencediff_py.unique_lcs_py
 
858
        self._recurse_matches = _patiencediff_py.recurse_matches_py
770
859
        self._PatienceSequenceMatcher = \
771
 
            bzrlib._patiencediff_py.PatienceSequenceMatcher_py
 
860
            _patiencediff_py.PatienceSequenceMatcher_py
772
861
 
773
862
    def test_diff_unicode_string(self):
774
863
        a = ''.join([unichr(i) for i in range(4000, 4500, 3)])
1081
1170
                 'how are you today?\n']
1082
1171
        txt_b = ['hello there\n',
1083
1172
                 'how are you today?\n']
1084
 
        unified_diff = bzrlib.patiencediff.unified_diff
 
1173
        unified_diff = patiencediff.unified_diff
1085
1174
        psm = self._PatienceSequenceMatcher
1086
1175
        self.assertEquals(['--- \n',
1087
1176
                           '+++ \n',
1135
1224
                 'how are you today?\n']
1136
1225
        txt_b = ['hello there\n',
1137
1226
                 'how are you today?\n']
1138
 
        unified_diff = bzrlib.patiencediff.unified_diff
 
1227
        unified_diff = patiencediff.unified_diff
1139
1228
        psm = self._PatienceSequenceMatcher
1140
1229
        self.assertEquals(['--- a\t2008-08-08\n',
1141
1230
                           '+++ b\t2008-09-09\n',
1153
1242
 
1154
1243
class TestPatienceDiffLib_c(TestPatienceDiffLib):
1155
1244
 
1156
 
    _test_needs_features = [CompiledPatienceDiffFeature]
 
1245
    _test_needs_features = [features.compiled_patiencediff_feature]
1157
1246
 
1158
1247
    def setUp(self):
1159
1248
        super(TestPatienceDiffLib_c, self).setUp()
1160
 
        import bzrlib._patiencediff_c
1161
 
        self._unique_lcs = bzrlib._patiencediff_c.unique_lcs_c
1162
 
        self._recurse_matches = bzrlib._patiencediff_c.recurse_matches_c
 
1249
        from bzrlib import _patiencediff_c
 
1250
        self._unique_lcs = _patiencediff_c.unique_lcs_c
 
1251
        self._recurse_matches = _patiencediff_c.recurse_matches_c
1163
1252
        self._PatienceSequenceMatcher = \
1164
 
            bzrlib._patiencediff_c.PatienceSequenceMatcher_c
 
1253
            _patiencediff_c.PatienceSequenceMatcher_c
1165
1254
 
1166
1255
    def test_unhashable(self):
1167
1256
        """We should get a proper exception here."""
1177
1266
                                         None, ['valid'], ['valid', []])
1178
1267
 
1179
1268
 
1180
 
class TestPatienceDiffLibFiles(TestCaseInTempDir):
 
1269
class TestPatienceDiffLibFiles(tests.TestCaseInTempDir):
1181
1270
 
1182
1271
    def setUp(self):
1183
1272
        super(TestPatienceDiffLibFiles, self).setUp()
1184
1273
        self._PatienceSequenceMatcher = \
1185
 
            bzrlib._patiencediff_py.PatienceSequenceMatcher_py
 
1274
            _patiencediff_py.PatienceSequenceMatcher_py
1186
1275
 
1187
1276
    def test_patience_unified_diff_files(self):
1188
1277
        txt_a = ['hello there\n',
1190
1279
                 'how are you today?\n']
1191
1280
        txt_b = ['hello there\n',
1192
1281
                 'how are you today?\n']
1193
 
        open('a1', 'wb').writelines(txt_a)
1194
 
        open('b1', 'wb').writelines(txt_b)
 
1282
        with open('a1', 'wb') as f: f.writelines(txt_a)
 
1283
        with open('b1', 'wb') as f: f.writelines(txt_b)
1195
1284
 
1196
 
        unified_diff_files = bzrlib.patiencediff.unified_diff_files
 
1285
        unified_diff_files = patiencediff.unified_diff_files
1197
1286
        psm = self._PatienceSequenceMatcher
1198
1287
        self.assertEquals(['--- a1\n',
1199
1288
                           '+++ b1\n',
1207
1296
 
1208
1297
        txt_a = map(lambda x: x+'\n', 'abcdefghijklmnop')
1209
1298
        txt_b = map(lambda x: x+'\n', 'abcdefxydefghijklmnop')
1210
 
        open('a2', 'wb').writelines(txt_a)
1211
 
        open('b2', 'wb').writelines(txt_b)
 
1299
        with open('a2', 'wb') as f: f.writelines(txt_a)
 
1300
        with open('b2', 'wb') as f: f.writelines(txt_b)
1212
1301
 
1213
1302
        # This is the result with LongestCommonSubstring matching
1214
1303
        self.assertEquals(['--- a2\n',
1249
1338
 
1250
1339
class TestPatienceDiffLibFiles_c(TestPatienceDiffLibFiles):
1251
1340
 
1252
 
    _test_needs_features = [CompiledPatienceDiffFeature]
 
1341
    _test_needs_features = [features.compiled_patiencediff_feature]
1253
1342
 
1254
1343
    def setUp(self):
1255
1344
        super(TestPatienceDiffLibFiles_c, self).setUp()
1256
 
        import bzrlib._patiencediff_c
 
1345
        from bzrlib import _patiencediff_c
1257
1346
        self._PatienceSequenceMatcher = \
1258
 
            bzrlib._patiencediff_c.PatienceSequenceMatcher_c
1259
 
 
1260
 
 
1261
 
class TestUsingCompiledIfAvailable(TestCase):
 
1347
            _patiencediff_c.PatienceSequenceMatcher_c
 
1348
 
 
1349
 
 
1350
class TestUsingCompiledIfAvailable(tests.TestCase):
1262
1351
 
1263
1352
    def test_PatienceSequenceMatcher(self):
1264
 
        if CompiledPatienceDiffFeature.available():
 
1353
        if features.compiled_patiencediff_feature.available():
1265
1354
            from bzrlib._patiencediff_c import PatienceSequenceMatcher_c
1266
1355
            self.assertIs(PatienceSequenceMatcher_c,
1267
 
                          bzrlib.patiencediff.PatienceSequenceMatcher)
 
1356
                          patiencediff.PatienceSequenceMatcher)
1268
1357
        else:
1269
1358
            from bzrlib._patiencediff_py import PatienceSequenceMatcher_py
1270
1359
            self.assertIs(PatienceSequenceMatcher_py,
1271
 
                          bzrlib.patiencediff.PatienceSequenceMatcher)
 
1360
                          patiencediff.PatienceSequenceMatcher)
1272
1361
 
1273
1362
    def test_unique_lcs(self):
1274
 
        if CompiledPatienceDiffFeature.available():
 
1363
        if features.compiled_patiencediff_feature.available():
1275
1364
            from bzrlib._patiencediff_c import unique_lcs_c
1276
1365
            self.assertIs(unique_lcs_c,
1277
 
                          bzrlib.patiencediff.unique_lcs)
 
1366
                          patiencediff.unique_lcs)
1278
1367
        else:
1279
1368
            from bzrlib._patiencediff_py import unique_lcs_py
1280
1369
            self.assertIs(unique_lcs_py,
1281
 
                          bzrlib.patiencediff.unique_lcs)
 
1370
                          patiencediff.unique_lcs)
1282
1371
 
1283
1372
    def test_recurse_matches(self):
1284
 
        if CompiledPatienceDiffFeature.available():
 
1373
        if features.compiled_patiencediff_feature.available():
1285
1374
            from bzrlib._patiencediff_c import recurse_matches_c
1286
1375
            self.assertIs(recurse_matches_c,
1287
 
                          bzrlib.patiencediff.recurse_matches)
 
1376
                          patiencediff.recurse_matches)
1288
1377
        else:
1289
1378
            from bzrlib._patiencediff_py import recurse_matches_py
1290
1379
            self.assertIs(recurse_matches_py,
1291
 
                          bzrlib.patiencediff.recurse_matches)
1292
 
 
1293
 
 
1294
 
class TestDiffFromTool(TestCaseWithTransport):
 
1380
                          patiencediff.recurse_matches)
 
1381
 
 
1382
 
 
1383
class TestDiffFromTool(tests.TestCaseWithTransport):
1295
1384
 
1296
1385
    def test_from_string(self):
1297
 
        diff_obj = DiffFromTool.from_string('diff', None, None, None)
 
1386
        diff_obj = diff.DiffFromTool.from_string('diff', None, None, None)
1298
1387
        self.addCleanup(diff_obj.finish)
1299
 
        self.assertEqual(['diff', '%(old_path)s', '%(new_path)s'],
 
1388
        self.assertEqual(['diff', '@old_path', '@new_path'],
1300
1389
            diff_obj.command_template)
1301
1390
 
1302
1391
    def test_from_string_u5(self):
1303
 
        diff_obj = DiffFromTool.from_string('diff -u\\ 5', None, None, None)
 
1392
        diff_obj = diff.DiffFromTool.from_string('diff "-u 5"',
 
1393
                                                 None, None, None)
1304
1394
        self.addCleanup(diff_obj.finish)
1305
 
        self.assertEqual(['diff', '-u 5', '%(old_path)s', '%(new_path)s'],
 
1395
        self.assertEqual(['diff', '-u 5', '@old_path', '@new_path'],
1306
1396
                         diff_obj.command_template)
1307
1397
        self.assertEqual(['diff', '-u 5', 'old-path', 'new-path'],
1308
1398
                         diff_obj._get_command('old-path', 'new-path'))
1309
1399
 
 
1400
    def test_from_string_path_with_backslashes(self):
 
1401
        self.requireFeature(features.backslashdir_feature)
 
1402
        tool = 'C:\\Tools\\Diff.exe'
 
1403
        diff_obj = diff.DiffFromTool.from_string(tool, None, None, None)
 
1404
        self.addCleanup(diff_obj.finish)
 
1405
        self.assertEqual(['C:\\Tools\\Diff.exe', '@old_path', '@new_path'],
 
1406
                         diff_obj.command_template)
 
1407
        self.assertEqual(['C:\\Tools\\Diff.exe', 'old-path', 'new-path'],
 
1408
                         diff_obj._get_command('old-path', 'new-path'))
 
1409
 
1310
1410
    def test_execute(self):
1311
1411
        output = StringIO()
1312
 
        diff_obj = DiffFromTool(['python', '-c',
1313
 
                                 'print "%(old_path)s %(new_path)s"'],
1314
 
                                None, None, output)
 
1412
        diff_obj = diff.DiffFromTool(['python', '-c',
 
1413
                                      'print "@old_path @new_path"'],
 
1414
                                     None, None, output)
1315
1415
        self.addCleanup(diff_obj.finish)
1316
1416
        diff_obj._execute('old', 'new')
1317
1417
        self.assertEqual(output.getvalue().rstrip(), 'old new')
1318
1418
 
1319
 
    def test_excute_missing(self):
1320
 
        diff_obj = DiffFromTool(['a-tool-which-is-unlikely-to-exist'],
1321
 
                                None, None, None)
 
1419
    def test_execute_missing(self):
 
1420
        diff_obj = diff.DiffFromTool(['a-tool-which-is-unlikely-to-exist'],
 
1421
                                     None, None, None)
1322
1422
        self.addCleanup(diff_obj.finish)
1323
 
        e = self.assertRaises(ExecutableMissing, diff_obj._execute, 'old',
1324
 
                              'new')
 
1423
        e = self.assertRaises(errors.ExecutableMissing, diff_obj._execute,
 
1424
                              'old', 'new')
1325
1425
        self.assertEqual('a-tool-which-is-unlikely-to-exist could not be found'
1326
1426
                         ' on this machine', str(e))
1327
1427
 
1328
1428
    def test_prepare_files_creates_paths_readable_by_windows_tool(self):
1329
 
        self.requireFeature(AttribFeature)
 
1429
        self.requireFeature(features.AttribFeature)
1330
1430
        output = StringIO()
1331
1431
        tree = self.make_branch_and_tree('tree')
1332
1432
        self.build_tree_contents([('tree/file', 'content')])
1334
1434
        tree.commit('old tree')
1335
1435
        tree.lock_read()
1336
1436
        self.addCleanup(tree.unlock)
1337
 
        diff_obj = DiffFromTool(['python', '-c',
1338
 
                                 'print "%(old_path)s %(new_path)s"'],
1339
 
                                tree, tree, output)
 
1437
        basis_tree = tree.basis_tree()
 
1438
        basis_tree.lock_read()
 
1439
        self.addCleanup(basis_tree.unlock)
 
1440
        diff_obj = diff.DiffFromTool(['python', '-c',
 
1441
                                      'print "@old_path @new_path"'],
 
1442
                                     basis_tree, tree, output)
1340
1443
        diff_obj._prepare_files('file-id', 'file', 'file')
1341
 
        self.assertReadableByAttrib(diff_obj._root, 'old\\file', r'old\\file')
1342
 
        self.assertReadableByAttrib(diff_obj._root, 'new\\file', r'new\\file')
 
1444
        # The old content should be readonly
 
1445
        self.assertReadableByAttrib(diff_obj._root, 'old\\file',
 
1446
                                    r'R.*old\\file$')
 
1447
        # The new content should use the tree object, not a 'new' file anymore
 
1448
        self.assertEndsWith(tree.basedir, 'work/tree')
 
1449
        self.assertReadableByAttrib(tree.basedir, 'file', r'work\\tree\\file$')
1343
1450
 
1344
1451
    def assertReadableByAttrib(self, cwd, relpath, regex):
1345
1452
        proc = subprocess.Popen(['attrib', relpath],
1346
1453
                                stdout=subprocess.PIPE,
1347
1454
                                cwd=cwd)
1348
 
        proc.wait()
1349
 
        result = proc.stdout.read()
1350
 
        self.assertContainsRe(result, regex)
 
1455
        (result, err) = proc.communicate()
 
1456
        self.assertContainsRe(result.replace('\r\n', '\n'), regex)
1351
1457
 
1352
1458
    def test_prepare_files(self):
1353
1459
        output = StringIO()
1356
1462
        self.build_tree_contents([('tree/oldname2', 'oldcontent2')])
1357
1463
        tree.add('oldname', 'file-id')
1358
1464
        tree.add('oldname2', 'file2-id')
1359
 
        tree.commit('old tree', timestamp=0)
 
1465
        # Earliest allowable date on FAT32 filesystems is 1980-01-01
 
1466
        tree.commit('old tree', timestamp=315532800)
1360
1467
        tree.rename_one('oldname', 'newname')
1361
1468
        tree.rename_one('oldname2', 'newname2')
1362
1469
        self.build_tree_contents([('tree/newname', 'newcontent')])
1366
1473
        self.addCleanup(old_tree.unlock)
1367
1474
        tree.lock_read()
1368
1475
        self.addCleanup(tree.unlock)
1369
 
        diff_obj = DiffFromTool(['python', '-c',
1370
 
                                 'print "%(old_path)s %(new_path)s"'],
1371
 
                                old_tree, tree, output)
 
1476
        diff_obj = diff.DiffFromTool(['python', '-c',
 
1477
                                      'print "@old_path @new_path"'],
 
1478
                                     old_tree, tree, output)
1372
1479
        self.addCleanup(diff_obj.finish)
1373
1480
        self.assertContainsRe(diff_obj._root, 'bzr-diff-[^/]*')
1374
1481
        old_path, new_path = diff_obj._prepare_files('file-id', 'oldname',
1375
1482
                                                     'newname')
1376
1483
        self.assertContainsRe(old_path, 'old/oldname$')
1377
 
        self.assertEqual(0, os.stat(old_path).st_mtime)
1378
 
        self.assertContainsRe(new_path, 'new/newname$')
 
1484
        self.assertEqual(315532800, os.stat(old_path).st_mtime)
 
1485
        self.assertContainsRe(new_path, 'tree/newname$')
1379
1486
        self.assertFileEqual('oldcontent', old_path)
1380
1487
        self.assertFileEqual('newcontent', new_path)
1381
1488
        if osutils.host_os_dereferences_symlinks():
1382
1489
            self.assertTrue(os.path.samefile('tree/newname', new_path))
1383
1490
        # make sure we can create files with the same parent directories
1384
1491
        diff_obj._prepare_files('file2-id', 'oldname2', 'newname2')
 
1492
 
 
1493
 
 
1494
class TestDiffFromToolEncodedFilename(tests.TestCaseWithTransport):
 
1495
 
 
1496
    def test_encodable_filename(self):
 
1497
        # Just checks file path for external diff tool.
 
1498
        # We cannot change CPython's internal encoding used by os.exec*.
 
1499
        diffobj = diff.DiffFromTool(['dummy', '@old_path', '@new_path'],
 
1500
                                    None, None, None)
 
1501
        for _, scenario in EncodingAdapter.encoding_scenarios:
 
1502
            encoding = scenario['encoding']
 
1503
            dirname  = scenario['info']['directory']
 
1504
            filename = scenario['info']['filename']
 
1505
 
 
1506
            self.overrideAttr(diffobj, '_fenc', lambda: encoding)
 
1507
            relpath = dirname + u'/' + filename
 
1508
            fullpath = diffobj._safe_filename('safe', relpath)
 
1509
            self.assertEqual(
 
1510
                    fullpath,
 
1511
                    fullpath.encode(encoding).decode(encoding)
 
1512
                    )
 
1513
            self.assert_(fullpath.startswith(diffobj._root + '/safe'))
 
1514
 
 
1515
    def test_unencodable_filename(self):
 
1516
        diffobj = diff.DiffFromTool(['dummy', '@old_path', '@new_path'],
 
1517
                                    None, None, None)
 
1518
        for _, scenario in EncodingAdapter.encoding_scenarios:
 
1519
            encoding = scenario['encoding']
 
1520
            dirname  = scenario['info']['directory']
 
1521
            filename = scenario['info']['filename']
 
1522
 
 
1523
            if encoding == 'iso-8859-1':
 
1524
                encoding = 'iso-8859-2'
 
1525
            else:
 
1526
                encoding = 'iso-8859-1'
 
1527
 
 
1528
            self.overrideAttr(diffobj, '_fenc', lambda: encoding)
 
1529
            relpath = dirname + u'/' + filename
 
1530
            fullpath = diffobj._safe_filename('safe', relpath)
 
1531
            self.assertEqual(
 
1532
                    fullpath,
 
1533
                    fullpath.encode(encoding).decode(encoding)
 
1534
                    )
 
1535
            self.assert_(fullpath.startswith(diffobj._root + '/safe'))
 
1536
 
 
1537
 
 
1538
class TestGetTreesAndBranchesToDiffLocked(tests.TestCaseWithTransport):
 
1539
 
 
1540
    def call_gtabtd(self, path_list, revision_specs, old_url, new_url):
 
1541
        """Call get_trees_and_branches_to_diff_locked."""
 
1542
        return diff.get_trees_and_branches_to_diff_locked(
 
1543
            path_list, revision_specs, old_url, new_url, self.addCleanup)
 
1544
 
 
1545
    def test_basic(self):
 
1546
        tree = self.make_branch_and_tree('tree')
 
1547
        (old_tree, new_tree,
 
1548
         old_branch, new_branch,
 
1549
         specific_files, extra_trees) = self.call_gtabtd(
 
1550
             ['tree'], None, None, None)
 
1551
 
 
1552
        self.assertIsInstance(old_tree, revisiontree.RevisionTree)
 
1553
        self.assertEqual(_mod_revision.NULL_REVISION,
 
1554
                         old_tree.get_revision_id())
 
1555
        self.assertEqual(tree.basedir, new_tree.basedir)
 
1556
        self.assertEqual(tree.branch.base, old_branch.base)
 
1557
        self.assertEqual(tree.branch.base, new_branch.base)
 
1558
        self.assertIs(None, specific_files)
 
1559
        self.assertIs(None, extra_trees)
 
1560
 
 
1561
    def test_with_rev_specs(self):
 
1562
        tree = self.make_branch_and_tree('tree')
 
1563
        self.build_tree_contents([('tree/file', 'oldcontent')])
 
1564
        tree.add('file', 'file-id')
 
1565
        tree.commit('old tree', timestamp=0, rev_id="old-id")
 
1566
        self.build_tree_contents([('tree/file', 'newcontent')])
 
1567
        tree.commit('new tree', timestamp=0, rev_id="new-id")
 
1568
 
 
1569
        revisions = [revisionspec.RevisionSpec.from_string('1'),
 
1570
                     revisionspec.RevisionSpec.from_string('2')]
 
1571
        (old_tree, new_tree,
 
1572
         old_branch, new_branch,
 
1573
         specific_files, extra_trees) = self.call_gtabtd(
 
1574
            ['tree'], revisions, None, None)
 
1575
 
 
1576
        self.assertIsInstance(old_tree, revisiontree.RevisionTree)
 
1577
        self.assertEqual("old-id", old_tree.get_revision_id())
 
1578
        self.assertIsInstance(new_tree, revisiontree.RevisionTree)
 
1579
        self.assertEqual("new-id", new_tree.get_revision_id())
 
1580
        self.assertEqual(tree.branch.base, old_branch.base)
 
1581
        self.assertEqual(tree.branch.base, new_branch.base)
 
1582
        self.assertIs(None, specific_files)
 
1583
        self.assertEqual(tree.basedir, extra_trees[0].basedir)