/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to tests/test_cache.py

Implement _bisect_recursive, which uses multiple bisect calls to
handle renames and finding entries in subdirs.
As is, this could be hooked into paths2ids() if the dirstate has not been loaded yet.
However, it doesn't quite provide enough, since the parsed entries would probably not
be saved. Further, the multiple bisect calls are less efficient then they could be,
because they do not remember the last bisect call.
We should explore switching to a caching structure, which maintains all records that
have been processed, in a structure that can be in-memory searched before going back
to disk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/test_cache.py
1
 
# Copyright (C) 2009 Jelmer Vernooij <jelmer@samba.org>
2
 
#
3
 
# This program is free software; you can redistribute it and/or modify
4
 
# it under the terms of the GNU General Public License as published by
5
 
# the Free Software Foundation; either version 2 of the License, or
6
 
# (at your option) any later version.
7
 
#
8
 
# This program is distributed in the hope that it will be useful,
9
 
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
 
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
 
# GNU General Public License for more details.
12
 
#
13
 
# You should have received a copy of the GNU General Public License
14
 
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
 
 
17
 
"""Tests for GitShaMap."""
18
 
 
19
 
from dulwich.objects import (
20
 
    Blob,
21
 
    Commit,
22
 
    Tree,
23
 
    )
24
 
 
25
 
import os
26
 
import stat
27
 
 
28
 
from bzrlib.inventory import (
29
 
    InventoryFile,
30
 
    InventoryDirectory,
31
 
    ROOT_ID,
32
 
    )
33
 
 
34
 
from bzrlib.revision import (
35
 
    Revision,
36
 
    )
37
 
 
38
 
from bzrlib.tests import (
39
 
    TestCase,
40
 
    TestCaseInTempDir,
41
 
    UnavailableFeature,
42
 
    )
43
 
from bzrlib.transport import (
44
 
    get_transport,
45
 
    )
46
 
 
47
 
from bzrlib.plugins.git.cache import (
48
 
    DictBzrGitCache,
49
 
    IndexBzrGitCache,
50
 
    IndexGitCacheFormat,
51
 
    SqliteBzrGitCache,
52
 
    TdbBzrGitCache,
53
 
    )
54
 
 
55
 
class TestGitShaMap:
56
 
 
57
 
    def _get_test_commit(self):
58
 
        c = Commit()
59
 
        c.committer = "Jelmer <jelmer@samba.org>"
60
 
        c.commit_time = 0
61
 
        c.commit_timezone = 0
62
 
        c.author = "Jelmer <jelmer@samba.org>"
63
 
        c.author_time = 0
64
 
        c.author_timezone = 0
65
 
        c.message = "Teh foo bar"
66
 
        c.tree = "cc9462f7f8263ef5adfbeff2fb936bb36b504cba"
67
 
        return c
68
 
 
69
 
    def test_commit(self):
70
 
        self.map.start_write_group()
71
 
        updater = self.cache.get_updater(Revision("myrevid"))
72
 
        c = self._get_test_commit()
73
 
        updater.add_object(c, {
74
 
            "testament3-sha1": "cc9462f7f8263ef5adf8eff2fb936bb36b504cba"},
75
 
            None)
76
 
        updater.finish()
77
 
        self.map.commit_write_group()
78
 
        self.assertEquals(
79
 
            ("commit", ("myrevid",
80
 
                "cc9462f7f8263ef5adfbeff2fb936bb36b504cba",
81
 
                {"testament3-sha1": "cc9462f7f8263ef5adf8eff2fb936bb36b504cba"},
82
 
                )),
83
 
            self.map.lookup_git_sha(c.id))
84
 
        self.assertEquals(c.id, self.map.lookup_commit("myrevid"))
85
 
 
86
 
    def test_lookup_notfound(self):
87
 
        self.assertRaises(KeyError,
88
 
            self.map.lookup_git_sha, "5686645d49063c73d35436192dfc9a160c672301")
89
 
 
90
 
    def test_blob(self):
91
 
        self.map.start_write_group()
92
 
        updater = self.cache.get_updater(Revision("myrevid"))
93
 
        updater.add_object(self._get_test_commit(), { "testament3-sha1": "Test" }, None)
94
 
        b = Blob()
95
 
        b.data = "TEH BLOB"
96
 
        ie = InventoryFile("myfileid", "somename", ROOT_ID)
97
 
        ie.revision = "myrevid"
98
 
        updater.add_object(b, ie, None)
99
 
        updater.finish()
100
 
        self.map.commit_write_group()
101
 
        self.assertEquals(
102
 
            ("blob", ("myfileid", "myrevid")),
103
 
            self.map.lookup_git_sha(b.id))
104
 
        self.assertEquals(b.id,
105
 
            self.map.lookup_blob_id("myfileid", "myrevid"))
106
 
 
107
 
    def test_tree(self):
108
 
        self.map.start_write_group()
109
 
        updater = self.cache.get_updater(Revision("myrevid"))
110
 
        updater.add_object(self._get_test_commit(), {
111
 
            "testament3-sha1": "mytestamentsha" }, None)
112
 
        t = Tree()
113
 
        t.add(stat.S_IFREG, "somename", Blob().id)
114
 
        ie = InventoryDirectory("fileid", "myname", ROOT_ID)
115
 
        ie.revision = "irrelevant"
116
 
        updater.add_object(t, ie, "")
117
 
        updater.finish()
118
 
        self.map.commit_write_group()
119
 
        self.assertEquals(("tree", ("fileid", "myrevid")),
120
 
            self.map.lookup_git_sha(t.id))
121
 
        # It's possible for a backend to not implement lookup_tree
122
 
        try:
123
 
            self.assertEquals(t.id,
124
 
                self.map.lookup_tree_id("fileid", "myrevid"))
125
 
        except NotImplementedError:
126
 
            pass
127
 
 
128
 
    def test_revids(self):
129
 
        self.map.start_write_group()
130
 
        updater = self.cache.get_updater(Revision("myrevid"))
131
 
        c = self._get_test_commit()
132
 
        updater.add_object(c, {"testament3-sha1": "mtestament"}, None)
133
 
        updater.finish()
134
 
        self.map.commit_write_group()
135
 
        self.assertEquals(["myrevid"], list(self.map.revids()))
136
 
 
137
 
    def test_missing_revisions(self):
138
 
        self.map.start_write_group()
139
 
        updater = self.cache.get_updater(Revision("myrevid"))
140
 
        c = self._get_test_commit()
141
 
        updater.add_object(c, {"testament3-sha1": "testament"}, None)
142
 
        updater.finish()
143
 
        self.map.commit_write_group()
144
 
        self.assertEquals(set(["lala", "bla"]),
145
 
            set(self.map.missing_revisions(["myrevid", "lala", "bla"])))
146
 
 
147
 
 
148
 
class DictGitShaMapTests(TestCase,TestGitShaMap):
149
 
 
150
 
    def setUp(self):
151
 
        TestCase.setUp(self)
152
 
        self.cache = DictBzrGitCache()
153
 
        self.map = self.cache.idmap
154
 
 
155
 
 
156
 
class SqliteGitShaMapTests(TestCaseInTempDir,TestGitShaMap):
157
 
 
158
 
    def setUp(self):
159
 
        TestCaseInTempDir.setUp(self)
160
 
        self.cache = SqliteBzrGitCache(os.path.join(self.test_dir, 'foo.db'))
161
 
        self.map = self.cache.idmap
162
 
 
163
 
 
164
 
class TdbGitShaMapTests(TestCaseInTempDir,TestGitShaMap):
165
 
 
166
 
    def setUp(self):
167
 
        TestCaseInTempDir.setUp(self)
168
 
        try:
169
 
            self.cache = TdbBzrGitCache(os.path.join(self.test_dir, 'foo.tdb'))
170
 
        except ImportError:
171
 
            raise UnavailableFeature("Missing tdb")
172
 
        self.map = self.cache.idmap
173
 
 
174
 
 
175
 
class IndexGitShaMapTests(TestCaseInTempDir,TestGitShaMap):
176
 
 
177
 
    def setUp(self):
178
 
        TestCaseInTempDir.setUp(self)
179
 
        transport = get_transport(self.test_dir)
180
 
        IndexGitCacheFormat().initialize(transport)
181
 
        self.cache = IndexBzrGitCache(transport)
182
 
        self.map = self.cache.idmap