/brz/remove-bazaar

# Copyright (C) 2005-2012, 2014, 2016, 2017 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

import re

import subprocess

import sys

import tempfile

from .. import (

    cleanup,

    diff,

    errors,

    osutils,

    revision as _mod_revision,

    revisionspec,

    revisiontree,

    tests,

    )

from ..sixish import (

    BytesIO,

    unichr,

    )

from ..tests import (

    features,

    EncodingAdapter,

    )

from ..tests.scenarios import load_tests_apply_scenarios

load_tests = load_tests_apply_scenarios

def subst_dates(string):

    """Replace date strings with constant values."""

    return re.sub(br'\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2} [-\+]\d{4}',

                  b'YYYY-MM-DD HH:MM:SS +ZZZZ', string)

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

    output = BytesIO()

    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:

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

        output = BytesIO()

    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 StubO(object):

    """Simple file-like object that allows writes with any type and records."""

    def __init__(self):

        self.write_record = []

    def write(self, data):

        self.write_record.append(data)

    def check_types(self, testcase, expected_type):

        testcase.assertFalse(

            any(not isinstance(o, expected_type) for o in self.write_record),

            "Not all writes of type %s: %r" % (

                expected_type.__name__, self.write_record))

class TestDiffOptions(tests.TestCase):

    def test_unified_added(self):

        """Check for default style '-u' only if no other style specified

        in 'diff-options'.

        """

        # Verify that style defaults to unified, id est '-u' appended

        # to option list, in the absence of an alternative style.

        self.assertEqual(['-a', '-u'], diff.default_style_unified(['-a']))

class TestDiffOptionsScenarios(tests.TestCase):

    scenarios = [(s, dict(style=s)) for s in diff.style_option_list]

    style = None  # Set by load_tests_apply_scenarios from scenarios

    def test_unified_not_added(self):

        # Verify that for all valid style options, '-u' is not

        # appended to option list.

        ret_opts = diff.default_style_unified(diff_opts=["%s" % (self.style,)])

        self.assertEqual(["%s" % (self.style,)], ret_opts)

class TestDiff(tests.TestCase):

    def test_add_nl(self):

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

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

        self.check_patch(lines)

        self.assertEqual(lines[4], b'\\ 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([b'boo'], [b'goo\n'])

        self.check_patch(lines)

        self.assertEqual(lines[4], b'\\ 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([b'boo\n'], [b'boo'])

        self.check_patch(lines)

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

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

    def check_patch(self, lines):

        self.assertTrue(len(lines) > 1)

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

        self.assertTrue(lines[0].startswith(b'---'))

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

        self.assertTrue(lines[1].startswith(b'+++'))

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

        self.assertTrue(len(lines) > 2)

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

        self.assertTrue(lines[2].startswith(b'@@'))

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

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

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

    def test_binary_lines(self):

        empty = []

        uni_lines = [1023 * b'a' + b'\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([b'boo\n'], [b'goo\n'])

        self.check_patch(lines)

        self.assertEqual(b'\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([b'boo\n'] * 10000,

                                     [b'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([b'\x00foobar\n'], [b'foo\x00bar\n'])

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

        # versions just say "Files".

        self.assertContainsRe(

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

        self.assertEqual(lines[1:], [b'\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,

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

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

    def test_internal_diff_default(self):

        # Default internal diff encoding is utf8

        output = BytesIO()

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

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

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

        self.check_patch(lines)

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

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

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

                          b'-old_text\n',

                          b'+new_text\n',

                          b'\n',

                          ], lines)

    def test_internal_diff_utf8(self):

        output = BytesIO()

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

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

                           path_encoding='utf8')

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

        self.check_patch(lines)

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

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

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

                          b'-old_text\n',

                          b'+new_text\n',

                          b'\n',

                          ], lines)

    def test_internal_diff_iso_8859_1(self):

        output = BytesIO()

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

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

                           path_encoding='iso-8859-1')

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

        self.check_patch(lines)

        self.assertEqual([b'--- old_\xb5\n',

                          b'+++ new_\xe5\n',

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

                          b'-old_text\n',

                          b'+new_text\n',

                          b'\n',

                          ], lines)

    def test_internal_diff_no_content(self):

        output = BytesIO()

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

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

    def test_internal_diff_no_changes(self):

        output = BytesIO()

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

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

                           output)

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

    def test_internal_diff_returns_bytes(self):

        output = StubO()

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

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

        output.check_types(self, bytes)

    def test_internal_diff_default_context(self):

        output = BytesIO()

        diff.internal_diff('old', [b'same_text\n', b'same_text\n', b'same_text\n',

                                   b'same_text\n', b'same_text\n', b'old_text\n'],

                           'new', [b'same_text\n', b'same_text\n', b'same_text\n',

                                   b'same_text\n', b'same_text\n', b'new_text\n'], output)

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

        self.check_patch(lines)

        self.assertEqual([b'--- old\n',

                          b'+++ new\n',

                          b'@@ -3,4 +3,4 @@\n',

                          b' same_text\n',

                          b' same_text\n',

                          b' same_text\n',

                          b'-old_text\n',

                          b'+new_text\n',

                          b'\n',

                          ], lines)

    def test_internal_diff_no_context(self):

        output = BytesIO()

        diff.internal_diff('old', [b'same_text\n', b'same_text\n', b'same_text\n',

                                   b'same_text\n', b'same_text\n', b'old_text\n'],

                           'new', [b'same_text\n', b'same_text\n', b'same_text\n',

                                   b'same_text\n', b'same_text\n', b'new_text\n'], output,

                           context_lines=0)

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

        self.check_patch(lines)

        self.assertEqual([b'--- old\n',

                          b'+++ new\n',

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

                          b'-old_text\n',

                          b'+new_text\n',

                          b'\n',

                          ], lines)

    def test_internal_diff_more_context(self):

        output = BytesIO()

        diff.internal_diff('old', [b'same_text\n', b'same_text\n', b'same_text\n',

                                   b'same_text\n', b'same_text\n', b'old_text\n'],

                           'new', [b'same_text\n', b'same_text\n', b'same_text\n',

                                   b'same_text\n', b'same_text\n', b'new_text\n'], output,

                           context_lines=4)

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

        self.check_patch(lines)

        self.assertEqual([b'--- old\n',

                          b'+++ new\n',

                          b'@@ -2,5 +2,5 @@\n',

                          b' same_text\n',

                          b' same_text\n',

                          b' same_text\n',

                          b' same_text\n',

                          b'-old_text\n',

                          b'+new_text\n',

                          b'\n',

                          ], lines)

class TestDiffFiles(tests.TestCaseInTempDir):

    def test_external_diff_binary(self):

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

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

            self.overrideEnv(lang, 'C')

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

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

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

        with open('old', 'wb') as f:

            f.write(b'\x00foobar\n')

        with open('new', 'wb') as f:

            f.write(b'foo\x00bar\n')

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

                                stdin=subprocess.PIPE)

        out, err = pipe.communicate()

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

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

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

    output = BytesIO()

    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', b'file1 contents at rev 1\n'),

            ('file2', b'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=b'rev-1')

        self.build_tree_contents([('file1', b'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=b'rev-2')

        self.build_tree_contents([('file2', b'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=b'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=b'rev-4')

        self.build_tree_contents([

            ('file1', b'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, b'''\

=== 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(b'rev-2')

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

        output = get_diff_as_string(tree1, tree2)

        self.assertEqualDiff(output, b'''\

=== 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(b'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, b'''\

=== 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(b'rev-3')

        tree2 = self.b.repository.revision_tree(b'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, b'''\

=== 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(b'rev-1')

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

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

                                 working_tree=self.wt)

        self.assertContainsRe(out, b'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(b'rev-1')

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

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

                                 working_tree=self.wt)

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

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

                                 working_tree=self.wt)

        self.assertNotContainsRe(out, b'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', b'contents\n')])

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

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

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

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

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

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

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

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

                                 b'\\+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', b'contents\n')])

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

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

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

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

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

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

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

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

        # location. What to do?

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

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

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

                                 b'\\+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', b'contents\n')])

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

        tree.commit('one', rev_id=b'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, b"=== 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', b'contents\n')])

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

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

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

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

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

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

        # change

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

    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', b'contents\n')])

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

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

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

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

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

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

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