~bzr-pqm/bzr/bzr.dev

# Copyright (C) 2005, 2006, 2007, 2008, 2009 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 bzrlib import (

    chk_map,

    groupcompress,

    bzrdir,

    errors,

    inventory,

    osutils,

    repository,

    revision,

    tests,

    )

from bzrlib.inventory import (CHKInventory, Inventory, ROOT_ID, InventoryFile,

    InventoryDirectory, InventoryEntry, TreeReference)

from bzrlib.tests import (

    TestCase,

    TestCaseWithTransport,

    condition_isinstance,

    multiply_tests,

    split_suite_by_condition,

    )

from bzrlib.tests.per_workingtree import workingtree_formats

def load_tests(standard_tests, module, loader):

    """Parameterise some inventory tests."""

    to_adapt, result = split_suite_by_condition(standard_tests,

        condition_isinstance(TestDeltaApplication))

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

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

            'apply_delta':apply_inventory_Repository_add_inventory_by_delta,

            'format':format}))

    for format in workingtree_formats():

        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 multiply_tests(to_adapt, scenarios, result)

def create_texts_for_inv(repo, inv):

    for path, ie in inv.iter_entries():

        if ie.text_size:

            lines = ['a' * ie.text_size]

        else:

            lines = []

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

def apply_inventory_Inventory(self, basis, delta):

    """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):

    """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_bzrdir('tree', format=self.format._matchingbzrdir)

    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.bzrdir.open_workingtree()

    tree.lock_write()

    try:

        tree.apply_inventory_delta(delta)

    finally:

        tree.unlock()

    # reload tree - ensure we get what was written.

    tree = tree.bzrdir.open_workingtree()

    tree.lock_read()

    self.addCleanup(tree.unlock)

    # One could add 'tree._validate' here but that would cause 'early' failues 

    # as far as higher level code is concerned. Possibly adding an

    # expect_fail parameter to this function and if that is False then do a

    # validate call.

    return tree.inventory

def apply_inventory_WT_basis(self, basis, delta):

    """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 = self.make_bzrdir('tree', format=self.format._matchingbzrdir)

    control.create_repository()

    control.create_branch()

    tree = self.format.initialize(control)

    tree.lock_write()

    try:

        repo = tree.branch.repository

        repo.start_write_group()

        try:

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

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

            basis.revision_id = 'basis'

            create_texts_for_inv(tree.branch.repository, basis)

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

            # Add a revision for the result, with the basis content - 

            # update_basis_by_delta doesn't check that the delta results in

            # result, and we want inconsistent deltas to get called on the

            # tree, or else the code isn't actually checked.

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

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

            basis.revision_id = 'result'

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

            repo.commit_write_group()

        except:

            repo.abort_write_group()

            raise

        # 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(['basis'])

        paths = {}

        parents = set()

        for old, new, id, entry in delta:

            if None in (new, entry):

                continue

            paths[new] = (entry.file_id, entry.kind)

            parents.add(osutils.dirname(new))

        parents = osutils.minimum_path_selection(parents)

        parents.discard('')

        # Put place holders in the tree to permit adding the other entries.

        for pos, parent in enumerate(parents):

            if not tree.path2id(parent):

                # add a synthetic directory in the tree so we can can put the

                # tree0 entries in place for dirstate.

                tree.add([parent], ["id%d" % pos], ["directory"])

        if paths:

            # Many deltas may cause this mini-apply to fail, but we want to see what

            # the delta application code says, not the prep that we do to deal with 

            # limitations of dirstate's update_basis code.

            for path, (file_id, kind) in sorted(paths.items()):

                try:

                    tree.add([path], [file_id], [kind])

                except (KeyboardInterrupt, SystemExit):

                    raise

                except:

                    pass

    finally:

        tree.unlock()

    # Fresh lock, reads disk again.

    tree.lock_write()

    try:

        tree.update_basis_by_delta('result', delta)

    finally:

        tree.unlock()

    # reload tree - ensure we get what was written.

    tree = tree.bzrdir.open_workingtree()

    basis_tree = tree.basis_tree()

    basis_tree.lock_read()

    self.addCleanup(basis_tree.unlock)

    # Note, that if the tree does not have a local cache, the trick above of

    # setting the result as the basis, will come back to bite us. That said,

    # all the implementations in bzr do have a local cache.

    return basis_tree.inventory

def apply_inventory_Repository_add_inventory_by_delta(self, basis, delta):

    """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_bzrdir('tree', format=format._matchingbzrdir)

    repo = format.initialize(control)

    repo.lock_write()

    try:

        repo.start_write_group()

        try:

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

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

            basis.revision_id = 'basis'

            create_texts_for_inv(repo, basis)

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

            repo.commit_write_group()

        except:

            repo.abort_write_group()

            raise

    finally:

        repo.unlock()

    repo.lock_write()

    try:

        repo.start_write_group()

        try:

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

                'result', ['basis'])

        except:

            repo.abort_write_group()

            raise

        else:

            repo.commit_write_group()

    finally:

        repo.unlock()

    # Fresh lock, reads disk again.

    repo = repo.bzrdir.open_repository()

    repo.lock_read()

    self.addCleanup(repo.unlock)

    return repo.get_inventory('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='tree-root')

        self.assertNotEqual(None, inv.root)

        self.assertEqual('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("", "directory", "my-root")

        ie.revision = 'test-rev'

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

        self.assertIs(ie, inv.root)

    def test_add_path(self):

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

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

        self.assertEqual('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='some-tree-root')

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

        inv2 = inv.copy()

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

        ie.name = 'file2'

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

        self.assertEqual('hello', inv2['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='someroot')

        inv.root.revision = 'therev'

        inv2 = inv.copy()

        self.assertEquals('someroot', inv2.root.file_id)

        self.assertEquals('therev', inv2.root.revision)

    def test_create_tree_reference(self):

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

        inv.add(TreeReference('nested-id', 'nested', parent_id='tree-root-123',

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

    def test_error_encoding(self):

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

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

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

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

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

    def test_add_recursive(self):

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

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

        parent.children[child.file_id] = child

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

        inv.add(parent)

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

class TestDeltaApplication(TestCaseWithTransport):

    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 = 'basis'

        return inv

    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(None, 'dir1', inv.root.file_id)

        dir1.revision = '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(u'dirid', 'dir1', inv.root.file_id)

        dir1.revision = '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('id', 'path1', inv.root.file_id)

        file1.revision = 'result'

        file1.text_size = 0

        file1.text_sha1 = ""

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

        file2.revision = 'result'

        file2.text_size = 0

        file2.text_sha1 = ""

        delta = [(None, u'path1', 'id', file1), (None, u'path2', '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('id1', 'path', inv.root.file_id)

        file1.revision = 'result'

        file1.text_size = 0

        file1.text_sha1 = ""

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

        file2.revision = 'result'

        file2.text_size = 0

        file2.text_sha1 = ""

        delta = [(None, u'path', 'id1', file1), (None, u'path', '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('id1', 'path', inv.root.file_id)

        file1.revision = 'result'

        file1.text_size = 0

        file1.text_sha1 = ""

        # 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('id2', 'path2', inv.root.file_id)

        file2.revision = 'result'

        file2.text_size = 0

        file2.text_sha1 = ""

        inv.add(file1)

        inv.add(file2)

        delta = [(u'path', None, 'id1', None), (u'path', None, '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('id1', 'path', inv.root.file_id)

        file1.revision = 'result'

        file1.text_size = 0

        file1.text_sha1 = ""

        delta = [(None, u'path', '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', '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('id1', 'path', inv.root.file_id)

        file1.revision = 'result'

        file1.text_size = 0

        file1.text_sha1 = ""

        delta = [(u"path", None, '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('id1', 'path', inv.root.file_id)

        file1.revision = 'result'

        file1.text_size = 0

        file1.text_sha1 = ""

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

        file2.revision = 'result'

        file2.text_size = 0

        file2.text_sha1 = ""

        inv.add(file1)

        delta = [(None, u'path/path2', '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('id2', 'path2', 'missingparent')

        file2.revision = 'result'

        file2.text_size = 0

        file2.text_sha1 = ""

        delta = [(None, u'path/path2', '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('p-1', 'dir', inv.root.file_id)

        parent1.revision = 'result'

        parent2 = inventory.InventoryDirectory('p-2', 'dir2', inv.root.file_id)

        parent2.revision = 'result'

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

        file1.revision = 'result'

        file1.text_size = 0

        file1.text_sha1 = ""

        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', '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('p-1', 'dir', inv.root.file_id)

        parent1.revision = 'result'

        parent2 = inventory.InventoryDirectory('p-2', 'dir2', inv.root.file_id)

        parent2.revision = 'result'

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

        file1.revision = 'result'

        file1.text_size = 0

        file1.text_sha1 = ""

        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, '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('p-1', 'dir', inv.root.file_id)

        parent1.revision = 'result'

        parent2 = inventory.InventoryDirectory('p-2', 'dir2', inv.root.file_id)

        parent2.revision = 'result'

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

        file1.revision = 'result'

        file1.text_size = 0

        file1.text_sha1 = ""

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

        file2.revision = 'result'

        file2.text_size = 0

        file2.text_sha1 = ""

        inv.add(parent1)

        inv.add(parent2)

        inv.add(file1)

        inv.add(file2)

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

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

        # is another entry we should not delete.

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

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

            inv, delta)

    def test_add_existing_id_new_path(self):

        inv = self.get_empty_inventory()

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

        parent1.revision = 'result'

        parent2 = inventory.InventoryDirectory('p-1', 'dir2', inv.root.file_id)

        parent2.revision = 'result'

        inv.add(parent1)

        delta = [(None, u'dir2', 'p-1', parent2)]

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

            inv, delta)

    def test_add_new_id_existing_path(self):

        inv = self.get_empty_inventory()

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

        parent1.revision = 'result'

        parent2 = inventory.InventoryDirectory('p-2', 'dir1', inv.root.file_id)

        parent2.revision = 'result'

        inv.add(parent1)

        delta = [(None, u'dir1', 'p-2', parent2)]

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

            inv, delta)

    def test_remove_dir_leaving_dangling_child(self):

        inv = self.get_empty_inventory()

        dir1 = inventory.InventoryDirectory('p-1', 'dir1', inv.root.file_id)

        dir1.revision = 'result'

        dir2 = inventory.InventoryDirectory('p-2', 'child1', 'p-1')

        dir2.revision = 'result'

        dir3 = inventory.InventoryDirectory('p-3', 'child2', 'p-1')

        dir3.revision = 'result'

        inv.add(dir1)

        inv.add(dir2)

        inv.add(dir3)

        delta = [(u'dir1', None, 'p-1', None),

            (u'dir1/child2', None, 'p-3', None)]

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

            inv, delta)

class TestInventory(TestCase):

    def test_is_root(self):

        """Ensure our root-checking code is accurate."""

        inv = inventory.Inventory('TREE_ROOT')

        self.assertTrue(inv.is_root('TREE_ROOT'))

        self.assertFalse(inv.is_root('booga'))

        inv.root.file_id = 'booga'

        self.assertFalse(inv.is_root('TREE_ROOT'))

        self.assertTrue(inv.is_root('booga'))

        # works properly even if no root is set

        inv.root = None

        self.assertFalse(inv.is_root('TREE_ROOT'))

        self.assertFalse(inv.is_root('booga'))

class TestInventoryEntry(TestCase):

    def test_file_kind_character(self):

        file = inventory.InventoryFile('123', 'hello.c', ROOT_ID)

        self.assertEqual(file.kind_character(), '')

    def test_dir_kind_character(self):

        dir = inventory.InventoryDirectory('123', 'hello.c', ROOT_ID)

        self.assertEqual(dir.kind_character(), '/')

    def test_link_kind_character(self):

        dir = inventory.InventoryLink('123', 'hello.c', ROOT_ID)

        self.assertEqual(dir.kind_character(), '')

    def test_dir_detect_changes(self):

        left = inventory.InventoryDirectory('123', 'hello.c', ROOT_ID)

        left.text_sha1 = 123

        left.executable = True

        left.symlink_target='foo'

        right = inventory.InventoryDirectory('123', 'hello.c', ROOT_ID)

        right.text_sha1 = 321

        right.symlink_target='bar'

        self.assertEqual((False, False), left.detect_changes(right))

        self.assertEqual((False, False), right.detect_changes(left))

    def test_file_detect_changes(self):

        left = inventory.InventoryFile('123', 'hello.c', ROOT_ID)

        left.text_sha1 = 123

        right = inventory.InventoryFile('123', 'hello.c', ROOT_ID)

        right.text_sha1 = 123

        self.assertEqual((False, False), left.detect_changes(right))

        self.assertEqual((False, False), right.detect_changes(left))

        left.executable = True

        self.assertEqual((False, True), left.detect_changes(right))

        self.assertEqual((False, True), right.detect_changes(left))

        right.text_sha1 = 321

        self.assertEqual((True, True), left.detect_changes(right))

        self.assertEqual((True, True), right.detect_changes(left))

    def test_symlink_detect_changes(self):

        left = inventory.InventoryLink('123', 'hello.c', ROOT_ID)

        left.text_sha1 = 123

        left.executable = True

        left.symlink_target='foo'

        right = inventory.InventoryLink('123', 'hello.c', ROOT_ID)

        right.text_sha1 = 321

        right.symlink_target='foo'

        self.assertEqual((False, False), left.detect_changes(right))

        self.assertEqual((False, False), right.detect_changes(left))

        left.symlink_target = 'different'