/brz/remove-bazaar

# Copyright (C) 2010-2018 Jelmer Vernooij <jelmer@jelmer.uk>

#

# 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

"""Tests for bzr-git's object store."""

from __future__ import absolute_import

import os

import shutil

import stat

from dulwich.objects import (

    Blob,

    Tree,

    )

from ...branchbuilder import (

    BranchBuilder,

    )

from ...bzr.inventory import (

    InventoryDirectory,

    InventoryFile,

    )

from ...errors import (

    NoSuchRevision,

    )

from ...graph import (

    DictParentsProvider,

    Graph,

    )

from ...tests import (

    TestCase,

    TestCaseWithTransport,

    )

from ...tests.features import SymlinkFeature

from ..cache import (

    DictGitShaMap,

    )

from ..object_store import (

    BazaarObjectStore,

    LRUTreeCache,

    directory_to_tree,

    _check_expected_sha,

    _find_missing_bzr_revids,

    _tree_to_objects,

    )

class ExpectedShaTests(TestCase):

    def setUp(self):

        super(ExpectedShaTests, self).setUp()

        self.obj = Blob()

        self.obj.data = b"foo"

    def test_none(self):

        _check_expected_sha(None, self.obj)

    def test_hex(self):

        _check_expected_sha(

            self.obj.sha().hexdigest().encode('ascii'), self.obj)

        self.assertRaises(AssertionError, _check_expected_sha,

                          b"0" * 40, self.obj)

    def test_binary(self):

        _check_expected_sha(self.obj.sha().digest(), self.obj)

        self.assertRaises(AssertionError, _check_expected_sha,

                          b"x" * 20, self.obj)

class FindMissingBzrRevidsTests(TestCase):

    def _find_missing(self, ancestry, want, have):

        return _find_missing_bzr_revids(

            Graph(DictParentsProvider(ancestry)),

            set(want), set(have))

    def test_simple(self):

        self.assertEqual(set(), self._find_missing({}, [], []))

    def test_up_to_date(self):

        self.assertEqual(set(),

                         self._find_missing({"a": ["b"]}, ["a"], ["a"]))

    def test_one_missing(self):

        self.assertEqual(set(["a"]),

                         self._find_missing({"a": ["b"]}, ["a"], ["b"]))

    def test_two_missing(self):

        self.assertEqual(set(["a", "b"]),

                         self._find_missing({"a": ["b"], "b": ["c"]}, ["a"], ["c"]))

    def test_two_missing_history(self):

        self.assertEqual(set(["a", "b"]),

                         self._find_missing({"a": ["b"], "b": ["c"], "c": ["d"]},

                                            ["a"], ["c"]))

class LRUTreeCacheTests(TestCaseWithTransport):

    def setUp(self):

        super(LRUTreeCacheTests, self).setUp()

        self.branch = self.make_branch(".")

        self.branch.lock_write()

        self.addCleanup(self.branch.unlock)

        self.cache = LRUTreeCache(self.branch.repository)

    def test_get_not_present(self):

        self.assertRaises(NoSuchRevision, self.cache.revision_tree,

                          "unknown")

    def test_revision_trees(self):

        self.assertRaises(NoSuchRevision, self.cache.revision_trees,

                          ["unknown", "la"])

    def test_iter_revision_trees(self):

        self.assertRaises(NoSuchRevision, self.cache.iter_revision_trees,

                          ["unknown", "la"])

    def test_get(self):

        bb = BranchBuilder(branch=self.branch)

        bb.start_series()

        revid = bb.build_snapshot(None,

                                  [('add', ('', None, 'directory', None)),

                                   ('add', ('foo', b'foo-id',

                                            'file', b'a\nb\nc\nd\ne\n')),

                                   ])

        bb.finish_series()

        tree = self.cache.revision_tree(revid)

        self.assertEqual(revid, tree.get_revision_id())

class BazaarObjectStoreTests(TestCaseWithTransport):

    def setUp(self):

        super(BazaarObjectStoreTests, self).setUp()

        self.branch = self.make_branch(".")

        self.store = BazaarObjectStore(self.branch.repository)

    def test_get_blob(self):

        self.branch.lock_write()

        self.addCleanup(self.branch.unlock)

        b = Blob()

        b.data = b'a\nb\nc\nd\ne\n'

        self.store.lock_read()

        self.addCleanup(self.store.unlock)

        self.assertRaises(KeyError, self.store.__getitem__, b.id)

        bb = BranchBuilder(branch=self.branch)

        bb.start_series()

        bb.build_snapshot(None,

                          [('add', ('', None, 'directory', None)),

                           ('add', ('foo', b'foo-id', 'file', b'a\nb\nc\nd\ne\n')),

                           ])

        bb.finish_series()

        # read locks cache

        self.assertRaises(KeyError, self.store.__getitem__, b.id)

        self.store.unlock()

        self.store.lock_read()

        self.assertEqual(b, self.store[b.id])

    def test_directory_converted_to_symlink(self):

        self.requireFeature(SymlinkFeature)

        b = Blob()

        b.data = b'trgt'

        self.store.lock_read()

        self.addCleanup(self.store.unlock)

        self.assertRaises(KeyError, self.store.__getitem__, b.id)

        tree = self.branch.controldir.create_workingtree()

        self.build_tree_contents([

            ('foo/', ),

            ('foo/bar', b'a\nb\nc\nd\ne\n')])

        tree.add(['foo', 'foo/bar'])

        revid1 = tree.commit('commit 1')

        shutil.rmtree('foo')

        os.symlink('trgt', 'foo')

        revid2 = tree.commit('commit 2')

        # read locks cache

        self.assertRaises(KeyError, self.store.__getitem__, b.id)

        self.store.unlock()

        self.store.lock_read()

        self.assertEqual(b, self.store[b.id])

    def test_get_raw(self):

        self.branch.lock_write()

        self.addCleanup(self.branch.unlock)

        b = Blob()

        b.data = b'a\nb\nc\nd\ne\n'

        self.store.lock_read()

        self.addCleanup(self.store.unlock)

        self.assertRaises(KeyError, self.store.get_raw, b.id)

        bb = BranchBuilder(branch=self.branch)

        bb.start_series()

        bb.build_snapshot(None,

                          [('add', ('', None, 'directory', None)),

                           ('add', ('foo', b'foo-id', 'file', b'a\nb\nc\nd\ne\n')),

                           ])

        bb.finish_series()

        # read locks cache

        self.assertRaises(KeyError, self.store.get_raw, b.id)

        self.store.unlock()

        self.store.lock_read()

        self.assertEqual(b.as_raw_string(), self.store.get_raw(b.id)[1])

    def test_contains(self):

        self.branch.lock_write()

        self.addCleanup(self.branch.unlock)

        b = Blob()

        b.data = b'a\nb\nc\nd\ne\n'

        self.store.lock_read()

        self.addCleanup(self.store.unlock)

        self.assertFalse(b.id in self.store)

        bb = BranchBuilder(branch=self.branch)

        bb.start_series()

        bb.build_snapshot(None,

                          [('add', ('', None, 'directory', None)),

                           ('add', ('foo', b'foo-id', 'file', b'a\nb\nc\nd\ne\n')),

                           ])

        bb.finish_series()

        # read locks cache

        self.assertFalse(b.id in self.store)

        self.store.unlock()

        self.store.lock_read()

        self.assertTrue(b.id in self.store)

class TreeToObjectsTests(TestCaseWithTransport):

    def setUp(self):

        super(TreeToObjectsTests, self).setUp()

        self.idmap = DictGitShaMap()

    def test_no_changes(self):

        tree = self.make_branch_and_tree('.')

        self.addCleanup(tree.lock_read().unlock)

        entries = list(_tree_to_objects(tree, [tree], self.idmap, {}))

        self.assertEqual([], entries)

    def test_with_gitdir(self):

        tree = self.make_branch_and_tree('.')

        self.build_tree(['.git', 'foo'])

        tree.add(['.git', 'foo'])

        revid = tree.commit('commit')

        revtree = tree.branch.repository.revision_tree(revid)

        self.addCleanup(revtree.lock_read().unlock)

        entries = list(_tree_to_objects(revtree, [], self.idmap, {}))

        self.assertEqual(['foo', ''], [p[0] for p in entries])

    def test_merge(self):

        basis_tree = self.make_branch_and_tree('base')

        self.build_tree(['base/foo/'])

        basis_tree.add(['foo'])

        basis_rev = basis_tree.commit('foo')

        basis_revtree = basis_tree.branch.repository.revision_tree(basis_rev)

        tree_a = self.make_branch_and_tree('a')

        tree_a.pull(basis_tree.branch)

        self.build_tree(['a/foo/file1'])

        self.build_tree(['a/foo/subdir-a/'])

        os.symlink('.', 'a/foo/subdir-a/symlink')

        tree_a.add(['foo/subdir-a', 'foo/subdir-a/symlink'])

        tree_a.add(['foo/file1'])

        rev_a = tree_a.commit('commit a')

        revtree_a = tree_a.branch.repository.revision_tree(rev_a)

        with revtree_a.lock_read():

            entries = list(_tree_to_objects(revtree_a, [basis_revtree],

                           self.idmap, {}))

            objects = {path: obj for (path, obj, key) in entries}

            subdir_a = objects['foo/subdir-a']

        tree_b = self.make_branch_and_tree('b')

        tree_b.pull(basis_tree.branch)

        self.build_tree(['b/foo/subdir/'])

        os.symlink('.', 'b/foo/subdir/symlink')

        tree_b.add(['foo/subdir', 'foo/subdir/symlink'])

        rev_b = tree_b.commit('commit b')

        revtree_b = tree_b.branch.repository.revision_tree(rev_b)

        self.addCleanup(revtree_b.lock_read().unlock)

        with revtree_b.lock_read():

            list(_tree_to_objects(revtree_b, [basis_revtree], self.idmap, {}))

        with tree_a.lock_write():

            tree_a.merge_from_branch(tree_b.branch)

        rev_merge = tree_a.commit('merge')

        revtree_merge = tree_a.branch.basis_tree()

        self.addCleanup(revtree_merge.lock_read().unlock)

        entries = list(_tree_to_objects(

            revtree_merge,

            [tree_a.branch.repository.revision_tree(r)

             for r in revtree_merge.get_parent_ids()],

            self.idmap, {}))

        objects = {path: obj for (path, obj, key) in entries}

        self.assertEqual(set(['', 'foo', 'foo/subdir']), set(objects))

        self.assertEqual(

            (stat.S_IFDIR, subdir_a.id), objects['foo'][b'subdir-a'])

class DirectoryToTreeTests(TestCase):

    def test_empty(self):

        t = directory_to_tree('', [], None, {}, None, allow_empty=False)

        self.assertEqual(None, t)

    def test_empty_dir(self):

        child_ie = InventoryDirectory(b'bar', 'bar', b'bar')

        t = directory_to_tree('', [child_ie], lambda p, x: None, {}, None,

                              allow_empty=False)

        self.assertEqual(None, t)

    def test_empty_dir_dummy_files(self):

        child_ie = InventoryDirectory(b'bar', 'bar', b'bar')

        t = directory_to_tree('', [child_ie], lambda p, x: None, {}, ".mydummy",

                              allow_empty=False)

        self.assertTrue(".mydummy" in t)

    def test_empty_root(self):

        child_ie = InventoryDirectory(b'bar', 'bar', b'bar')

        t = directory_to_tree('', [child_ie], lambda p, x: None, {}, None,

                              allow_empty=True)

        self.assertEqual(Tree(), t)

    def test_with_file(self):

        child_ie = InventoryFile(b'bar', 'bar', b'bar')

        b = Blob.from_string(b"bla")

        t1 = directory_to_tree('', [child_ie], lambda p, x: b.id, {}, None,

                               allow_empty=False)

        t2 = Tree()

        t2.add(b"bar", 0o100644, b.id)

        self.assertEqual(t1, t2)

    def test_with_gitdir(self):

        child_ie = InventoryFile(b'bar', 'bar', b'bar')

        git_file_ie = InventoryFile(b'gitid', '.git', b'bar')

        b = Blob.from_string(b"bla")

        t1 = directory_to_tree('', [child_ie, git_file_ie],

                               lambda p, x: b.id, {}, None,

                               allow_empty=False)

        t2 = Tree()

        t2.add(b"bar", 0o100644, b.id)

        self.assertEqual(t1, t2)