~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_diff.py

• browse files at revision 3135
• compare with another revision
• download diff
• download tarball
• view history from revision 3135

• reverse the comparison (3135 to 3641.5.3)
• stop comparing with revision 3641.5.3

Show diffs side-by-side

added

removed

bzrlib/tests/test_diff.py

15

15

# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

16

16

 

17

17

import os

18

 

import os.path

19

18

from cStringIO import StringIO

20

19

import errno

21

20

import subprocess

22

 

import sys

23

21

from tempfile import TemporaryFile

24

22

 

25

 

from bzrlib import tests

26

23

from bzrlib.diff import (

27

 

    DiffFromTool,

 

24

    internal_diff,

 

25

    external_diff,

28

26

    DiffPath,

 

27

    show_diff_trees,

29

28

    DiffSymlink,

30

29

    DiffTree,

31

30

    DiffText,

32

 

    external_diff,

33

 

    internal_diff,

34

 

    show_diff_trees,

35

31

    )

36

 

from bzrlib.errors import BinaryFile, NoDiff, ExecutableMissing

 

32

from bzrlib.errors import BinaryFile, NoDiff

37

33

import bzrlib.osutils as osutils

38

 

import bzrlib.transform as transform

39

34

import bzrlib.patiencediff

40

35

import bzrlib._patiencediff_py

41

36

from bzrlib.tests import (Feature, TestCase, TestCaseWithTransport,

42

37

                          TestCaseInTempDir, TestSkipped)

43

38

 

44

39

 

45

 

class _AttribFeature(Feature):

46

 

 

47

 

    def _probe(self):

48

 

        if (sys.platform not in ('cygwin', 'win32')):

49

 

            return False

50

 

        try:

51

 

            proc = subprocess.Popen(['attrib', '.'], stdout=subprocess.PIPE)

52

 

        except OSError, e:

53

 

            return False

54

 

        return (0 == proc.wait())

55

 

 

56

 

    def feature_name(self):

57

 

        return 'attrib Windows command-line tool'

58

 

 

59

 

AttribFeature = _AttribFeature()

60

 

 

61

 

 

62

40

class _CompiledPatienceDiffFeature(Feature):

63

41

 

64

42

    def _probe(self):

74

52

CompiledPatienceDiffFeature = _CompiledPatienceDiffFeature()

75

53

 

76

54

 

 

55

class _UnicodeFilename(Feature):

 

56

    """Does the filesystem support Unicode filenames?"""

 

57

 

 

58

    def _probe(self):

 

59

        try:

 

60

            os.stat(u'\u03b1')

 

61

        except UnicodeEncodeError:

 

62

            return False

 

63

        except (IOError, OSError):

 

64

            # The filesystem allows the Unicode filename but the file doesn't

 

65

            # exist.

 

66

            return True

 

67

        else:

 

68

            # The filesystem allows the Unicode filename and the file exists,

 

69

            # for some reason.

 

70

            return True

 

71

 

 

72

UnicodeFilename = _UnicodeFilename()

 

73

 

 

74

 

 

75

class TestUnicodeFilename(TestCase):

 

76

 

 

77

    def test_probe_passes(self):

 

78

        """UnicodeFilename._probe passes."""

 

79

        # We can't test much more than that because the behaviour depends

 

80

        # on the platform.

 

81

        UnicodeFilename._probe()

 

82

        

 

83

 

77

84

def udiff_lines(old, new, allow_binary=False):

78

85

    output = StringIO()

79

86

    internal_diff('old', old, 'new', new, output, allow_binary)

499

506

        self.assertContainsRe(diff, '-contents\n'

500

507

                                    '\\+new contents\n')

501

508

 

502

 

 

503

 

    def test_internal_diff_exec_property(self):

504

 

        tree = self.make_branch_and_tree('tree')

505

 

 

506

 

        tt = transform.TreeTransform(tree)

507

 

        tt.new_file('a', tt.root, 'contents\n', 'a-id', True)

508

 

        tt.new_file('b', tt.root, 'contents\n', 'b-id', False)

509

 

        tt.new_file('c', tt.root, 'contents\n', 'c-id', True)

510

 

        tt.new_file('d', tt.root, 'contents\n', 'd-id', False)

511

 

        tt.new_file('e', tt.root, 'contents\n', 'control-e-id', True)

512

 

        tt.new_file('f', tt.root, 'contents\n', 'control-f-id', False)

513

 

        tt.apply()

514

 

        tree.commit('one', rev_id='rev-1')

515

 

 

516

 

        tt = transform.TreeTransform(tree)

517

 

        tt.set_executability(False, tt.trans_id_file_id('a-id'))

518

 

        tt.set_executability(True, tt.trans_id_file_id('b-id'))

519

 

        tt.set_executability(False, tt.trans_id_file_id('c-id'))

520

 

        tt.set_executability(True, tt.trans_id_file_id('d-id'))

521

 

        tt.apply()

522

 

        tree.rename_one('c', 'new-c')

523

 

        tree.rename_one('d', 'new-d')

524

 

 

525

 

        diff = self.get_diff(tree.basis_tree(), tree)

526

 

 

527

 

        self.assertContainsRe(diff, r"file 'a'.*\(properties changed:.*\+x to -x.*\)")

528

 

        self.assertContainsRe(diff, r"file 'b'.*\(properties changed:.*-x to \+x.*\)")

529

 

        self.assertContainsRe(diff, r"file 'c'.*\(properties changed:.*\+x to -x.*\)")

530

 

        self.assertContainsRe(diff, r"file 'd'.*\(properties changed:.*-x to \+x.*\)")

531

 

        self.assertNotContainsRe(diff, r"file 'e'")

532

 

        self.assertNotContainsRe(diff, r"file 'f'")

533

 

 

534

 

 

535

509

    def test_binary_unicode_filenames(self):

536

510

        """Test that contents of files are *not* encoded in UTF-8 when there

537

511

        is a binary file in the diff.

538

512

        """

539

513

        # See https://bugs.launchpad.net/bugs/110092.

540

 

        self.requireFeature(tests.UnicodeFilenameFeature)

 

514

        self.requireFeature(UnicodeFilename)

541

515

 

542

516

        # This bug isn't triggered with cStringIO.

543

517

        from StringIO import StringIO

562

536

 

563

537

    def test_unicode_filename(self):

564

538

        """Test when the filename are unicode."""

565

 

        self.requireFeature(tests.UnicodeFilenameFeature)

 

539

        self.requireFeature(UnicodeFilename)

566

540

 

567

541

        alpha, omega = u'\u03b1', u'\u03c9'

568

542

        autf8, outf8 = alpha.encode('utf8'), omega.encode('utf8')

688

662

             ' \@\@\n-old\n\+new\n\n')

689

663

 

690

664

    def test_diff_kind_change(self):

691

 

        self.requireFeature(tests.SymlinkFeature)

692

665

        self.build_tree_contents([('old-tree/olddir/',),

693

666

                                  ('old-tree/olddir/oldfile', 'old\n')])

694

667

        self.old_tree.add('olddir')

1260

1233

            from bzrlib._patiencediff_py import recurse_matches_py

1261

1234

            self.assertIs(recurse_matches_py,

1262

1235

                          bzrlib.patiencediff.recurse_matches)

1263

 

 

1264

 

 

1265

 

class TestDiffFromTool(TestCaseWithTransport):

1266

 

 

1267

 

    def test_from_string(self):

1268

 

        diff_obj = DiffFromTool.from_string('diff', None, None, None)

1269

 

        self.addCleanup(diff_obj.finish)

1270

 

        self.assertEqual(['diff', '%(old_path)s', '%(new_path)s'],

1271

 

            diff_obj.command_template)

1272

 

 

1273

 

    def test_from_string_u5(self):

1274

 

        diff_obj = DiffFromTool.from_string('diff -u\\ 5', None, None, None)

1275

 

        self.addCleanup(diff_obj.finish)

1276

 

        self.assertEqual(['diff', '-u 5', '%(old_path)s', '%(new_path)s'],

1277

 

                         diff_obj.command_template)

1278

 

        self.assertEqual(['diff', '-u 5', 'old-path', 'new-path'],

1279

 

                         diff_obj._get_command('old-path', 'new-path'))

1280

 

 

1281

 

    def test_execute(self):

1282

 

        output = StringIO()

1283

 

        diff_obj = DiffFromTool(['python', '-c',

1284

 

                                 'print "%(old_path)s %(new_path)s"'],

1285

 

                                None, None, output)

1286

 

        self.addCleanup(diff_obj.finish)

1287

 

        diff_obj._execute('old', 'new')

1288

 

        self.assertEqual(output.getvalue().rstrip(), 'old new')

1289

 

 

1290

 

    def test_excute_missing(self):

1291

 

        diff_obj = DiffFromTool(['a-tool-which-is-unlikely-to-exist'],

1292

 

                                None, None, None)

1293

 

        self.addCleanup(diff_obj.finish)

1294

 

        e = self.assertRaises(ExecutableMissing, diff_obj._execute, 'old',

1295

 

                              'new')

1296

 

        self.assertEqual('a-tool-which-is-unlikely-to-exist could not be found'

1297

 

                         ' on this machine', str(e))

1298

 

 

1299

 

    def test_prepare_files_creates_paths_readable_by_windows_tool(self):

1300

 

        self.requireFeature(AttribFeature)

1301

 

        output = StringIO()

1302

 

        tree = self.make_branch_and_tree('tree')

1303

 

        self.build_tree_contents([('tree/file', 'content')])

1304

 

        tree.add('file', 'file-id')

1305

 

        tree.commit('old tree')

1306

 

        tree.lock_read()

1307

 

        self.addCleanup(tree.unlock)

1308

 

        diff_obj = DiffFromTool(['python', '-c',

1309

 

                                 'print "%(old_path)s %(new_path)s"'],

1310

 

                                tree, tree, output)

1311

 

        diff_obj._prepare_files('file-id', 'file', 'file')

1312

 

        self.assertReadableByAttrib(diff_obj._root, 'old\\file', r'old\\file')

1313

 

        self.assertReadableByAttrib(diff_obj._root, 'new\\file', r'new\\file')

1314

 

 

1315

 

    def assertReadableByAttrib(self, cwd, relpath, regex):

1316

 

        proc = subprocess.Popen(['attrib', relpath],

1317

 

                                stdout=subprocess.PIPE,

1318

 

                                cwd=cwd)

1319

 

        proc.wait()

1320

 

        result = proc.stdout.read()

1321

 

        self.assertContainsRe(result, regex)

1322

 

 

1323

 

    def test_prepare_files(self):

1324

 

        output = StringIO()

1325

 

        tree = self.make_branch_and_tree('tree')

1326

 

        self.build_tree_contents([('tree/oldname', 'oldcontent')])

1327

 

        self.build_tree_contents([('tree/oldname2', 'oldcontent2')])

1328

 

        tree.add('oldname', 'file-id')

1329

 

        tree.add('oldname2', 'file2-id')

1330

 

        tree.commit('old tree', timestamp=0)

1331

 

        tree.rename_one('oldname', 'newname')

1332

 

        tree.rename_one('oldname2', 'newname2')

1333

 

        self.build_tree_contents([('tree/newname', 'newcontent')])

1334

 

        self.build_tree_contents([('tree/newname2', 'newcontent2')])

1335

 

        old_tree = tree.basis_tree()

1336

 

        old_tree.lock_read()

1337

 

        self.addCleanup(old_tree.unlock)

1338

 

        tree.lock_read()

1339

 

        self.addCleanup(tree.unlock)

1340

 

        diff_obj = DiffFromTool(['python', '-c',

1341

 

                                 'print "%(old_path)s %(new_path)s"'],

1342

 

                                old_tree, tree, output)

1343

 

        self.addCleanup(diff_obj.finish)

1344

 

        self.assertContainsRe(diff_obj._root, 'bzr-diff-[^/]*')

1345

 

        old_path, new_path = diff_obj._prepare_files('file-id', 'oldname',

1346

 

                                                     'newname')

1347

 

        self.assertContainsRe(old_path, 'old/oldname$')

1348

 

        self.assertEqual(0, os.stat(old_path).st_mtime)

1349

 

        self.assertContainsRe(new_path, 'new/newname$')

1350

 

        self.assertFileEqual('oldcontent', old_path)

1351

 

        self.assertFileEqual('newcontent', new_path)

1352

 

        if osutils.host_os_dereferences_symlinks():

1353

 

            self.assertTrue(os.path.samefile('tree/newname', new_path))

1354

 

        # make sure we can create files with the same parent directories

1355

 

        diff_obj._prepare_files('file2-id', 'oldname2', 'newname2')

• Older »

Loggerhead is a web-based interface for Breezy
Version: 2.0.1