~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: 2016-04-21 05:06:57 UTC
  • mfrom: (6603.4.1 bzr)
  • Revision ID: pqm@pqm.ubuntu.com-20160421050657-ygnzfybewvudf1j9
(richard-wilbur) Use initial_comment as commit_message for lp_propose.(Shawn
 Wang) (Shawn Wang)

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2006, 2007 Canonical Ltd
 
1
# Copyright (C) 2006-2012, 2016 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
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
"""Tests for the Repository facility that are not interface tests.
18
18
 
19
 
For interface tests see tests/repository_implementations/*.py.
 
19
For interface tests see tests/per_repository/*.py.
20
20
 
21
21
For concrete class tests see this file, and for storage formats tests
22
22
also see this file.
23
23
"""
24
24
 
25
 
import md5
26
25
from stat import S_ISDIR
27
 
from StringIO import StringIO
28
26
 
29
27
import bzrlib
30
 
from bzrlib.errors import (NotBranchError,
31
 
                           NoSuchFile,
32
 
                           UnknownFormatError,
33
 
                           UnsupportedFormatError,
34
 
                           )
35
 
from bzrlib import graph
36
 
from bzrlib.index import GraphIndex, InMemoryGraphIndex
 
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
    )
 
39
from bzrlib.btree_index import BTreeBuilder, BTreeGraphIndex
 
40
from bzrlib.index import GraphIndex
37
41
from bzrlib.repository import RepositoryFormat
38
 
from bzrlib.smart import server
39
42
from bzrlib.tests import (
40
43
    TestCase,
41
44
    TestCaseWithTransport,
42
 
    TestSkipped,
43
 
    test_knit,
44
 
    )
45
 
from bzrlib.transport import (
46
 
    fakenfs,
47
 
    get_transport,
48
 
    )
49
 
from bzrlib.transport.memory import MemoryServer
50
 
from bzrlib.util import bencode
 
45
    )
51
46
from bzrlib import (
52
47
    bzrdir,
 
48
    controldir,
53
49
    errors,
54
50
    inventory,
55
 
    progress,
 
51
    osutils,
56
52
    repository,
57
53
    revision as _mod_revision,
58
 
    symbol_versioning,
59
54
    upgrade,
 
55
    versionedfile,
 
56
    vf_repository,
60
57
    workingtree,
61
58
    )
62
 
from bzrlib.repofmt import knitrepo, weaverepo, pack_repo
 
59
from bzrlib.repofmt import (
 
60
    groupcompress_repo,
 
61
    knitrepo,
 
62
    knitpack_repo,
 
63
    pack_repo,
 
64
    )
63
65
 
64
66
 
65
67
class TestDefaultFormat(TestCase):
66
68
 
67
69
    def test_get_set_default_format(self):
68
 
        old_default = bzrdir.format_registry.get('default')
 
70
        old_default = controldir.format_registry.get('default')
69
71
        private_default = old_default().repository_format.__class__
70
 
        old_format = repository.RepositoryFormat.get_default_format()
 
72
        old_format = repository.format_registry.get_default()
71
73
        self.assertTrue(isinstance(old_format, private_default))
72
74
        def make_sample_bzrdir():
73
75
            my_bzrdir = bzrdir.BzrDirMetaFormat1()
74
76
            my_bzrdir.repository_format = SampleRepositoryFormat()
75
77
            return my_bzrdir
76
 
        bzrdir.format_registry.remove('default')
77
 
        bzrdir.format_registry.register('sample', make_sample_bzrdir, '')
78
 
        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')
79
81
        # creating a repository should now create an instrumented dir.
80
82
        try:
81
83
            # the default branch format is used by the meta dir format
84
86
            result = dir.create_repository()
85
87
            self.assertEqual(result, 'A bzr repository dir')
86
88
        finally:
87
 
            bzrdir.format_registry.remove('default')
88
 
            bzrdir.format_registry.remove('sample')
89
 
            bzrdir.format_registry.register('default', old_default, '')
90
 
        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(),
91
93
                              old_format.__class__)
92
94
 
93
95
 
94
 
class SampleRepositoryFormat(repository.RepositoryFormat):
 
96
class SampleRepositoryFormat(repository.RepositoryFormatMetaDir):
95
97
    """A sample format
96
98
 
97
 
    this format is initializable, unsupported to aid in testing the 
 
99
    this format is initializable, unsupported to aid in testing the
98
100
    open and open(unsupported=True) routines.
99
101
    """
100
102
 
101
 
    def get_format_string(self):
 
103
    @classmethod
 
104
    def get_format_string(cls):
102
105
        """See RepositoryFormat.get_format_string()."""
103
106
        return "Sample .bzr repository format."
104
107
 
115
118
        return "opened repository."
116
119
 
117
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
 
118
130
class TestRepositoryFormat(TestCaseWithTransport):
119
131
    """Tests for the Repository format detection used by the bzr meta dir facility.BzrBranchFormat facility."""
120
132
 
121
133
    def test_find_format(self):
122
134
        # is the right format object found for a repository?
123
135
        # create a branch with a few known format objects.
124
 
        # this is not quite the same as 
 
136
        # this is not quite the same as
125
137
        self.build_tree(["foo/", "bar/"])
126
138
        def check_format(format, url):
127
139
            dir = format._matchingbzrdir.initialize(url)
128
140
            format.initialize(dir)
129
 
            t = get_transport(url)
130
 
            found_format = repository.RepositoryFormat.find_format(dir)
131
 
            self.failUnless(isinstance(found_format, format.__class__))
132
 
        check_format(weaverepo.RepositoryFormat7(), "bar")
133
 
        
 
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")
 
145
 
134
146
    def test_find_format_no_repository(self):
135
147
        dir = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
136
148
        self.assertRaises(errors.NoRepositoryPresent,
137
 
                          repository.RepositoryFormat.find_format,
 
149
                          repository.RepositoryFormatMetaDir.find_format,
138
150
                          dir)
139
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
 
140
161
    def test_find_format_unknown_format(self):
141
162
        dir = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
142
163
        SampleRepositoryFormat().initialize(dir)
143
164
        self.assertRaises(UnknownFormatError,
144
 
                          repository.RepositoryFormat.find_format,
 
165
                          repository.RepositoryFormatMetaDir.find_format,
145
166
                          dir)
146
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.assertEqual(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
 
147
188
    def test_register_unregister_format(self):
148
189
        format = SampleRepositoryFormat()
149
 
        # make a control dir
150
 
        dir = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
151
 
        # make a repo
152
 
        format.initialize(dir)
153
 
        # register a format for it.
154
 
        repository.RepositoryFormat.register_format(format)
155
 
        # which repository.Open will refuse (not supported)
156
 
        self.assertRaises(UnsupportedFormatError, repository.Repository.open, self.get_url())
157
 
        # but open(unsupported) will work
158
 
        self.assertEqual(format.open(dir), "opened repository.")
159
 
        # unregister the format
160
 
        repository.RepositoryFormat.unregister_format(format)
161
 
 
162
 
 
163
 
class TestFormat6(TestCaseWithTransport):
164
 
 
165
 
    def test_no_ancestry_weave(self):
166
 
        control = bzrdir.BzrDirFormat6().initialize(self.get_url())
167
 
        repo = weaverepo.RepositoryFormat6().initialize(control)
168
 
        # We no longer need to create the ancestry.weave file
169
 
        # since it is *never* used.
170
 
        self.assertRaises(NoSuchFile,
171
 
                          control.transport.get,
172
 
                          'ancestry.weave')
173
 
 
174
 
    def test_supports_external_lookups(self):
175
 
        control = bzrdir.BzrDirFormat6().initialize(self.get_url())
176
 
        repo = weaverepo.RepositoryFormat6().initialize(control)
177
 
        self.assertFalse(repo._format.supports_external_lookups)
178
 
 
179
 
 
180
 
class TestFormat7(TestCaseWithTransport):
181
 
    
182
 
    def test_disk_layout(self):
183
 
        control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
184
 
        repo = weaverepo.RepositoryFormat7().initialize(control)
185
 
        # in case of side effects of locking.
186
 
        repo.lock_write()
187
 
        repo.unlock()
188
 
        # we want:
189
 
        # format 'Bazaar-NG Repository format 7'
190
 
        # lock ''
191
 
        # inventory.weave == empty_weave
192
 
        # empty revision-store directory
193
 
        # empty weaves directory
194
 
        t = control.get_repository_transport(None)
195
 
        self.assertEqualDiff('Bazaar-NG Repository format 7',
196
 
                             t.get('format').read())
197
 
        self.assertTrue(S_ISDIR(t.stat('revision-store').st_mode))
198
 
        self.assertTrue(S_ISDIR(t.stat('weaves').st_mode))
199
 
        self.assertEqualDiff('# bzr weave file v5\n'
200
 
                             'w\n'
201
 
                             'W\n',
202
 
                             t.get('inventory.weave').read())
203
 
        # Creating a file with id Foo:Bar results in a non-escaped file name on
204
 
        # disk.
205
 
        control.create_branch()
206
 
        tree = control.create_workingtree()
207
 
        tree.add(['foo'], ['Foo:Bar'], ['file'])
208
 
        tree.put_file_bytes_non_atomic('Foo:Bar', 'content\n')
209
 
        tree.commit('first post', rev_id='first')
210
 
        self.assertEqualDiff(
211
 
            '# bzr weave file v5\n'
212
 
            'i\n'
213
 
            '1 7fe70820e08a1aac0ef224d9c66ab66831cc4ab1\n'
214
 
            'n first\n'
215
 
            '\n'
216
 
            'w\n'
217
 
            '{ 0\n'
218
 
            '. content\n'
219
 
            '}\n'
220
 
            'W\n',
221
 
            t.get('weaves/74/Foo%3ABar.weave').read())
222
 
 
223
 
    def test_shared_disk_layout(self):
224
 
        control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
225
 
        repo = weaverepo.RepositoryFormat7().initialize(control, shared=True)
226
 
        # we want:
227
 
        # format 'Bazaar-NG Repository format 7'
228
 
        # inventory.weave == empty_weave
229
 
        # empty revision-store directory
230
 
        # empty weaves directory
231
 
        # a 'shared-storage' marker file.
232
 
        # lock is not present when unlocked
233
 
        t = control.get_repository_transport(None)
234
 
        self.assertEqualDiff('Bazaar-NG Repository format 7',
235
 
                             t.get('format').read())
236
 
        self.assertEqualDiff('', t.get('shared-storage').read())
237
 
        self.assertTrue(S_ISDIR(t.stat('revision-store').st_mode))
238
 
        self.assertTrue(S_ISDIR(t.stat('weaves').st_mode))
239
 
        self.assertEqualDiff('# bzr weave file v5\n'
240
 
                             'w\n'
241
 
                             'W\n',
242
 
                             t.get('inventory.weave').read())
243
 
        self.assertFalse(t.has('branch-lock'))
244
 
 
245
 
    def test_creates_lockdir(self):
246
 
        """Make sure it appears to be controlled by a LockDir existence"""
247
 
        control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
248
 
        repo = weaverepo.RepositoryFormat7().initialize(control, shared=True)
249
 
        t = control.get_repository_transport(None)
250
 
        # TODO: Should check there is a 'lock' toplevel directory, 
251
 
        # regardless of contents
252
 
        self.assertFalse(t.has('lock/held/info'))
253
 
        repo.lock_write()
254
 
        try:
255
 
            self.assertTrue(t.has('lock/held/info'))
256
 
        finally:
257
 
            # unlock so we don't get a warning about failing to do so
258
 
            repo.unlock()
259
 
 
260
 
    def test_uses_lockdir(self):
261
 
        """repo format 7 actually locks on lockdir"""
262
 
        base_url = self.get_url()
263
 
        control = bzrdir.BzrDirMetaFormat1().initialize(base_url)
264
 
        repo = weaverepo.RepositoryFormat7().initialize(control, shared=True)
265
 
        t = control.get_repository_transport(None)
266
 
        repo.lock_write()
267
 
        repo.unlock()
268
 
        del repo
269
 
        # make sure the same lock is created by opening it
270
 
        repo = repository.Repository.open(base_url)
271
 
        repo.lock_write()
272
 
        self.assertTrue(t.has('lock/held/info'))
273
 
        repo.unlock()
274
 
        self.assertFalse(t.has('lock/held/info'))
275
 
 
276
 
    def test_shared_no_tree_disk_layout(self):
277
 
        control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
278
 
        repo = weaverepo.RepositoryFormat7().initialize(control, shared=True)
279
 
        repo.set_make_working_trees(False)
280
 
        # we want:
281
 
        # format 'Bazaar-NG Repository format 7'
282
 
        # lock ''
283
 
        # inventory.weave == empty_weave
284
 
        # empty revision-store directory
285
 
        # empty weaves directory
286
 
        # a 'shared-storage' marker file.
287
 
        t = control.get_repository_transport(None)
288
 
        self.assertEqualDiff('Bazaar-NG Repository format 7',
289
 
                             t.get('format').read())
290
 
        ## self.assertEqualDiff('', t.get('lock').read())
291
 
        self.assertEqualDiff('', t.get('shared-storage').read())
292
 
        self.assertEqualDiff('', t.get('no-working-trees').read())
293
 
        repo.set_make_working_trees(True)
294
 
        self.assertFalse(t.has('no-working-trees'))
295
 
        self.assertTrue(S_ISDIR(t.stat('revision-store').st_mode))
296
 
        self.assertTrue(S_ISDIR(t.stat('weaves').st_mode))
297
 
        self.assertEqualDiff('# bzr weave file v5\n'
298
 
                             'w\n'
299
 
                             'W\n',
300
 
                             t.get('inventory.weave').read())
301
 
 
302
 
    def test_supports_external_lookups(self):
303
 
        control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
304
 
        repo = weaverepo.RepositoryFormat7().initialize(control)
305
 
        self.assertFalse(repo._format.supports_external_lookups)
 
190
        self.registry.register(format)
 
191
        self.assertEqual(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.assertEqual([], self.registry._get_all())
 
198
        self.registry.register(format)
 
199
        self.assertEqual([format], self.registry._get_all())
 
200
 
 
201
    def test_register_extra(self):
 
202
        format = SampleExtraRepositoryFormat()
 
203
        self.assertEqual([], self.registry._get_all())
 
204
        self.registry.register_extra(format)
 
205
        self.assertEqual([format], self.registry._get_all())
 
206
 
 
207
    def test_register_extra_lazy(self):
 
208
        self.assertEqual([], self.registry._get_all())
 
209
        self.registry.register_extra_lazy("bzrlib.tests.test_repository",
 
210
            "SampleExtraRepositoryFormat")
 
211
        formats = self.registry._get_all()
 
212
        self.assertEqual(1, len(formats))
 
213
        self.assertIsInstance(formats[0], SampleExtraRepositoryFormat)
306
214
 
307
215
 
308
216
class TestFormatKnit1(TestCaseWithTransport):
309
 
    
 
217
 
 
218
    def test_attribute__fetch_order(self):
 
219
        """Knits need topological data insertion."""
 
220
        repo = self.make_repository('.',
 
221
                format=controldir.format_registry.get('knit')())
 
222
        self.assertEqual('topological', repo._format._fetch_order)
 
223
 
 
224
    def test_attribute__fetch_uses_deltas(self):
 
225
        """Knits reuse deltas."""
 
226
        repo = self.make_repository('.',
 
227
                format=controldir.format_registry.get('knit')())
 
228
        self.assertEqual(True, repo._format._fetch_uses_deltas)
 
229
 
310
230
    def test_disk_layout(self):
311
231
        control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
312
232
        repo = knitrepo.RepositoryFormatKnit1().initialize(control)
396
316
        is valid when the api is not being abused.
397
317
        """
398
318
        repo = self.make_repository('.',
399
 
                format=bzrdir.format_registry.get('knit')())
 
319
                format=controldir.format_registry.get('knit')())
400
320
        inv_xml = '<inventory format="5">\n</inventory>\n'
401
 
        inv = repo.deserialise_inventory('test-rev-id', inv_xml)
 
321
        inv = repo._deserialise_inventory('test-rev-id', inv_xml)
402
322
        self.assertEqual('test-rev-id', inv.root.revision)
403
323
 
404
324
    def test_deserialise_uses_global_revision_id(self):
405
325
        """If it is set, then we re-use the global revision id"""
406
326
        repo = self.make_repository('.',
407
 
                format=bzrdir.format_registry.get('knit')())
 
327
                format=controldir.format_registry.get('knit')())
408
328
        inv_xml = ('<inventory format="5" revision_id="other-rev-id">\n'
409
329
                   '</inventory>\n')
410
330
        # Arguably, the deserialise_inventory should detect a mismatch, and
411
331
        # raise an error, rather than silently using one revision_id over the
412
332
        # other.
413
 
        self.assertRaises(AssertionError, repo.deserialise_inventory,
 
333
        self.assertRaises(AssertionError, repo._deserialise_inventory,
414
334
            'test-rev-id', inv_xml)
415
 
        inv = repo.deserialise_inventory('other-rev-id', inv_xml)
 
335
        inv = repo._deserialise_inventory('other-rev-id', inv_xml)
416
336
        self.assertEqual('other-rev-id', inv.root.revision)
417
337
 
418
338
    def test_supports_external_lookups(self):
419
339
        repo = self.make_repository('.',
420
 
                format=bzrdir.format_registry.get('knit')())
 
340
                format=controldir.format_registry.get('knit')())
421
341
        self.assertFalse(repo._format.supports_external_lookups)
422
342
 
423
343
 
424
344
class DummyRepository(object):
425
345
    """A dummy repository for testing."""
426
346
 
 
347
    _format = None
427
348
    _serializer = None
428
349
 
429
350
    def supports_rich_root(self):
 
351
        if self._format is not None:
 
352
            return self._format.rich_root_data
430
353
        return False
431
354
 
 
355
    def get_graph(self):
 
356
        raise NotImplementedError
 
357
 
 
358
    def get_parent_map(self, revision_ids):
 
359
        raise NotImplementedError
 
360
 
432
361
 
433
362
class InterDummy(repository.InterRepository):
434
363
    """An inter-repository optimised code path for DummyRepository.
441
370
    @staticmethod
442
371
    def is_compatible(repo_source, repo_target):
443
372
        """InterDummy is compatible with DummyRepository."""
444
 
        return (isinstance(repo_source, DummyRepository) and 
 
373
        return (isinstance(repo_source, DummyRepository) and
445
374
            isinstance(repo_target, DummyRepository))
446
375
 
447
376
 
455
384
        # classes do not barf inappropriately when a surprising repository type
456
385
        # is handed to them.
457
386
        dummy_a = DummyRepository()
 
387
        dummy_a._format = RepositoryFormat()
 
388
        dummy_a._format.supports_full_versioned_files = True
458
389
        dummy_b = DummyRepository()
 
390
        dummy_b._format = RepositoryFormat()
 
391
        dummy_b._format.supports_full_versioned_files = True
459
392
        self.assertGetsDefaultInterRepository(dummy_a, dummy_b)
460
393
 
461
394
    def assertGetsDefaultInterRepository(self, repo_a, repo_b):
462
395
        """Asserts that InterRepository.get(repo_a, repo_b) -> the default.
463
 
        
 
396
 
464
397
        The effective default is now InterSameDataRepository because there is
465
398
        no actual sane default in the presence of incompatible data models.
466
399
        """
467
400
        inter_repo = repository.InterRepository.get(repo_a, repo_b)
468
 
        self.assertEqual(repository.InterSameDataRepository,
 
401
        self.assertEqual(vf_repository.InterSameDataRepository,
469
402
                         inter_repo.__class__)
470
403
        self.assertEqual(repo_a, inter_repo.source)
471
404
        self.assertEqual(repo_b, inter_repo.target)
477
410
        # pair that it returns true on for the is_compatible static method
478
411
        # check
479
412
        dummy_a = DummyRepository()
 
413
        dummy_a._format = RepositoryFormat()
480
414
        dummy_b = DummyRepository()
 
415
        dummy_b._format = RepositoryFormat()
481
416
        repo = self.make_repository('.')
482
417
        # hack dummies to look like repo somewhat.
483
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
484
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
485
426
        repository.InterRepository.register_optimiser(InterDummy)
486
427
        try:
487
428
            # we should get the default for something InterDummy returns False
500
441
        self.assertGetsDefaultInterRepository(dummy_a, dummy_b)
501
442
 
502
443
 
503
 
class TestInterWeaveRepo(TestCaseWithTransport):
504
 
 
505
 
    def test_is_compatible_and_registered(self):
506
 
        # InterWeaveRepo is compatible when either side
507
 
        # is a format 5/6/7 branch
508
 
        from bzrlib.repofmt import knitrepo, weaverepo
509
 
        formats = [weaverepo.RepositoryFormat5(),
510
 
                   weaverepo.RepositoryFormat6(),
511
 
                   weaverepo.RepositoryFormat7()]
512
 
        incompatible_formats = [weaverepo.RepositoryFormat4(),
513
 
                                knitrepo.RepositoryFormatKnit1(),
514
 
                                ]
515
 
        repo_a = self.make_repository('a')
516
 
        repo_b = self.make_repository('b')
517
 
        is_compatible = repository.InterWeaveRepo.is_compatible
518
 
        for source in incompatible_formats:
519
 
            # force incompatible left then right
520
 
            repo_a._format = source
521
 
            repo_b._format = formats[0]
522
 
            self.assertFalse(is_compatible(repo_a, repo_b))
523
 
            self.assertFalse(is_compatible(repo_b, repo_a))
524
 
        for source in formats:
525
 
            repo_a._format = source
526
 
            for target in formats:
527
 
                repo_b._format = target
528
 
                self.assertTrue(is_compatible(repo_a, repo_b))
529
 
        self.assertEqual(repository.InterWeaveRepo,
530
 
                         repository.InterRepository.get(repo_a,
531
 
                                                        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"
532
456
 
533
457
 
534
458
class TestRepositoryConverter(TestCaseWithTransport):
535
459
 
536
460
    def test_convert_empty(self):
537
 
        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()
538
470
        t.mkdir('repository')
539
471
        repo_dir = bzrdir.BzrDirMetaFormat1().initialize('repository')
540
 
        repo = weaverepo.RepositoryFormat7().initialize(repo_dir)
541
 
        target_format = knitrepo.RepositoryFormatKnit1()
 
472
        repo = TestRepositoryFormat1().initialize(repo_dir)
542
473
        converter = repository.CopyConverter(target_format)
543
474
        pb = bzrlib.ui.ui_factory.nested_progress_bar()
544
475
        try:
549
480
        self.assertTrue(isinstance(target_format, repo._format.__class__))
550
481
 
551
482
 
552
 
class TestMisc(TestCase):
553
 
    
554
 
    def test_unescape_xml(self):
555
 
        """We get some kind of error when malformed entities are passed"""
556
 
        self.assertRaises(KeyError, repository._unescape_xml, 'foo&bar;') 
557
 
 
558
 
 
559
483
class TestRepositoryFormatKnit3(TestCaseWithTransport):
560
484
 
 
485
    def test_attribute__fetch_order(self):
 
486
        """Knits need topological data insertion."""
 
487
        format = bzrdir.BzrDirMetaFormat1()
 
488
        format.repository_format = knitrepo.RepositoryFormatKnit3()
 
489
        repo = self.make_repository('.', format=format)
 
490
        self.assertEqual('topological', repo._format._fetch_order)
 
491
 
 
492
    def test_attribute__fetch_uses_deltas(self):
 
493
        """Knits reuse deltas."""
 
494
        format = bzrdir.BzrDirMetaFormat1()
 
495
        format.repository_format = knitrepo.RepositoryFormatKnit3()
 
496
        repo = self.make_repository('.', format=format)
 
497
        self.assertEqual(True, repo._format._fetch_uses_deltas)
 
498
 
561
499
    def test_convert(self):
562
500
        """Ensure the upgrade adds weaves for roots"""
563
501
        format = bzrdir.BzrDirMetaFormat1()
568
506
        revision_tree.lock_read()
569
507
        try:
570
508
            self.assertRaises(errors.NoSuchFile, revision_tree.get_file_lines,
571
 
                revision_tree.inventory.root.file_id)
 
509
                revision_tree.get_root_id())
572
510
        finally:
573
511
            revision_tree.unlock()
574
512
        format = bzrdir.BzrDirMetaFormat1()
578
516
        revision_tree = tree.branch.repository.revision_tree('dull')
579
517
        revision_tree.lock_read()
580
518
        try:
581
 
            revision_tree.get_file_lines(revision_tree.inventory.root.file_id)
 
519
            revision_tree.get_file_lines(revision_tree.get_root_id())
582
520
        finally:
583
521
            revision_tree.unlock()
584
522
        tree.commit("Another dull commit", rev_id='dull2')
585
523
        revision_tree = tree.branch.repository.revision_tree('dull2')
586
524
        revision_tree.lock_read()
587
525
        self.addCleanup(revision_tree.unlock)
588
 
        self.assertEqual('dull', revision_tree.inventory.root.revision)
 
526
        self.assertEqual('dull',
 
527
                revision_tree.get_file_revision(revision_tree.get_root_id()))
589
528
 
590
529
    def test_supports_external_lookups(self):
591
530
        format = bzrdir.BzrDirMetaFormat1()
594
533
        self.assertFalse(repo._format.supports_external_lookups)
595
534
 
596
535
 
 
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)
 
622
 
 
623
    def test_inventories_use_chk_map_with_parent_base_dict(self):
 
624
        tree = self.make_branch_and_memory_tree('repo', format="2a")
 
625
        tree.lock_write()
 
626
        tree.add([''], ['TREE_ROOT'])
 
627
        revid = tree.commit("foo")
 
628
        tree.unlock()
 
629
        tree.lock_read()
 
630
        self.addCleanup(tree.unlock)
 
631
        inv = tree.branch.repository.get_inventory(revid)
 
632
        self.assertNotEqual(None, inv.parent_id_basename_to_file_id)
 
633
        inv.parent_id_basename_to_file_id._ensure_root()
 
634
        inv.id_to_entry._ensure_root()
 
635
        self.assertEqual(65536, inv.id_to_entry._root_node.maximum_size)
 
636
        self.assertEqual(65536,
 
637
            inv.parent_id_basename_to_file_id._root_node.maximum_size)
 
638
 
 
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."""
 
825
 
 
826
    def setUp(self):
 
827
        super(TestDevelopment6FindParentIdsOfRevisions, self).setUp()
 
828
        self.builder = self.make_branch_builder('source')
 
829
        self.builder.start_series()
 
830
        self.builder.build_snapshot('initial', None,
 
831
            [('add', ('', 'tree-root', 'directory', None))])
 
832
        self.repo = self.builder.get_branch().repository
 
833
        self.addCleanup(self.builder.finish_series)
 
834
 
 
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)))
 
838
 
 
839
    def test_simple(self):
 
840
        self.builder.build_snapshot('revid1', None, [])
 
841
        self.builder.build_snapshot('revid2', ['revid1'], [])
 
842
        rev_set = ['revid2']
 
843
        self.assertParentIds(['revid1'], rev_set)
 
844
 
 
845
    def test_not_first_parent(self):
 
846
        self.builder.build_snapshot('revid1', None, [])
 
847
        self.builder.build_snapshot('revid2', ['revid1'], [])
 
848
        self.builder.build_snapshot('revid3', ['revid2'], [])
 
849
        rev_set = ['revid3', 'revid2']
 
850
        self.assertParentIds(['revid1'], rev_set)
 
851
 
 
852
    def test_not_null(self):
 
853
        rev_set = ['initial']
 
854
        self.assertParentIds([], rev_set)
 
855
 
 
856
    def test_not_null_set(self):
 
857
        self.builder.build_snapshot('revid1', None, [])
 
858
        rev_set = [_mod_revision.NULL_REVISION]
 
859
        self.assertParentIds([], rev_set)
 
860
 
 
861
    def test_ghost(self):
 
862
        self.builder.build_snapshot('revid1', None, [])
 
863
        rev_set = ['ghost', 'revid1']
 
864
        self.assertParentIds(['initial'], rev_set)
 
865
 
 
866
    def test_ghost_parent(self):
 
867
        self.builder.build_snapshot('revid1', None, [])
 
868
        self.builder.build_snapshot('revid2', ['revid1', 'ghost'], [])
 
869
        rev_set = ['revid2', 'revid1']
 
870
        self.assertParentIds(['ghost', 'initial'], rev_set)
 
871
 
 
872
    def test_righthand_parent(self):
 
873
        self.builder.build_snapshot('revid1', None, [])
 
874
        self.builder.build_snapshot('revid2a', ['revid1'], [])
 
875
        self.builder.build_snapshot('revid2b', ['revid1'], [])
 
876
        self.builder.build_snapshot('revid3', ['revid2a', 'revid2b'], [])
 
877
        rev_set = ['revid3', 'revid2a']
 
878
        self.assertParentIds(['revid1', 'revid2b'], rev_set)
 
879
 
 
880
 
597
881
class TestWithBrokenRepo(TestCaseWithTransport):
598
882
    """These tests seem to be more appropriate as interface tests?"""
599
883
 
612
896
            inv = inventory.Inventory(revision_id='rev1a')
613
897
            inv.root.revision = 'rev1a'
614
898
            self.add_file(repo, inv, 'file1', 'rev1a', [])
 
899
            repo.texts.add_lines((inv.root.file_id, 'rev1a'), [], [])
615
900
            repo.add_inventory('rev1a', inv, [])
616
901
            revision = _mod_revision.Revision('rev1a',
617
902
                committer='jrandom@example.com', timestamp=0,
618
903
                inventory_sha1='', timezone=0, message='foo', parent_ids=[])
619
 
            repo.add_revision('rev1a',revision, inv)
 
904
            repo.add_revision('rev1a', revision, inv)
620
905
 
621
906
            # make rev1b, which has no Revision, but has an Inventory, and
622
907
            # file1
652
937
    def add_revision(self, repo, revision_id, inv, parent_ids):
653
938
        inv.revision_id = revision_id
654
939
        inv.root.revision = revision_id
 
940
        repo.texts.add_lines((inv.root.file_id, revision_id), [], [])
655
941
        repo.add_inventory(revision_id, inv, parent_ids)
656
942
        revision = _mod_revision.Revision(revision_id,
657
943
            committer='jrandom@example.com', timestamp=0, inventory_sha1='',
658
944
            timezone=0, message='foo', parent_ids=parent_ids)
659
 
        repo.add_revision(revision_id,revision, inv)
 
945
        repo.add_revision(revision_id, revision, inv)
660
946
 
661
947
    def add_file(self, repo, inv, filename, revision, parents):
662
948
        file_id = filename + '-id'
674
960
        """
675
961
        broken_repo = self.make_broken_repository()
676
962
        empty_repo = self.make_repository('empty-repo')
677
 
        self.assertRaises(errors.RevisionNotPresent, empty_repo.fetch, broken_repo)
678
 
 
679
 
 
680
 
class TestKnitPackNoSubtrees(TestCaseWithTransport):
681
 
 
682
 
    def get_format(self):
683
 
        return bzrdir.format_registry.make_bzrdir('pack-0.92')
684
 
 
685
 
    def test_disk_layout(self):
686
 
        format = self.get_format()
687
 
        repo = self.make_repository('.', format=format)
688
 
        # in case of side effects of locking.
689
 
        repo.lock_write()
690
 
        repo.unlock()
691
 
        t = repo.bzrdir.get_repository_transport(None)
692
 
        self.check_format(t)
693
 
        # XXX: no locks left when unlocked at the moment
694
 
        # self.assertEqualDiff('', t.get('lock').read())
695
 
        self.check_databases(t)
696
 
 
697
 
    def check_format(self, t):
698
 
        self.assertEqualDiff(
699
 
            "Bazaar pack repository format 1 (needs bzr 0.92)\n",
700
 
                             t.get('format').read())
701
 
 
702
 
    def assertHasNoKndx(self, t, knit_name):
703
 
        """Assert that knit_name has no index on t."""
704
 
        self.assertFalse(t.has(knit_name + '.kndx'))
705
 
 
706
 
    def assertHasNoKnit(self, t, knit_name):
707
 
        """Assert that knit_name exists on t."""
708
 
        # no default content
709
 
        self.assertFalse(t.has(knit_name + '.knit'))
710
 
 
711
 
    def check_databases(self, t):
712
 
        """check knit content for a repository."""
713
 
        # check conversion worked
714
 
        self.assertHasNoKndx(t, 'inventory')
715
 
        self.assertHasNoKnit(t, 'inventory')
716
 
        self.assertHasNoKndx(t, 'revisions')
717
 
        self.assertHasNoKnit(t, 'revisions')
718
 
        self.assertHasNoKndx(t, 'signatures')
719
 
        self.assertHasNoKnit(t, 'signatures')
720
 
        self.assertFalse(t.has('knits'))
721
 
        # revision-indexes file-container directory
722
 
        self.assertEqual([],
723
 
            list(GraphIndex(t, 'pack-names', None).iter_all_entries()))
724
 
        self.assertTrue(S_ISDIR(t.stat('packs').st_mode))
725
 
        self.assertTrue(S_ISDIR(t.stat('upload').st_mode))
726
 
        self.assertTrue(S_ISDIR(t.stat('indices').st_mode))
727
 
        self.assertTrue(S_ISDIR(t.stat('obsolete_packs').st_mode))
728
 
 
729
 
    def test_shared_disk_layout(self):
730
 
        format = self.get_format()
731
 
        repo = self.make_repository('.', shared=True, format=format)
732
 
        # we want:
733
 
        t = repo.bzrdir.get_repository_transport(None)
734
 
        self.check_format(t)
735
 
        # XXX: no locks left when unlocked at the moment
736
 
        # self.assertEqualDiff('', t.get('lock').read())
737
 
        # We should have a 'shared-storage' marker file.
738
 
        self.assertEqualDiff('', t.get('shared-storage').read())
739
 
        self.check_databases(t)
740
 
 
741
 
    def test_shared_no_tree_disk_layout(self):
742
 
        format = self.get_format()
743
 
        repo = self.make_repository('.', shared=True, format=format)
744
 
        repo.set_make_working_trees(False)
745
 
        # we want:
746
 
        t = repo.bzrdir.get_repository_transport(None)
747
 
        self.check_format(t)
748
 
        # XXX: no locks left when unlocked at the moment
749
 
        # self.assertEqualDiff('', t.get('lock').read())
750
 
        # We should have a 'shared-storage' marker file.
751
 
        self.assertEqualDiff('', t.get('shared-storage').read())
752
 
        # We should have a marker for the no-working-trees flag.
753
 
        self.assertEqualDiff('', t.get('no-working-trees').read())
754
 
        # The marker should go when we toggle the setting.
755
 
        repo.set_make_working_trees(True)
756
 
        self.assertFalse(t.has('no-working-trees'))
757
 
        self.check_databases(t)
758
 
 
759
 
    def test_adding_revision_creates_pack_indices(self):
760
 
        format = self.get_format()
761
 
        tree = self.make_branch_and_tree('.', format=format)
762
 
        trans = tree.branch.repository.bzrdir.get_repository_transport(None)
763
 
        self.assertEqual([],
764
 
            list(GraphIndex(trans, 'pack-names', None).iter_all_entries()))
765
 
        tree.commit('foobarbaz')
766
 
        index = GraphIndex(trans, 'pack-names', None)
767
 
        index_nodes = list(index.iter_all_entries())
768
 
        self.assertEqual(1, len(index_nodes))
769
 
        node = index_nodes[0]
770
 
        name = node[1][0]
771
 
        # the pack sizes should be listed in the index
772
 
        pack_value = node[2]
773
 
        sizes = [int(digits) for digits in pack_value.split(' ')]
774
 
        for size, suffix in zip(sizes, ['.rix', '.iix', '.tix', '.six']):
775
 
            stat = trans.stat('indices/%s%s' % (name, suffix))
776
 
            self.assertEqual(size, stat.st_size)
777
 
 
778
 
    def test_pulling_nothing_leads_to_no_new_names(self):
779
 
        format = self.get_format()
780
 
        tree1 = self.make_branch_and_tree('1', format=format)
781
 
        tree2 = self.make_branch_and_tree('2', format=format)
782
 
        tree1.branch.repository.fetch(tree2.branch.repository)
783
 
        trans = tree1.branch.repository.bzrdir.get_repository_transport(None)
784
 
        self.assertEqual([],
785
 
            list(GraphIndex(trans, 'pack-names', None).iter_all_entries()))
786
 
 
787
 
    def test_commit_across_pack_shape_boundary_autopacks(self):
788
 
        format = self.get_format()
789
 
        tree = self.make_branch_and_tree('.', format=format)
790
 
        trans = tree.branch.repository.bzrdir.get_repository_transport(None)
791
 
        # This test could be a little cheaper by replacing the packs
792
 
        # attribute on the repository to allow a different pack distribution
793
 
        # and max packs policy - so we are checking the policy is honoured
794
 
        # in the test. But for now 11 commits is not a big deal in a single
795
 
        # test.
796
 
        for x in range(9):
797
 
            tree.commit('commit %s' % x)
798
 
        # there should be 9 packs:
799
 
        index = GraphIndex(trans, 'pack-names', None)
800
 
        self.assertEqual(9, len(list(index.iter_all_entries())))
801
 
        # insert some files in obsolete_packs which should be removed by pack.
802
 
        trans.put_bytes('obsolete_packs/foo', '123')
803
 
        trans.put_bytes('obsolete_packs/bar', '321')
804
 
        # committing one more should coalesce to 1 of 10.
805
 
        tree.commit('commit triggering pack')
806
 
        index = GraphIndex(trans, 'pack-names', None)
807
 
        self.assertEqual(1, len(list(index.iter_all_entries())))
808
 
        # packing should not damage data
809
 
        tree = tree.bzrdir.open_workingtree()
810
 
        check_result = tree.branch.repository.check(
811
 
            [tree.branch.last_revision()])
812
 
        # We should have 50 (10x5) files in the obsolete_packs directory.
813
 
        obsolete_files = list(trans.list_dir('obsolete_packs'))
814
 
        self.assertFalse('foo' in obsolete_files)
815
 
        self.assertFalse('bar' in obsolete_files)
816
 
        self.assertEqual(50, len(obsolete_files))
817
 
        # XXX: Todo check packs obsoleted correctly - old packs and indices
818
 
        # in the obsolete_packs directory.
819
 
        large_pack_name = list(index.iter_all_entries())[0][1][0]
820
 
        # finally, committing again should not touch the large pack.
821
 
        tree.commit('commit not triggering pack')
822
 
        index = GraphIndex(trans, 'pack-names', None)
823
 
        self.assertEqual(2, len(list(index.iter_all_entries())))
824
 
        pack_names = [node[1][0] for node in index.iter_all_entries()]
825
 
        self.assertTrue(large_pack_name in pack_names)
826
 
 
827
 
    def test_fail_obsolete_deletion(self):
828
 
        # failing to delete obsolete packs is not fatal
829
 
        format = self.get_format()
830
 
        server = fakenfs.FakeNFSServer()
831
 
        server.setUp()
832
 
        self.addCleanup(server.tearDown)
833
 
        transport = get_transport(server.get_url())
834
 
        bzrdir = self.get_format().initialize_on_transport(transport)
835
 
        repo = bzrdir.create_repository()
836
 
        repo_transport = bzrdir.get_repository_transport(None)
837
 
        self.assertTrue(repo_transport.has('obsolete_packs'))
838
 
        # these files are in use by another client and typically can't be deleted
839
 
        repo_transport.put_bytes('obsolete_packs/.nfsblahblah', 'contents')
840
 
        repo._pack_collection._clear_obsolete_packs()
841
 
        self.assertTrue(repo_transport.has('obsolete_packs/.nfsblahblah'))
842
 
 
843
 
    def test_pack_after_two_commits_packs_everything(self):
844
 
        format = self.get_format()
845
 
        tree = self.make_branch_and_tree('.', format=format)
846
 
        trans = tree.branch.repository.bzrdir.get_repository_transport(None)
847
 
        tree.commit('start')
848
 
        tree.commit('more work')
849
 
        tree.branch.repository.pack()
850
 
        # there should be 1 pack:
851
 
        index = GraphIndex(trans, 'pack-names', None)
852
 
        self.assertEqual(1, len(list(index.iter_all_entries())))
853
 
        self.assertEqual(2, len(tree.branch.repository.all_revision_ids()))
854
 
 
855
 
    def test_pack_layout(self):
856
 
        format = self.get_format()
857
 
        tree = self.make_branch_and_tree('.', format=format)
858
 
        trans = tree.branch.repository.bzrdir.get_repository_transport(None)
859
 
        tree.commit('start', rev_id='1')
860
 
        tree.commit('more work', rev_id='2')
861
 
        tree.branch.repository.pack()
862
 
        tree.lock_read()
863
 
        self.addCleanup(tree.unlock)
864
 
        pack = tree.branch.repository._pack_collection.get_pack_by_name(
865
 
            tree.branch.repository._pack_collection.names()[0])
866
 
        # revision access tends to be tip->ancestor, so ordering that way on 
867
 
        # disk is a good idea.
868
 
        for _1, key, val, refs in pack.revision_index.iter_all_entries():
869
 
            if key == ('1',):
870
 
                pos_1 = int(val[1:].split()[0])
871
 
            else:
872
 
                pos_2 = int(val[1:].split()[0])
873
 
        self.assertTrue(pos_2 < pos_1)
874
 
 
875
 
    def test_pack_repositories_support_multiple_write_locks(self):
876
 
        format = self.get_format()
877
 
        self.make_repository('.', shared=True, format=format)
878
 
        r1 = repository.Repository.open('.')
879
 
        r2 = repository.Repository.open('.')
880
 
        r1.lock_write()
881
 
        self.addCleanup(r1.unlock)
882
 
        r2.lock_write()
883
 
        r2.unlock()
884
 
 
885
 
    def _add_text(self, repo, fileid):
886
 
        """Add a text to the repository within a write group."""
887
 
        repo.texts.add_lines((fileid, 'samplerev+'+fileid), [], [])
888
 
 
889
 
    def test_concurrent_writers_merge_new_packs(self):
890
 
        format = self.get_format()
891
 
        self.make_repository('.', shared=True, format=format)
892
 
        r1 = repository.Repository.open('.')
893
 
        r2 = repository.Repository.open('.')
894
 
        r1.lock_write()
895
 
        try:
896
 
            # access enough data to load the names list
897
 
            list(r1.all_revision_ids())
898
 
            r2.lock_write()
899
 
            try:
900
 
                # access enough data to load the names list
901
 
                list(r2.all_revision_ids())
902
 
                r1.start_write_group()
903
 
                try:
904
 
                    r2.start_write_group()
905
 
                    try:
906
 
                        self._add_text(r1, 'fileidr1')
907
 
                        self._add_text(r2, 'fileidr2')
908
 
                    except:
909
 
                        r2.abort_write_group()
910
 
                        raise
911
 
                except:
912
 
                    r1.abort_write_group()
913
 
                    raise
914
 
                # both r1 and r2 have open write groups with data in them
915
 
                # created while the other's write group was open.
916
 
                # Commit both which requires a merge to the pack-names.
917
 
                try:
918
 
                    r1.commit_write_group()
919
 
                except:
920
 
                    r1.abort_write_group()
921
 
                    r2.abort_write_group()
922
 
                    raise
923
 
                r2.commit_write_group()
924
 
                # tell r1 to reload from disk
925
 
                r1._pack_collection.reset()
926
 
                # Now both repositories should know about both names
927
 
                r1._pack_collection.ensure_loaded()
928
 
                r2._pack_collection.ensure_loaded()
929
 
                self.assertEqual(r1._pack_collection.names(), r2._pack_collection.names())
930
 
                self.assertEqual(2, len(r1._pack_collection.names()))
931
 
            finally:
932
 
                r2.unlock()
933
 
        finally:
934
 
            r1.unlock()
935
 
 
936
 
    def test_concurrent_writer_second_preserves_dropping_a_pack(self):
937
 
        format = self.get_format()
938
 
        self.make_repository('.', shared=True, format=format)
939
 
        r1 = repository.Repository.open('.')
940
 
        r2 = repository.Repository.open('.')
941
 
        # add a pack to drop
942
 
        r1.lock_write()
943
 
        try:
944
 
            r1.start_write_group()
945
 
            try:
946
 
                self._add_text(r1, 'fileidr1')
947
 
            except:
948
 
                r1.abort_write_group()
949
 
                raise
950
 
            else:
951
 
                r1.commit_write_group()
952
 
            r1._pack_collection.ensure_loaded()
953
 
            name_to_drop = r1._pack_collection.all_packs()[0].name
954
 
        finally:
955
 
            r1.unlock()
956
 
        r1.lock_write()
957
 
        try:
958
 
            # access enough data to load the names list
959
 
            list(r1.all_revision_ids())
960
 
            r2.lock_write()
961
 
            try:
962
 
                # access enough data to load the names list
963
 
                list(r2.all_revision_ids())
964
 
                r1._pack_collection.ensure_loaded()
965
 
                try:
966
 
                    r2.start_write_group()
967
 
                    try:
968
 
                        # in r1, drop the pack
969
 
                        r1._pack_collection._remove_pack_from_memory(
970
 
                            r1._pack_collection.get_pack_by_name(name_to_drop))
971
 
                        # in r2, add a pack
972
 
                        self._add_text(r2, 'fileidr2')
973
 
                    except:
974
 
                        r2.abort_write_group()
975
 
                        raise
976
 
                except:
977
 
                    r1._pack_collection.reset()
978
 
                    raise
979
 
                # r1 has a changed names list, and r2 an open write groups with
980
 
                # changes.
981
 
                # save r1, and then commit the r2 write group, which requires a
982
 
                # merge to the pack-names, which should not reinstate
983
 
                # name_to_drop
984
 
                try:
985
 
                    r1._pack_collection._save_pack_names()
986
 
                    r1._pack_collection.reset()
987
 
                except:
988
 
                    r2.abort_write_group()
989
 
                    raise
990
 
                try:
991
 
                    r2.commit_write_group()
992
 
                except:
993
 
                    r2.abort_write_group()
994
 
                    raise
995
 
                # Now both repositories should now about just one name.
996
 
                r1._pack_collection.ensure_loaded()
997
 
                r2._pack_collection.ensure_loaded()
998
 
                self.assertEqual(r1._pack_collection.names(), r2._pack_collection.names())
999
 
                self.assertEqual(1, len(r1._pack_collection.names()))
1000
 
                self.assertFalse(name_to_drop in r1._pack_collection.names())
1001
 
            finally:
1002
 
                r2.unlock()
1003
 
        finally:
1004
 
            r1.unlock()
1005
 
 
1006
 
    def test_lock_write_does_not_physically_lock(self):
1007
 
        repo = self.make_repository('.', format=self.get_format())
1008
 
        repo.lock_write()
1009
 
        self.addCleanup(repo.unlock)
1010
 
        self.assertFalse(repo.get_physical_lock_status())
1011
 
 
1012
 
    def prepare_for_break_lock(self):
1013
 
        # Setup the global ui factory state so that a break-lock method call
1014
 
        # will find usable input in the input stream.
1015
 
        old_factory = bzrlib.ui.ui_factory
1016
 
        def restoreFactory():
1017
 
            bzrlib.ui.ui_factory = old_factory
1018
 
        self.addCleanup(restoreFactory)
1019
 
        bzrlib.ui.ui_factory = bzrlib.ui.SilentUIFactory()
1020
 
        bzrlib.ui.ui_factory.stdin = StringIO("y\n")
1021
 
 
1022
 
    def test_break_lock_breaks_physical_lock(self):
1023
 
        repo = self.make_repository('.', format=self.get_format())
1024
 
        repo._pack_collection.lock_names()
1025
 
        repo2 = repository.Repository.open('.')
1026
 
        self.assertTrue(repo.get_physical_lock_status())
1027
 
        self.prepare_for_break_lock()
1028
 
        repo2.break_lock()
1029
 
        self.assertFalse(repo.get_physical_lock_status())
1030
 
 
1031
 
    def test_broken_physical_locks_error_on__unlock_names_lock(self):
1032
 
        repo = self.make_repository('.', format=self.get_format())
1033
 
        repo._pack_collection.lock_names()
1034
 
        self.assertTrue(repo.get_physical_lock_status())
1035
 
        repo2 = repository.Repository.open('.')
1036
 
        self.prepare_for_break_lock()
1037
 
        repo2.break_lock()
1038
 
        self.assertRaises(errors.LockBroken, repo._pack_collection._unlock_names)
1039
 
 
1040
 
    def test_fetch_without_find_ghosts_ignores_ghosts(self):
1041
 
        # we want two repositories at this point:
1042
 
        # one with a revision that is a ghost in the other
1043
 
        # repository.
1044
 
        # 'ghost' is present in has_ghost, 'ghost' is absent in 'missing_ghost'.
1045
 
        # 'references' is present in both repositories, and 'tip' is present
1046
 
        # just in has_ghost.
1047
 
        # has_ghost       missing_ghost
1048
 
        #------------------------------
1049
 
        # 'ghost'             -
1050
 
        # 'references'    'references'
1051
 
        # 'tip'               -
1052
 
        # In this test we fetch 'tip' which should not fetch 'ghost'
1053
 
        has_ghost = self.make_repository('has_ghost', format=self.get_format())
1054
 
        missing_ghost = self.make_repository('missing_ghost',
1055
 
            format=self.get_format())
1056
 
 
1057
 
        def add_commit(repo, revision_id, parent_ids):
1058
 
            repo.lock_write()
1059
 
            repo.start_write_group()
1060
 
            inv = inventory.Inventory(revision_id=revision_id)
1061
 
            inv.root.revision = revision_id
1062
 
            root_id = inv.root.file_id
1063
 
            sha1 = repo.add_inventory(revision_id, inv, [])
1064
 
            repo.texts.add_lines((root_id, revision_id), [], [])
1065
 
            rev = bzrlib.revision.Revision(timestamp=0,
1066
 
                                           timezone=None,
1067
 
                                           committer="Foo Bar <foo@example.com>",
1068
 
                                           message="Message",
1069
 
                                           inventory_sha1=sha1,
1070
 
                                           revision_id=revision_id)
1071
 
            rev.parent_ids = parent_ids
1072
 
            repo.add_revision(revision_id, rev)
1073
 
            repo.commit_write_group()
1074
 
            repo.unlock()
1075
 
        add_commit(has_ghost, 'ghost', [])
1076
 
        add_commit(has_ghost, 'references', ['ghost'])
1077
 
        add_commit(missing_ghost, 'references', ['ghost'])
1078
 
        add_commit(has_ghost, 'tip', ['references'])
1079
 
        missing_ghost.fetch(has_ghost, 'tip')
1080
 
        # missing ghost now has tip and not ghost.
1081
 
        rev = missing_ghost.get_revision('tip')
1082
 
        inv = missing_ghost.get_inventory('tip')
1083
 
        self.assertRaises(errors.NoSuchRevision,
1084
 
            missing_ghost.get_revision, 'ghost')
1085
 
        self.assertRaises(errors.NoSuchRevision,
1086
 
            missing_ghost.get_inventory, 'ghost')
1087
 
 
1088
 
    def test_supports_external_lookups(self):
1089
 
        repo = self.make_repository('.', format=self.get_format())
1090
 
        self.assertFalse(repo._format.supports_external_lookups)
1091
 
 
1092
 
 
1093
 
class TestKnitPackSubtrees(TestKnitPackNoSubtrees):
1094
 
 
1095
 
    def get_format(self):
1096
 
        return bzrdir.format_registry.make_bzrdir(
1097
 
            'pack-0.92-subtree')
1098
 
 
1099
 
    def check_format(self, t):
1100
 
        self.assertEqualDiff(
1101
 
            "Bazaar pack repository format 1 with subtree support (needs bzr 0.92)\n",
1102
 
            t.get('format').read())
1103
 
 
1104
 
 
1105
 
class TestDevelopment0(TestKnitPackNoSubtrees):
1106
 
 
1107
 
    def get_format(self):
1108
 
        return bzrdir.format_registry.make_bzrdir(
1109
 
            'development0')
1110
 
 
1111
 
    def check_format(self, t):
1112
 
        self.assertEqualDiff(
1113
 
            "Bazaar development format 0 (needs bzr.dev from before 1.3)\n",
1114
 
            t.get('format').read())
1115
 
 
1116
 
 
1117
 
class TestDevelopment0Subtree(TestKnitPackNoSubtrees):
1118
 
 
1119
 
    def get_format(self):
1120
 
        return bzrdir.format_registry.make_bzrdir(
1121
 
            'development0-subtree')
1122
 
 
1123
 
    def check_format(self, t):
1124
 
        self.assertEqualDiff(
1125
 
            "Bazaar development format 0 with subtree support "
1126
 
            "(needs bzr.dev from before 1.3)\n",
1127
 
            t.get('format').read())
1128
 
 
1129
 
 
1130
 
class TestExternalDevelopment1(object):
1131
 
 
1132
 
    # mixin class for testing stack-supporting development formats
1133
 
 
1134
 
    def test_compatible_cross_formats(self):
1135
 
        # early versions of the packing code relied on pack internals to
1136
 
        # stack, but the current version should be able to stack on any
1137
 
        # format.
1138
 
        repo = self.make_repository('repo', format=self.get_format())
1139
 
        if repo.supports_rich_root():
1140
 
            # can only stack on repositories that have compatible internal
1141
 
            # metadata
1142
 
            matching_format_name = 'pack-0.92-subtree'
1143
 
            mismatching_format_name = 'pack-0.92'
1144
 
        else:
1145
 
            matching_format_name = 'pack-0.92'
1146
 
            mismatching_format_name = 'pack-0.92-subtree'
1147
 
        base = self.make_repository('base', format=matching_format_name)
1148
 
        repo.add_fallback_repository(base)
1149
 
        # you can't stack on something with incompatible data
1150
 
        bad_repo = self.make_repository('mismatch',
1151
 
            format=mismatching_format_name)
1152
 
        self.assertRaises(errors.IncompatibleRepositories,
1153
 
            repo.add_fallback_repository, bad_repo)
1154
 
 
1155
 
    def test_adding_pack_does_not_record_pack_names_from_other_repositories(self):
1156
 
        base = self.make_branch_and_tree('base', format=self.get_format())
1157
 
        base.commit('foo')
1158
 
        referencing = self.make_branch_and_tree('repo', format=self.get_format())
1159
 
        referencing.branch.repository.add_fallback_repository(base.branch.repository)
1160
 
        referencing.commit('bar')
1161
 
        new_instance = referencing.bzrdir.open_repository()
1162
 
        new_instance.lock_read()
1163
 
        self.addCleanup(new_instance.unlock)
1164
 
        new_instance._pack_collection.ensure_loaded()
1165
 
        self.assertEqual(1, len(new_instance._pack_collection.all_packs()))
1166
 
 
1167
 
    def test_autopack_only_considers_main_repo_packs(self):
1168
 
        base = self.make_branch_and_tree('base', format=self.get_format())
1169
 
        base.commit('foo')
1170
 
        tree = self.make_branch_and_tree('repo', format=self.get_format())
1171
 
        tree.branch.repository.add_fallback_repository(base.branch.repository)
1172
 
        trans = tree.branch.repository.bzrdir.get_repository_transport(None)
1173
 
        # This test could be a little cheaper by replacing the packs
1174
 
        # attribute on the repository to allow a different pack distribution
1175
 
        # and max packs policy - so we are checking the policy is honoured
1176
 
        # in the test. But for now 11 commits is not a big deal in a single
1177
 
        # test.
1178
 
        for x in range(9):
1179
 
            tree.commit('commit %s' % x)
1180
 
        # there should be 9 packs:
1181
 
        index = GraphIndex(trans, 'pack-names', None)
1182
 
        self.assertEqual(9, len(list(index.iter_all_entries())))
1183
 
        # committing one more should coalesce to 1 of 10.
1184
 
        tree.commit('commit triggering pack')
1185
 
        index = GraphIndex(trans, 'pack-names', None)
1186
 
        self.assertEqual(1, len(list(index.iter_all_entries())))
1187
 
        # packing should not damage data
1188
 
        tree = tree.bzrdir.open_workingtree()
1189
 
        check_result = tree.branch.repository.check(
1190
 
            [tree.branch.last_revision()])
1191
 
        # We should have 50 (10x5) files in the obsolete_packs directory.
1192
 
        obsolete_files = list(trans.list_dir('obsolete_packs'))
1193
 
        self.assertFalse('foo' in obsolete_files)
1194
 
        self.assertFalse('bar' in obsolete_files)
1195
 
        self.assertEqual(50, len(obsolete_files))
1196
 
        # XXX: Todo check packs obsoleted correctly - old packs and indices
1197
 
        # in the obsolete_packs directory.
1198
 
        large_pack_name = list(index.iter_all_entries())[0][1][0]
1199
 
        # finally, committing again should not touch the large pack.
1200
 
        tree.commit('commit not triggering pack')
1201
 
        index = GraphIndex(trans, 'pack-names', None)
1202
 
        self.assertEqual(2, len(list(index.iter_all_entries())))
1203
 
        pack_names = [node[1][0] for node in index.iter_all_entries()]
1204
 
        self.assertTrue(large_pack_name in pack_names)
1205
 
 
1206
 
 
1207
 
class TestDevelopment1(TestKnitPackNoSubtrees, TestExternalDevelopment1):
1208
 
 
1209
 
    def get_format(self):
1210
 
        return bzrdir.format_registry.make_bzrdir(
1211
 
            'development')
1212
 
 
1213
 
    def check_format(self, t):
1214
 
        self.assertEqualDiff(
1215
 
            "Bazaar development format 1 (needs bzr.dev from before 1.6)\n",
1216
 
            t.get('format').read())
1217
 
 
1218
 
    def test_supports_external_lookups(self):
1219
 
        repo = self.make_repository('.', format=self.get_format())
1220
 
        self.assertTrue(repo._format.supports_external_lookups)
1221
 
 
1222
 
 
1223
 
class TestDevelopment1Subtree(TestKnitPackNoSubtrees, TestExternalDevelopment1):
1224
 
 
1225
 
    def get_format(self):
1226
 
        return bzrdir.format_registry.make_bzrdir(
1227
 
            'development-subtree')
1228
 
 
1229
 
    def check_format(self, t):
1230
 
        self.assertEqualDiff(
1231
 
            "Bazaar development format 1 with subtree support "
1232
 
            "(needs bzr.dev from before 1.6)\n",
1233
 
            t.get('format').read())
1234
 
 
1235
 
    def test_supports_external_lookups(self):
1236
 
        repo = self.make_repository('.', format=self.get_format())
1237
 
        self.assertTrue(repo._format.supports_external_lookups)
 
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'))
1238
974
 
1239
975
 
1240
976
class TestRepositoryPackCollection(TestCaseWithTransport):
1241
977
 
1242
978
    def get_format(self):
1243
 
        return bzrdir.format_registry.make_bzrdir('pack-0.92')
 
979
        return controldir.format_registry.make_bzrdir('pack-0.92')
 
980
 
 
981
    def get_packs(self):
 
982
        format = self.get_format()
 
983
        repo = self.make_repository('.', format=format)
 
984
        return repo._pack_collection
 
985
 
 
986
    def make_packs_and_alt_repo(self, write_lock=False):
 
987
        """Create a pack repo with 3 packs, and access it via a second repo."""
 
988
        tree = self.make_branch_and_tree('.', format=self.get_format())
 
989
        tree.lock_write()
 
990
        self.addCleanup(tree.unlock)
 
991
        rev1 = tree.commit('one')
 
992
        rev2 = tree.commit('two')
 
993
        rev3 = tree.commit('three')
 
994
        r = repository.Repository.open('.')
 
995
        if write_lock:
 
996
            r.lock_write()
 
997
        else:
 
998
            r.lock_read()
 
999
        self.addCleanup(r.unlock)
 
1000
        packs = r._pack_collection
 
1001
        packs.ensure_loaded()
 
1002
        return tree, r, packs, [rev1, rev2, rev3]
 
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('.')))
1244
1028
 
1245
1029
    def test__max_pack_count(self):
1246
1030
        """The maximum pack count is a function of the number of revisions."""
1247
 
        format = self.get_format()
1248
 
        repo = self.make_repository('.', format=format)
1249
 
        packs = repo._pack_collection
1250
1031
        # no revisions - one pack, so that we can have a revision free repo
1251
1032
        # without it blowing up
 
1033
        packs = self.get_packs()
1252
1034
        self.assertEqual(1, packs._max_pack_count(0))
1253
1035
        # after that the sum of the digits, - check the first 1-9
1254
1036
        self.assertEqual(1, packs._max_pack_count(1))
1269
1051
        # check some arbitrary big numbers
1270
1052
        self.assertEqual(25, packs._max_pack_count(112894))
1271
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
 
1272
1098
    def test_pack_distribution_zero(self):
1273
 
        format = self.get_format()
1274
 
        repo = self.make_repository('.', format=format)
1275
 
        packs = repo._pack_collection
 
1099
        packs = self.get_packs()
1276
1100
        self.assertEqual([0], packs.pack_distribution(0))
1277
1101
 
1278
1102
    def test_ensure_loaded_unlocked(self):
1279
 
        format = self.get_format()
1280
 
        repo = self.make_repository('.', format=format)
 
1103
        packs = self.get_packs()
1281
1104
        self.assertRaises(errors.ObjectNotLocked,
1282
 
                          repo._pack_collection.ensure_loaded)
 
1105
                          packs.ensure_loaded)
1283
1106
 
1284
1107
    def test_pack_distribution_one_to_nine(self):
1285
 
        format = self.get_format()
1286
 
        repo = self.make_repository('.', format=format)
1287
 
        packs = repo._pack_collection
 
1108
        packs = self.get_packs()
1288
1109
        self.assertEqual([1],
1289
1110
            packs.pack_distribution(1))
1290
1111
        self.assertEqual([1, 1],
1306
1127
 
1307
1128
    def test_pack_distribution_stable_at_boundaries(self):
1308
1129
        """When there are multi-rev packs the counts are stable."""
1309
 
        format = self.get_format()
1310
 
        repo = self.make_repository('.', format=format)
1311
 
        packs = repo._pack_collection
 
1130
        packs = self.get_packs()
1312
1131
        # in 10s:
1313
1132
        self.assertEqual([10], packs.pack_distribution(10))
1314
1133
        self.assertEqual([10, 1], packs.pack_distribution(11))
1323
1142
        self.assertEqual([100, 100, 10, 1], packs.pack_distribution(211))
1324
1143
 
1325
1144
    def test_plan_pack_operations_2009_revisions_skip_all_packs(self):
1326
 
        format = self.get_format()
1327
 
        repo = self.make_repository('.', format=format)
1328
 
        packs = repo._pack_collection
 
1145
        packs = self.get_packs()
1329
1146
        existing_packs = [(2000, "big"), (9, "medium")]
1330
1147
        # rev count - 2009 -> 2x1000 + 9x1
1331
1148
        pack_operations = packs.plan_autopack_combinations(
1333
1150
        self.assertEqual([], pack_operations)
1334
1151
 
1335
1152
    def test_plan_pack_operations_2010_revisions_skip_all_packs(self):
1336
 
        format = self.get_format()
1337
 
        repo = self.make_repository('.', format=format)
1338
 
        packs = repo._pack_collection
 
1153
        packs = self.get_packs()
1339
1154
        existing_packs = [(2000, "big"), (9, "medium"), (1, "single")]
1340
1155
        # rev count - 2010 -> 2x1000 + 1x10
1341
1156
        pack_operations = packs.plan_autopack_combinations(
1343
1158
        self.assertEqual([], pack_operations)
1344
1159
 
1345
1160
    def test_plan_pack_operations_2010_combines_smallest_two(self):
1346
 
        format = self.get_format()
1347
 
        repo = self.make_repository('.', format=format)
1348
 
        packs = repo._pack_collection
 
1161
        packs = self.get_packs()
1349
1162
        existing_packs = [(1999, "big"), (9, "medium"), (1, "single2"),
1350
1163
            (1, "single1")]
1351
1164
        # rev count - 2010 -> 2x1000 + 1x10 (3)
1352
1165
        pack_operations = packs.plan_autopack_combinations(
1353
1166
            existing_packs, [1000, 1000, 10])
1354
 
        self.assertEqual([[2, ["single2", "single1"]], [0, []]], pack_operations)
 
1167
        self.assertEqual([[2, ["single2", "single1"]]], pack_operations)
 
1168
 
 
1169
    def test_plan_pack_operations_creates_a_single_op(self):
 
1170
        packs = self.get_packs()
 
1171
        existing_packs = [(50, 'a'), (40, 'b'), (30, 'c'), (10, 'd'),
 
1172
                          (10, 'e'), (6, 'f'), (4, 'g')]
 
1173
        # rev count 150 -> 1x100 and 5x10
 
1174
        # The two size 10 packs do not need to be touched. The 50, 40, 30 would
 
1175
        # be combined into a single 120 size pack, and the 6 & 4 would
 
1176
        # becombined into a size 10 pack. However, if we have to rewrite them,
 
1177
        # we save a pack file with no increased I/O by putting them into the
 
1178
        # same file.
 
1179
        distribution = packs.pack_distribution(150)
 
1180
        pack_operations = packs.plan_autopack_combinations(existing_packs,
 
1181
                                                           distribution)
 
1182
        self.assertEqual([[130, ['a', 'b', 'c', 'f', 'g']]], pack_operations)
1355
1183
 
1356
1184
    def test_all_packs_none(self):
1357
1185
        format = self.get_format()
1395
1223
        tree.lock_read()
1396
1224
        self.addCleanup(tree.unlock)
1397
1225
        packs = tree.branch.repository._pack_collection
 
1226
        packs.reset()
1398
1227
        packs.ensure_loaded()
1399
1228
        name = packs.names()[0]
1400
1229
        pack_1 = packs.get_pack_by_name(name)
1409
1238
        # and the same instance should be returned on successive calls.
1410
1239
        self.assertTrue(pack_1 is packs.get_pack_by_name(name))
1411
1240
 
 
1241
    def test_reload_pack_names_new_entry(self):
 
1242
        tree, r, packs, revs = self.make_packs_and_alt_repo()
 
1243
        names = packs.names()
 
1244
        # Add a new pack file into the repository
 
1245
        rev4 = tree.commit('four')
 
1246
        new_names = tree.branch.repository._pack_collection.names()
 
1247
        new_name = set(new_names).difference(names)
 
1248
        self.assertEqual(1, len(new_name))
 
1249
        new_name = new_name.pop()
 
1250
        # The old collection hasn't noticed yet
 
1251
        self.assertEqual(names, packs.names())
 
1252
        self.assertTrue(packs.reload_pack_names())
 
1253
        self.assertEqual(new_names, packs.names())
 
1254
        # And the repository can access the new revision
 
1255
        self.assertEqual({rev4:(revs[-1],)}, r.get_parent_map([rev4]))
 
1256
        self.assertFalse(packs.reload_pack_names())
 
1257
 
 
1258
    def test_reload_pack_names_added_and_removed(self):
 
1259
        tree, r, packs, revs = self.make_packs_and_alt_repo()
 
1260
        names = packs.names()
 
1261
        # Now repack the whole thing
 
1262
        tree.branch.repository.pack()
 
1263
        new_names = tree.branch.repository._pack_collection.names()
 
1264
        # The other collection hasn't noticed yet
 
1265
        self.assertEqual(names, packs.names())
 
1266
        self.assertTrue(packs.reload_pack_names())
 
1267
        self.assertEqual(new_names, packs.names())
 
1268
        self.assertEqual({revs[-1]:(revs[-2],)}, r.get_parent_map([revs[-1]]))
 
1269
        self.assertFalse(packs.reload_pack_names())
 
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
 
 
1325
    def test_autopack_reloads_and_stops(self):
 
1326
        tree, r, packs, revs = self.make_packs_and_alt_repo(write_lock=True)
 
1327
        # After we have determined what needs to be autopacked, trigger a
 
1328
        # full-pack via the other repo which will cause us to re-evaluate and
 
1329
        # decide we don't need to do anything
 
1330
        orig_execute = packs._execute_pack_operations
 
1331
        def _munged_execute_pack_ops(*args, **kwargs):
 
1332
            tree.branch.repository.pack()
 
1333
            return orig_execute(*args, **kwargs)
 
1334
        packs._execute_pack_operations = _munged_execute_pack_ops
 
1335
        packs._max_pack_count = lambda x: 1
 
1336
        packs.pack_distribution = lambda x: [10]
 
1337
        self.assertFalse(packs.autopack())
 
1338
        self.assertEqual(1, len(packs.names()))
 
1339
        self.assertEqual(tree.branch.repository._pack_collection.names(),
 
1340
                         packs.names())
 
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
 
1412
1380
 
1413
1381
class TestPack(TestCaseWithTransport):
1414
1382
    """Tests for the Pack object."""
1468
1436
        pack_transport = self.get_transport('pack')
1469
1437
        index_transport = self.get_transport('index')
1470
1438
        upload_transport.mkdir('.')
1471
 
        pack = pack_repo.NewPack(upload_transport, index_transport,
1472
 
            pack_transport)
1473
 
        self.assertIsInstance(pack.revision_index, InMemoryGraphIndex)
1474
 
        self.assertIsInstance(pack.inventory_index, InMemoryGraphIndex)
1475
 
        self.assertIsInstance(pack._hash, type(md5.new()))
 
1439
        collection = pack_repo.RepositoryPackCollection(
 
1440
            repo=None,
 
1441
            transport=self.get_transport('.'),
 
1442
            index_transport=index_transport,
 
1443
            upload_transport=upload_transport,
 
1444
            pack_transport=pack_transport,
 
1445
            index_builder_class=BTreeBuilder,
 
1446
            index_class=BTreeGraphIndex,
 
1447
            use_chk_index=False)
 
1448
        pack = pack_repo.NewPack(collection)
 
1449
        self.addCleanup(pack.abort) # Make sure the write stream gets closed
 
1450
        self.assertIsInstance(pack.revision_index, BTreeBuilder)
 
1451
        self.assertIsInstance(pack.inventory_index, BTreeBuilder)
 
1452
        self.assertIsInstance(pack._hash, type(osutils.md5()))
1476
1453
        self.assertTrue(pack.upload_transport is upload_transport)
1477
1454
        self.assertTrue(pack.index_transport is index_transport)
1478
1455
        self.assertTrue(pack.pack_transport is pack_transport)
1485
1462
class TestPacker(TestCaseWithTransport):
1486
1463
    """Tests for the packs repository Packer class."""
1487
1464
 
1488
 
    # To date, this class has been factored out and nothing new added to it;
1489
 
    # thus there are not yet any tests.
1490
 
 
1491
 
 
1492
 
class TestInterDifferingSerializer(TestCaseWithTransport):
1493
 
 
1494
 
    def test_progress_bar(self):
1495
 
        tree = self.make_branch_and_tree('tree')
1496
 
        tree.commit('rev1', rev_id='rev-1')
1497
 
        tree.commit('rev2', rev_id='rev-2')
1498
 
        tree.commit('rev3', rev_id='rev-3')
1499
 
        repo = self.make_repository('repo')
1500
 
        inter_repo = repository.InterDifferingSerializer(
1501
 
            tree.branch.repository, repo)
1502
 
        pb = progress.InstrumentedProgress(to_file=StringIO())
1503
 
        pb.never_throttle = True
1504
 
        inter_repo.fetch('rev-1', pb)
1505
 
        self.assertEqual('Transferring revisions', pb.last_msg)
1506
 
        self.assertEqual(1, pb.last_cnt)
1507
 
        self.assertEqual(1, pb.last_total)
1508
 
        inter_repo.fetch('rev-3', pb)
1509
 
        self.assertEqual(2, pb.last_cnt)
1510
 
        self.assertEqual(2, pb.last_total)
 
1465
    def test_pack_optimizes_pack_order(self):
 
1466
        builder = self.make_branch_builder('.', format="1.9")
 
1467
        builder.start_series()
 
1468
        builder.build_snapshot('A', None, [
 
1469
            ('add', ('', 'root-id', 'directory', None)),
 
1470
            ('add', ('f', 'f-id', 'file', 'content\n'))])
 
1471
        builder.build_snapshot('B', ['A'],
 
1472
            [('modify', ('f-id', 'new-content\n'))])
 
1473
        builder.build_snapshot('C', ['B'],
 
1474
            [('modify', ('f-id', 'third-content\n'))])
 
1475
        builder.build_snapshot('D', ['C'],
 
1476
            [('modify', ('f-id', 'fourth-content\n'))])
 
1477
        b = builder.get_branch()
 
1478
        b.lock_read()
 
1479
        builder.finish_series()
 
1480
        self.addCleanup(b.unlock)
 
1481
        # At this point, we should have 4 pack files available
 
1482
        # Because of how they were built, they correspond to
 
1483
        # ['D', 'C', 'B', 'A']
 
1484
        packs = b.repository._pack_collection.packs
 
1485
        packer = knitpack_repo.KnitPacker(b.repository._pack_collection,
 
1486
                                  packs, 'testing',
 
1487
                                  revision_ids=['B', 'C'])
 
1488
        # Now, when we are copying the B & C revisions, their pack files should
 
1489
        # be moved to the front of the stack
 
1490
        # The new ordering moves B & C to the front of the .packs attribute,
 
1491
        # and leaves the others in the original order.
 
1492
        new_packs = [packs[1], packs[2], packs[0], packs[3]]
 
1493
        new_pack = packer.pack()
 
1494
        self.assertEqual(new_packs, packer.packs)
 
1495
 
 
1496
 
 
1497
class TestOptimisingPacker(TestCaseWithTransport):
 
1498
    """Tests for the OptimisingPacker class."""
 
1499
 
 
1500
    def get_pack_collection(self):
 
1501
        repo = self.make_repository('.')
 
1502
        return repo._pack_collection
 
1503
 
 
1504
    def test_open_pack_will_optimise(self):
 
1505
        packer = knitpack_repo.OptimisingKnitPacker(self.get_pack_collection(),
 
1506
                                            [], '.test')
 
1507
        new_pack = packer.open_pack()
 
1508
        self.addCleanup(new_pack.abort) # ensure cleanup
 
1509
        self.assertIsInstance(new_pack, pack_repo.NewPack)
 
1510
        self.assertTrue(new_pack.revision_index._optimize_for_size)
 
1511
        self.assertTrue(new_pack.inventory_index._optimize_for_size)
 
1512
        self.assertTrue(new_pack.text_index._optimize_for_size)
 
1513
        self.assertTrue(new_pack.signature_index._optimize_for_size)
 
1514
 
 
1515
 
 
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)