/brz/remove-bazaar

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

from .. import (

    errors,

    osutils,

    repository,

    revision,

    tests,

    workingtree,

    )

from ..sixish import text_type

from ..bzr import (

    chk_map,

    groupcompress,

    inventory,

    )

from ..bzr.inventory import (

    CHKInventory,

    Inventory,

    ROOT_ID,

    InventoryFile,

    InventoryDirectory,

    InventoryEntry,

    TreeReference,

    mutable_inventory_from_tree,

    )

from . import (

    TestCase,

    TestCaseWithTransport,

    )

from .scenarios import load_tests_apply_scenarios

load_tests = load_tests_apply_scenarios

def delta_application_scenarios():

    scenarios = [

        ('Inventory', {'apply_delta': apply_inventory_Inventory}),

        ]

    # Working tree basis delta application

    # Repository add_inv_by_delta.

    # Reduce form of the per_repository test logic - that logic needs to be

    # be able to get /just/ repositories whereas these tests are fine with

    # just creating trees.

    formats = set()

    for _, format in repository.format_registry.iteritems():

        if format.supports_full_versioned_files:

            scenarios.append((str(format.__name__), {

                'apply_delta': apply_inventory_Repository_add_inventory_by_delta,

                'format': format}))

    for getter in workingtree.format_registry._get_all_lazy():

        try:

            format = getter()

            if callable(format):

                format = format()

        except ImportError:

            pass  # Format with unmet dependency

        repo_fmt = format._matchingcontroldir.repository_format

        if not repo_fmt.supports_full_versioned_files:

            continue

        scenarios.append(

            (str(format.__class__.__name__) + ".update_basis_by_delta", {

                'apply_delta': apply_inventory_WT_basis,

                'format': format}))

        scenarios.append(

            (str(format.__class__.__name__) + ".apply_inventory_delta", {

                'apply_delta': apply_inventory_WT,

                'format': format}))

    return scenarios

def create_texts_for_inv(repo, inv):

    for path, ie in inv.iter_entries():

        if ie.text_size:

            lines = [b'a' * ie.text_size]

        else:

            lines = []

        repo.texts.add_lines((ie.file_id, ie.revision), [], lines)

def apply_inventory_Inventory(self, basis, delta, invalid_delta=True):

    """Apply delta to basis and return the result.

    :param basis: An inventory to be used as the basis.

    :param delta: The inventory delta to apply:

    :return: An inventory resulting from the application.

    """

    basis.apply_delta(delta)

    return basis

def apply_inventory_WT(self, basis, delta, invalid_delta=True):

    """Apply delta to basis and return the result.

    This sets the tree state to be basis, and then calls apply_inventory_delta.

    :param basis: An inventory to be used as the basis.

    :param delta: The inventory delta to apply:

    :return: An inventory resulting from the application.

    """

    control = self.make_controldir(

        'tree', format=self.format._matchingcontroldir)

    control.create_repository()

    control.create_branch()

    tree = self.format.initialize(control)

    tree.lock_write()

    try:

        tree._write_inventory(basis)

    finally:

        tree.unlock()

    # Fresh object, reads disk again.

    tree = tree.controldir.open_workingtree()

    tree.lock_write()

    try:

        tree.apply_inventory_delta(delta)

    finally:

        tree.unlock()

    # reload tree - ensure we get what was written.

    tree = tree.controldir.open_workingtree()

    tree.lock_read()

    self.addCleanup(tree.unlock)

    if not invalid_delta:

        tree._validate()

    return tree.root_inventory

def _create_repo_revisions(repo, basis, delta, invalid_delta):

    repo.start_write_group()

    try:

        rev = revision.Revision(b'basis', timestamp=0, timezone=None,

                                message="", committer="foo@example.com")

        basis.revision_id = b'basis'

        create_texts_for_inv(repo, basis)

        repo.add_revision(b'basis', rev, basis)

        if invalid_delta:

            # We don't want to apply the delta to the basis, because we expect

            # the delta is invalid.

            result_inv = basis

            result_inv.revision_id = b'result'

            target_entries = None

        else:

            result_inv = basis.create_by_apply_delta(delta, b'result')

            create_texts_for_inv(repo, result_inv)

            target_entries = list(result_inv.iter_entries_by_dir())

        rev = revision.Revision(b'result', timestamp=0, timezone=None,

                                message="", committer="foo@example.com")

        repo.add_revision(b'result', rev, result_inv)

        repo.commit_write_group()

    except:

        repo.abort_write_group()

        raise

    return target_entries

def _get_basis_entries(tree):

    basis_tree = tree.basis_tree()

    basis_tree.lock_read()

    basis_tree_entries = list(basis_tree.inventory.iter_entries_by_dir())

    basis_tree.unlock()

    return basis_tree_entries

def _populate_different_tree(tree, basis, delta):

    """Put all entries into tree, but at a unique location."""

    added_ids = set()

    added_paths = set()

    tree.add(['unique-dir'], [b'unique-dir-id'], ['directory'])

    for path, ie in basis.iter_entries_by_dir():

        if ie.file_id in added_ids:

            continue

        # We want a unique path for each of these, we use the file-id

        tree.add(['unique-dir/' + ie.file_id], [ie.file_id], [ie.kind])

        added_ids.add(ie.file_id)

    for old_path, new_path, file_id, ie in delta:

        if file_id in added_ids:

            continue

        tree.add(['unique-dir/' + file_id], [file_id], [ie.kind])

def apply_inventory_WT_basis(test, basis, delta, invalid_delta=True):

    """Apply delta to basis and return the result.

    This sets the parent and then calls update_basis_by_delta.

    It also puts the basis in the repository under both 'basis' and 'result' to

    allow safety checks made by the WT to succeed, and finally ensures that all

    items in the delta with a new path are present in the WT before calling

    update_basis_by_delta.

    :param basis: An inventory to be used as the basis.

    :param delta: The inventory delta to apply:

    :return: An inventory resulting from the application.

    """

    control = test.make_controldir(

        'tree', format=test.format._matchingcontroldir)

    control.create_repository()

    control.create_branch()

    tree = test.format.initialize(control)

    tree.lock_write()

    try:

        target_entries = _create_repo_revisions(tree.branch.repository, basis,

                                                delta, invalid_delta)

        # Set the basis state as the trees current state

        tree._write_inventory(basis)

        # This reads basis from the repo and puts it into the tree's local

        # cache, if it has one.

        tree.set_parent_ids([b'basis'])

    finally:

        tree.unlock()

    # Fresh lock, reads disk again.

    with tree.lock_write():

        tree.update_basis_by_delta(b'result', delta)

        if not invalid_delta:

            tree._validate()

    # reload tree - ensure we get what was written.

    tree = tree.controldir.open_workingtree()

    basis_tree = tree.basis_tree()

    basis_tree.lock_read()

    test.addCleanup(basis_tree.unlock)

    basis_inv = basis_tree.root_inventory

    if target_entries:

        basis_entries = list(basis_inv.iter_entries_by_dir())

        test.assertEqual(target_entries, basis_entries)

    return basis_inv

def apply_inventory_Repository_add_inventory_by_delta(self, basis, delta,

                                                      invalid_delta=True):

    """Apply delta to basis and return the result.

    This inserts basis as a whole inventory and then uses

    add_inventory_by_delta to add delta.

    :param basis: An inventory to be used as the basis.

    :param delta: The inventory delta to apply:

    :return: An inventory resulting from the application.

    """

    format = self.format()

    control = self.make_controldir('tree', format=format._matchingcontroldir)

    repo = format.initialize(control)

    with repo.lock_write():

        repo.start_write_group()

        try:

            rev = revision.Revision(b'basis', timestamp=0, timezone=None,

                                    message="", committer="foo@example.com")

            basis.revision_id = b'basis'

            create_texts_for_inv(repo, basis)

            repo.add_revision(b'basis', rev, basis)

            repo.commit_write_group()

        except:

            repo.abort_write_group()

            raise

    with repo.lock_write():

        repo.start_write_group()

        try:

            inv_sha1 = repo.add_inventory_by_delta(b'basis', delta,

                                                   b'result', [b'basis'])

        except:

            repo.abort_write_group()

            raise

        else:

            repo.commit_write_group()

    # Fresh lock, reads disk again.

    repo = repo.controldir.open_repository()

    repo.lock_read()

    self.addCleanup(repo.unlock)

    return repo.get_inventory(b'result')

class TestInventoryUpdates(TestCase):

    def test_creation_from_root_id(self):

        # iff a root id is passed to the constructor, a root directory is made

        inv = inventory.Inventory(root_id=b'tree-root')

        self.assertNotEqual(None, inv.root)

        self.assertEqual(b'tree-root', inv.root.file_id)

    def test_add_path_of_root(self):

        # if no root id is given at creation time, there is no root directory

        inv = inventory.Inventory(root_id=None)

        self.assertIs(None, inv.root)

        # add a root entry by adding its path

        ie = inv.add_path(u"", "directory", b"my-root")

        ie.revision = b'test-rev'

        self.assertEqual(b"my-root", ie.file_id)

        self.assertIs(ie, inv.root)

    def test_add_path(self):

        inv = inventory.Inventory(root_id=b'tree_root')

        ie = inv.add_path(u'hello', 'file', b'hello-id')

        self.assertEqual(b'hello-id', ie.file_id)

        self.assertEqual('file', ie.kind)

    def test_copy(self):

        """Make sure copy() works and creates a deep copy."""

        inv = inventory.Inventory(root_id=b'some-tree-root')

        ie = inv.add_path(u'hello', 'file', b'hello-id')

        inv2 = inv.copy()

        inv.root.file_id = b'some-new-root'

        ie.name = u'file2'

        self.assertEqual(b'some-tree-root', inv2.root.file_id)

        self.assertEqual(u'hello', inv2.get_entry(b'hello-id').name)

    def test_copy_empty(self):

        """Make sure an empty inventory can be copied."""

        inv = inventory.Inventory(root_id=None)

        inv2 = inv.copy()

        self.assertIs(None, inv2.root)

    def test_copy_copies_root_revision(self):

        """Make sure the revision of the root gets copied."""

        inv = inventory.Inventory(root_id=b'someroot')

        inv.root.revision = b'therev'

        inv2 = inv.copy()

        self.assertEqual(b'someroot', inv2.root.file_id)

        self.assertEqual(b'therev', inv2.root.revision)

    def test_create_tree_reference(self):

        inv = inventory.Inventory(b'tree-root-123')

        inv.add(TreeReference(

            b'nested-id', 'nested', parent_id=b'tree-root-123',

            revision=b'rev', reference_revision=b'rev2'))

    def test_error_encoding(self):

        inv = inventory.Inventory(b'tree-root')

        inv.add(InventoryFile(b'a-id', u'\u1234', b'tree-root'))

        e = self.assertRaises(errors.InconsistentDelta, inv.add,

                              InventoryFile(b'b-id', u'\u1234', b'tree-root'))

        self.assertContainsRe(str(e), '\\u1234')

    def test_add_recursive(self):

        parent = InventoryDirectory(b'src-id', 'src', b'tree-root')

        child = InventoryFile(b'hello-id', 'hello.c', b'src-id')

        parent.children[child.file_id] = child

        inv = inventory.Inventory(b'tree-root')

        inv.add(parent)

        self.assertEqual('src/hello.c', inv.id2path(b'hello-id'))

class TestDeltaApplication(TestCaseWithTransport):

    scenarios = delta_application_scenarios()

    def get_empty_inventory(self, reference_inv=None):

        """Get an empty inventory.

        Note that tests should not depend on the revision of the root for

        setting up test conditions, as it has to be flexible to accomodate non

        rich root repositories.

        :param reference_inv: If not None, get the revision for the root from

            this inventory. This is useful for dealing with older repositories

            that routinely discarded the root entry data. If None, the root's

            revision is set to 'basis'.

        """

        inv = inventory.Inventory()

        if reference_inv is not None:

            inv.root.revision = reference_inv.root.revision

        else:

            inv.root.revision = b'basis'

        return inv

    def make_file_ie(self, file_id=b'file-id', name='name', parent_id=None):

        ie_file = inventory.InventoryFile(file_id, name, parent_id)

        ie_file.revision = b'result'

        ie_file.text_size = 0

        ie_file.text_sha1 = b''

        return ie_file

    def test_empty_delta(self):

        inv = self.get_empty_inventory()

        delta = []

        inv = self.apply_delta(self, inv, delta)

        inv2 = self.get_empty_inventory(inv)

        self.assertEqual([], inv2._make_delta(inv))

    def test_None_file_id(self):

        inv = self.get_empty_inventory()

        dir1 = inventory.InventoryDirectory(b'dirid', 'dir1', inv.root.file_id)

        dir1.file_id = None

        dir1.revision = b'result'

        delta = [(None, u'dir1', None, dir1)]

        self.assertRaises(errors.InconsistentDelta, self.apply_delta, self,

                          inv, delta)

    def test_unicode_file_id(self):

        inv = self.get_empty_inventory()

        dir1 = inventory.InventoryDirectory(b'dirid', 'dir1', inv.root.file_id)

        dir1.file_id = u'dirid'

        dir1.revision = b'result'

        delta = [(None, u'dir1', dir1.file_id, dir1)]

        self.assertRaises(errors.InconsistentDelta, self.apply_delta, self,

                          inv, delta)

    def test_repeated_file_id(self):

        inv = self.get_empty_inventory()

        file1 = inventory.InventoryFile(b'id', 'path1', inv.root.file_id)

        file1.revision = b'result'

        file1.text_size = 0

        file1.text_sha1 = b""

        file2 = file1.copy()

        file2.name = 'path2'

        delta = [(None, u'path1', b'id', file1),

                 (None, u'path2', b'id', file2)]

        self.assertRaises(errors.InconsistentDelta, self.apply_delta, self,

                          inv, delta)

    def test_repeated_new_path(self):

        inv = self.get_empty_inventory()

        file1 = inventory.InventoryFile(b'id1', 'path', inv.root.file_id)

        file1.revision = b'result'

        file1.text_size = 0

        file1.text_sha1 = b""

        file2 = file1.copy()

        file2.file_id = b'id2'

        delta = [(None, u'path', b'id1', file1),

                 (None, u'path', b'id2', file2)]

        self.assertRaises(errors.InconsistentDelta, self.apply_delta, self,

                          inv, delta)

    def test_repeated_old_path(self):

        inv = self.get_empty_inventory()

        file1 = inventory.InventoryFile(b'id1', 'path', inv.root.file_id)

        file1.revision = b'result'

        file1.text_size = 0

        file1.text_sha1 = b""

        # We can't *create* a source inventory with the same path, but

        # a badly generated partial delta might claim the same source twice.

        # This would be buggy in two ways: the path is repeated in the delta,

        # And the path for one of the file ids doesn't match the source

        # location. Alternatively, we could have a repeated fileid, but that

        # is separately checked for.

        file2 = inventory.InventoryFile(b'id2', 'path2', inv.root.file_id)

        file2.revision = b'result'

        file2.text_size = 0

        file2.text_sha1 = b""

        inv.add(file1)

        inv.add(file2)

        delta = [(u'path', None, b'id1', None), (u'path', None, b'id2', None)]

        self.assertRaises(errors.InconsistentDelta, self.apply_delta, self,

                          inv, delta)

    def test_mismatched_id_entry_id(self):

        inv = self.get_empty_inventory()

        file1 = inventory.InventoryFile(b'id1', 'path', inv.root.file_id)

        file1.revision = b'result'

        file1.text_size = 0

        file1.text_sha1 = b""

        delta = [(None, u'path', b'id', file1)]

        self.assertRaises(errors.InconsistentDelta, self.apply_delta, self,

                          inv, delta)

    def test_mismatched_new_path_entry_None(self):

        inv = self.get_empty_inventory()

        delta = [(None, u'path', b'id', None)]

        self.assertRaises(errors.InconsistentDelta, self.apply_delta, self,

                          inv, delta)

    def test_mismatched_new_path_None_entry(self):

        inv = self.get_empty_inventory()

        file1 = inventory.InventoryFile(b'id1', 'path', inv.root.file_id)

        file1.revision = b'result'

        file1.text_size = 0

        file1.text_sha1 = b""

        delta = [(u"path", None, b'id1', file1)]

        self.assertRaises(errors.InconsistentDelta, self.apply_delta, self,

                          inv, delta)

    def test_parent_is_not_directory(self):

        inv = self.get_empty_inventory()

        file1 = inventory.InventoryFile(b'id1', 'path', inv.root.file_id)

        file1.revision = b'result'

        file1.text_size = 0

        file1.text_sha1 = b""

        file2 = inventory.InventoryFile(b'id2', 'path2', b'id1')

        file2.revision = b'result'

        file2.text_size = 0

        file2.text_sha1 = b""

        inv.add(file1)

        delta = [(None, u'path/path2', b'id2', file2)]

        self.assertRaises(errors.InconsistentDelta, self.apply_delta, self,

                          inv, delta)

    def test_parent_is_missing(self):

        inv = self.get_empty_inventory()

        file2 = inventory.InventoryFile(b'id2', 'path2', b'missingparent')

        file2.revision = b'result'

        file2.text_size = 0

        file2.text_sha1 = b""

        delta = [(None, u'path/path2', b'id2', file2)]

        self.assertRaises(errors.InconsistentDelta, self.apply_delta, self,

                          inv, delta)

    def test_new_parent_path_has_wrong_id(self):

        inv = self.get_empty_inventory()

        parent1 = inventory.InventoryDirectory(b'p-1', 'dir', inv.root.file_id)

        parent1.revision = b'result'

        parent2 = inventory.InventoryDirectory(

            b'p-2', 'dir2', inv.root.file_id)

        parent2.revision = b'result'

        file1 = inventory.InventoryFile(b'id', 'path', b'p-2')

        file1.revision = b'result'

        file1.text_size = 0

        file1.text_sha1 = b""

        inv.add(parent1)

        inv.add(parent2)

        # This delta claims that file1 is at dir/path, but actually its at

        # dir2/path if you follow the inventory parent structure.

        delta = [(None, u'dir/path', b'id', file1)]

        self.assertRaises(errors.InconsistentDelta, self.apply_delta, self,

                          inv, delta)

    def test_old_parent_path_is_wrong(self):

        inv = self.get_empty_inventory()

        parent1 = inventory.InventoryDirectory(b'p-1', 'dir', inv.root.file_id)

        parent1.revision = b'result'

        parent2 = inventory.InventoryDirectory(

            b'p-2', 'dir2', inv.root.file_id)

        parent2.revision = b'result'

        file1 = inventory.InventoryFile(b'id', 'path', b'p-2')

        file1.revision = b'result'

        file1.text_size = 0

        file1.text_sha1 = b""

        inv.add(parent1)

        inv.add(parent2)

        inv.add(file1)

        # This delta claims that file1 was at dir/path, but actually it was at

        # dir2/path if you follow the inventory parent structure.

        delta = [(u'dir/path', None, b'id', None)]

        self.assertRaises(errors.InconsistentDelta, self.apply_delta, self,

                          inv, delta)

    def test_old_parent_path_is_for_other_id(self):

        inv = self.get_empty_inventory()

        parent1 = inventory.InventoryDirectory(b'p-1', 'dir', inv.root.file_id)

        parent1.revision = b'result'

        parent2 = inventory.InventoryDirectory(

            b'p-2', 'dir2', inv.root.file_id)

        parent2.revision = b'result'

        file1 = inventory.InventoryFile(b'id', 'path', b'p-2')

        file1.revision = b'result'

        file1.text_size = 0

        file1.text_sha1 = b""

        file2 = inventory.InventoryFile(b'id2', 'path', b'p-1')

        file2.revision = b'result'

        file2.text_size = 0

        file2.text_sha1 = b""

        inv.add(parent1)

        inv.add(parent2)

        inv.add(file1)