← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_repository.py

  • Committer: Patch Queue Manager
  • Date: 2014-02-12 18:22:22 UTC
  • mfrom: (6589.2.1 trunk)
  • Revision ID: pqm@pqm.ubuntu.com-20140212182222-beouo25gaf1cny76
(vila) The XDG Base Directory Specification uses the XDG_CACHE_HOME,
 not XDG_CACHE_DIR. (Andrew Starr-Bochicchio)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_repository.py
1
 
# Copyright (C) 2006, 2007, 2008, 2009 Canonical Ltd
 
1
# Copyright (C) 2006-2011 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
23
23
"""
24
24
 
25
25
from stat import S_ISDIR
26
 
from StringIO import StringIO
27
26
 
28
27
import bzrlib
29
 
from bzrlib.errors import (NotBranchError,
30
 
                           NoSuchFile,
31
 
                           UnknownFormatError,
32
 
                           UnsupportedFormatError,
33
 
                           )
34
 
from bzrlib import graph
35
 
from bzrlib.branchbuilder import BranchBuilder
 
28
from bzrlib.errors import (
 
29
    UnknownFormatError,
 
30
    UnsupportedFormatError,
 
31
    )
 
32
from bzrlib import (
 
33
    btree_index,
 
34
    symbol_versioning,
 
35
    tests,
 
36
    transport,
 
37
    vf_search,
 
38
    )
36
39
from bzrlib.btree_index import BTreeBuilder, BTreeGraphIndex
37
 
from bzrlib.index import GraphIndex, InMemoryGraphIndex
 
40
from bzrlib.index import GraphIndex
38
41
from bzrlib.repository import RepositoryFormat
39
 
from bzrlib.smart import server
40
42
from bzrlib.tests import (
41
43
    TestCase,
42
44
    TestCaseWithTransport,
43
 
    TestSkipped,
44
 
    test_knit,
45
 
    )
46
 
from bzrlib.transport import (
47
 
    fakenfs,
48
 
    get_transport,
49
 
    )
50
 
from bzrlib.transport.memory import MemoryServer
51
 
from bzrlib.util import bencode
 
45
    )
52
46
from bzrlib import (
53
47
    bzrdir,
 
48
    controldir,
54
49
    errors,
55
50
    inventory,
56
51
    osutils,
57
 
    progress,
58
52
    repository,
59
53
    revision as _mod_revision,
60
 
    symbol_versioning,
61
54
    upgrade,
 
55
    versionedfile,
 
56
    vf_repository,
62
57
    workingtree,
63
58
    )
64
59
from bzrlib.repofmt import (
65
60
    groupcompress_repo,
66
61
    knitrepo,
 
62
    knitpack_repo,
67
63
    pack_repo,
68
 
    weaverepo,
69
64
    )
70
65
 
71
66
 
72
67
class TestDefaultFormat(TestCase):
73
68
 
74
69
    def test_get_set_default_format(self):
75
 
        old_default = bzrdir.format_registry.get('default')
 
70
        old_default = controldir.format_registry.get('default')
76
71
        private_default = old_default().repository_format.__class__
77
 
        old_format = repository.RepositoryFormat.get_default_format()
 
72
        old_format = repository.format_registry.get_default()
78
73
        self.assertTrue(isinstance(old_format, private_default))
79
74
        def make_sample_bzrdir():
80
75
            my_bzrdir = bzrdir.BzrDirMetaFormat1()
81
76
            my_bzrdir.repository_format = SampleRepositoryFormat()
82
77
            return my_bzrdir
83
 
        bzrdir.format_registry.remove('default')
84
 
        bzrdir.format_registry.register('sample', make_sample_bzrdir, '')
85
 
        bzrdir.format_registry.set_default('sample')
 
78
        controldir.format_registry.remove('default')
 
79
        controldir.format_registry.register('sample', make_sample_bzrdir, '')
 
80
        controldir.format_registry.set_default('sample')
86
81
        # creating a repository should now create an instrumented dir.
87
82
        try:
88
83
            # the default branch format is used by the meta dir format
91
86
            result = dir.create_repository()
92
87
            self.assertEqual(result, 'A bzr repository dir')
93
88
        finally:
94
 
            bzrdir.format_registry.remove('default')
95
 
            bzrdir.format_registry.remove('sample')
96
 
            bzrdir.format_registry.register('default', old_default, '')
97
 
        self.assertIsInstance(repository.RepositoryFormat.get_default_format(),
 
89
            controldir.format_registry.remove('default')
 
90
            controldir.format_registry.remove('sample')
 
91
            controldir.format_registry.register('default', old_default, '')
 
92
        self.assertIsInstance(repository.format_registry.get_default(),
98
93
                              old_format.__class__)
99
94
 
100
95
 
101
 
class SampleRepositoryFormat(repository.RepositoryFormat):
 
96
class SampleRepositoryFormat(repository.RepositoryFormatMetaDir):
102
97
    """A sample format
103
98
 
104
99
    this format is initializable, unsupported to aid in testing the
105
100
    open and open(unsupported=True) routines.
106
101
    """
107
102
 
108
 
    def get_format_string(self):
 
103
    @classmethod
 
104
    def get_format_string(cls):
109
105
        """See RepositoryFormat.get_format_string()."""
110
106
        return "Sample .bzr repository format."
111
107
 
122
118
        return "opened repository."
123
119
 
124
120
 
 
121
class SampleExtraRepositoryFormat(repository.RepositoryFormat):
 
122
    """A sample format that can not be used in a metadir
 
123
 
 
124
    """
 
125
 
 
126
    def get_format_string(self):
 
127
        raise NotImplementedError
 
128
 
 
129
 
125
130
class TestRepositoryFormat(TestCaseWithTransport):
126
131
    """Tests for the Repository format detection used by the bzr meta dir facility.BzrBranchFormat facility."""
127
132
 
133
138
        def check_format(format, url):
134
139
            dir = format._matchingbzrdir.initialize(url)
135
140
            format.initialize(dir)
136
 
            t = get_transport(url)
137
 
            found_format = repository.RepositoryFormat.find_format(dir)
138
 
            self.failUnless(isinstance(found_format, format.__class__))
139
 
        check_format(weaverepo.RepositoryFormat7(), "bar")
 
141
            t = transport.get_transport_from_path(url)
 
142
            found_format = repository.RepositoryFormatMetaDir.find_format(dir)
 
143
            self.assertIsInstance(found_format, format.__class__)
 
144
        check_format(repository.format_registry.get_default(), "bar")
140
145
 
141
146
    def test_find_format_no_repository(self):
142
147
        dir = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
143
148
        self.assertRaises(errors.NoRepositoryPresent,
144
 
                          repository.RepositoryFormat.find_format,
 
149
                          repository.RepositoryFormatMetaDir.find_format,
145
150
                          dir)
146
151
 
 
152
    def test_from_string(self):
 
153
        self.assertIsInstance(
 
154
            SampleRepositoryFormat.from_string(
 
155
                "Sample .bzr repository format."),
 
156
            SampleRepositoryFormat)
 
157
        self.assertRaises(AssertionError,
 
158
            SampleRepositoryFormat.from_string,
 
159
                "Different .bzr repository format.")
 
160
 
147
161
    def test_find_format_unknown_format(self):
148
162
        dir = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
149
163
        SampleRepositoryFormat().initialize(dir)
150
164
        self.assertRaises(UnknownFormatError,
151
 
                          repository.RepositoryFormat.find_format,
 
165
                          repository.RepositoryFormatMetaDir.find_format,
152
166
                          dir)
153
167
 
 
168
    def test_find_format_with_features(self):
 
169
        tree = self.make_branch_and_tree('.', format='2a')
 
170
        tree.branch.repository.update_feature_flags({"name": "necessity"})
 
171
        found_format = repository.RepositoryFormatMetaDir.find_format(tree.bzrdir)
 
172
        self.assertIsInstance(found_format, repository.RepositoryFormatMetaDir)
 
173
        self.assertEquals(found_format.features.get("name"), "necessity")
 
174
        self.assertRaises(errors.MissingFeature, found_format.check_support_status,
 
175
            True)
 
176
        self.addCleanup(repository.RepositoryFormatMetaDir.unregister_feature,
 
177
            "name")
 
178
        repository.RepositoryFormatMetaDir.register_feature("name")
 
179
        found_format.check_support_status(True)
 
180
 
 
181
 
 
182
class TestRepositoryFormatRegistry(TestCase):
 
183
 
 
184
    def setUp(self):
 
185
        super(TestRepositoryFormatRegistry, self).setUp()
 
186
        self.registry = repository.RepositoryFormatRegistry()
 
187
 
154
188
    def test_register_unregister_format(self):
155
189
        format = SampleRepositoryFormat()
156
 
        # make a control dir
157
 
        dir = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
158
 
        # make a repo
159
 
        format.initialize(dir)
160
 
        # register a format for it.
161
 
        repository.RepositoryFormat.register_format(format)
162
 
        # which repository.Open will refuse (not supported)
163
 
        self.assertRaises(UnsupportedFormatError, repository.Repository.open, self.get_url())
164
 
        # but open(unsupported) will work
165
 
        self.assertEqual(format.open(dir), "opened repository.")
166
 
        # unregister the format
167
 
        repository.RepositoryFormat.unregister_format(format)
168
 
 
169
 
 
170
 
class TestFormat6(TestCaseWithTransport):
171
 
 
172
 
    def test_attribute__fetch_order(self):
173
 
        """Weaves need topological data insertion."""
174
 
        control = bzrdir.BzrDirFormat6().initialize(self.get_url())
175
 
        repo = weaverepo.RepositoryFormat6().initialize(control)
176
 
        self.assertEqual('topological', repo._format._fetch_order)
177
 
 
178
 
    def test_attribute__fetch_uses_deltas(self):
179
 
        """Weaves do not reuse deltas."""
180
 
        control = bzrdir.BzrDirFormat6().initialize(self.get_url())
181
 
        repo = weaverepo.RepositoryFormat6().initialize(control)
182
 
        self.assertEqual(False, repo._format._fetch_uses_deltas)
183
 
 
184
 
    def test_attribute__fetch_reconcile(self):
185
 
        """Weave repositories need a reconcile after fetch."""
186
 
        control = bzrdir.BzrDirFormat6().initialize(self.get_url())
187
 
        repo = weaverepo.RepositoryFormat6().initialize(control)
188
 
        self.assertEqual(True, repo._format._fetch_reconcile)
189
 
 
190
 
    def test_no_ancestry_weave(self):
191
 
        control = bzrdir.BzrDirFormat6().initialize(self.get_url())
192
 
        repo = weaverepo.RepositoryFormat6().initialize(control)
193
 
        # We no longer need to create the ancestry.weave file
194
 
        # since it is *never* used.
195
 
        self.assertRaises(NoSuchFile,
196
 
                          control.transport.get,
197
 
                          'ancestry.weave')
198
 
 
199
 
    def test_supports_external_lookups(self):
200
 
        control = bzrdir.BzrDirFormat6().initialize(self.get_url())
201
 
        repo = weaverepo.RepositoryFormat6().initialize(control)
202
 
        self.assertFalse(repo._format.supports_external_lookups)
203
 
 
204
 
 
205
 
class TestFormat7(TestCaseWithTransport):
206
 
 
207
 
    def test_attribute__fetch_order(self):
208
 
        """Weaves need topological data insertion."""
209
 
        control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
210
 
        repo = weaverepo.RepositoryFormat7().initialize(control)
211
 
        self.assertEqual('topological', repo._format._fetch_order)
212
 
 
213
 
    def test_attribute__fetch_uses_deltas(self):
214
 
        """Weaves do not reuse deltas."""
215
 
        control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
216
 
        repo = weaverepo.RepositoryFormat7().initialize(control)
217
 
        self.assertEqual(False, repo._format._fetch_uses_deltas)
218
 
 
219
 
    def test_attribute__fetch_reconcile(self):
220
 
        """Weave repositories need a reconcile after fetch."""
221
 
        control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
222
 
        repo = weaverepo.RepositoryFormat7().initialize(control)
223
 
        self.assertEqual(True, repo._format._fetch_reconcile)
224
 
 
225
 
    def test_disk_layout(self):
226
 
        control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
227
 
        repo = weaverepo.RepositoryFormat7().initialize(control)
228
 
        # in case of side effects of locking.
229
 
        repo.lock_write()
230
 
        repo.unlock()
231
 
        # we want:
232
 
        # format 'Bazaar-NG Repository format 7'
233
 
        # lock ''
234
 
        # inventory.weave == empty_weave
235
 
        # empty revision-store directory
236
 
        # empty weaves directory
237
 
        t = control.get_repository_transport(None)
238
 
        self.assertEqualDiff('Bazaar-NG Repository format 7',
239
 
                             t.get('format').read())
240
 
        self.assertTrue(S_ISDIR(t.stat('revision-store').st_mode))
241
 
        self.assertTrue(S_ISDIR(t.stat('weaves').st_mode))
242
 
        self.assertEqualDiff('# bzr weave file v5\n'
243
 
                             'w\n'
244
 
                             'W\n',
245
 
                             t.get('inventory.weave').read())
246
 
        # Creating a file with id Foo:Bar results in a non-escaped file name on
247
 
        # disk.
248
 
        control.create_branch()
249
 
        tree = control.create_workingtree()
250
 
        tree.add(['foo'], ['Foo:Bar'], ['file'])
251
 
        tree.put_file_bytes_non_atomic('Foo:Bar', 'content\n')
252
 
        tree.commit('first post', rev_id='first')
253
 
        self.assertEqualDiff(
254
 
            '# bzr weave file v5\n'
255
 
            'i\n'
256
 
            '1 7fe70820e08a1aac0ef224d9c66ab66831cc4ab1\n'
257
 
            'n first\n'
258
 
            '\n'
259
 
            'w\n'
260
 
            '{ 0\n'
261
 
            '. content\n'
262
 
            '}\n'
263
 
            'W\n',
264
 
            t.get('weaves/74/Foo%3ABar.weave').read())
265
 
 
266
 
    def test_shared_disk_layout(self):
267
 
        control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
268
 
        repo = weaverepo.RepositoryFormat7().initialize(control, shared=True)
269
 
        # we want:
270
 
        # format 'Bazaar-NG Repository format 7'
271
 
        # inventory.weave == empty_weave
272
 
        # empty revision-store directory
273
 
        # empty weaves directory
274
 
        # a 'shared-storage' marker file.
275
 
        # lock is not present when unlocked
276
 
        t = control.get_repository_transport(None)
277
 
        self.assertEqualDiff('Bazaar-NG Repository format 7',
278
 
                             t.get('format').read())
279
 
        self.assertEqualDiff('', t.get('shared-storage').read())
280
 
        self.assertTrue(S_ISDIR(t.stat('revision-store').st_mode))
281
 
        self.assertTrue(S_ISDIR(t.stat('weaves').st_mode))
282
 
        self.assertEqualDiff('# bzr weave file v5\n'
283
 
                             'w\n'
284
 
                             'W\n',
285
 
                             t.get('inventory.weave').read())
286
 
        self.assertFalse(t.has('branch-lock'))
287
 
 
288
 
    def test_creates_lockdir(self):
289
 
        """Make sure it appears to be controlled by a LockDir existence"""
290
 
        control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
291
 
        repo = weaverepo.RepositoryFormat7().initialize(control, shared=True)
292
 
        t = control.get_repository_transport(None)
293
 
        # TODO: Should check there is a 'lock' toplevel directory,
294
 
        # regardless of contents
295
 
        self.assertFalse(t.has('lock/held/info'))
296
 
        repo.lock_write()
297
 
        try:
298
 
            self.assertTrue(t.has('lock/held/info'))
299
 
        finally:
300
 
            # unlock so we don't get a warning about failing to do so
301
 
            repo.unlock()
302
 
 
303
 
    def test_uses_lockdir(self):
304
 
        """repo format 7 actually locks on lockdir"""
305
 
        base_url = self.get_url()
306
 
        control = bzrdir.BzrDirMetaFormat1().initialize(base_url)
307
 
        repo = weaverepo.RepositoryFormat7().initialize(control, shared=True)
308
 
        t = control.get_repository_transport(None)
309
 
        repo.lock_write()
310
 
        repo.unlock()
311
 
        del repo
312
 
        # make sure the same lock is created by opening it
313
 
        repo = repository.Repository.open(base_url)
314
 
        repo.lock_write()
315
 
        self.assertTrue(t.has('lock/held/info'))
316
 
        repo.unlock()
317
 
        self.assertFalse(t.has('lock/held/info'))
318
 
 
319
 
    def test_shared_no_tree_disk_layout(self):
320
 
        control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
321
 
        repo = weaverepo.RepositoryFormat7().initialize(control, shared=True)
322
 
        repo.set_make_working_trees(False)
323
 
        # we want:
324
 
        # format 'Bazaar-NG Repository format 7'
325
 
        # lock ''
326
 
        # inventory.weave == empty_weave
327
 
        # empty revision-store directory
328
 
        # empty weaves directory
329
 
        # a 'shared-storage' marker file.
330
 
        t = control.get_repository_transport(None)
331
 
        self.assertEqualDiff('Bazaar-NG Repository format 7',
332
 
                             t.get('format').read())
333
 
        ## self.assertEqualDiff('', t.get('lock').read())
334
 
        self.assertEqualDiff('', t.get('shared-storage').read())
335
 
        self.assertEqualDiff('', t.get('no-working-trees').read())
336
 
        repo.set_make_working_trees(True)
337
 
        self.assertFalse(t.has('no-working-trees'))
338
 
        self.assertTrue(S_ISDIR(t.stat('revision-store').st_mode))
339
 
        self.assertTrue(S_ISDIR(t.stat('weaves').st_mode))
340
 
        self.assertEqualDiff('# bzr weave file v5\n'
341
 
                             'w\n'
342
 
                             'W\n',
343
 
                             t.get('inventory.weave').read())
344
 
 
345
 
    def test_supports_external_lookups(self):
346
 
        control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
347
 
        repo = weaverepo.RepositoryFormat7().initialize(control)
348
 
        self.assertFalse(repo._format.supports_external_lookups)
 
190
        self.registry.register(format)
 
191
        self.assertEquals(format, self.registry.get("Sample .bzr repository format."))
 
192
        self.registry.remove(format)
 
193
        self.assertRaises(KeyError, self.registry.get, "Sample .bzr repository format.")
 
194
 
 
195
    def test_get_all(self):
 
196
        format = SampleRepositoryFormat()
 
197
        self.assertEquals([], self.registry._get_all())
 
198
        self.registry.register(format)
 
199
        self.assertEquals([format], self.registry._get_all())
 
200
 
 
201
    def test_register_extra(self):
 
202
        format = SampleExtraRepositoryFormat()
 
203
        self.assertEquals([], self.registry._get_all())
 
204
        self.registry.register_extra(format)
 
205
        self.assertEquals([format], self.registry._get_all())
 
206
 
 
207
    def test_register_extra_lazy(self):
 
208
        self.assertEquals([], self.registry._get_all())
 
209
        self.registry.register_extra_lazy("bzrlib.tests.test_repository",
 
210
            "SampleExtraRepositoryFormat")
 
211
        formats = self.registry._get_all()
 
212
        self.assertEquals(1, len(formats))
 
213
        self.assertIsInstance(formats[0], SampleExtraRepositoryFormat)
349
214
 
350
215
 
351
216
class TestFormatKnit1(TestCaseWithTransport):
353
218
    def test_attribute__fetch_order(self):
354
219
        """Knits need topological data insertion."""
355
220
        repo = self.make_repository('.',
356
 
                format=bzrdir.format_registry.get('knit')())
 
221
                format=controldir.format_registry.get('knit')())
357
222
        self.assertEqual('topological', repo._format._fetch_order)
358
223
 
359
224
    def test_attribute__fetch_uses_deltas(self):
360
225
        """Knits reuse deltas."""
361
226
        repo = self.make_repository('.',
362
 
                format=bzrdir.format_registry.get('knit')())
 
227
                format=controldir.format_registry.get('knit')())
363
228
        self.assertEqual(True, repo._format._fetch_uses_deltas)
364
229
 
365
230
    def test_disk_layout(self):
451
316
        is valid when the api is not being abused.
452
317
        """
453
318
        repo = self.make_repository('.',
454
 
                format=bzrdir.format_registry.get('knit')())
 
319
                format=controldir.format_registry.get('knit')())
455
320
        inv_xml = '<inventory format="5">\n</inventory>\n'
456
 
        inv = repo.deserialise_inventory('test-rev-id', inv_xml)
 
321
        inv = repo._deserialise_inventory('test-rev-id', inv_xml)
457
322
        self.assertEqual('test-rev-id', inv.root.revision)
458
323
 
459
324
    def test_deserialise_uses_global_revision_id(self):
460
325
        """If it is set, then we re-use the global revision id"""
461
326
        repo = self.make_repository('.',
462
 
                format=bzrdir.format_registry.get('knit')())
 
327
                format=controldir.format_registry.get('knit')())
463
328
        inv_xml = ('<inventory format="5" revision_id="other-rev-id">\n'
464
329
                   '</inventory>\n')
465
330
        # Arguably, the deserialise_inventory should detect a mismatch, and
466
331
        # raise an error, rather than silently using one revision_id over the
467
332
        # other.
468
 
        self.assertRaises(AssertionError, repo.deserialise_inventory,
 
333
        self.assertRaises(AssertionError, repo._deserialise_inventory,
469
334
            'test-rev-id', inv_xml)
470
 
        inv = repo.deserialise_inventory('other-rev-id', inv_xml)
 
335
        inv = repo._deserialise_inventory('other-rev-id', inv_xml)
471
336
        self.assertEqual('other-rev-id', inv.root.revision)
472
337
 
473
338
    def test_supports_external_lookups(self):
474
339
        repo = self.make_repository('.',
475
 
                format=bzrdir.format_registry.get('knit')())
 
340
                format=controldir.format_registry.get('knit')())
476
341
        self.assertFalse(repo._format.supports_external_lookups)
477
342
 
478
343
 
483
348
    _serializer = None
484
349
 
485
350
    def supports_rich_root(self):
 
351
        if self._format is not None:
 
352
            return self._format.rich_root_data
486
353
        return False
487
354
 
488
355
    def get_graph(self):
517
384
        # classes do not barf inappropriately when a surprising repository type
518
385
        # is handed to them.
519
386
        dummy_a = DummyRepository()
 
387
        dummy_a._format = RepositoryFormat()
 
388
        dummy_a._format.supports_full_versioned_files = True
520
389
        dummy_b = DummyRepository()
 
390
        dummy_b._format = RepositoryFormat()
 
391
        dummy_b._format.supports_full_versioned_files = True
521
392
        self.assertGetsDefaultInterRepository(dummy_a, dummy_b)
522
393
 
523
394
    def assertGetsDefaultInterRepository(self, repo_a, repo_b):
527
398
        no actual sane default in the presence of incompatible data models.
528
399
        """
529
400
        inter_repo = repository.InterRepository.get(repo_a, repo_b)
530
 
        self.assertEqual(repository.InterSameDataRepository,
 
401
        self.assertEqual(vf_repository.InterSameDataRepository,
531
402
                         inter_repo.__class__)
532
403
        self.assertEqual(repo_a, inter_repo.source)
533
404
        self.assertEqual(repo_b, inter_repo.target)
539
410
        # pair that it returns true on for the is_compatible static method
540
411
        # check
541
412
        dummy_a = DummyRepository()
 
413
        dummy_a._format = RepositoryFormat()
542
414
        dummy_b = DummyRepository()
 
415
        dummy_b._format = RepositoryFormat()
543
416
        repo = self.make_repository('.')
544
417
        # hack dummies to look like repo somewhat.
545
418
        dummy_a._serializer = repo._serializer
 
419
        dummy_a._format.supports_tree_reference = repo._format.supports_tree_reference
 
420
        dummy_a._format.rich_root_data = repo._format.rich_root_data
 
421
        dummy_a._format.supports_full_versioned_files = repo._format.supports_full_versioned_files
546
422
        dummy_b._serializer = repo._serializer
 
423
        dummy_b._format.supports_tree_reference = repo._format.supports_tree_reference
 
424
        dummy_b._format.rich_root_data = repo._format.rich_root_data
 
425
        dummy_b._format.supports_full_versioned_files = repo._format.supports_full_versioned_files
547
426
        repository.InterRepository.register_optimiser(InterDummy)
548
427
        try:
549
428
            # we should get the default for something InterDummy returns False
562
441
        self.assertGetsDefaultInterRepository(dummy_a, dummy_b)
563
442
 
564
443
 
565
 
class TestInterWeaveRepo(TestCaseWithTransport):
566
 
 
567
 
    def test_is_compatible_and_registered(self):
568
 
        # InterWeaveRepo is compatible when either side
569
 
        # is a format 5/6/7 branch
570
 
        from bzrlib.repofmt import knitrepo, weaverepo
571
 
        formats = [weaverepo.RepositoryFormat5(),
572
 
                   weaverepo.RepositoryFormat6(),
573
 
                   weaverepo.RepositoryFormat7()]
574
 
        incompatible_formats = [weaverepo.RepositoryFormat4(),
575
 
                                knitrepo.RepositoryFormatKnit1(),
576
 
                                ]
577
 
        repo_a = self.make_repository('a')
578
 
        repo_b = self.make_repository('b')
579
 
        is_compatible = repository.InterWeaveRepo.is_compatible
580
 
        for source in incompatible_formats:
581
 
            # force incompatible left then right
582
 
            repo_a._format = source
583
 
            repo_b._format = formats[0]
584
 
            self.assertFalse(is_compatible(repo_a, repo_b))
585
 
            self.assertFalse(is_compatible(repo_b, repo_a))
586
 
        for source in formats:
587
 
            repo_a._format = source
588
 
            for target in formats:
589
 
                repo_b._format = target
590
 
                self.assertTrue(is_compatible(repo_a, repo_b))
591
 
        self.assertEqual(repository.InterWeaveRepo,
592
 
                         repository.InterRepository.get(repo_a,
593
 
                                                        repo_b).__class__)
 
444
class TestRepositoryFormat1(knitrepo.RepositoryFormatKnit1):
 
445
 
 
446
    @classmethod
 
447
    def get_format_string(cls):
 
448
        return "Test Format 1"
 
449
 
 
450
 
 
451
class TestRepositoryFormat2(knitrepo.RepositoryFormatKnit1):
 
452
 
 
453
    @classmethod
 
454
    def get_format_string(cls):
 
455
        return "Test Format 2"
594
456
 
595
457
 
596
458
class TestRepositoryConverter(TestCaseWithTransport):
597
459
 
598
460
    def test_convert_empty(self):
599
 
        t = get_transport(self.get_url('.'))
 
461
        source_format = TestRepositoryFormat1()
 
462
        target_format = TestRepositoryFormat2()
 
463
        repository.format_registry.register(source_format)
 
464
        self.addCleanup(repository.format_registry.remove,
 
465
            source_format)
 
466
        repository.format_registry.register(target_format)
 
467
        self.addCleanup(repository.format_registry.remove,
 
468
            target_format)
 
469
        t = self.get_transport()
600
470
        t.mkdir('repository')
601
471
        repo_dir = bzrdir.BzrDirMetaFormat1().initialize('repository')
602
 
        repo = weaverepo.RepositoryFormat7().initialize(repo_dir)
603
 
        target_format = knitrepo.RepositoryFormatKnit1()
 
472
        repo = TestRepositoryFormat1().initialize(repo_dir)
604
473
        converter = repository.CopyConverter(target_format)
605
474
        pb = bzrlib.ui.ui_factory.nested_progress_bar()
606
475
        try:
611
480
        self.assertTrue(isinstance(target_format, repo._format.__class__))
612
481
 
613
482
 
614
 
class TestMisc(TestCase):
615
 
 
616
 
    def test_unescape_xml(self):
617
 
        """We get some kind of error when malformed entities are passed"""
618
 
        self.assertRaises(KeyError, repository._unescape_xml, 'foo&bar;')
619
 
 
620
 
 
621
483
class TestRepositoryFormatKnit3(TestCaseWithTransport):
622
484
 
623
485
    def test_attribute__fetch_order(self):
644
506
        revision_tree.lock_read()
645
507
        try:
646
508
            self.assertRaises(errors.NoSuchFile, revision_tree.get_file_lines,
647
 
                revision_tree.inventory.root.file_id)
 
509
                revision_tree.get_root_id())
648
510
        finally:
649
511
            revision_tree.unlock()
650
512
        format = bzrdir.BzrDirMetaFormat1()
654
516
        revision_tree = tree.branch.repository.revision_tree('dull')
655
517
        revision_tree.lock_read()
656
518
        try:
657
 
            revision_tree.get_file_lines(revision_tree.inventory.root.file_id)
 
519
            revision_tree.get_file_lines(revision_tree.get_root_id())
658
520
        finally:
659
521
            revision_tree.unlock()
660
522
        tree.commit("Another dull commit", rev_id='dull2')
661
523
        revision_tree = tree.branch.repository.revision_tree('dull2')
662
524
        revision_tree.lock_read()
663
525
        self.addCleanup(revision_tree.unlock)
664
 
        self.assertEqual('dull', revision_tree.inventory.root.revision)
 
526
        self.assertEqual('dull',
 
527
                revision_tree.get_file_revision(revision_tree.get_root_id()))
665
528
 
666
529
    def test_supports_external_lookups(self):
667
530
        format = bzrdir.BzrDirMetaFormat1()
670
533
        self.assertFalse(repo._format.supports_external_lookups)
671
534
 
672
535
 
673
 
class TestDevelopment6(TestCaseWithTransport):
 
536
class Test2a(tests.TestCaseWithMemoryTransport):
 
537
 
 
538
    def test_chk_bytes_uses_custom_btree_parser(self):
 
539
        mt = self.make_branch_and_memory_tree('test', format='2a')
 
540
        mt.lock_write()
 
541
        self.addCleanup(mt.unlock)
 
542
        mt.add([''], ['root-id'])
 
543
        mt.commit('first')
 
544
        index = mt.branch.repository.chk_bytes._index._graph_index._indices[0]
 
545
        self.assertEqual(btree_index._gcchk_factory, index._leaf_factory)
 
546
        # It should also work if we re-open the repo
 
547
        repo = mt.branch.repository.bzrdir.open_repository()
 
548
        repo.lock_read()
 
549
        self.addCleanup(repo.unlock)
 
550
        index = repo.chk_bytes._index._graph_index._indices[0]
 
551
        self.assertEqual(btree_index._gcchk_factory, index._leaf_factory)
 
552
 
 
553
    def test_fetch_combines_groups(self):
 
554
        builder = self.make_branch_builder('source', format='2a')
 
555
        builder.start_series()
 
556
        builder.build_snapshot('1', None, [
 
557
            ('add', ('', 'root-id', 'directory', '')),
 
558
            ('add', ('file', 'file-id', 'file', 'content\n'))])
 
559
        builder.build_snapshot('2', ['1'], [
 
560
            ('modify', ('file-id', 'content-2\n'))])
 
561
        builder.finish_series()
 
562
        source = builder.get_branch()
 
563
        target = self.make_repository('target', format='2a')
 
564
        target.fetch(source.repository)
 
565
        target.lock_read()
 
566
        self.addCleanup(target.unlock)
 
567
        details = target.texts._index.get_build_details(
 
568
            [('file-id', '1',), ('file-id', '2',)])
 
569
        file_1_details = details[('file-id', '1')]
 
570
        file_2_details = details[('file-id', '2')]
 
571
        # The index, and what to read off disk, should be the same for both
 
572
        # versions of the file.
 
573
        self.assertEqual(file_1_details[0][:3], file_2_details[0][:3])
 
574
 
 
575
    def test_fetch_combines_groups(self):
 
576
        builder = self.make_branch_builder('source', format='2a')
 
577
        builder.start_series()
 
578
        builder.build_snapshot('1', None, [
 
579
            ('add', ('', 'root-id', 'directory', '')),
 
580
            ('add', ('file', 'file-id', 'file', 'content\n'))])
 
581
        builder.build_snapshot('2', ['1'], [
 
582
            ('modify', ('file-id', 'content-2\n'))])
 
583
        builder.finish_series()
 
584
        source = builder.get_branch()
 
585
        target = self.make_repository('target', format='2a')
 
586
        target.fetch(source.repository)
 
587
        target.lock_read()
 
588
        self.addCleanup(target.unlock)
 
589
        details = target.texts._index.get_build_details(
 
590
            [('file-id', '1',), ('file-id', '2',)])
 
591
        file_1_details = details[('file-id', '1')]
 
592
        file_2_details = details[('file-id', '2')]
 
593
        # The index, and what to read off disk, should be the same for both
 
594
        # versions of the file.
 
595
        self.assertEqual(file_1_details[0][:3], file_2_details[0][:3])
 
596
 
 
597
    def test_fetch_combines_groups(self):
 
598
        builder = self.make_branch_builder('source', format='2a')
 
599
        builder.start_series()
 
600
        builder.build_snapshot('1', None, [
 
601
            ('add', ('', 'root-id', 'directory', '')),
 
602
            ('add', ('file', 'file-id', 'file', 'content\n'))])
 
603
        builder.build_snapshot('2', ['1'], [
 
604
            ('modify', ('file-id', 'content-2\n'))])
 
605
        builder.finish_series()
 
606
        source = builder.get_branch()
 
607
        target = self.make_repository('target', format='2a')
 
608
        target.fetch(source.repository)
 
609
        target.lock_read()
 
610
        self.addCleanup(target.unlock)
 
611
        details = target.texts._index.get_build_details(
 
612
            [('file-id', '1',), ('file-id', '2',)])
 
613
        file_1_details = details[('file-id', '1')]
 
614
        file_2_details = details[('file-id', '2')]
 
615
        # The index, and what to read off disk, should be the same for both
 
616
        # versions of the file.
 
617
        self.assertEqual(file_1_details[0][:3], file_2_details[0][:3])
 
618
 
 
619
    def test_format_pack_compresses_True(self):
 
620
        repo = self.make_repository('repo', format='2a')
 
621
        self.assertTrue(repo._format.pack_compresses)
674
622
 
675
623
    def test_inventories_use_chk_map_with_parent_base_dict(self):
676
 
        tree = self.make_branch_and_tree('repo', format="development6-rich-root")
 
624
        tree = self.make_branch_and_memory_tree('repo', format="2a")
 
625
        tree.lock_write()
 
626
        tree.add([''], ['TREE_ROOT'])
677
627
        revid = tree.commit("foo")
 
628
        tree.unlock()
678
629
        tree.lock_read()
679
630
        self.addCleanup(tree.unlock)
680
631
        inv = tree.branch.repository.get_inventory(revid)
685
636
        self.assertEqual(65536,
686
637
            inv.parent_id_basename_to_file_id._root_node.maximum_size)
687
638
 
688
 
 
689
 
class TestDevelopment6FindRevisionOutsideSet(TestCaseWithTransport):
690
 
    """Tests for _find_revision_outside_set."""
 
639
    def test_autopack_unchanged_chk_nodes(self):
 
640
        # at 20 unchanged commits, chk pages are packed that are split into
 
641
        # two groups such that the new pack being made doesn't have all its
 
642
        # pages in the source packs (though they are in the repository).
 
643
        # Use a memory backed repository, we don't need to hit disk for this
 
644
        tree = self.make_branch_and_memory_tree('tree', format='2a')
 
645
        tree.lock_write()
 
646
        self.addCleanup(tree.unlock)
 
647
        tree.add([''], ['TREE_ROOT'])
 
648
        for pos in range(20):
 
649
            tree.commit(str(pos))
 
650
 
 
651
    def test_pack_with_hint(self):
 
652
        tree = self.make_branch_and_memory_tree('tree', format='2a')
 
653
        tree.lock_write()
 
654
        self.addCleanup(tree.unlock)
 
655
        tree.add([''], ['TREE_ROOT'])
 
656
        # 1 commit to leave untouched
 
657
        tree.commit('1')
 
658
        to_keep = tree.branch.repository._pack_collection.names()
 
659
        # 2 to combine
 
660
        tree.commit('2')
 
661
        tree.commit('3')
 
662
        all = tree.branch.repository._pack_collection.names()
 
663
        combine = list(set(all) - set(to_keep))
 
664
        self.assertLength(3, all)
 
665
        self.assertLength(2, combine)
 
666
        tree.branch.repository.pack(hint=combine)
 
667
        final = tree.branch.repository._pack_collection.names()
 
668
        self.assertLength(2, final)
 
669
        self.assertFalse(combine[0] in final)
 
670
        self.assertFalse(combine[1] in final)
 
671
        self.assertSubset(to_keep, final)
 
672
 
 
673
    def test_stream_source_to_gc(self):
 
674
        source = self.make_repository('source', format='2a')
 
675
        target = self.make_repository('target', format='2a')
 
676
        stream = source._get_source(target._format)
 
677
        self.assertIsInstance(stream, groupcompress_repo.GroupCHKStreamSource)
 
678
 
 
679
    def test_stream_source_to_non_gc(self):
 
680
        source = self.make_repository('source', format='2a')
 
681
        target = self.make_repository('target', format='rich-root-pack')
 
682
        stream = source._get_source(target._format)
 
683
        # We don't want the child GroupCHKStreamSource
 
684
        self.assertIs(type(stream), vf_repository.StreamSource)
 
685
 
 
686
    def test_get_stream_for_missing_keys_includes_all_chk_refs(self):
 
687
        source_builder = self.make_branch_builder('source',
 
688
                            format='2a')
 
689
        # We have to build a fairly large tree, so that we are sure the chk
 
690
        # pages will have split into multiple pages.
 
691
        entries = [('add', ('', 'a-root-id', 'directory', None))]
 
692
        for i in 'abcdefghijklmnopqrstuvwxyz123456789':
 
693
            for j in 'abcdefghijklmnopqrstuvwxyz123456789':
 
694
                fname = i + j
 
695
                fid = fname + '-id'
 
696
                content = 'content for %s\n' % (fname,)
 
697
                entries.append(('add', (fname, fid, 'file', content)))
 
698
        source_builder.start_series()
 
699
        source_builder.build_snapshot('rev-1', None, entries)
 
700
        # Now change a few of them, so we get a few new pages for the second
 
701
        # revision
 
702
        source_builder.build_snapshot('rev-2', ['rev-1'], [
 
703
            ('modify', ('aa-id', 'new content for aa-id\n')),
 
704
            ('modify', ('cc-id', 'new content for cc-id\n')),
 
705
            ('modify', ('zz-id', 'new content for zz-id\n')),
 
706
            ])
 
707
        source_builder.finish_series()
 
708
        source_branch = source_builder.get_branch()
 
709
        source_branch.lock_read()
 
710
        self.addCleanup(source_branch.unlock)
 
711
        target = self.make_repository('target', format='2a')
 
712
        source = source_branch.repository._get_source(target._format)
 
713
        self.assertIsInstance(source, groupcompress_repo.GroupCHKStreamSource)
 
714
 
 
715
        # On a regular pass, getting the inventories and chk pages for rev-2
 
716
        # would only get the newly created chk pages
 
717
        search = vf_search.SearchResult(set(['rev-2']), set(['rev-1']), 1,
 
718
                                    set(['rev-2']))
 
719
        simple_chk_records = []
 
720
        for vf_name, substream in source.get_stream(search):
 
721
            if vf_name == 'chk_bytes':
 
722
                for record in substream:
 
723
                    simple_chk_records.append(record.key)
 
724
            else:
 
725
                for _ in substream:
 
726
                    continue
 
727
        # 3 pages, the root (InternalNode), + 2 pages which actually changed
 
728
        self.assertEqual([('sha1:91481f539e802c76542ea5e4c83ad416bf219f73',),
 
729
                          ('sha1:4ff91971043668583985aec83f4f0ab10a907d3f',),
 
730
                          ('sha1:81e7324507c5ca132eedaf2d8414ee4bb2226187',),
 
731
                          ('sha1:b101b7da280596c71a4540e9a1eeba8045985ee0',)],
 
732
                         simple_chk_records)
 
733
        # Now, when we do a similar call using 'get_stream_for_missing_keys'
 
734
        # we should get a much larger set of pages.
 
735
        missing = [('inventories', 'rev-2')]
 
736
        full_chk_records = []
 
737
        for vf_name, substream in source.get_stream_for_missing_keys(missing):
 
738
            if vf_name == 'inventories':
 
739
                for record in substream:
 
740
                    self.assertEqual(('rev-2',), record.key)
 
741
            elif vf_name == 'chk_bytes':
 
742
                for record in substream:
 
743
                    full_chk_records.append(record.key)
 
744
            else:
 
745
                self.fail('Should not be getting a stream of %s' % (vf_name,))
 
746
        # We have 257 records now. This is because we have 1 root page, and 256
 
747
        # leaf pages in a complete listing.
 
748
        self.assertEqual(257, len(full_chk_records))
 
749
        self.assertSubset(simple_chk_records, full_chk_records)
 
750
 
 
751
    def test_inconsistency_fatal(self):
 
752
        repo = self.make_repository('repo', format='2a')
 
753
        self.assertTrue(repo.revisions._index._inconsistency_fatal)
 
754
        self.assertFalse(repo.texts._index._inconsistency_fatal)
 
755
        self.assertFalse(repo.inventories._index._inconsistency_fatal)
 
756
        self.assertFalse(repo.signatures._index._inconsistency_fatal)
 
757
        self.assertFalse(repo.chk_bytes._index._inconsistency_fatal)
 
758
 
 
759
 
 
760
class TestKnitPackStreamSource(tests.TestCaseWithMemoryTransport):
 
761
 
 
762
    def test_source_to_exact_pack_092(self):
 
763
        source = self.make_repository('source', format='pack-0.92')
 
764
        target = self.make_repository('target', format='pack-0.92')
 
765
        stream_source = source._get_source(target._format)
 
766
        self.assertIsInstance(stream_source, knitpack_repo.KnitPackStreamSource)
 
767
 
 
768
    def test_source_to_exact_pack_rich_root_pack(self):
 
769
        source = self.make_repository('source', format='rich-root-pack')
 
770
        target = self.make_repository('target', format='rich-root-pack')
 
771
        stream_source = source._get_source(target._format)
 
772
        self.assertIsInstance(stream_source, knitpack_repo.KnitPackStreamSource)
 
773
 
 
774
    def test_source_to_exact_pack_19(self):
 
775
        source = self.make_repository('source', format='1.9')
 
776
        target = self.make_repository('target', format='1.9')
 
777
        stream_source = source._get_source(target._format)
 
778
        self.assertIsInstance(stream_source, knitpack_repo.KnitPackStreamSource)
 
779
 
 
780
    def test_source_to_exact_pack_19_rich_root(self):
 
781
        source = self.make_repository('source', format='1.9-rich-root')
 
782
        target = self.make_repository('target', format='1.9-rich-root')
 
783
        stream_source = source._get_source(target._format)
 
784
        self.assertIsInstance(stream_source, knitpack_repo.KnitPackStreamSource)
 
785
 
 
786
    def test_source_to_remote_exact_pack_19(self):
 
787
        trans = self.make_smart_server('target')
 
788
        trans.ensure_base()
 
789
        source = self.make_repository('source', format='1.9')
 
790
        target = self.make_repository('target', format='1.9')
 
791
        target = repository.Repository.open(trans.base)
 
792
        stream_source = source._get_source(target._format)
 
793
        self.assertIsInstance(stream_source, knitpack_repo.KnitPackStreamSource)
 
794
 
 
795
    def test_stream_source_to_non_exact(self):
 
796
        source = self.make_repository('source', format='pack-0.92')
 
797
        target = self.make_repository('target', format='1.9')
 
798
        stream = source._get_source(target._format)
 
799
        self.assertIs(type(stream), vf_repository.StreamSource)
 
800
 
 
801
    def test_stream_source_to_non_exact_rich_root(self):
 
802
        source = self.make_repository('source', format='1.9')
 
803
        target = self.make_repository('target', format='1.9-rich-root')
 
804
        stream = source._get_source(target._format)
 
805
        self.assertIs(type(stream), vf_repository.StreamSource)
 
806
 
 
807
    def test_source_to_remote_non_exact_pack_19(self):
 
808
        trans = self.make_smart_server('target')
 
809
        trans.ensure_base()
 
810
        source = self.make_repository('source', format='1.9')
 
811
        target = self.make_repository('target', format='1.6')
 
812
        target = repository.Repository.open(trans.base)
 
813
        stream_source = source._get_source(target._format)
 
814
        self.assertIs(type(stream_source), vf_repository.StreamSource)
 
815
 
 
816
    def test_stream_source_to_knit(self):
 
817
        source = self.make_repository('source', format='pack-0.92')
 
818
        target = self.make_repository('target', format='dirstate')
 
819
        stream = source._get_source(target._format)
 
820
        self.assertIs(type(stream), vf_repository.StreamSource)
 
821
 
 
822
 
 
823
class TestDevelopment6FindParentIdsOfRevisions(TestCaseWithTransport):
 
824
    """Tests for _find_parent_ids_of_revisions."""
691
825
 
692
826
    def setUp(self):
693
 
        super(TestDevelopment6FindRevisionOutsideSet, self).setUp()
694
 
        self.builder = self.make_branch_builder('source',
695
 
            format='development6-rich-root')
 
827
        super(TestDevelopment6FindParentIdsOfRevisions, self).setUp()
 
828
        self.builder = self.make_branch_builder('source')
696
829
        self.builder.start_series()
697
830
        self.builder.build_snapshot('initial', None,
698
831
            [('add', ('', 'tree-root', 'directory', None))])
699
832
        self.repo = self.builder.get_branch().repository
700
833
        self.addCleanup(self.builder.finish_series)
701
834
 
702
 
    def assertRevisionOutsideSet(self, expected_result, rev_set):
703
 
        self.assertEqual(
704
 
            expected_result, self.repo._find_revision_outside_set(rev_set))
 
835
    def assertParentIds(self, expected_result, rev_set):
 
836
        self.assertEqual(sorted(expected_result),
 
837
            sorted(self.repo._find_parent_ids_of_revisions(rev_set)))
705
838
 
706
839
    def test_simple(self):
707
840
        self.builder.build_snapshot('revid1', None, [])
708
 
        self.builder.build_snapshot('revid2', None, [])
 
841
        self.builder.build_snapshot('revid2', ['revid1'], [])
709
842
        rev_set = ['revid2']
710
 
        self.assertRevisionOutsideSet('revid1', rev_set)
 
843
        self.assertParentIds(['revid1'], rev_set)
711
844
 
712
845
    def test_not_first_parent(self):
713
846
        self.builder.build_snapshot('revid1', None, [])
714
 
        self.builder.build_snapshot('revid2', None, [])
715
 
        self.builder.build_snapshot('revid3', None, [])
 
847
        self.builder.build_snapshot('revid2', ['revid1'], [])
 
848
        self.builder.build_snapshot('revid3', ['revid2'], [])
716
849
        rev_set = ['revid3', 'revid2']
717
 
        self.assertRevisionOutsideSet('revid1', rev_set)
 
850
        self.assertParentIds(['revid1'], rev_set)
718
851
 
719
852
    def test_not_null(self):
720
853
        rev_set = ['initial']
721
 
        self.assertRevisionOutsideSet(_mod_revision.NULL_REVISION, rev_set)
 
854
        self.assertParentIds([], rev_set)
722
855
 
723
856
    def test_not_null_set(self):
724
857
        self.builder.build_snapshot('revid1', None, [])
725
858
        rev_set = [_mod_revision.NULL_REVISION]
726
 
        self.assertRevisionOutsideSet(_mod_revision.NULL_REVISION, rev_set)
 
859
        self.assertParentIds([], rev_set)
727
860
 
728
861
    def test_ghost(self):
729
862
        self.builder.build_snapshot('revid1', None, [])
730
863
        rev_set = ['ghost', 'revid1']
731
 
        self.assertRevisionOutsideSet('initial', rev_set)
 
864
        self.assertParentIds(['initial'], rev_set)
732
865
 
733
866
    def test_ghost_parent(self):
734
867
        self.builder.build_snapshot('revid1', None, [])
735
868
        self.builder.build_snapshot('revid2', ['revid1', 'ghost'], [])
736
869
        rev_set = ['revid2', 'revid1']
737
 
        self.assertRevisionOutsideSet('initial', rev_set)
 
870
        self.assertParentIds(['ghost', 'initial'], rev_set)
738
871
 
739
872
    def test_righthand_parent(self):
740
873
        self.builder.build_snapshot('revid1', None, [])
742
875
        self.builder.build_snapshot('revid2b', ['revid1'], [])
743
876
        self.builder.build_snapshot('revid3', ['revid2a', 'revid2b'], [])
744
877
        rev_set = ['revid3', 'revid2a']
745
 
        self.assertRevisionOutsideSet('revid2b', rev_set)
 
878
        self.assertParentIds(['revid1', 'revid2b'], rev_set)
746
879
 
747
880
 
748
881
class TestWithBrokenRepo(TestCaseWithTransport):
763
896
            inv = inventory.Inventory(revision_id='rev1a')
764
897
            inv.root.revision = 'rev1a'
765
898
            self.add_file(repo, inv, 'file1', 'rev1a', [])
 
899
            repo.texts.add_lines((inv.root.file_id, 'rev1a'), [], [])
766
900
            repo.add_inventory('rev1a', inv, [])
767
901
            revision = _mod_revision.Revision('rev1a',
768
902
                committer='jrandom@example.com', timestamp=0,
769
903
                inventory_sha1='', timezone=0, message='foo', parent_ids=[])
770
 
            repo.add_revision('rev1a',revision, inv)
 
904
            repo.add_revision('rev1a', revision, inv)
771
905
 
772
906
            # make rev1b, which has no Revision, but has an Inventory, and
773
907
            # file1
803
937
    def add_revision(self, repo, revision_id, inv, parent_ids):
804
938
        inv.revision_id = revision_id
805
939
        inv.root.revision = revision_id
 
940
        repo.texts.add_lines((inv.root.file_id, revision_id), [], [])
806
941
        repo.add_inventory(revision_id, inv, parent_ids)
807
942
        revision = _mod_revision.Revision(revision_id,
808
943
            committer='jrandom@example.com', timestamp=0, inventory_sha1='',
809
944
            timezone=0, message='foo', parent_ids=parent_ids)
810
 
        repo.add_revision(revision_id,revision, inv)
 
945
        repo.add_revision(revision_id, revision, inv)
811
946
 
812
947
    def add_file(self, repo, inv, filename, revision, parents):
813
948
        file_id = filename + '-id'
825
960
        """
826
961
        broken_repo = self.make_broken_repository()
827
962
        empty_repo = self.make_repository('empty-repo')
828
 
        self.assertRaises((errors.RevisionNotPresent, errors.BzrCheckError),
829
 
                          empty_repo.fetch, broken_repo)
 
963
        try:
 
964
            empty_repo.fetch(broken_repo)
 
965
        except (errors.RevisionNotPresent, errors.BzrCheckError):
 
966
            # Test successful: compression parent not being copied leads to
 
967
            # error.
 
968
            return
 
969
        empty_repo.lock_read()
 
970
        self.addCleanup(empty_repo.unlock)
 
971
        text = empty_repo.texts.get_record_stream(
 
972
            [('file2-id', 'rev3')], 'topological', True).next()
 
973
        self.assertEqual('line\n', text.get_bytes_as('fulltext'))
830
974
 
831
975
 
832
976
class TestRepositoryPackCollection(TestCaseWithTransport):
833
977
 
834
978
    def get_format(self):
835
 
        return bzrdir.format_registry.make_bzrdir('pack-0.92')
 
979
        return controldir.format_registry.make_bzrdir('pack-0.92')
836
980
 
837
981
    def get_packs(self):
838
982
        format = self.get_format()
841
985
 
842
986
    def make_packs_and_alt_repo(self, write_lock=False):
843
987
        """Create a pack repo with 3 packs, and access it via a second repo."""
844
 
        tree = self.make_branch_and_tree('.')
 
988
        tree = self.make_branch_and_tree('.', format=self.get_format())
845
989
        tree.lock_write()
846
990
        self.addCleanup(tree.unlock)
847
991
        rev1 = tree.commit('one')
857
1001
        packs.ensure_loaded()
858
1002
        return tree, r, packs, [rev1, rev2, rev3]
859
1003
 
 
1004
    def test__clear_obsolete_packs(self):
 
1005
        packs = self.get_packs()
 
1006
        obsolete_pack_trans = packs.transport.clone('obsolete_packs')
 
1007
        obsolete_pack_trans.put_bytes('a-pack.pack', 'content\n')
 
1008
        obsolete_pack_trans.put_bytes('a-pack.rix', 'content\n')
 
1009
        obsolete_pack_trans.put_bytes('a-pack.iix', 'content\n')
 
1010
        obsolete_pack_trans.put_bytes('another-pack.pack', 'foo\n')
 
1011
        obsolete_pack_trans.put_bytes('not-a-pack.rix', 'foo\n')
 
1012
        res = packs._clear_obsolete_packs()
 
1013
        self.assertEqual(['a-pack', 'another-pack'], sorted(res))
 
1014
        self.assertEqual([], obsolete_pack_trans.list_dir('.'))
 
1015
 
 
1016
    def test__clear_obsolete_packs_preserve(self):
 
1017
        packs = self.get_packs()
 
1018
        obsolete_pack_trans = packs.transport.clone('obsolete_packs')
 
1019
        obsolete_pack_trans.put_bytes('a-pack.pack', 'content\n')
 
1020
        obsolete_pack_trans.put_bytes('a-pack.rix', 'content\n')
 
1021
        obsolete_pack_trans.put_bytes('a-pack.iix', 'content\n')
 
1022
        obsolete_pack_trans.put_bytes('another-pack.pack', 'foo\n')
 
1023
        obsolete_pack_trans.put_bytes('not-a-pack.rix', 'foo\n')
 
1024
        res = packs._clear_obsolete_packs(preserve=set(['a-pack']))
 
1025
        self.assertEqual(['a-pack', 'another-pack'], sorted(res))
 
1026
        self.assertEqual(['a-pack.iix', 'a-pack.pack', 'a-pack.rix'],
 
1027
                         sorted(obsolete_pack_trans.list_dir('.')))
 
1028
 
860
1029
    def test__max_pack_count(self):
861
1030
        """The maximum pack count is a function of the number of revisions."""
862
1031
        # no revisions - one pack, so that we can have a revision free repo
882
1051
        # check some arbitrary big numbers
883
1052
        self.assertEqual(25, packs._max_pack_count(112894))
884
1053
 
 
1054
    def test_repr(self):
 
1055
        packs = self.get_packs()
 
1056
        self.assertContainsRe(repr(packs),
 
1057
            'RepositoryPackCollection(.*Repository(.*))')
 
1058
 
 
1059
    def test__obsolete_packs(self):
 
1060
        tree, r, packs, revs = self.make_packs_and_alt_repo(write_lock=True)
 
1061
        names = packs.names()
 
1062
        pack = packs.get_pack_by_name(names[0])
 
1063
        # Schedule this one for removal
 
1064
        packs._remove_pack_from_memory(pack)
 
1065
        # Simulate a concurrent update by renaming the .pack file and one of
 
1066
        # the indices
 
1067
        packs.transport.rename('packs/%s.pack' % (names[0],),
 
1068
                               'obsolete_packs/%s.pack' % (names[0],))
 
1069
        packs.transport.rename('indices/%s.iix' % (names[0],),
 
1070
                               'obsolete_packs/%s.iix' % (names[0],))
 
1071
        # Now trigger the obsoletion, and ensure that all the remaining files
 
1072
        # are still renamed
 
1073
        packs._obsolete_packs([pack])
 
1074
        self.assertEqual([n + '.pack' for n in names[1:]],
 
1075
                         sorted(packs._pack_transport.list_dir('.')))
 
1076
        # names[0] should not be present in the index anymore
 
1077
        self.assertEqual(names[1:],
 
1078
            sorted(set([osutils.splitext(n)[0] for n in
 
1079
                        packs._index_transport.list_dir('.')])))
 
1080
 
 
1081
    def test__obsolete_packs_missing_directory(self):
 
1082
        tree, r, packs, revs = self.make_packs_and_alt_repo(write_lock=True)
 
1083
        r.control_transport.rmdir('obsolete_packs')
 
1084
        names = packs.names()
 
1085
        pack = packs.get_pack_by_name(names[0])
 
1086
        # Schedule this one for removal
 
1087
        packs._remove_pack_from_memory(pack)
 
1088
        # Now trigger the obsoletion, and ensure that all the remaining files
 
1089
        # are still renamed
 
1090
        packs._obsolete_packs([pack])
 
1091
        self.assertEqual([n + '.pack' for n in names[1:]],
 
1092
                         sorted(packs._pack_transport.list_dir('.')))
 
1093
        # names[0] should not be present in the index anymore
 
1094
        self.assertEqual(names[1:],
 
1095
            sorted(set([osutils.splitext(n)[0] for n in
 
1096
                        packs._index_transport.list_dir('.')])))
 
1097
 
885
1098
    def test_pack_distribution_zero(self):
886
1099
        packs = self.get_packs()
887
1100
        self.assertEqual([0], packs.pack_distribution(0))
1055
1268
        self.assertEqual({revs[-1]:(revs[-2],)}, r.get_parent_map([revs[-1]]))
1056
1269
        self.assertFalse(packs.reload_pack_names())
1057
1270
 
 
1271
    def test_reload_pack_names_preserves_pending(self):
 
1272
        # TODO: Update this to also test for pending-deleted names
 
1273
        tree, r, packs, revs = self.make_packs_and_alt_repo(write_lock=True)
 
1274
        # We will add one pack (via start_write_group + insert_record_stream),
 
1275
        # and remove another pack (via _remove_pack_from_memory)
 
1276
        orig_names = packs.names()
 
1277
        orig_at_load = packs._packs_at_load
 
1278
        to_remove_name = iter(orig_names).next()
 
1279
        r.start_write_group()
 
1280
        self.addCleanup(r.abort_write_group)
 
1281
        r.texts.insert_record_stream([versionedfile.FulltextContentFactory(
 
1282
            ('text', 'rev'), (), None, 'content\n')])
 
1283
        new_pack = packs._new_pack
 
1284
        self.assertTrue(new_pack.data_inserted())
 
1285
        new_pack.finish()
 
1286
        packs.allocate(new_pack)
 
1287
        packs._new_pack = None
 
1288
        removed_pack = packs.get_pack_by_name(to_remove_name)
 
1289
        packs._remove_pack_from_memory(removed_pack)
 
1290
        names = packs.names()
 
1291
        all_nodes, deleted_nodes, new_nodes, _ = packs._diff_pack_names()
 
1292
        new_names = set([x[0][0] for x in new_nodes])
 
1293
        self.assertEqual(names, sorted([x[0][0] for x in all_nodes]))
 
1294
        self.assertEqual(set(names) - set(orig_names), new_names)
 
1295
        self.assertEqual(set([new_pack.name]), new_names)
 
1296
        self.assertEqual([to_remove_name],
 
1297
                         sorted([x[0][0] for x in deleted_nodes]))
 
1298
        packs.reload_pack_names()
 
1299
        reloaded_names = packs.names()
 
1300
        self.assertEqual(orig_at_load, packs._packs_at_load)
 
1301
        self.assertEqual(names, reloaded_names)
 
1302
        all_nodes, deleted_nodes, new_nodes, _ = packs._diff_pack_names()
 
1303
        new_names = set([x[0][0] for x in new_nodes])
 
1304
        self.assertEqual(names, sorted([x[0][0] for x in all_nodes]))
 
1305
        self.assertEqual(set(names) - set(orig_names), new_names)
 
1306
        self.assertEqual(set([new_pack.name]), new_names)
 
1307
        self.assertEqual([to_remove_name],
 
1308
                         sorted([x[0][0] for x in deleted_nodes]))
 
1309
 
 
1310
    def test_autopack_obsoletes_new_pack(self):
 
1311
        tree, r, packs, revs = self.make_packs_and_alt_repo(write_lock=True)
 
1312
        packs._max_pack_count = lambda x: 1
 
1313
        packs.pack_distribution = lambda x: [10]
 
1314
        r.start_write_group()
 
1315
        r.revisions.insert_record_stream([versionedfile.FulltextContentFactory(
 
1316
            ('bogus-rev',), (), None, 'bogus-content\n')])
 
1317
        # This should trigger an autopack, which will combine everything into a
 
1318
        # single pack file.
 
1319
        new_names = r.commit_write_group()
 
1320
        names = packs.names()
 
1321
        self.assertEqual(1, len(names))
 
1322
        self.assertEqual([names[0] + '.pack'],
 
1323
                         packs._pack_transport.list_dir('.'))
 
1324
 
1058
1325
    def test_autopack_reloads_and_stops(self):
1059
1326
        tree, r, packs, revs = self.make_packs_and_alt_repo(write_lock=True)
1060
1327
        # After we have determined what needs to be autopacked, trigger a
1072
1339
        self.assertEqual(tree.branch.repository._pack_collection.names(),
1073
1340
                         packs.names())
1074
1341
 
 
1342
    def test__save_pack_names(self):
 
1343
        tree, r, packs, revs = self.make_packs_and_alt_repo(write_lock=True)
 
1344
        names = packs.names()
 
1345
        pack = packs.get_pack_by_name(names[0])
 
1346
        packs._remove_pack_from_memory(pack)
 
1347
        packs._save_pack_names(obsolete_packs=[pack])
 
1348
        cur_packs = packs._pack_transport.list_dir('.')
 
1349
        self.assertEqual([n + '.pack' for n in names[1:]], sorted(cur_packs))
 
1350
        # obsolete_packs will also have stuff like .rix and .iix present.
 
1351
        obsolete_packs = packs.transport.list_dir('obsolete_packs')
 
1352
        obsolete_names = set([osutils.splitext(n)[0] for n in obsolete_packs])
 
1353
        self.assertEqual([pack.name], sorted(obsolete_names))
 
1354
 
 
1355
    def test__save_pack_names_already_obsoleted(self):
 
1356
        tree, r, packs, revs = self.make_packs_and_alt_repo(write_lock=True)
 
1357
        names = packs.names()
 
1358
        pack = packs.get_pack_by_name(names[0])
 
1359
        packs._remove_pack_from_memory(pack)
 
1360
        # We are going to simulate a concurrent autopack by manually obsoleting
 
1361
        # the pack directly.
 
1362
        packs._obsolete_packs([pack])
 
1363
        packs._save_pack_names(clear_obsolete_packs=True,
 
1364
                               obsolete_packs=[pack])
 
1365
        cur_packs = packs._pack_transport.list_dir('.')
 
1366
        self.assertEqual([n + '.pack' for n in names[1:]], sorted(cur_packs))
 
1367
        # Note that while we set clear_obsolete_packs=True, it should not
 
1368
        # delete a pack file that we have also scheduled for obsoletion.
 
1369
        obsolete_packs = packs.transport.list_dir('obsolete_packs')
 
1370
        obsolete_names = set([osutils.splitext(n)[0] for n in obsolete_packs])
 
1371
        self.assertEqual([pack.name], sorted(obsolete_names))
 
1372
 
 
1373
    def test_pack_no_obsolete_packs_directory(self):
 
1374
        """Bug #314314, don't fail if obsolete_packs directory does
 
1375
        not exist."""
 
1376
        tree, r, packs, revs = self.make_packs_and_alt_repo(write_lock=True)
 
1377
        r.control_transport.rmdir('obsolete_packs')
 
1378
        packs._clear_obsolete_packs()
 
1379
 
1075
1380
 
1076
1381
class TestPack(TestCaseWithTransport):
1077
1382
    """Tests for the Pack object."""
1141
1446
            index_class=BTreeGraphIndex,
1142
1447
            use_chk_index=False)
1143
1448
        pack = pack_repo.NewPack(collection)
 
1449
        self.addCleanup(pack.abort) # Make sure the write stream gets closed
1144
1450
        self.assertIsInstance(pack.revision_index, BTreeBuilder)
1145
1451
        self.assertIsInstance(pack.inventory_index, BTreeBuilder)
1146
1452
        self.assertIsInstance(pack._hash, type(osutils.md5()))
1157
1463
    """Tests for the packs repository Packer class."""
1158
1464
 
1159
1465
    def test_pack_optimizes_pack_order(self):
1160
 
        builder = self.make_branch_builder('.')
 
1466
        builder = self.make_branch_builder('.', format="1.9")
1161
1467
        builder.start_series()
1162
1468
        builder.build_snapshot('A', None, [
1163
1469
            ('add', ('', 'root-id', 'directory', None)),
1176
1482
        # Because of how they were built, they correspond to
1177
1483
        # ['D', 'C', 'B', 'A']
1178
1484
        packs = b.repository._pack_collection.packs
1179
 
        packer = pack_repo.Packer(b.repository._pack_collection,
 
1485
        packer = knitpack_repo.KnitPacker(b.repository._pack_collection,
1180
1486
                                  packs, 'testing',
1181
1487
                                  revision_ids=['B', 'C'])
1182
1488
        # Now, when we are copying the B & C revisions, their pack files should
1196
1502
        return repo._pack_collection
1197
1503
 
1198
1504
    def test_open_pack_will_optimise(self):
1199
 
        packer = pack_repo.OptimisingPacker(self.get_pack_collection(),
 
1505
        packer = knitpack_repo.OptimisingKnitPacker(self.get_pack_collection(),
1200
1506
                                            [], '.test')
1201
1507
        new_pack = packer.open_pack()
 
1508
        self.addCleanup(new_pack.abort) # ensure cleanup
1202
1509
        self.assertIsInstance(new_pack, pack_repo.NewPack)
1203
1510
        self.assertTrue(new_pack.revision_index._optimize_for_size)
1204
1511
        self.assertTrue(new_pack.inventory_index._optimize_for_size)
1206
1513
        self.assertTrue(new_pack.signature_index._optimize_for_size)
1207
1514
 
1208
1515
 
1209
 
class TestGCCHKPackCollection(TestCaseWithTransport):
1210
 
 
1211
 
    def test_stream_source_to_gc(self):
1212
 
        source = self.make_repository('source', format='development6-rich-root')
1213
 
        target = self.make_repository('target', format='development6-rich-root')
1214
 
        stream = source._get_source(target._format)
1215
 
        self.assertIsInstance(stream, groupcompress_repo.GroupCHKStreamSource)
1216
 
 
1217
 
    def test_stream_source_to_non_gc(self):
1218
 
        source = self.make_repository('source', format='development6-rich-root')
1219
 
        target = self.make_repository('target', format='rich-root-pack')
1220
 
        stream = source._get_source(target._format)
1221
 
        # We don't want the child GroupCHKStreamSource
1222
 
        self.assertIs(type(stream), repository.StreamSource)
 
1516
class TestGCCHKPacker(TestCaseWithTransport):
 
1517
 
 
1518
    def make_abc_branch(self):
 
1519
        builder = self.make_branch_builder('source')
 
1520
        builder.start_series()
 
1521
        builder.build_snapshot('A', None, [
 
1522
            ('add', ('', 'root-id', 'directory', None)),
 
1523
            ('add', ('file', 'file-id', 'file', 'content\n')),
 
1524
            ])
 
1525
        builder.build_snapshot('B', ['A'], [
 
1526
            ('add', ('dir', 'dir-id', 'directory', None))])
 
1527
        builder.build_snapshot('C', ['B'], [
 
1528
            ('modify', ('file-id', 'new content\n'))])
 
1529
        builder.finish_series()
 
1530
        return builder.get_branch()
 
1531
 
 
1532
    def make_branch_with_disjoint_inventory_and_revision(self):
 
1533
        """a repo with separate packs for a revisions Revision and Inventory.
 
1534
 
 
1535
        There will be one pack file that holds the Revision content, and one
 
1536
        for the Inventory content.
 
1537
 
 
1538
        :return: (repository,
 
1539
                  pack_name_with_rev_A_Revision,
 
1540
                  pack_name_with_rev_A_Inventory,
 
1541
                  pack_name_with_rev_C_content)
 
1542
        """
 
1543
        b_source = self.make_abc_branch()
 
1544
        b_base = b_source.bzrdir.sprout('base', revision_id='A').open_branch()
 
1545
        b_stacked = b_base.bzrdir.sprout('stacked', stacked=True).open_branch()
 
1546
        b_stacked.lock_write()
 
1547
        self.addCleanup(b_stacked.unlock)
 
1548
        b_stacked.fetch(b_source, 'B')
 
1549
        # Now re-open the stacked repo directly (no fallbacks) so that we can
 
1550
        # fill in the A rev.
 
1551
        repo_not_stacked = b_stacked.bzrdir.open_repository()
 
1552
        repo_not_stacked.lock_write()
 
1553
        self.addCleanup(repo_not_stacked.unlock)
 
1554
        # Now we should have a pack file with A's inventory, but not its
 
1555
        # Revision
 
1556
        self.assertEqual([('A',), ('B',)],
 
1557
                         sorted(repo_not_stacked.inventories.keys()))
 
1558
        self.assertEqual([('B',)],
 
1559
                         sorted(repo_not_stacked.revisions.keys()))
 
1560
        stacked_pack_names = repo_not_stacked._pack_collection.names()
 
1561
        # We have a couple names here, figure out which has A's inventory
 
1562
        for name in stacked_pack_names:
 
1563
            pack = repo_not_stacked._pack_collection.get_pack_by_name(name)
 
1564
            keys = [n[1] for n in pack.inventory_index.iter_all_entries()]
 
1565
            if ('A',) in keys:
 
1566
                inv_a_pack_name = name
 
1567
                break
 
1568
        else:
 
1569
            self.fail('Could not find pack containing A\'s inventory')
 
1570
        repo_not_stacked.fetch(b_source.repository, 'A')
 
1571
        self.assertEqual([('A',), ('B',)],
 
1572
                         sorted(repo_not_stacked.revisions.keys()))
 
1573
        new_pack_names = set(repo_not_stacked._pack_collection.names())
 
1574
        rev_a_pack_names = new_pack_names.difference(stacked_pack_names)
 
1575
        self.assertEqual(1, len(rev_a_pack_names))
 
1576
        rev_a_pack_name = list(rev_a_pack_names)[0]
 
1577
        # Now fetch 'C', so we have a couple pack files to join
 
1578
        repo_not_stacked.fetch(b_source.repository, 'C')
 
1579
        rev_c_pack_names = set(repo_not_stacked._pack_collection.names())
 
1580
        rev_c_pack_names = rev_c_pack_names.difference(new_pack_names)
 
1581
        self.assertEqual(1, len(rev_c_pack_names))
 
1582
        rev_c_pack_name = list(rev_c_pack_names)[0]
 
1583
        return (repo_not_stacked, rev_a_pack_name, inv_a_pack_name,
 
1584
                rev_c_pack_name)
 
1585
 
 
1586
    def test_pack_with_distant_inventories(self):
 
1587
        # See https://bugs.launchpad.net/bzr/+bug/437003
 
1588
        # When repacking, it is possible to have an inventory in a different
 
1589
        # pack file than the associated revision. An autopack can then come
 
1590
        # along, and miss that inventory, and complain.
 
1591
        (repo, rev_a_pack_name, inv_a_pack_name, rev_c_pack_name
 
1592
         ) = self.make_branch_with_disjoint_inventory_and_revision()
 
1593
        a_pack = repo._pack_collection.get_pack_by_name(rev_a_pack_name)
 
1594
        c_pack = repo._pack_collection.get_pack_by_name(rev_c_pack_name)
 
1595
        packer = groupcompress_repo.GCCHKPacker(repo._pack_collection,
 
1596
                    [a_pack, c_pack], '.test-pack')
 
1597
        # This would raise ValueError in bug #437003, but should not raise an
 
1598
        # error once fixed.
 
1599
        packer.pack()
 
1600
 
 
1601
    def test_pack_with_missing_inventory(self):
 
1602
        # Similar to test_pack_with_missing_inventory, but this time, we force
 
1603
        # the A inventory to actually be gone from the repository.
 
1604
        (repo, rev_a_pack_name, inv_a_pack_name, rev_c_pack_name
 
1605
         ) = self.make_branch_with_disjoint_inventory_and_revision()
 
1606
        inv_a_pack = repo._pack_collection.get_pack_by_name(inv_a_pack_name)
 
1607
        repo._pack_collection._remove_pack_from_memory(inv_a_pack)
 
1608
        packer = groupcompress_repo.GCCHKPacker(repo._pack_collection,
 
1609
            repo._pack_collection.all_packs(), '.test-pack')
 
1610
        e = self.assertRaises(ValueError, packer.pack)
 
1611
        packer.new_pack.abort()
 
1612
        self.assertContainsRe(str(e),
 
1613
            r"We are missing inventories for revisions: .*'A'")
 
1614
 
 
1615
 
 
1616
class TestCrossFormatPacks(TestCaseWithTransport):
 
1617
 
 
1618
    def log_pack(self, hint=None):
 
1619
        self.calls.append(('pack', hint))
 
1620
        self.orig_pack(hint=hint)
 
1621
        if self.expect_hint:
 
1622
            self.assertTrue(hint)
 
1623
 
 
1624
    def run_stream(self, src_fmt, target_fmt, expect_pack_called):
 
1625
        self.expect_hint = expect_pack_called
 
1626
        self.calls = []
 
1627
        source_tree = self.make_branch_and_tree('src', format=src_fmt)
 
1628
        source_tree.lock_write()
 
1629
        self.addCleanup(source_tree.unlock)
 
1630
        tip = source_tree.commit('foo')
 
1631
        target = self.make_repository('target', format=target_fmt)
 
1632
        target.lock_write()
 
1633
        self.addCleanup(target.unlock)
 
1634
        source = source_tree.branch.repository._get_source(target._format)
 
1635
        self.orig_pack = target.pack
 
1636
        self.overrideAttr(target, "pack", self.log_pack)
 
1637
        search = target.search_missing_revision_ids(
 
1638
            source_tree.branch.repository, revision_ids=[tip])
 
1639
        stream = source.get_stream(search)
 
1640
        from_format = source_tree.branch.repository._format
 
1641
        sink = target._get_sink()
 
1642
        sink.insert_stream(stream, from_format, [])
 
1643
        if expect_pack_called:
 
1644
            self.assertLength(1, self.calls)
 
1645
        else:
 
1646
            self.assertLength(0, self.calls)
 
1647
 
 
1648
    def run_fetch(self, src_fmt, target_fmt, expect_pack_called):
 
1649
        self.expect_hint = expect_pack_called
 
1650
        self.calls = []
 
1651
        source_tree = self.make_branch_and_tree('src', format=src_fmt)
 
1652
        source_tree.lock_write()
 
1653
        self.addCleanup(source_tree.unlock)
 
1654
        tip = source_tree.commit('foo')
 
1655
        target = self.make_repository('target', format=target_fmt)
 
1656
        target.lock_write()
 
1657
        self.addCleanup(target.unlock)
 
1658
        source = source_tree.branch.repository
 
1659
        self.orig_pack = target.pack
 
1660
        self.overrideAttr(target, "pack", self.log_pack)
 
1661
        target.fetch(source)
 
1662
        if expect_pack_called:
 
1663
            self.assertLength(1, self.calls)
 
1664
        else:
 
1665
            self.assertLength(0, self.calls)
 
1666
 
 
1667
    def test_sink_format_hint_no(self):
 
1668
        # When the target format says packing makes no difference, pack is not
 
1669
        # called.
 
1670
        self.run_stream('1.9', 'rich-root-pack', False)
 
1671
 
 
1672
    def test_sink_format_hint_yes(self):
 
1673
        # When the target format says packing makes a difference, pack is
 
1674
        # called.
 
1675
        self.run_stream('1.9', '2a', True)
 
1676
 
 
1677
    def test_sink_format_same_no(self):
 
1678
        # When the formats are the same, pack is not called.
 
1679
        self.run_stream('2a', '2a', False)
 
1680
 
 
1681
    def test_IDS_format_hint_no(self):
 
1682
        # When the target format says packing makes no difference, pack is not
 
1683
        # called.
 
1684
        self.run_fetch('1.9', 'rich-root-pack', False)
 
1685
 
 
1686
    def test_IDS_format_hint_yes(self):
 
1687
        # When the target format says packing makes a difference, pack is
 
1688
        # called.
 
1689
        self.run_fetch('1.9', '2a', True)
 
1690
 
 
1691
    def test_IDS_format_same_no(self):
 
1692
        # When the formats are the same, pack is not called.
 
1693
        self.run_fetch('2a', '2a', False)
 
1694
 
 
1695
 
 
1696
class Test_LazyListJoin(tests.TestCase):
 
1697
 
 
1698
    def test__repr__(self):
 
1699
        lazy = repository._LazyListJoin(['a'], ['b'])
 
1700
        self.assertEqual("bzrlib.repository._LazyListJoin((['a'], ['b']))",
 
1701
                         repr(lazy))
 
1702
 
 
1703
 
 
1704
class TestFeatures(tests.TestCaseWithTransport):
 
1705
 
 
1706
    def test_open_with_present_feature(self):
 
1707
        self.addCleanup(
 
1708
            repository.RepositoryFormatMetaDir.unregister_feature,
 
1709
            "makes-cheese-sandwich")
 
1710
        repository.RepositoryFormatMetaDir.register_feature(
 
1711
            "makes-cheese-sandwich")
 
1712
        repo = self.make_repository('.')
 
1713
        repo.lock_write()
 
1714
        repo._format.features["makes-cheese-sandwich"] = "required"
 
1715
        repo._format.check_support_status(False)
 
1716
        repo.unlock()
 
1717
 
 
1718
    def test_open_with_missing_required_feature(self):
 
1719
        repo = self.make_repository('.')
 
1720
        repo.lock_write()
 
1721
        repo._format.features["makes-cheese-sandwich"] = "required"
 
1722
        self.assertRaises(errors.MissingFeature,
 
1723
            repo._format.check_support_status, False)