/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/test_diff.py

  • Committer: Vincent Ladeuil
  • Date: 2011-08-16 13:12:40 UTC
  • mfrom: (6071 +trunk)
  • mto: This revision was merged to the branch mainline in revision 6076.
  • Revision ID: v.ladeuil+lp@free.fr-20110816131240-gcyn9cik86dxwgz3
Merge into trunk

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_diff.py
33
33
    transform,
34
34
    )
35
35
from bzrlib.symbol_versioning import deprecated_in
36
 
from bzrlib.tests import features
 
36
from bzrlib.tests import features, EncodingAdapter
37
37
from bzrlib.tests.blackbox.test_diff import subst_dates
38
 
 
39
 
 
40
 
class _AttribFeature(tests.Feature):
41
 
 
42
 
    def _probe(self):
43
 
        if (sys.platform not in ('cygwin', 'win32')):
44
 
            return False
45
 
        try:
46
 
            proc = subprocess.Popen(['attrib', '.'], stdout=subprocess.PIPE)
47
 
        except OSError, e:
48
 
            return False
49
 
        return (0 == proc.wait())
50
 
 
51
 
    def feature_name(self):
52
 
        return 'attrib Windows command-line tool'
53
 
 
54
 
AttribFeature = _AttribFeature()
55
 
 
56
 
 
57
 
compiled_patiencediff_feature = tests.ModuleAvailableFeature(
58
 
                                    'bzrlib._patiencediff_c')
 
38
from bzrlib.tests import (
 
39
    features,
 
40
    )
59
41
 
60
42
 
61
43
def udiff_lines(old, new, allow_binary=False):
226
208
        output = StringIO.StringIO()
227
209
        diff.internal_diff(u'old_\xb5', ['old_text\n'],
228
210
                            u'new_\xe5', ['new_text\n'], output)
229
 
        self.failUnless(isinstance(output.getvalue(), str),
 
211
        self.assertIsInstance(output.getvalue(), str,
230
212
            'internal_diff should return bytestrings')
231
213
 
232
214
 
249
231
        self.assertEqual(out.splitlines(True) + ['\n'], lines)
250
232
 
251
233
 
252
 
class TestShowDiffTreesHelper(tests.TestCaseWithTransport):
253
 
    """Has a helper for running show_diff_trees"""
254
 
 
255
 
    def get_diff(self, tree1, tree2, specific_files=None, working_tree=None):
256
 
        output = StringIO()
257
 
        if working_tree is not None:
258
 
            extra_trees = (working_tree,)
259
 
        else:
260
 
            extra_trees = ()
261
 
        diff.show_diff_trees(tree1, tree2, output,
262
 
                             specific_files=specific_files,
263
 
                             extra_trees=extra_trees, old_label='old/',
264
 
                             new_label='new/')
265
 
        return output.getvalue()
266
 
 
267
 
 
268
 
class TestDiffDates(TestShowDiffTreesHelper):
 
234
def get_diff_as_string(tree1, tree2, specific_files=None, working_tree=None):
 
235
    output = StringIO()
 
236
    if working_tree is not None:
 
237
        extra_trees = (working_tree,)
 
238
    else:
 
239
        extra_trees = ()
 
240
    diff.show_diff_trees(tree1, tree2, output,
 
241
        specific_files=specific_files,
 
242
        extra_trees=extra_trees, old_label='old/',
 
243
        new_label='new/')
 
244
    return output.getvalue()
 
245
 
 
246
 
 
247
class TestDiffDates(tests.TestCaseWithTransport):
269
248
 
270
249
    def setUp(self):
271
250
        super(TestDiffDates, self).setUp()
306
285
        os.utime('file1', (1144195200, 1144195200)) # 2006-04-05 00:00:00 UTC
307
286
 
308
287
    def test_diff_rev_tree_working_tree(self):
309
 
        output = self.get_diff(self.wt.basis_tree(), self.wt)
 
288
        output = get_diff_as_string(self.wt.basis_tree(), self.wt)
310
289
        # note that the date for old/file1 is from rev 2 rather than from
311
290
        # the basis revision (rev 4)
312
291
        self.assertEqualDiff(output, '''\
322
301
    def test_diff_rev_tree_rev_tree(self):
323
302
        tree1 = self.b.repository.revision_tree('rev-2')
324
303
        tree2 = self.b.repository.revision_tree('rev-3')
325
 
        output = self.get_diff(tree1, tree2)
 
304
        output = get_diff_as_string(tree1, tree2)
326
305
        self.assertEqualDiff(output, '''\
327
306
=== modified file 'file2'
328
307
--- old/file2\t2006-04-01 00:00:00 +0000
336
315
    def test_diff_add_files(self):
337
316
        tree1 = self.b.repository.revision_tree(_mod_revision.NULL_REVISION)
338
317
        tree2 = self.b.repository.revision_tree('rev-1')
339
 
        output = self.get_diff(tree1, tree2)
 
318
        output = get_diff_as_string(tree1, tree2)
340
319
        # the files have the epoch time stamp for the tree in which
341
320
        # they don't exist.
342
321
        self.assertEqualDiff(output, '''\
357
336
    def test_diff_remove_files(self):
358
337
        tree1 = self.b.repository.revision_tree('rev-3')
359
338
        tree2 = self.b.repository.revision_tree('rev-4')
360
 
        output = self.get_diff(tree1, tree2)
 
339
        output = get_diff_as_string(tree1, tree2)
361
340
        # the file has the epoch time stamp for the tree in which
362
341
        # it doesn't exist.
363
342
        self.assertEqualDiff(output, '''\
374
353
        self.wt.rename_one('file1', 'file1b')
375
354
        old_tree = self.b.repository.revision_tree('rev-1')
376
355
        new_tree = self.b.repository.revision_tree('rev-4')
377
 
        out = self.get_diff(old_tree, new_tree, specific_files=['file1b'],
 
356
        out = get_diff_as_string(old_tree, new_tree, specific_files=['file1b'],
378
357
                            working_tree=self.wt)
379
358
        self.assertContainsRe(out, 'file1\t')
380
359
 
386
365
        self.wt.rename_one('file1', 'dir1/file1')
387
366
        old_tree = self.b.repository.revision_tree('rev-1')
388
367
        new_tree = self.b.repository.revision_tree('rev-4')
389
 
        out = self.get_diff(old_tree, new_tree, specific_files=['dir1'],
 
368
        out = get_diff_as_string(old_tree, new_tree, specific_files=['dir1'],
390
369
                            working_tree=self.wt)
391
370
        self.assertContainsRe(out, 'file1\t')
392
 
        out = self.get_diff(old_tree, new_tree, specific_files=['dir2'],
 
371
        out = get_diff_as_string(old_tree, new_tree, specific_files=['dir2'],
393
372
                            working_tree=self.wt)
394
373
        self.assertNotContainsRe(out, 'file1\t')
395
374
 
396
375
 
397
 
 
398
 
class TestShowDiffTrees(TestShowDiffTreesHelper):
 
376
class TestShowDiffTrees(tests.TestCaseWithTransport):
399
377
    """Direct tests for show_diff_trees"""
400
378
 
401
379
    def test_modified_file(self):
406
384
        tree.commit('one', rev_id='rev-1')
407
385
 
408
386
        self.build_tree_contents([('tree/file', 'new contents\n')])
409
 
        d = self.get_diff(tree.basis_tree(), tree)
 
387
        d = get_diff_as_string(tree.basis_tree(), tree)
410
388
        self.assertContainsRe(d, "=== modified file 'file'\n")
411
389
        self.assertContainsRe(d, '--- old/file\t')
412
390
        self.assertContainsRe(d, '\\+\\+\\+ new/file\t')
423
401
 
424
402
        tree.rename_one('dir', 'other')
425
403
        self.build_tree_contents([('tree/other/file', 'new contents\n')])
426
 
        d = self.get_diff(tree.basis_tree(), tree)
 
404
        d = get_diff_as_string(tree.basis_tree(), tree)
427
405
        self.assertContainsRe(d, "=== renamed directory 'dir' => 'other'\n")
428
406
        self.assertContainsRe(d, "=== modified file 'other/file'\n")
429
407
        # XXX: This is technically incorrect, because it used to be at another
442
420
        tree.commit('one', rev_id='rev-1')
443
421
 
444
422
        tree.rename_one('dir', 'newdir')
445
 
        d = self.get_diff(tree.basis_tree(), tree)
 
423
        d = get_diff_as_string(tree.basis_tree(), tree)
446
424
        # Renaming a directory should be a single "you renamed this dir" even
447
425
        # when there are files inside.
448
426
        self.assertEqual(d, "=== renamed directory 'dir' => 'newdir'\n")
455
433
        tree.commit('one', rev_id='rev-1')
456
434
 
457
435
        tree.rename_one('file', 'newname')
458
 
        d = self.get_diff(tree.basis_tree(), tree)
 
436
        d = get_diff_as_string(tree.basis_tree(), tree)
459
437
        self.assertContainsRe(d, "=== renamed file 'file' => 'newname'\n")
460
438
        # We shouldn't have a --- or +++ line, because there is no content
461
439
        # change
470
448
 
471
449
        tree.rename_one('file', 'newname')
472
450
        self.build_tree_contents([('tree/newname', 'new contents\n')])
473
 
        d = self.get_diff(tree.basis_tree(), tree)
 
451
        d = get_diff_as_string(tree.basis_tree(), tree)
474
452
        self.assertContainsRe(d, "=== renamed file 'file' => 'newname'\n")
475
453
        self.assertContainsRe(d, '--- old/file\t')
476
454
        self.assertContainsRe(d, '\\+\\+\\+ new/newname\t')
500
478
        tree.rename_one('c', 'new-c')
501
479
        tree.rename_one('d', 'new-d')
502
480
 
503
 
        d = self.get_diff(tree.basis_tree(), tree)
 
481
        d = get_diff_as_string(tree.basis_tree(), tree)
504
482
 
505
483
        self.assertContainsRe(d, r"file 'a'.*\(properties changed:"
506
484
                                  ".*\+x to -x.*\)")
518
496
        is a binary file in the diff.
519
497
        """
520
498
        # See https://bugs.launchpad.net/bugs/110092.
521
 
        self.requireFeature(tests.UnicodeFilenameFeature)
 
499
        self.requireFeature(features.UnicodeFilenameFeature)
522
500
 
523
501
        # This bug isn't triggered with cStringIO.
524
502
        from StringIO import StringIO
543
521
 
544
522
    def test_unicode_filename(self):
545
523
        """Test when the filename are unicode."""
546
 
        self.requireFeature(tests.UnicodeFilenameFeature)
 
524
        self.requireFeature(features.UnicodeFilenameFeature)
547
525
 
548
526
        alpha, omega = u'\u03b1', u'\u03c9'
549
527
        autf8, outf8 = alpha.encode('utf8'), omega.encode('utf8')
564
542
        tree.add(['add_'+alpha], ['file-id'])
565
543
        self.build_tree_contents([('tree/mod_'+alpha, 'contents_mod\n')])
566
544
 
567
 
        d = self.get_diff(tree.basis_tree(), tree)
 
545
        d = get_diff_as_string(tree.basis_tree(), tree)
568
546
        self.assertContainsRe(d,
569
547
                "=== renamed file 'ren_%s' => 'ren_%s'\n"%(autf8, outf8))
570
548
        self.assertContainsRe(d, "=== added file 'add_%s'"%autf8)
575
553
        """Test for bug #382699: unicode filenames on Windows should be shown
576
554
        in user encoding.
577
555
        """
578
 
        self.requireFeature(tests.UnicodeFilenameFeature)
 
556
        self.requireFeature(features.UnicodeFilenameFeature)
579
557
        # The word 'test' in Russian
580
558
        _russian_test = u'\u0422\u0435\u0441\u0442'
581
559
        directory = _russian_test + u'/'
712
690
             ' \@\@\n-old\n\+new\n\n')
713
691
 
714
692
    def test_diff_kind_change(self):
715
 
        self.requireFeature(tests.SymlinkFeature)
 
693
        self.requireFeature(features.SymlinkFeature)
716
694
        self.build_tree_contents([('old-tree/olddir/',),
717
695
                                  ('old-tree/olddir/oldfile', 'old\n')])
718
696
        self.old_tree.add('olddir')
1176
1154
 
1177
1155
class TestPatienceDiffLib_c(TestPatienceDiffLib):
1178
1156
 
1179
 
    _test_needs_features = [compiled_patiencediff_feature]
 
1157
    _test_needs_features = [features.compiled_patiencediff_feature]
1180
1158
 
1181
1159
    def setUp(self):
1182
1160
        super(TestPatienceDiffLib_c, self).setUp()
1272
1250
 
1273
1251
class TestPatienceDiffLibFiles_c(TestPatienceDiffLibFiles):
1274
1252
 
1275
 
    _test_needs_features = [compiled_patiencediff_feature]
 
1253
    _test_needs_features = [features.compiled_patiencediff_feature]
1276
1254
 
1277
1255
    def setUp(self):
1278
1256
        super(TestPatienceDiffLibFiles_c, self).setUp()
1284
1262
class TestUsingCompiledIfAvailable(tests.TestCase):
1285
1263
 
1286
1264
    def test_PatienceSequenceMatcher(self):
1287
 
        if compiled_patiencediff_feature.available():
 
1265
        if features.compiled_patiencediff_feature.available():
1288
1266
            from bzrlib._patiencediff_c import PatienceSequenceMatcher_c
1289
1267
            self.assertIs(PatienceSequenceMatcher_c,
1290
1268
                          patiencediff.PatienceSequenceMatcher)
1294
1272
                          patiencediff.PatienceSequenceMatcher)
1295
1273
 
1296
1274
    def test_unique_lcs(self):
1297
 
        if compiled_patiencediff_feature.available():
 
1275
        if features.compiled_patiencediff_feature.available():
1298
1276
            from bzrlib._patiencediff_c import unique_lcs_c
1299
1277
            self.assertIs(unique_lcs_c,
1300
1278
                          patiencediff.unique_lcs)
1304
1282
                          patiencediff.unique_lcs)
1305
1283
 
1306
1284
    def test_recurse_matches(self):
1307
 
        if compiled_patiencediff_feature.available():
 
1285
        if features.compiled_patiencediff_feature.available():
1308
1286
            from bzrlib._patiencediff_c import recurse_matches_c
1309
1287
            self.assertIs(recurse_matches_c,
1310
1288
                          patiencediff.recurse_matches)
1360
1338
                         ' on this machine', str(e))
1361
1339
 
1362
1340
    def test_prepare_files_creates_paths_readable_by_windows_tool(self):
1363
 
        self.requireFeature(AttribFeature)
 
1341
        self.requireFeature(features.AttribFeature)
1364
1342
        output = StringIO()
1365
1343
        tree = self.make_branch_and_tree('tree')
1366
1344
        self.build_tree_contents([('tree/file', 'content')])
1425
1403
        diff_obj._prepare_files('file2-id', 'oldname2', 'newname2')
1426
1404
 
1427
1405
 
 
1406
class TestDiffFromToolEncodedFilename(tests.TestCaseWithTransport):
 
1407
 
 
1408
    def test_encodable_filename(self):
 
1409
        # Just checks file path for external diff tool.
 
1410
        # We cannot change CPython's internal encoding used by os.exec*.
 
1411
        import sys
 
1412
        diffobj = diff.DiffFromTool(['dummy', '@old_path', '@new_path'],
 
1413
                                    None, None, None)
 
1414
        for _, scenario in EncodingAdapter.encoding_scenarios:
 
1415
            encoding = scenario['encoding']
 
1416
            dirname  = scenario['info']['directory']
 
1417
            filename = scenario['info']['filename']
 
1418
 
 
1419
            self.overrideAttr(diffobj, '_fenc', lambda: encoding)
 
1420
            relpath = dirname + u'/' + filename
 
1421
            fullpath = diffobj._safe_filename('safe', relpath)
 
1422
            self.assertEqual(
 
1423
                    fullpath,
 
1424
                    fullpath.encode(encoding).decode(encoding)
 
1425
                    )
 
1426
            self.assert_(fullpath.startswith(diffobj._root + '/safe'))
 
1427
 
 
1428
    def test_unencodable_filename(self):
 
1429
        import sys
 
1430
        diffobj = diff.DiffFromTool(['dummy', '@old_path', '@new_path'],
 
1431
                                    None, None, None)
 
1432
        for _, scenario in EncodingAdapter.encoding_scenarios:
 
1433
            encoding = scenario['encoding']
 
1434
            dirname  = scenario['info']['directory']
 
1435
            filename = scenario['info']['filename']
 
1436
 
 
1437
            if encoding == 'iso-8859-1':
 
1438
                encoding = 'iso-8859-2'
 
1439
            else:
 
1440
                encoding = 'iso-8859-1'
 
1441
 
 
1442
            self.overrideAttr(diffobj, '_fenc', lambda: encoding)
 
1443
            relpath = dirname + u'/' + filename
 
1444
            fullpath = diffobj._safe_filename('safe', relpath)
 
1445
            self.assertEqual(
 
1446
                    fullpath,
 
1447
                    fullpath.encode(encoding).decode(encoding)
 
1448
                    )
 
1449
            self.assert_(fullpath.startswith(diffobj._root + '/safe'))
 
1450
 
 
1451
 
1428
1452
class TestGetTreesAndBranchesToDiffLocked(tests.TestCaseWithTransport):
1429
1453
 
1430
1454
    def call_gtabtd(self, path_list, revision_specs, old_url, new_url):
1431
 
        """Call get_trees_and_branches_to_diff_locked.  Overridden by
1432
 
        TestGetTreesAndBranchesToDiff.
1433
 
        """
 
1455
        """Call get_trees_and_branches_to_diff_locked."""
1434
1456
        return diff.get_trees_and_branches_to_diff_locked(
1435
1457
            path_list, revision_specs, old_url, new_url, self.addCleanup)
1436
1458
 
1473
1495
        self.assertEqual(tree.branch.base, new_branch.base)
1474
1496
        self.assertIs(None, specific_files)
1475
1497
        self.assertEqual(tree.basedir, extra_trees[0].basedir)
1476
 
 
1477
 
 
1478
 
class TestGetTreesAndBranchesToDiff(TestGetTreesAndBranchesToDiffLocked):
1479
 
    """Apply the tests for get_trees_and_branches_to_diff_locked to the
1480
 
    deprecated get_trees_and_branches_to_diff function.
1481
 
    """
1482
 
 
1483
 
    def call_gtabtd(self, path_list, revision_specs, old_url, new_url):
1484
 
        return self.applyDeprecated(
1485
 
            deprecated_in((2, 2, 0)), diff.get_trees_and_branches_to_diff,
1486
 
            path_list, revision_specs, old_url, new_url)
1487