/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: John Arbash Meinel
  • Date: 2009-06-17 19:08:25 UTC
  • mto: This revision was merged to the branch mainline in revision 4460.
  • Revision ID: john@arbash-meinel.com-20090617190825-ktfk82li57rf2im6
It seems that fetch() no longer returns the number of revisions fetched.
It still does for *some* InterRepository fetch paths, but the generic one does not.
It is also not easy to get it to, since the Source and Sink are the ones
that would know how many keys were transmitted, and they are potentially 'remote'
objects.

This was also only tested to occur as a by-product in a random 'test_commit' test.
I assume if we really wanted the assurance, we would have a per_repo or interrepo
test for it.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_foreign.py
1
 
# Copyright (C) 2008, 2009, 2010 Canonical Ltd
 
1
# Copyright (C) 2008 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
20
20
 
21
21
from bzrlib import (
22
22
    branch,
23
 
    bzrdir,
24
23
    errors,
25
24
    foreign,
26
25
    lockable_files,
27
26
    lockdir,
28
 
    revision,
29
 
    tests,
30
27
    trace,
31
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 (
 
38
    NULL_REVISION,
 
39
    Revision,
 
40
    )
 
41
from bzrlib.tests import (
 
42
    TestCase,
 
43
    TestCaseWithTransport,
 
44
    )
32
45
 
33
46
# This is the dummy foreign revision control system, used 
34
47
# mainly here in the testsuite to test the foreign VCS infrastructure.
74
87
        self.mapping_registry = DummyForeignVcsMappingRegistry()
75
88
        self.mapping_registry.register("v1", DummyForeignVcsMapping(self),
76
89
                                       "Version 1")
77
 
        self.abbreviation = "dummy"
78
90
 
79
91
    def show_foreign_revid(self, foreign_revid):
80
92
        return { "dummy ding": "%s/%s\\%s" % foreign_revid }
81
93
 
82
 
    def serialize_foreign_revid(self, foreign_revid):
83
 
        return "%s|%s|%s" % foreign_revid
84
 
 
85
94
 
86
95
class DummyForeignVcsBranch(branch.BzrBranch6,foreign.ForeignBranch):
87
96
    """A Dummy VCS Branch."""
90
99
        self._format = _format
91
100
        self._base = a_bzrdir.transport.base
92
101
        self._ignore_fallbacks = False
93
 
        self.bzrdir = a_bzrdir
94
102
        foreign.ForeignBranch.__init__(self, 
95
103
            DummyForeignVcsMapping(DummyForeignVcs()))
96
104
        branch.BzrBranch6.__init__(self, _format, _control_files, a_bzrdir, 
104
112
    def is_compatible(source, target):
105
113
        return isinstance(target, DummyForeignVcsBranch)
106
114
 
107
 
    def push(self, overwrite=False, stop_revision=None):
108
 
        raise errors.NoRoundtrippingSupport(self.source, self.target)
109
 
 
110
115
    def lossy_push(self, stop_revision=None):
111
116
        result = branch.BranchPushResult()
112
117
        result.source_branch = self.source
131
136
                    (str(rev.timestamp), str(rev.timezone), 
132
137
                        str(self.target.revno())))
133
138
                parent_revno, parent_revid= self.target.last_revision_info()
134
 
                if parent_revid == revision.NULL_REVISION:
 
139
                if parent_revid == NULL_REVISION:
135
140
                    parent_revids = []
136
141
                else:
137
142
                    parent_revids = [parent_revid]
172
177
        super(DummyForeignVcsBranchFormat, self).__init__()
173
178
        self._matchingbzrdir = DummyForeignVcsDirFormat()
174
179
 
175
 
    def open(self, a_bzrdir, name=None, _found=False):
 
180
    def open(self, a_bzrdir, _found=False):
176
181
        if not _found:
177
182
            raise NotImplementedError
178
183
        try:
179
 
            transport = a_bzrdir.get_branch_transport(None, name=name)
 
184
            transport = a_bzrdir.get_branch_transport(None)
180
185
            control_files = lockable_files.LockableFiles(transport, 'lock',
181
186
                                                         lockdir.LockDir)
182
187
            return DummyForeignVcsBranch(_format=self,
187
192
            raise errors.NotBranchError(path=transport.base)
188
193
 
189
194
 
190
 
class DummyForeignVcsDirFormat(bzrdir.BzrDirMetaFormat1):
 
195
class DummyForeignVcsDirFormat(BzrDirMetaFormat1):
191
196
    """BzrDirFormat for the dummy foreign VCS."""
192
197
 
193
198
    @classmethod
234
239
        return DummyForeignVcsDir(transport, self)
235
240
 
236
241
 
237
 
class DummyForeignVcsDir(bzrdir.BzrDirMeta1):
 
242
class DummyForeignVcsDir(BzrDirMeta1):
238
243
 
239
244
    def __init__(self, _transport, _format):
240
245
        self._format = _format
244
249
        self._control_files = lockable_files.LockableFiles(self.transport,
245
250
            "lock", lockable_files.TransportLock)
246
251
 
247
 
    def open_branch(self, name=None, unsupported=False, ignore_fallbacks=True):
248
 
        if name is not None:
249
 
            raise errors.NoColocatedBranchSupport(self)
 
252
    def open_branch(self, ignore_fallbacks=True):
250
253
        return self._format.get_branch_format().open(self, _found=True)
251
254
 
252
255
    def cloning_metadir(self, stacked=False):
253
256
        """Produce a metadir suitable for cloning with."""
254
 
        return bzrdir.format_registry.make_bzrdir("default")
 
257
        return format_registry.make_bzrdir("default")
255
258
 
256
259
    def sprout(self, url, revision_id=None, force_new_repo=False,
257
260
               recurse='down', possible_transports=None,
265
268
                hardlink=hardlink, stacked=stacked, source_branch=source_branch)
266
269
 
267
270
 
268
 
def register_dummy_foreign_for_test(testcase):
269
 
    bzrdir.BzrDirFormat.register_control_format(DummyForeignVcsDirFormat)
270
 
    testcase.addCleanup(bzrdir.BzrDirFormat.unregister_control_format,
271
 
                        DummyForeignVcsDirFormat)
272
 
    # We need to register the optimiser to make the dummy appears really
273
 
    # different from a regular bzr repository.
274
 
    branch.InterBranch.register_optimiser(InterToDummyVcsBranch)
275
 
    testcase.addCleanup(branch.InterBranch.unregister_optimiser,
276
 
                        InterToDummyVcsBranch)
277
 
 
278
 
 
279
 
class ForeignVcsRegistryTests(tests.TestCase):
 
271
class ForeignVcsRegistryTests(TestCase):
280
272
    """Tests for the ForeignVcsRegistry class."""
281
273
 
282
274
    def test_parse_revision_id_no_dash(self):
297
289
                          reg.parse_revision_id("dummy-v1:some-foreign-revid"))
298
290
 
299
291
 
300
 
class ForeignRevisionTests(tests.TestCase):
 
292
class ForeignRevisionTests(TestCase):
301
293
    """Tests for the ForeignRevision class."""
302
294
 
303
295
    def test_create(self):
309
301
        self.assertEquals(mapp, rev.mapping)
310
302
 
311
303
 
312
 
class WorkingTreeFileUpdateTests(tests.TestCaseWithTransport):
 
304
class WorkingTreeFileUpdateTests(TestCaseWithTransport):
313
305
    """Tests for update_workingtree_fileids()."""
314
306
 
315
307
    def test_update_workingtree(self):
317
309
        self.build_tree_contents([('br1/bla', 'original contents\n')])
318
310
        wt.add('bla', 'bla-a')
319
311
        wt.commit('bla-a')
320
 
        root_id = wt.get_root_id()
321
312
        target = wt.bzrdir.sprout('br2').open_workingtree()
322
313
        target.unversion(['bla-a'])
323
314
        target.add('bla', 'bla-b')
328
319
        foreign.update_workingtree_fileids(wt, target_basis)
329
320
        wt.lock_read()
330
321
        try:
331
 
            self.assertEquals(set([root_id, "bla-b"]), set(wt.inventory))
 
322
            self.assertEquals(["TREE_ROOT", "bla-b"], list(wt.inventory))
332
323
        finally:
333
324
            wt.unlock()
334
325
 
335
326
 
336
 
class DummyForeignVcsTests(tests.TestCaseWithTransport):
 
327
class DummyForeignVcsTests(TestCaseWithTransport):
337
328
    """Very basic test for DummyForeignVcs."""
338
329
 
339
330
    def setUp(self):
 
331
        BzrDirFormat.register_control_format(DummyForeignVcsDirFormat)
 
332
        branch.InterBranch.register_optimiser(InterToDummyVcsBranch)
 
333
        self.addCleanup(self.unregister)
340
334
        super(DummyForeignVcsTests, self).setUp()
341
 
        register_dummy_foreign_for_test(self)
 
335
 
 
336
    def unregister(self):
 
337
        try:
 
338
            BzrDirFormat.unregister_control_format(DummyForeignVcsDirFormat)
 
339
        except ValueError:
 
340
            pass
 
341
        branch.InterBranch.unregister_optimiser(InterToDummyVcsBranch)
342
342
 
343
343
    def test_create(self):
344
344
        """Test we can create dummies."""
345
345
        self.make_branch_and_tree("d", format=DummyForeignVcsDirFormat())
346
 
        dir = bzrdir.BzrDir.open("d")
 
346
        dir = BzrDir.open("d")
347
347
        self.assertEquals("A Dummy VCS Dir", dir._format.get_format_string())
348
348
        dir.open_repository()
349
349
        dir.open_branch()
352
352
    def test_sprout(self):
353
353
        """Test we can clone dummies and that the format is not preserved."""
354
354
        self.make_branch_and_tree("d", format=DummyForeignVcsDirFormat())
355
 
        dir = bzrdir.BzrDir.open("d")
 
355
        dir = BzrDir.open("d")
356
356
        newdir = dir.sprout("e")
357
 
        self.assertNotEquals("A Dummy VCS Dir",
358
 
                             newdir._format.get_format_string())
359
 
 
360
 
    def test_push_not_supported(self):
361
 
        source_tree = self.make_branch_and_tree("source")
362
 
        target_tree = self.make_branch_and_tree("target", 
363
 
            format=DummyForeignVcsDirFormat())
364
 
        self.assertRaises(errors.NoRoundtrippingSupport, 
365
 
            source_tree.branch.push, target_tree.branch)
 
357
        self.assertNotEquals("A Dummy VCS Dir", newdir._format.get_format_string())
366
358
 
367
359
    def test_lossy_push_empty(self):
368
360
        source_tree = self.make_branch_and_tree("source")
369
361
        target_tree = self.make_branch_and_tree("target", 
370
362
            format=DummyForeignVcsDirFormat())
371
363
        pushresult = source_tree.branch.lossy_push(target_tree.branch)
372
 
        self.assertEquals(revision.NULL_REVISION, pushresult.old_revid)
373
 
        self.assertEquals(revision.NULL_REVISION, pushresult.new_revid)
 
364
        self.assertEquals(NULL_REVISION, pushresult.old_revid)
 
365
        self.assertEquals(NULL_REVISION, pushresult.new_revid)
374
366
        self.assertEquals({}, pushresult.revidmap)
375
367
 
376
368
    def test_lossy_push_simple(self):
385
377
            pushresult = source_tree.branch.lossy_push(target_tree.branch)
386
378
        finally:
387
379
            target_tree.branch.unlock()
388
 
        self.assertEquals(revision.NULL_REVISION, pushresult.old_revid)
 
380
        self.assertEquals(NULL_REVISION, pushresult.old_revid)
389
381
        self.assertEquals({revid1:target_tree.branch.last_revision()}, 
390
382
                           pushresult.revidmap)
391
383
        self.assertEquals(pushresult.revidmap[revid1], pushresult.new_revid)