~bzr-pqm/bzr/bzr.dev

# Copyright (C) 2005-2011 Canonical Ltd

#

# This program is free software; you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation; either version 2 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

import os

from cStringIO import StringIO

import subprocess

import sys

import tempfile

from bzrlib import (

    diff,

    errors,

    osutils,

    patiencediff,

    _patiencediff_py,

    revision as _mod_revision,

    revisionspec,

    revisiontree,

    tests,

    transform,

    )

from bzrlib.symbol_versioning import deprecated_in

from bzrlib.tests import features, EncodingAdapter

from bzrlib.tests.blackbox.test_diff import subst_dates

from bzrlib.tests import (

    features,

    )

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

    output = StringIO()

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

    output.seek(0, 0)

    return output.readlines()

def external_udiff_lines(old, new, use_stringio=False):

    if use_stringio:

        # StringIO has no fileno, so it tests a different codepath

        output = StringIO()

    else:

        output = tempfile.TemporaryFile()

    try:

        diff.external_diff('old', old, 'new', new, output, diff_opts=['-u'])

    except errors.NoDiff:

        raise tests.TestSkipped('external "diff" not present to test')

    output.seek(0, 0)

    lines = output.readlines()

    output.close()

    return lines

class TestDiff(tests.TestCase):

    def test_add_nl(self):

        """diff generates a valid diff for patches that add a newline"""

        lines = udiff_lines(['boo'], ['boo\n'])

        self.check_patch(lines)

        self.assertEquals(lines[4], '\\ No newline at end of file\n')

            ## "expected no-nl, got %r" % lines[4]

    def test_add_nl_2(self):

        """diff generates a valid diff for patches that change last line and

        add a newline.

        """

        lines = udiff_lines(['boo'], ['goo\n'])

        self.check_patch(lines)

        self.assertEquals(lines[4], '\\ No newline at end of file\n')

            ## "expected no-nl, got %r" % lines[4]

    def test_remove_nl(self):

        """diff generates a valid diff for patches that change last line and

        add a newline.

        """

        lines = udiff_lines(['boo\n'], ['boo'])

        self.check_patch(lines)

        self.assertEquals(lines[5], '\\ No newline at end of file\n')

            ## "expected no-nl, got %r" % lines[5]

    def check_patch(self, lines):

        self.assert_(len(lines) > 1)

            ## "Not enough lines for a file header for patch:\n%s" % "".join(lines)

        self.assert_(lines[0].startswith ('---'))

            ## 'No orig line for patch:\n%s' % "".join(lines)

        self.assert_(lines[1].startswith ('+++'))

            ## 'No mod line for patch:\n%s' % "".join(lines)

        self.assert_(len(lines) > 2)

            ## "No hunks for patch:\n%s" % "".join(lines)

        self.assert_(lines[2].startswith('@@'))

            ## "No hunk header for patch:\n%s" % "".join(lines)

        self.assert_('@@' in lines[2][2:])

            ## "Unterminated hunk header for patch:\n%s" % "".join(lines)

    def test_binary_lines(self):

        empty = []

        uni_lines = [1023 * 'a' + '\x00']

        self.assertRaises(errors.BinaryFile, udiff_lines, uni_lines , empty)

        self.assertRaises(errors.BinaryFile, udiff_lines, empty, uni_lines)

        udiff_lines(uni_lines , empty, allow_binary=True)

        udiff_lines(empty, uni_lines, allow_binary=True)

    def test_external_diff(self):

        lines = external_udiff_lines(['boo\n'], ['goo\n'])

        self.check_patch(lines)

        self.assertEqual('\n', lines[-1])

    def test_external_diff_no_fileno(self):

        # Make sure that we can handle not having a fileno, even

        # if the diff is large

        lines = external_udiff_lines(['boo\n']*10000,

                                     ['goo\n']*10000,

                                     use_stringio=True)

        self.check_patch(lines)

    def test_external_diff_binary_lang_c(self):

        for lang in ('LANG', 'LC_ALL', 'LANGUAGE'):

            self.overrideEnv(lang, 'C')

        lines = external_udiff_lines(['\x00foobar\n'], ['foo\x00bar\n'])

        # Older versions of diffutils say "Binary files", newer

        # versions just say "Files".

        self.assertContainsRe(lines[0], '(Binary f|F)iles old and new differ\n')

        self.assertEquals(lines[1:], ['\n'])

    def test_no_external_diff(self):

        """Check that NoDiff is raised when diff is not available"""

        # Make sure no 'diff' command is available

        # XXX: Weird, using None instead of '' breaks the test -- vila 20101216

        self.overrideEnv('PATH', '')

        self.assertRaises(errors.NoDiff, diff.external_diff,

                          'old', ['boo\n'], 'new', ['goo\n'],

                          StringIO(), diff_opts=['-u'])

    def test_internal_diff_default(self):

        # Default internal diff encoding is utf8

        output = StringIO()

        diff.internal_diff(u'old_\xb5', ['old_text\n'],

                           u'new_\xe5', ['new_text\n'], output)

        lines = output.getvalue().splitlines(True)

        self.check_patch(lines)

        self.assertEquals(['--- old_\xc2\xb5\n',

                           '+++ new_\xc3\xa5\n',

                           '@@ -1,1 +1,1 @@\n',

                           '-old_text\n',

                           '+new_text\n',

                           '\n',

                          ]

                          , lines)

    def test_internal_diff_utf8(self):

        output = StringIO()

        diff.internal_diff(u'old_\xb5', ['old_text\n'],

                           u'new_\xe5', ['new_text\n'], output,

                           path_encoding='utf8')

        lines = output.getvalue().splitlines(True)

        self.check_patch(lines)

        self.assertEquals(['--- old_\xc2\xb5\n',

                           '+++ new_\xc3\xa5\n',

                           '@@ -1,1 +1,1 @@\n',

                           '-old_text\n',

                           '+new_text\n',

                           '\n',

                          ]

                          , lines)

    def test_internal_diff_iso_8859_1(self):

        output = StringIO()

        diff.internal_diff(u'old_\xb5', ['old_text\n'],

                           u'new_\xe5', ['new_text\n'], output,

                           path_encoding='iso-8859-1')

        lines = output.getvalue().splitlines(True)

        self.check_patch(lines)

        self.assertEquals(['--- old_\xb5\n',

                           '+++ new_\xe5\n',

                           '@@ -1,1 +1,1 @@\n',

                           '-old_text\n',

                           '+new_text\n',

                           '\n',

                          ]

                          , lines)

    def test_internal_diff_no_content(self):

        output = StringIO()

        diff.internal_diff(u'old', [], u'new', [], output)

        self.assertEqual('', output.getvalue())

    def test_internal_diff_no_changes(self):

        output = StringIO()

        diff.internal_diff(u'old', ['text\n', 'contents\n'],

                           u'new', ['text\n', 'contents\n'],

                           output)

        self.assertEqual('', output.getvalue())

    def test_internal_diff_returns_bytes(self):

        import StringIO

        output = StringIO.StringIO()

        diff.internal_diff(u'old_\xb5', ['old_text\n'],

                            u'new_\xe5', ['new_text\n'], output)

        self.assertIsInstance(output.getvalue(), str,

            'internal_diff should return bytestrings')

class TestDiffFiles(tests.TestCaseInTempDir):

    def test_external_diff_binary(self):

        """The output when using external diff should use diff's i18n error"""

        # Make sure external_diff doesn't fail in the current LANG

        lines = external_udiff_lines(['\x00foobar\n'], ['foo\x00bar\n'])

        cmd = ['diff', '-u', '--binary', 'old', 'new']

        open('old', 'wb').write('\x00foobar\n')

        open('new', 'wb').write('foo\x00bar\n')

        pipe = subprocess.Popen(cmd, stdout=subprocess.PIPE,

                                     stdin=subprocess.PIPE)

        out, err = pipe.communicate()

        # Diff returns '2' on Binary files.

        self.assertEqual(2, pipe.returncode)

        # We should output whatever diff tells us, plus a trailing newline

        self.assertEqual(out.splitlines(True) + ['\n'], lines)

def get_diff_as_string(tree1, tree2, specific_files=None, working_tree=None):

    output = StringIO()

    if working_tree is not None:

        extra_trees = (working_tree,)

    else:

        extra_trees = ()

    diff.show_diff_trees(tree1, tree2, output,

        specific_files=specific_files,

        extra_trees=extra_trees, old_label='old/',

        new_label='new/')

    return output.getvalue()

class TestDiffDates(tests.TestCaseWithTransport):

    def setUp(self):

        super(TestDiffDates, self).setUp()

        self.wt = self.make_branch_and_tree('.')

        self.b = self.wt.branch

        self.build_tree_contents([

            ('file1', 'file1 contents at rev 1\n'),

            ('file2', 'file2 contents at rev 1\n')

            ])

        self.wt.add(['file1', 'file2'])

        self.wt.commit(

            message='Revision 1',

            timestamp=1143849600, # 2006-04-01 00:00:00 UTC

            timezone=0,

            rev_id='rev-1')

        self.build_tree_contents([('file1', 'file1 contents at rev 2\n')])

        self.wt.commit(

            message='Revision 2',

            timestamp=1143936000, # 2006-04-02 00:00:00 UTC

            timezone=28800,

            rev_id='rev-2')

        self.build_tree_contents([('file2', 'file2 contents at rev 3\n')])

        self.wt.commit(

            message='Revision 3',

            timestamp=1144022400, # 2006-04-03 00:00:00 UTC

            timezone=-3600,

            rev_id='rev-3')

        self.wt.remove(['file2'])

        self.wt.commit(

            message='Revision 4',

            timestamp=1144108800, # 2006-04-04 00:00:00 UTC

            timezone=0,

            rev_id='rev-4')

        self.build_tree_contents([

            ('file1', 'file1 contents in working tree\n')

            ])

        # set the date stamps for files in the working tree to known values

        os.utime('file1', (1144195200, 1144195200)) # 2006-04-05 00:00:00 UTC

    def test_diff_rev_tree_working_tree(self):

        output = get_diff_as_string(self.wt.basis_tree(), self.wt)

        # note that the date for old/file1 is from rev 2 rather than from

        # the basis revision (rev 4)

        self.assertEqualDiff(output, '''\

=== modified file 'file1'

--- old/file1\t2006-04-02 00:00:00 +0000

+++ new/file1\t2006-04-05 00:00:00 +0000

@@ -1,1 +1,1 @@

-file1 contents at rev 2

+file1 contents in working tree

''')

    def test_diff_rev_tree_rev_tree(self):

        tree1 = self.b.repository.revision_tree('rev-2')

        tree2 = self.b.repository.revision_tree('rev-3')

        output = get_diff_as_string(tree1, tree2)

        self.assertEqualDiff(output, '''\

=== modified file 'file2'

--- old/file2\t2006-04-01 00:00:00 +0000

+++ new/file2\t2006-04-03 00:00:00 +0000

@@ -1,1 +1,1 @@

-file2 contents at rev 1

+file2 contents at rev 3

''')

    def test_diff_add_files(self):

        tree1 = self.b.repository.revision_tree(_mod_revision.NULL_REVISION)

        tree2 = self.b.repository.revision_tree('rev-1')

        output = get_diff_as_string(tree1, tree2)

        # the files have the epoch time stamp for the tree in which

        # they don't exist.

        self.assertEqualDiff(output, '''\

=== added file 'file1'

--- old/file1\t1970-01-01 00:00:00 +0000

+++ new/file1\t2006-04-01 00:00:00 +0000

@@ -0,0 +1,1 @@

+file1 contents at rev 1

=== added file 'file2'

--- old/file2\t1970-01-01 00:00:00 +0000

+++ new/file2\t2006-04-01 00:00:00 +0000

@@ -0,0 +1,1 @@

+file2 contents at rev 1

''')

    def test_diff_remove_files(self):

        tree1 = self.b.repository.revision_tree('rev-3')

        tree2 = self.b.repository.revision_tree('rev-4')

        output = get_diff_as_string(tree1, tree2)

        # the file has the epoch time stamp for the tree in which

        # it doesn't exist.

        self.assertEqualDiff(output, '''\

=== removed file 'file2'

--- old/file2\t2006-04-03 00:00:00 +0000

+++ new/file2\t1970-01-01 00:00:00 +0000

@@ -1,1 +0,0 @@

-file2 contents at rev 3

''')

    def test_show_diff_specified(self):

        """A working tree filename can be used to identify a file"""

        self.wt.rename_one('file1', 'file1b')

        old_tree = self.b.repository.revision_tree('rev-1')

        new_tree = self.b.repository.revision_tree('rev-4')

        out = get_diff_as_string(old_tree, new_tree, specific_files=['file1b'],

                            working_tree=self.wt)

        self.assertContainsRe(out, 'file1\t')

    def test_recursive_diff(self):

        """Children of directories are matched"""

        os.mkdir('dir1')

        os.mkdir('dir2')

        self.wt.add(['dir1', 'dir2'])

        self.wt.rename_one('file1', 'dir1/file1')

        old_tree = self.b.repository.revision_tree('rev-1')

        new_tree = self.b.repository.revision_tree('rev-4')

        out = get_diff_as_string(old_tree, new_tree, specific_files=['dir1'],

                            working_tree=self.wt)

        self.assertContainsRe(out, 'file1\t')

        out = get_diff_as_string(old_tree, new_tree, specific_files=['dir2'],

                            working_tree=self.wt)

        self.assertNotContainsRe(out, 'file1\t')

class TestShowDiffTrees(tests.TestCaseWithTransport):

    """Direct tests for show_diff_trees"""

    def test_modified_file(self):

        """Test when a file is modified."""

        tree = self.make_branch_and_tree('tree')

        self.build_tree_contents([('tree/file', 'contents\n')])

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

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

        self.build_tree_contents([('tree/file', 'new contents\n')])

        d = get_diff_as_string(tree.basis_tree(), tree)

        self.assertContainsRe(d, "=== modified file 'file'\n")

        self.assertContainsRe(d, '--- old/file\t')

        self.assertContainsRe(d, '\\+\\+\\+ new/file\t')

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

                                 '\\+new contents\n')

    def test_modified_file_in_renamed_dir(self):

        """Test when a file is modified in a renamed directory."""

        tree = self.make_branch_and_tree('tree')

        self.build_tree(['tree/dir/'])

        self.build_tree_contents([('tree/dir/file', 'contents\n')])

        tree.add(['dir', 'dir/file'], ['dir-id', 'file-id'])

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

        tree.rename_one('dir', 'other')

        self.build_tree_contents([('tree/other/file', 'new contents\n')])

        d = get_diff_as_string(tree.basis_tree(), tree)

        self.assertContainsRe(d, "=== renamed directory 'dir' => 'other'\n")

        self.assertContainsRe(d, "=== modified file 'other/file'\n")

        # XXX: This is technically incorrect, because it used to be at another

        # location. What to do?

        self.assertContainsRe(d, '--- old/dir/file\t')

        self.assertContainsRe(d, '\\+\\+\\+ new/other/file\t')

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

                                 '\\+new contents\n')

    def test_renamed_directory(self):

        """Test when only a directory is only renamed."""

        tree = self.make_branch_and_tree('tree')

        self.build_tree(['tree/dir/'])

        self.build_tree_contents([('tree/dir/file', 'contents\n')])

        tree.add(['dir', 'dir/file'], ['dir-id', 'file-id'])

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

        tree.rename_one('dir', 'newdir')

        d = get_diff_as_string(tree.basis_tree(), tree)

        # Renaming a directory should be a single "you renamed this dir" even

        # when there are files inside.

        self.assertEqual(d, "=== renamed directory 'dir' => 'newdir'\n")

    def test_renamed_file(self):

        """Test when a file is only renamed."""

        tree = self.make_branch_and_tree('tree')

        self.build_tree_contents([('tree/file', 'contents\n')])

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

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

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

        d = get_diff_as_string(tree.basis_tree(), tree)

        self.assertContainsRe(d, "=== renamed file 'file' => 'newname'\n")

        # We shouldn't have a --- or +++ line, because there is no content

        # change

        self.assertNotContainsRe(d, '---')

    def test_renamed_and_modified_file(self):

        """Test when a file is only renamed."""

        tree = self.make_branch_and_tree('tree')

        self.build_tree_contents([('tree/file', 'contents\n')])

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

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

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

        self.build_tree_contents([('tree/newname', 'new contents\n')])

        d = get_diff_as_string(tree.basis_tree(), tree)

        self.assertContainsRe(d, "=== renamed file 'file' => 'newname'\n")

        self.assertContainsRe(d, '--- old/file\t')

        self.assertContainsRe(d, '\\+\\+\\+ new/newname\t')

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

                                 '\\+new contents\n')

    def test_internal_diff_exec_property(self):

        tree = self.make_branch_and_tree('tree')

        tt = transform.TreeTransform(tree)

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

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

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

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

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

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

        tt.apply()

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

        tt = transform.TreeTransform(tree)

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

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

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

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

        tt.apply()

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

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

        d = get_diff_as_string(tree.basis_tree(), tree)

        self.assertContainsRe(d, r"file 'a'.*\(properties changed:"

                                  ".*\+x to -x.*\)")

        self.assertContainsRe(d, r"file 'b'.*\(properties changed:"

                                  ".*-x to \+x.*\)")

        self.assertContainsRe(d, r"file 'c'.*\(properties changed:"

                                  ".*\+x to -x.*\)")

        self.assertContainsRe(d, r"file 'd'.*\(properties changed:"

                                  ".*-x to \+x.*\)")

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

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

    def test_binary_unicode_filenames(self):

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

        is a binary file in the diff.

        """

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

        self.requireFeature(features.UnicodeFilenameFeature)

        # This bug isn't triggered with cStringIO.

        from StringIO import StringIO

        tree = self.make_branch_and_tree('tree')

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

        alpha_utf8, omega_utf8 = alpha.encode('utf8'), omega.encode('utf8')

        self.build_tree_contents(

            [('tree/' + alpha, chr(0)),

             ('tree/' + omega,

              ('The %s and the %s\n' % (alpha_utf8, omega_utf8)))])

        tree.add([alpha], ['file-id'])

        tree.add([omega], ['file-id-2'])

        diff_content = StringIO()

        diff.show_diff_trees(tree.basis_tree(), tree, diff_content)

        d = diff_content.getvalue()

        self.assertContainsRe(d, r"=== added file '%s'" % alpha_utf8)

        self.assertContainsRe(d, "Binary files a/%s.*and b/%s.* differ\n"

                              % (alpha_utf8, alpha_utf8))

        self.assertContainsRe(d, r"=== added file '%s'" % omega_utf8)

        self.assertContainsRe(d, r"--- a/%s" % (omega_utf8,))

        self.assertContainsRe(d, r"\+\+\+ b/%s" % (omega_utf8,))

    def test_unicode_filename(self):

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

        self.requireFeature(features.UnicodeFilenameFeature)

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

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

        tree = self.make_branch_and_tree('tree')

        self.build_tree_contents([('tree/ren_'+alpha, 'contents\n')])

        tree.add(['ren_'+alpha], ['file-id-2'])

        self.build_tree_contents([('tree/del_'+alpha, 'contents\n')])

        tree.add(['del_'+alpha], ['file-id-3'])

        self.build_tree_contents([('tree/mod_'+alpha, 'contents\n')])

        tree.add(['mod_'+alpha], ['file-id-4'])

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

        tree.rename_one('ren_'+alpha, 'ren_'+omega)

        tree.remove('del_'+alpha)

        self.build_tree_contents([('tree/add_'+alpha, 'contents\n')])

        tree.add(['add_'+alpha], ['file-id'])

        self.build_tree_contents([('tree/mod_'+alpha, 'contents_mod\n')])

        d = get_diff_as_string(tree.basis_tree(), tree)

        self.assertContainsRe(d,

                "=== renamed file 'ren_%s' => 'ren_%s'\n"%(autf8, outf8))

        self.assertContainsRe(d, "=== added file 'add_%s'"%autf8)

        self.assertContainsRe(d, "=== modified file 'mod_%s'"%autf8)

        self.assertContainsRe(d, "=== removed file 'del_%s'"%autf8)

    def test_unicode_filename_path_encoding(self):

        """Test for bug #382699: unicode filenames on Windows should be shown

        in user encoding.

        """

        self.requireFeature(features.UnicodeFilenameFeature)

        # The word 'test' in Russian

        _russian_test = u'\u0422\u0435\u0441\u0442'

        directory = _russian_test + u'/'

        test_txt = _russian_test + u'.txt'

        u1234 = u'\u1234.txt'

        tree = self.make_branch_and_tree('.')

        self.build_tree_contents([

            (test_txt, 'foo\n'),

            (u1234, 'foo\n'),

            (directory, None),

            ])

        tree.add([test_txt, u1234, directory])

        sio = StringIO()

        diff.show_diff_trees(tree.basis_tree(), tree, sio,

            path_encoding='cp1251')

        output = subst_dates(sio.getvalue())

        shouldbe = ('''\

=== added directory '%(directory)s'

=== added file '%(test_txt)s'

--- a/%(test_txt)s\tYYYY-MM-DD HH:MM:SS +ZZZZ

+++ b/%(test_txt)s\tYYYY-MM-DD HH:MM:SS +ZZZZ

@@ -0,0 +1,1 @@

+foo

=== added file '?.txt'

--- a/?.txt\tYYYY-MM-DD HH:MM:SS +ZZZZ

+++ b/?.txt\tYYYY-MM-DD HH:MM:SS +ZZZZ

@@ -0,0 +1,1 @@

+foo

''' % {'directory': _russian_test.encode('cp1251'),

       'test_txt': test_txt.encode('cp1251'),

      })

        self.assertEqualDiff(output, shouldbe)

class DiffWasIs(diff.DiffPath):

    def diff(self, file_id, old_path, new_path, old_kind, new_kind):

        self.to_file.write('was: ')

        self.to_file.write(self.old_tree.get_file(file_id).read())

        self.to_file.write('is: ')

        self.to_file.write(self.new_tree.get_file(file_id).read())

        pass

class TestDiffTree(tests.TestCaseWithTransport):

    def setUp(self):

        super(TestDiffTree, self).setUp()

        self.old_tree = self.make_branch_and_tree('old-tree')