/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 bzrlib/tests/test_foreign.py

  • Committer: Robert Collins
  • Date: 2009-04-20 04:19:45 UTC
  • mto: This revision was merged to the branch mainline in revision 4304.
  • Revision ID: robertc@robertcollins.net-20090420041945-qvim67wg99c3euki
Move directory checking for bzr push options into Branch.create_clone_on_transport.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_foreign.py
 
1
# Copyright (C) 2008 Canonical Ltd
 
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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
16
 
 
17
 
 
18
"""Tests for foreign VCS utility code."""
 
19
 
 
20
 
 
21
from bzrlib import (
 
22
    branch,
 
23
    errors,
 
24
    foreign,
 
25
    lockable_files,
 
26
    lockdir,
 
27
    trace,
 
28
    )
 
29
from bzrlib.bzrdir import (
 
30
    BzrDir,
 
31
    BzrDirFormat,
 
32
    BzrDirMeta1,
 
33
    BzrDirMetaFormat1,
 
34
    format_registry,
 
35
    )
 
36
from bzrlib.inventory import Inventory
 
37
from bzrlib.revision import Revision
 
38
from bzrlib.tests import (
 
39
    TestCase,
 
40
    TestCaseWithTransport,
 
41
    )
 
42
 
 
43
# This is the dummy foreign revision control system, used 
 
44
# mainly here in the testsuite to test the foreign VCS infrastructure.
 
45
# It is basically standard Bazaar with some minor modifications to 
 
46
# make it "foreign". 
 
47
# 
 
48
# It has the following differences to "regular" Bazaar:
 
49
# - The control directory is named ".dummy", not ".bzr".
 
50
# - The revision ids are tuples, not strings.
 
51
# - Doesn't support more than one parent natively
 
52
 
 
53
 
 
54
class DummyForeignVcsMapping(foreign.VcsMapping):
 
55
    """A simple mapping for the dummy Foreign VCS, for use with testing."""
 
56
 
 
57
    def __eq__(self, other):
 
58
        return type(self) == type(other)
 
59
 
 
60
    def revision_id_bzr_to_foreign(self, bzr_revid):
 
61
        return tuple(bzr_revid[len("dummy-v1:"):].split("-")), self
 
62
 
 
63
    def revision_id_foreign_to_bzr(self, foreign_revid):
 
64
        return "dummy-v1:%s-%s-%s" % foreign_revid
 
65
 
 
66
 
 
67
class DummyForeignVcsMappingRegistry(foreign.VcsMappingRegistry):
 
68
 
 
69
    def revision_id_bzr_to_foreign(self, revid):
 
70
        if not revid.startswith("dummy-"):
 
71
            raise errors.InvalidRevisionId(revid, None)
 
72
        mapping_version = revid[len("dummy-"):len("dummy-vx")]
 
73
        mapping = self.get(mapping_version)
 
74
        return mapping.revision_id_bzr_to_foreign(revid)
 
75
 
 
76
 
 
77
class DummyForeignVcs(foreign.ForeignVcs):
 
78
    """A dummy Foreign VCS, for use with testing.
 
79
 
 
80
    It has revision ids that are a tuple with three strings.
 
81
    """
 
82
 
 
83
    def __init__(self):
 
84
        self.mapping_registry = DummyForeignVcsMappingRegistry()
 
85
        self.mapping_registry.register("v1", DummyForeignVcsMapping(self),
 
86
                                       "Version 1")
 
87
 
 
88
    def show_foreign_revid(self, foreign_revid):
 
89
        return { "dummy ding": "%s/%s\\%s" % foreign_revid }
 
90
 
 
91
 
 
92
class DummyForeignVcsBranch(branch.BzrBranch6,foreign.ForeignBranch):
 
93
    """A Dummy VCS Branch."""
 
94
 
 
95
    def __init__(self, _format, _control_files, a_bzrdir, *args, **kwargs):
 
96
        self._format = _format
 
97
        self._base = a_bzrdir.transport.base
 
98
        self._ignore_fallbacks = False
 
99
        foreign.ForeignBranch.__init__(self, 
 
100
            DummyForeignVcsMapping(DummyForeignVcs()))
 
101
        branch.BzrBranch6.__init__(self, _format, _control_files, a_bzrdir, 
 
102
            *args, **kwargs)
 
103
 
 
104
    def dpull(self, source, stop_revision=None):
 
105
        source.lock_read()
 
106
        try:
 
107
            # This just handles simple cases, but that's good enough for tests
 
108
            my_history = self.revision_history()
 
109
            their_history = source.revision_history()
 
110
            if their_history[:min(len(my_history), len(their_history))] != my_history:
 
111
                raise errors.DivergedBranches(self, source)
 
112
            todo = their_history[len(my_history):]
 
113
            revidmap = {}
 
114
            for revid in todo:
 
115
                rev = source.repository.get_revision(revid)
 
116
                tree = source.repository.revision_tree(revid)
 
117
                def get_file_with_stat(file_id, path=None):
 
118
                    return (tree.get_file(file_id), None)
 
119
                tree.get_file_with_stat = get_file_with_stat
 
120
                new_revid = self.mapping.revision_id_foreign_to_bzr(
 
121
                    (str(rev.timestamp), str(rev.timezone), str(self.revno())))
 
122
                parent_revno, parent_revid= self.last_revision_info()
 
123
                builder = self.get_commit_builder([parent_revid], 
 
124
                        self.get_config(), rev.timestamp,
 
125
                        rev.timezone, rev.committer, rev.properties,
 
126
                        new_revid)
 
127
                try:
 
128
                    for path, ie in tree.inventory.iter_entries():
 
129
                        new_ie = ie.copy()
 
130
                        new_ie.revision = None
 
131
                        builder.record_entry_contents(new_ie, 
 
132
                            [self.repository.get_inventory(parent_revid)],
 
133
                            path, tree, 
 
134
                            (ie.kind, ie.text_size, ie.executable, ie.text_sha1))
 
135
                    builder.finish_inventory()
 
136
                except:
 
137
                    builder.abort()
 
138
                    raise
 
139
                revidmap[revid] = builder.commit(rev.message)
 
140
                self.set_last_revision_info(parent_revno+1, revidmap[revid])
 
141
                trace.mutter('lossily pushed revision %s -> %s', 
 
142
                    revid, revidmap[revid])
 
143
        finally:
 
144
            source.unlock()
 
145
        return revidmap
 
146
 
 
147
 
 
148
class DummyForeignVcsBranchFormat(branch.BzrBranchFormat6):
 
149
 
 
150
    def get_format_string(self):
 
151
        return "Branch for Testing"
 
152
 
 
153
    def __init__(self):
 
154
        super(DummyForeignVcsBranchFormat, self).__init__()
 
155
        self._matchingbzrdir = DummyForeignVcsDirFormat()
 
156
 
 
157
    def open(self, a_bzrdir, _found=False):
 
158
        if not _found:
 
159
            raise NotImplementedError
 
160
        try:
 
161
            transport = a_bzrdir.get_branch_transport(None)
 
162
            control_files = lockable_files.LockableFiles(transport, 'lock',
 
163
                                                         lockdir.LockDir)
 
164
            return DummyForeignVcsBranch(_format=self,
 
165
                              _control_files=control_files,
 
166
                              a_bzrdir=a_bzrdir,
 
167
                              _repository=a_bzrdir.find_repository())
 
168
        except errors.NoSuchFile:
 
169
            raise errors.NotBranchError(path=transport.base)
 
170
 
 
171
 
 
172
class DummyForeignVcsDirFormat(BzrDirMetaFormat1):
 
173
    """BzrDirFormat for the dummy foreign VCS."""
 
174
 
 
175
    @classmethod
 
176
    def get_format_string(cls):
 
177
        return "A Dummy VCS Dir"
 
178
 
 
179
    @classmethod
 
180
    def get_format_description(cls):
 
181
        return "A Dummy VCS Dir"
 
182
 
 
183
    @classmethod
 
184
    def is_supported(cls):
 
185
        return True
 
186
 
 
187
    def get_branch_format(self):
 
188
        return DummyForeignVcsBranchFormat()
 
189
 
 
190
    @classmethod
 
191
    def probe_transport(klass, transport):
 
192
        """Return the .bzrdir style format present in a directory."""
 
193
        if not transport.has('.dummy'):
 
194
            raise errors.NotBranchError(path=transport.base)
 
195
        return klass()
 
196
 
 
197
    def initialize_on_transport(self, transport):
 
198
        """Initialize a new bzrdir in the base directory of a Transport."""
 
199
        # Since we don't have a .bzr directory, inherit the
 
200
        # mode from the root directory
 
201
        temp_control = lockable_files.LockableFiles(transport,
 
202
                            '', lockable_files.TransportLock)
 
203
        temp_control._transport.mkdir('.dummy',
 
204
                                      # FIXME: RBC 20060121 don't peek under
 
205
                                      # the covers
 
206
                                      mode=temp_control._dir_mode)
 
207
        del temp_control
 
208
        bzrdir_transport = transport.clone('.dummy')
 
209
        # NB: no need to escape relative paths that are url safe.
 
210
        control_files = lockable_files.LockableFiles(bzrdir_transport,
 
211
            self._lock_file_name, self._lock_class)
 
212
        control_files.create_lock()
 
213
        return self.open(transport, _found=True)
 
214
 
 
215
    def _open(self, transport):
 
216
        return DummyForeignVcsDir(transport, self)
 
217
 
 
218
 
 
219
class DummyForeignVcsDir(BzrDirMeta1):
 
220
 
 
221
    def __init__(self, _transport, _format):
 
222
        self._format = _format
 
223
        self.transport = _transport.clone('.dummy')
 
224
        self.root_transport = _transport
 
225
        self._mode_check_done = False
 
226
        self._control_files = lockable_files.LockableFiles(self.transport,
 
227
            "lock", lockable_files.TransportLock)
 
228
 
 
229
    def open_branch(self, ignore_fallbacks=True):
 
230
        return self._format.get_branch_format().open(self, _found=True)
 
231
 
 
232
    def cloning_metadir(self, stacked=False):
 
233
        """Produce a metadir suitable for cloning with."""
 
234
        return format_registry.make_bzrdir("default")
 
235
 
 
236
    def sprout(self, url, revision_id=None, force_new_repo=False,
 
237
               recurse='down', possible_transports=None,
 
238
               accelerator_tree=None, hardlink=False, stacked=False,
 
239
               source_branch=None):
 
240
        # dirstate doesn't cope with accelerator_trees well 
 
241
        # that have a different control dir
 
242
        return super(DummyForeignVcsDir, self).sprout(url=url, 
 
243
                revision_id=revision_id, force_new_repo=force_new_repo, 
 
244
                recurse=recurse, possible_transports=possible_transports, 
 
245
                hardlink=hardlink, stacked=stacked, source_branch=source_branch)
 
246
 
 
247
 
 
248
class ForeignVcsRegistryTests(TestCase):
 
249
    """Tests for the ForeignVcsRegistry class."""
 
250
 
 
251
    def test_parse_revision_id_no_dash(self):
 
252
        reg = foreign.ForeignVcsRegistry()
 
253
        self.assertRaises(errors.InvalidRevisionId,
 
254
                          reg.parse_revision_id, "invalid")
 
255
 
 
256
    def test_parse_revision_id_unknown_mapping(self):
 
257
        reg = foreign.ForeignVcsRegistry()
 
258
        self.assertRaises(errors.InvalidRevisionId,
 
259
                          reg.parse_revision_id, "unknown-foreignrevid")
 
260
 
 
261
    def test_parse_revision_id(self):
 
262
        reg = foreign.ForeignVcsRegistry()
 
263
        vcs = DummyForeignVcs()
 
264
        reg.register("dummy", vcs, "Dummy VCS")
 
265
        self.assertEquals((("some", "foreign", "revid"), DummyForeignVcsMapping(vcs)),
 
266
                          reg.parse_revision_id("dummy-v1:some-foreign-revid"))
 
267
 
 
268
 
 
269
class ForeignRevisionTests(TestCase):
 
270
    """Tests for the ForeignRevision class."""
 
271
 
 
272
    def test_create(self):
 
273
        mapp = DummyForeignVcsMapping(DummyForeignVcs())
 
274
        rev = foreign.ForeignRevision(("a", "foreign", "revid"),
 
275
                                      mapp, "roundtripped-revid")
 
276
        self.assertEquals("", rev.inventory_sha1)
 
277
        self.assertEquals(("a", "foreign", "revid"), rev.foreign_revid)
 
278
        self.assertEquals(mapp, rev.mapping)
 
279
 
 
280
 
 
281
class ShowForeignPropertiesTests(TestCase):
 
282
    """Tests for the show_foreign_properties() function."""
 
283
 
 
284
    def setUp(self):
 
285
        super(ShowForeignPropertiesTests, self).setUp()
 
286
        self.vcs = DummyForeignVcs()
 
287
        foreign.foreign_vcs_registry.register("dummy",
 
288
            self.vcs, "Dummy VCS")
 
289
 
 
290
    def tearDown(self):
 
291
        super(ShowForeignPropertiesTests, self).tearDown()
 
292
        foreign.foreign_vcs_registry.remove("dummy")
 
293
 
 
294
    def test_show_non_foreign(self):
 
295
        """Test use with a native (non-foreign) bzr revision."""
 
296
        self.assertEquals({}, foreign.show_foreign_properties(Revision("arevid")))
 
297
 
 
298
    def test_show_imported(self):
 
299
        rev = Revision("dummy-v1:my-foreign-revid")
 
300
        self.assertEquals({ "dummy ding": "my/foreign\\revid" },
 
301
                          foreign.show_foreign_properties(rev))
 
302
 
 
303
    def test_show_direct(self):
 
304
        rev = foreign.ForeignRevision(("some", "foreign", "revid"),
 
305
                                      DummyForeignVcsMapping(self.vcs),
 
306
                                      "roundtrip-revid")
 
307
        self.assertEquals({ "dummy ding": "some/foreign\\revid" },
 
308
                          foreign.show_foreign_properties(rev))
 
309
 
 
310
 
 
311
class WorkingTreeFileUpdateTests(TestCaseWithTransport):
 
312
    """Tests for update_workingtree_fileids()."""
 
313
 
 
314
    def test_update_workingtree(self):
 
315
        wt = self.make_branch_and_tree('br1')
 
316
        self.build_tree_contents([('br1/bla', 'original contents\n')])
 
317
        wt.add('bla', 'bla-a')
 
318
        wt.commit('bla-a')
 
319
        target = wt.bzrdir.sprout('br2').open_workingtree()
 
320
        target.unversion(['bla-a'])
 
321
        target.add('bla', 'bla-b')
 
322
        target.commit('bla-b')
 
323
        target_basis = target.basis_tree()
 
324
        target_basis.lock_read()
 
325
        self.addCleanup(target_basis.unlock)
 
326
        foreign.update_workingtree_fileids(wt, target_basis)
 
327
        wt.lock_read()
 
328
        try:
 
329
            self.assertEquals(["TREE_ROOT", "bla-b"], list(wt.inventory))
 
330
        finally:
 
331
            wt.unlock()
 
332
 
 
333
 
 
334
class DummyForeignVcsTests(TestCaseWithTransport):
 
335
    """Very basic test for DummyForeignVcs."""
 
336
 
 
337
    def setUp(self):
 
338
        BzrDirFormat.register_control_format(DummyForeignVcsDirFormat)
 
339
        self.addCleanup(self.unregister)
 
340
        super(DummyForeignVcsTests, self).setUp()
 
341
 
 
342
    def unregister(self):
 
343
        try:
 
344
            BzrDirFormat.unregister_control_format(DummyForeignVcsDirFormat)
 
345
        except ValueError:
 
346
            pass
 
347
 
 
348
    def test_create(self):
 
349
        """Test we can create dummies."""
 
350
        self.make_branch_and_tree("d", format=DummyForeignVcsDirFormat())
 
351
        dir = BzrDir.open("d")
 
352
        self.assertEquals("A Dummy VCS Dir", dir._format.get_format_string())
 
353
        dir.open_repository()
 
354
        dir.open_branch()
 
355
        dir.open_workingtree()
 
356
 
 
357
    def test_sprout(self):
 
358
        """Test we can clone dummies and that the format is not preserved."""
 
359
        self.make_branch_and_tree("d", format=DummyForeignVcsDirFormat())
 
360
        dir = BzrDir.open("d")
 
361
        newdir = dir.sprout("e")
 
362
        self.assertNotEquals("A Dummy VCS Dir", newdir._format.get_format_string())