← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_repository.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2006-07-12 12:36:57 UTC
  • mfrom: (1732.3.4 bzr.revnoX)
  • Revision ID: pqm@pqm.ubuntu.com-20060712123657-365eeb32b69308bf
(matthieu) revno:x:url revision spec

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_repository.py
1
 
# Copyright (C) 2006-2010 Canonical Ltd
 
1
# Copyright (C) 2006 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
"""Tests for the Repository facility that are not interface tests.
18
18
 
19
 
For interface tests see tests/per_repository/*.py.
 
19
For interface tests see tests/repository_implementations/*.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
25
from stat import S_ISDIR
26
 
import sys
 
26
from StringIO import StringIO
27
27
 
28
28
import bzrlib
29
 
from bzrlib.errors import (NoSuchFile,
 
29
import bzrlib.bzrdir as bzrdir
 
30
import bzrlib.errors as errors
 
31
from bzrlib.errors import (NotBranchError,
 
32
                           NoSuchFile,
30
33
                           UnknownFormatError,
31
34
                           UnsupportedFormatError,
32
35
                           )
33
 
from bzrlib import (
34
 
    btree_index,
35
 
    graph,
36
 
    tests,
37
 
    )
38
 
from bzrlib.btree_index import BTreeBuilder, BTreeGraphIndex
39
 
from bzrlib.index import GraphIndex
40
 
from bzrlib.repository import RepositoryFormat
41
 
from bzrlib.tests import (
42
 
    TestCase,
43
 
    TestCaseWithTransport,
44
 
    )
45
 
from bzrlib.transport import (
46
 
    get_transport,
47
 
    )
48
 
from bzrlib import (
49
 
    bzrdir,
50
 
    errors,
51
 
    inventory,
52
 
    osutils,
53
 
    repository,
54
 
    revision as _mod_revision,
55
 
    upgrade,
56
 
    versionedfile,
57
 
    workingtree,
58
 
    )
59
 
from bzrlib.repofmt import (
60
 
    groupcompress_repo,
61
 
    knitrepo,
62
 
    pack_repo,
63
 
    weaverepo,
64
 
    )
 
36
import bzrlib.repository as repository
 
37
from bzrlib.tests import TestCase, TestCaseWithTransport
 
38
from bzrlib.transport import get_transport
 
39
from bzrlib.transport.http import HttpServer
 
40
from bzrlib.transport.memory import MemoryServer
65
41
 
66
42
 
67
43
class TestDefaultFormat(TestCase):
68
44
 
69
45
    def test_get_set_default_format(self):
70
 
        old_default = bzrdir.format_registry.get('default')
71
 
        private_default = old_default().repository_format.__class__
72
46
        old_format = repository.RepositoryFormat.get_default_format()
73
 
        self.assertTrue(isinstance(old_format, private_default))
74
 
        def make_sample_bzrdir():
75
 
            my_bzrdir = bzrdir.BzrDirMetaFormat1()
76
 
            my_bzrdir.repository_format = SampleRepositoryFormat()
77
 
            return my_bzrdir
78
 
        bzrdir.format_registry.remove('default')
79
 
        bzrdir.format_registry.register('sample', make_sample_bzrdir, '')
80
 
        bzrdir.format_registry.set_default('sample')
 
47
        self.assertTrue(isinstance(old_format, repository.RepositoryFormatKnit1))
 
48
        repository.RepositoryFormat.set_default_format(SampleRepositoryFormat())
81
49
        # creating a repository should now create an instrumented dir.
82
50
        try:
83
51
            # the default branch format is used by the meta dir format
86
54
            result = dir.create_repository()
87
55
            self.assertEqual(result, 'A bzr repository dir')
88
56
        finally:
89
 
            bzrdir.format_registry.remove('default')
90
 
            bzrdir.format_registry.remove('sample')
91
 
            bzrdir.format_registry.register('default', old_default, '')
92
 
        self.assertIsInstance(repository.RepositoryFormat.get_default_format(),
93
 
                              old_format.__class__)
 
57
            repository.RepositoryFormat.set_default_format(old_format)
 
58
        self.assertEqual(old_format, repository.RepositoryFormat.get_default_format())
94
59
 
95
60
 
96
61
class SampleRepositoryFormat(repository.RepositoryFormat):
97
62
    """A sample format
98
63
 
99
 
    this format is initializable, unsupported to aid in testing the
 
64
    this format is initializable, unsupported to aid in testing the 
100
65
    open and open(unsupported=True) routines.
101
66
    """
102
67
 
107
72
    def initialize(self, a_bzrdir, shared=False):
108
73
        """Initialize a repository in a BzrDir"""
109
74
        t = a_bzrdir.get_repository_transport(self)
110
 
        t.put_bytes('format', self.get_format_string())
 
75
        t.put('format', StringIO(self.get_format_string()))
111
76
        return 'A bzr repository dir'
112
77
 
113
78
    def is_supported(self):
123
88
    def test_find_format(self):
124
89
        # is the right format object found for a repository?
125
90
        # create a branch with a few known format objects.
126
 
        # this is not quite the same as
 
91
        # this is not quite the same as 
127
92
        self.build_tree(["foo/", "bar/"])
128
93
        def check_format(format, url):
129
94
            dir = format._matchingbzrdir.initialize(url)
131
96
            t = get_transport(url)
132
97
            found_format = repository.RepositoryFormat.find_format(dir)
133
98
            self.failUnless(isinstance(found_format, format.__class__))
134
 
        check_format(weaverepo.RepositoryFormat7(), "bar")
135
 
 
 
99
        check_format(repository.RepositoryFormat7(), "bar")
 
100
        
136
101
    def test_find_format_no_repository(self):
137
102
        dir = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
138
103
        self.assertRaises(errors.NoRepositoryPresent,
164
129
 
165
130
class TestFormat6(TestCaseWithTransport):
166
131
 
167
 
    def test_attribute__fetch_order(self):
168
 
        """Weaves need topological data insertion."""
169
 
        control = bzrdir.BzrDirFormat6().initialize(self.get_url())
170
 
        repo = weaverepo.RepositoryFormat6().initialize(control)
171
 
        self.assertEqual('topological', repo._format._fetch_order)
172
 
 
173
 
    def test_attribute__fetch_uses_deltas(self):
174
 
        """Weaves do not reuse deltas."""
175
 
        control = bzrdir.BzrDirFormat6().initialize(self.get_url())
176
 
        repo = weaverepo.RepositoryFormat6().initialize(control)
177
 
        self.assertEqual(False, repo._format._fetch_uses_deltas)
178
 
 
179
 
    def test_attribute__fetch_reconcile(self):
180
 
        """Weave repositories need a reconcile after fetch."""
181
 
        control = bzrdir.BzrDirFormat6().initialize(self.get_url())
182
 
        repo = weaverepo.RepositoryFormat6().initialize(control)
183
 
        self.assertEqual(True, repo._format._fetch_reconcile)
184
 
 
185
132
    def test_no_ancestry_weave(self):
186
133
        control = bzrdir.BzrDirFormat6().initialize(self.get_url())
187
 
        repo = weaverepo.RepositoryFormat6().initialize(control)
 
134
        repo = repository.RepositoryFormat6().initialize(control)
188
135
        # We no longer need to create the ancestry.weave file
189
136
        # since it is *never* used.
190
137
        self.assertRaises(NoSuchFile,
191
138
                          control.transport.get,
192
139
                          'ancestry.weave')
193
140
 
194
 
    def test_supports_external_lookups(self):
195
 
        control = bzrdir.BzrDirFormat6().initialize(self.get_url())
196
 
        repo = weaverepo.RepositoryFormat6().initialize(control)
197
 
        self.assertFalse(repo._format.supports_external_lookups)
198
 
 
199
141
 
200
142
class TestFormat7(TestCaseWithTransport):
201
 
 
202
 
    def test_attribute__fetch_order(self):
203
 
        """Weaves need topological data insertion."""
204
 
        control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
205
 
        repo = weaverepo.RepositoryFormat7().initialize(control)
206
 
        self.assertEqual('topological', repo._format._fetch_order)
207
 
 
208
 
    def test_attribute__fetch_uses_deltas(self):
209
 
        """Weaves do not reuse deltas."""
210
 
        control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
211
 
        repo = weaverepo.RepositoryFormat7().initialize(control)
212
 
        self.assertEqual(False, repo._format._fetch_uses_deltas)
213
 
 
214
 
    def test_attribute__fetch_reconcile(self):
215
 
        """Weave repositories need a reconcile after fetch."""
216
 
        control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
217
 
        repo = weaverepo.RepositoryFormat7().initialize(control)
218
 
        self.assertEqual(True, repo._format._fetch_reconcile)
219
 
 
 
143
    
220
144
    def test_disk_layout(self):
221
145
        control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
222
 
        repo = weaverepo.RepositoryFormat7().initialize(control)
 
146
        repo = repository.RepositoryFormat7().initialize(control)
223
147
        # in case of side effects of locking.
224
148
        repo.lock_write()
225
149
        repo.unlock()
238
162
                             'w\n'
239
163
                             'W\n',
240
164
                             t.get('inventory.weave').read())
241
 
        # Creating a file with id Foo:Bar results in a non-escaped file name on
242
 
        # disk.
243
 
        control.create_branch()
244
 
        tree = control.create_workingtree()
245
 
        tree.add(['foo'], ['Foo:Bar'], ['file'])
246
 
        tree.put_file_bytes_non_atomic('Foo:Bar', 'content\n')
247
 
        try:
248
 
            tree.commit('first post', rev_id='first')
249
 
        except errors.IllegalPath:
250
 
            if sys.platform != 'win32':
251
 
                raise
252
 
            self.knownFailure('Foo:Bar cannot be used as a file-id on windows'
253
 
                              ' in repo format 7')
254
 
            return
255
 
        self.assertEqualDiff(
256
 
            '# bzr weave file v5\n'
257
 
            'i\n'
258
 
            '1 7fe70820e08a1aac0ef224d9c66ab66831cc4ab1\n'
259
 
            'n first\n'
260
 
            '\n'
261
 
            'w\n'
262
 
            '{ 0\n'
263
 
            '. content\n'
264
 
            '}\n'
265
 
            'W\n',
266
 
            t.get('weaves/74/Foo%3ABar.weave').read())
267
165
 
268
166
    def test_shared_disk_layout(self):
269
167
        control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
270
 
        repo = weaverepo.RepositoryFormat7().initialize(control, shared=True)
 
168
        repo = repository.RepositoryFormat7().initialize(control, shared=True)
271
169
        # we want:
272
170
        # format 'Bazaar-NG Repository format 7'
273
171
        # inventory.weave == empty_weave
290
188
    def test_creates_lockdir(self):
291
189
        """Make sure it appears to be controlled by a LockDir existence"""
292
190
        control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
293
 
        repo = weaverepo.RepositoryFormat7().initialize(control, shared=True)
 
191
        repo = repository.RepositoryFormat7().initialize(control, shared=True)
294
192
        t = control.get_repository_transport(None)
295
 
        # TODO: Should check there is a 'lock' toplevel directory,
 
193
        # TODO: Should check there is a 'lock' toplevel directory, 
296
194
        # regardless of contents
297
195
        self.assertFalse(t.has('lock/held/info'))
298
196
        repo.lock_write()
306
204
        """repo format 7 actually locks on lockdir"""
307
205
        base_url = self.get_url()
308
206
        control = bzrdir.BzrDirMetaFormat1().initialize(base_url)
309
 
        repo = weaverepo.RepositoryFormat7().initialize(control, shared=True)
 
207
        repo = repository.RepositoryFormat7().initialize(control, shared=True)
310
208
        t = control.get_repository_transport(None)
311
209
        repo.lock_write()
312
210
        repo.unlock()
320
218
 
321
219
    def test_shared_no_tree_disk_layout(self):
322
220
        control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
323
 
        repo = weaverepo.RepositoryFormat7().initialize(control, shared=True)
 
221
        repo = repository.RepositoryFormat7().initialize(control, shared=True)
324
222
        repo.set_make_working_trees(False)
325
223
        # we want:
326
224
        # format 'Bazaar-NG Repository format 7'
344
242
                             'W\n',
345
243
                             t.get('inventory.weave').read())
346
244
 
347
 
    def test_supports_external_lookups(self):
348
 
        control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
349
 
        repo = weaverepo.RepositoryFormat7().initialize(control)
350
 
        self.assertFalse(repo._format.supports_external_lookups)
351
 
 
352
245
 
353
246
class TestFormatKnit1(TestCaseWithTransport):
354
 
 
355
 
    def test_attribute__fetch_order(self):
356
 
        """Knits need topological data insertion."""
357
 
        repo = self.make_repository('.',
358
 
                format=bzrdir.format_registry.get('knit')())
359
 
        self.assertEqual('topological', repo._format._fetch_order)
360
 
 
361
 
    def test_attribute__fetch_uses_deltas(self):
362
 
        """Knits reuse deltas."""
363
 
        repo = self.make_repository('.',
364
 
                format=bzrdir.format_registry.get('knit')())
365
 
        self.assertEqual(True, repo._format._fetch_uses_deltas)
366
 
 
 
247
    
367
248
    def test_disk_layout(self):
368
249
        control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
369
 
        repo = knitrepo.RepositoryFormatKnit1().initialize(control)
 
250
        repo = repository.RepositoryFormatKnit1().initialize(control)
370
251
        # in case of side effects of locking.
371
252
        repo.lock_write()
372
253
        repo.unlock()
383
264
        # self.assertEqualDiff('', t.get('lock').read())
384
265
        self.assertTrue(S_ISDIR(t.stat('knits').st_mode))
385
266
        self.check_knits(t)
386
 
        # Check per-file knits.
387
 
        branch = control.create_branch()
388
 
        tree = control.create_workingtree()
389
 
        tree.add(['foo'], ['Nasty-IdC:'], ['file'])
390
 
        tree.put_file_bytes_non_atomic('Nasty-IdC:', '')
391
 
        tree.commit('1st post', rev_id='foo')
392
 
        self.assertHasKnit(t, 'knits/e8/%254easty-%2549d%2543%253a',
393
 
            '\nfoo fulltext 0 81  :')
394
267
 
395
 
    def assertHasKnit(self, t, knit_name, extra_content=''):
 
268
    def assertHasKnit(self, t, knit_name):
396
269
        """Assert that knit_name exists on t."""
397
 
        self.assertEqualDiff('# bzr knit index 8\n' + extra_content,
 
270
        self.assertEqualDiff('# bzr knit index 8\n',
398
271
                             t.get(knit_name + '.kndx').read())
 
272
        # no default content
 
273
        self.assertTrue(t.has(knit_name + '.knit'))
399
274
 
400
275
    def check_knits(self, t):
401
276
        """check knit content for a repository."""
405
280
 
406
281
    def test_shared_disk_layout(self):
407
282
        control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
408
 
        repo = knitrepo.RepositoryFormatKnit1().initialize(control, shared=True)
 
283
        repo = repository.RepositoryFormatKnit1().initialize(control, shared=True)
409
284
        # we want:
410
285
        # format 'Bazaar-NG Knit Repository Format 1'
411
286
        # lock: is a directory
424
299
 
425
300
    def test_shared_no_tree_disk_layout(self):
426
301
        control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
427
 
        repo = knitrepo.RepositoryFormatKnit1().initialize(control, shared=True)
 
302
        repo = repository.RepositoryFormatKnit1().initialize(control, shared=True)
428
303
        repo.set_make_working_trees(False)
429
304
        # we want:
430
305
        # format 'Bazaar-NG Knit Repository Format 1'
445
320
        self.assertTrue(S_ISDIR(t.stat('knits').st_mode))
446
321
        self.check_knits(t)
447
322
 
448
 
    def test_deserialise_sets_root_revision(self):
449
 
        """We must have a inventory.root.revision
450
 
 
451
 
        Old versions of the XML5 serializer did not set the revision_id for
452
 
        the whole inventory. So we grab the one from the expected text. Which
453
 
        is valid when the api is not being abused.
454
 
        """
455
 
        repo = self.make_repository('.',
456
 
                format=bzrdir.format_registry.get('knit')())
457
 
        inv_xml = '<inventory format="5">\n</inventory>\n'
458
 
        inv = repo._deserialise_inventory('test-rev-id', inv_xml)
459
 
        self.assertEqual('test-rev-id', inv.root.revision)
460
 
 
461
 
    def test_deserialise_uses_global_revision_id(self):
462
 
        """If it is set, then we re-use the global revision id"""
463
 
        repo = self.make_repository('.',
464
 
                format=bzrdir.format_registry.get('knit')())
465
 
        inv_xml = ('<inventory format="5" revision_id="other-rev-id">\n'
466
 
                   '</inventory>\n')
467
 
        # Arguably, the deserialise_inventory should detect a mismatch, and
468
 
        # raise an error, rather than silently using one revision_id over the
469
 
        # other.
470
 
        self.assertRaises(AssertionError, repo._deserialise_inventory,
471
 
            'test-rev-id', inv_xml)
472
 
        inv = repo._deserialise_inventory('other-rev-id', inv_xml)
473
 
        self.assertEqual('other-rev-id', inv.root.revision)
474
 
 
475
 
    def test_supports_external_lookups(self):
476
 
        repo = self.make_repository('.',
477
 
                format=bzrdir.format_registry.get('knit')())
478
 
        self.assertFalse(repo._format.supports_external_lookups)
479
 
 
480
 
 
481
 
class DummyRepository(object):
482
 
    """A dummy repository for testing."""
483
 
 
484
 
    _format = None
485
 
    _serializer = None
486
 
 
487
 
    def supports_rich_root(self):
488
 
        if self._format is not None:
489
 
            return self._format.rich_root_data
490
 
        return False
491
 
 
492
 
    def get_graph(self):
493
 
        raise NotImplementedError
494
 
 
495
 
    def get_parent_map(self, revision_ids):
496
 
        raise NotImplementedError
497
 
 
498
 
 
499
 
class InterDummy(repository.InterRepository):
500
 
    """An inter-repository optimised code path for DummyRepository.
501
 
 
502
 
    This is for use during testing where we use DummyRepository as repositories
 
323
 
 
324
class InterString(repository.InterRepository):
 
325
    """An inter-repository optimised code path for strings.
 
326
 
 
327
    This is for use during testing where we use strings as repositories
503
328
    so that none of the default regsitered inter-repository classes will
504
 
    MATCH.
 
329
    match.
505
330
    """
506
331
 
507
332
    @staticmethod
508
333
    def is_compatible(repo_source, repo_target):
509
 
        """InterDummy is compatible with DummyRepository."""
510
 
        return (isinstance(repo_source, DummyRepository) and
511
 
            isinstance(repo_target, DummyRepository))
 
334
        """InterString is compatible with strings-as-repos."""
 
335
        return isinstance(repo_source, str) and isinstance(repo_target, str)
512
336
 
513
337
 
514
338
class TestInterRepository(TestCaseWithTransport):
520
344
        # This also tests that the default registered optimised interrepository
521
345
        # classes do not barf inappropriately when a surprising repository type
522
346
        # is handed to them.
523
 
        dummy_a = DummyRepository()
524
 
        dummy_b = DummyRepository()
 
347
        dummy_a = "Repository 1."
 
348
        dummy_b = "Repository 2."
525
349
        self.assertGetsDefaultInterRepository(dummy_a, dummy_b)
526
350
 
527
351
    def assertGetsDefaultInterRepository(self, repo_a, repo_b):
528
 
        """Asserts that InterRepository.get(repo_a, repo_b) -> the default.
529
 
 
530
 
        The effective default is now InterSameDataRepository because there is
531
 
        no actual sane default in the presence of incompatible data models.
532
 
        """
 
352
        """Asserts that InterRepository.get(repo_a, repo_b) -> the default."""
533
353
        inter_repo = repository.InterRepository.get(repo_a, repo_b)
534
 
        self.assertEqual(repository.InterSameDataRepository,
 
354
        self.assertEqual(repository.InterRepository,
535
355
                         inter_repo.__class__)
536
356
        self.assertEqual(repo_a, inter_repo.source)
537
357
        self.assertEqual(repo_b, inter_repo.target)
542
362
        # and that it is correctly selected when given a repository
543
363
        # pair that it returns true on for the is_compatible static method
544
364
        # check
545
 
        dummy_a = DummyRepository()
546
 
        dummy_a._format = RepositoryFormat()
547
 
        dummy_b = DummyRepository()
548
 
        dummy_b._format = RepositoryFormat()
549
 
        repo = self.make_repository('.')
550
 
        # hack dummies to look like repo somewhat.
551
 
        dummy_a._serializer = repo._serializer
552
 
        dummy_a._format.supports_tree_reference = repo._format.supports_tree_reference
553
 
        dummy_a._format.rich_root_data = repo._format.rich_root_data
554
 
        dummy_b._serializer = repo._serializer
555
 
        dummy_b._format.supports_tree_reference = repo._format.supports_tree_reference
556
 
        dummy_b._format.rich_root_data = repo._format.rich_root_data
557
 
        repository.InterRepository.register_optimiser(InterDummy)
 
365
        dummy_a = "Repository 1."
 
366
        dummy_b = "Repository 2."
 
367
        repository.InterRepository.register_optimiser(InterString)
558
368
        try:
559
 
            # we should get the default for something InterDummy returns False
 
369
            # we should get the default for something InterString returns False
560
370
            # to
561
 
            self.assertFalse(InterDummy.is_compatible(dummy_a, repo))
562
 
            self.assertGetsDefaultInterRepository(dummy_a, repo)
563
 
            # and we should get an InterDummy for a pair it 'likes'
564
 
            self.assertTrue(InterDummy.is_compatible(dummy_a, dummy_b))
 
371
            self.assertFalse(InterString.is_compatible(dummy_a, None))
 
372
            self.assertGetsDefaultInterRepository(dummy_a, None)
 
373
            # and we should get an InterString for a pair it 'likes'
 
374
            self.assertTrue(InterString.is_compatible(dummy_a, dummy_b))
565
375
            inter_repo = repository.InterRepository.get(dummy_a, dummy_b)
566
 
            self.assertEqual(InterDummy, inter_repo.__class__)
 
376
            self.assertEqual(InterString, inter_repo.__class__)
567
377
            self.assertEqual(dummy_a, inter_repo.source)
568
378
            self.assertEqual(dummy_b, inter_repo.target)
569
379
        finally:
570
 
            repository.InterRepository.unregister_optimiser(InterDummy)
 
380
            repository.InterRepository.unregister_optimiser(InterString)
571
381
        # now we should get the default InterRepository object again.
572
382
        self.assertGetsDefaultInterRepository(dummy_a, dummy_b)
573
383
 
577
387
    def test_is_compatible_and_registered(self):
578
388
        # InterWeaveRepo is compatible when either side
579
389
        # is a format 5/6/7 branch
580
 
        from bzrlib.repofmt import knitrepo, weaverepo
581
 
        formats = [weaverepo.RepositoryFormat5(),
582
 
                   weaverepo.RepositoryFormat6(),
583
 
                   weaverepo.RepositoryFormat7()]
584
 
        incompatible_formats = [weaverepo.RepositoryFormat4(),
585
 
                                knitrepo.RepositoryFormatKnit1(),
 
390
        formats = [repository.RepositoryFormat5(),
 
391
                   repository.RepositoryFormat6(),
 
392
                   repository.RepositoryFormat7()]
 
393
        incompatible_formats = [repository.RepositoryFormat4(),
 
394
                                repository.RepositoryFormatKnit1(),
586
395
                                ]
587
396
        repo_a = self.make_repository('a')
588
397
        repo_b = self.make_repository('b')
609
418
        t = get_transport(self.get_url('.'))
610
419
        t.mkdir('repository')
611
420
        repo_dir = bzrdir.BzrDirMetaFormat1().initialize('repository')
612
 
        repo = weaverepo.RepositoryFormat7().initialize(repo_dir)
613
 
        target_format = knitrepo.RepositoryFormatKnit1()
 
421
        repo = repository.RepositoryFormat7().initialize(repo_dir)
 
422
        target_format = repository.RepositoryFormatKnit1()
614
423
        converter = repository.CopyConverter(target_format)
615
424
        pb = bzrlib.ui.ui_factory.nested_progress_bar()
616
425
        try:
622
431
 
623
432
 
624
433
class TestMisc(TestCase):
625
 
 
 
434
    
626
435
    def test_unescape_xml(self):
627
436
        """We get some kind of error when malformed entities are passed"""
628
 
        self.assertRaises(KeyError, repository._unescape_xml, 'foo&bar;')
629
 
 
630
 
 
631
 
class TestRepositoryFormatKnit3(TestCaseWithTransport):
632
 
 
633
 
    def test_attribute__fetch_order(self):
634
 
        """Knits need topological data insertion."""
635
 
        format = bzrdir.BzrDirMetaFormat1()
636
 
        format.repository_format = knitrepo.RepositoryFormatKnit3()
637
 
        repo = self.make_repository('.', format=format)
638
 
        self.assertEqual('topological', repo._format._fetch_order)
639
 
 
640
 
    def test_attribute__fetch_uses_deltas(self):
641
 
        """Knits reuse deltas."""
642
 
        format = bzrdir.BzrDirMetaFormat1()
643
 
        format.repository_format = knitrepo.RepositoryFormatKnit3()
644
 
        repo = self.make_repository('.', format=format)
645
 
        self.assertEqual(True, repo._format._fetch_uses_deltas)
646
 
 
647
 
    def test_convert(self):
648
 
        """Ensure the upgrade adds weaves for roots"""
649
 
        format = bzrdir.BzrDirMetaFormat1()
650
 
        format.repository_format = knitrepo.RepositoryFormatKnit1()
651
 
        tree = self.make_branch_and_tree('.', format)
652
 
        tree.commit("Dull commit", rev_id="dull")
653
 
        revision_tree = tree.branch.repository.revision_tree('dull')
654
 
        revision_tree.lock_read()
655
 
        try:
656
 
            self.assertRaises(errors.NoSuchFile, revision_tree.get_file_lines,
657
 
                revision_tree.inventory.root.file_id)
658
 
        finally:
659
 
            revision_tree.unlock()
660
 
        format = bzrdir.BzrDirMetaFormat1()
661
 
        format.repository_format = knitrepo.RepositoryFormatKnit3()
662
 
        upgrade.Convert('.', format)
663
 
        tree = workingtree.WorkingTree.open('.')
664
 
        revision_tree = tree.branch.repository.revision_tree('dull')
665
 
        revision_tree.lock_read()
666
 
        try:
667
 
            revision_tree.get_file_lines(revision_tree.inventory.root.file_id)
668
 
        finally:
669
 
            revision_tree.unlock()
670
 
        tree.commit("Another dull commit", rev_id='dull2')
671
 
        revision_tree = tree.branch.repository.revision_tree('dull2')
672
 
        revision_tree.lock_read()
673
 
        self.addCleanup(revision_tree.unlock)
674
 
        self.assertEqual('dull', revision_tree.inventory.root.revision)
675
 
 
676
 
    def test_supports_external_lookups(self):
677
 
        format = bzrdir.BzrDirMetaFormat1()
678
 
        format.repository_format = knitrepo.RepositoryFormatKnit3()
679
 
        repo = self.make_repository('.', format=format)
680
 
        self.assertFalse(repo._format.supports_external_lookups)
681
 
 
682
 
 
683
 
class Test2a(tests.TestCaseWithMemoryTransport):
684
 
 
685
 
    def test_chk_bytes_uses_custom_btree_parser(self):
686
 
        mt = self.make_branch_and_memory_tree('test', format='2a')
687
 
        mt.lock_write()
688
 
        self.addCleanup(mt.unlock)
689
 
        mt.add([''], ['root-id'])
690
 
        mt.commit('first')
691
 
        index = mt.branch.repository.chk_bytes._index._graph_index._indices[0]
692
 
        self.assertEqual(btree_index._gcchk_factory, index._leaf_factory)
693
 
        # It should also work if we re-open the repo
694
 
        repo = mt.branch.repository.bzrdir.open_repository()
695
 
        repo.lock_read()
696
 
        self.addCleanup(repo.unlock)
697
 
        index = repo.chk_bytes._index._graph_index._indices[0]
698
 
        self.assertEqual(btree_index._gcchk_factory, index._leaf_factory)
699
 
 
700
 
    def test_fetch_combines_groups(self):
701
 
        builder = self.make_branch_builder('source', format='2a')
702
 
        builder.start_series()
703
 
        builder.build_snapshot('1', None, [
704
 
            ('add', ('', 'root-id', 'directory', '')),
705
 
            ('add', ('file', 'file-id', 'file', 'content\n'))])
706
 
        builder.build_snapshot('2', ['1'], [
707
 
            ('modify', ('file-id', 'content-2\n'))])
708
 
        builder.finish_series()
709
 
        source = builder.get_branch()
710
 
        target = self.make_repository('target', format='2a')
711
 
        target.fetch(source.repository)
712
 
        target.lock_read()
713
 
        self.addCleanup(target.unlock)
714
 
        details = target.texts._index.get_build_details(
715
 
            [('file-id', '1',), ('file-id', '2',)])
716
 
        file_1_details = details[('file-id', '1')]
717
 
        file_2_details = details[('file-id', '2')]
718
 
        # The index, and what to read off disk, should be the same for both
719
 
        # versions of the file.
720
 
        self.assertEqual(file_1_details[0][:3], file_2_details[0][:3])
721
 
 
722
 
    def test_fetch_combines_groups(self):
723
 
        builder = self.make_branch_builder('source', format='2a')
724
 
        builder.start_series()
725
 
        builder.build_snapshot('1', None, [
726
 
            ('add', ('', 'root-id', 'directory', '')),
727
 
            ('add', ('file', 'file-id', 'file', 'content\n'))])
728
 
        builder.build_snapshot('2', ['1'], [
729
 
            ('modify', ('file-id', 'content-2\n'))])
730
 
        builder.finish_series()
731
 
        source = builder.get_branch()
732
 
        target = self.make_repository('target', format='2a')
733
 
        target.fetch(source.repository)
734
 
        target.lock_read()
735
 
        self.addCleanup(target.unlock)
736
 
        details = target.texts._index.get_build_details(
737
 
            [('file-id', '1',), ('file-id', '2',)])
738
 
        file_1_details = details[('file-id', '1')]
739
 
        file_2_details = details[('file-id', '2')]
740
 
        # The index, and what to read off disk, should be the same for both
741
 
        # versions of the file.
742
 
        self.assertEqual(file_1_details[0][:3], file_2_details[0][:3])
743
 
 
744
 
    def test_fetch_combines_groups(self):
745
 
        builder = self.make_branch_builder('source', format='2a')
746
 
        builder.start_series()
747
 
        builder.build_snapshot('1', None, [
748
 
            ('add', ('', 'root-id', 'directory', '')),
749
 
            ('add', ('file', 'file-id', 'file', 'content\n'))])
750
 
        builder.build_snapshot('2', ['1'], [
751
 
            ('modify', ('file-id', 'content-2\n'))])
752
 
        builder.finish_series()
753
 
        source = builder.get_branch()
754
 
        target = self.make_repository('target', format='2a')
755
 
        target.fetch(source.repository)
756
 
        target.lock_read()
757
 
        self.addCleanup(target.unlock)
758
 
        details = target.texts._index.get_build_details(
759
 
            [('file-id', '1',), ('file-id', '2',)])
760
 
        file_1_details = details[('file-id', '1')]
761
 
        file_2_details = details[('file-id', '2')]
762
 
        # The index, and what to read off disk, should be the same for both
763
 
        # versions of the file.
764
 
        self.assertEqual(file_1_details[0][:3], file_2_details[0][:3])
765
 
 
766
 
    def test_format_pack_compresses_True(self):
767
 
        repo = self.make_repository('repo', format='2a')
768
 
        self.assertTrue(repo._format.pack_compresses)
769
 
 
770
 
    def test_inventories_use_chk_map_with_parent_base_dict(self):
771
 
        tree = self.make_branch_and_memory_tree('repo', format="2a")
772
 
        tree.lock_write()
773
 
        tree.add([''], ['TREE_ROOT'])
774
 
        revid = tree.commit("foo")
775
 
        tree.unlock()
776
 
        tree.lock_read()
777
 
        self.addCleanup(tree.unlock)
778
 
        inv = tree.branch.repository.get_inventory(revid)
779
 
        self.assertNotEqual(None, inv.parent_id_basename_to_file_id)
780
 
        inv.parent_id_basename_to_file_id._ensure_root()
781
 
        inv.id_to_entry._ensure_root()
782
 
        self.assertEqual(65536, inv.id_to_entry._root_node.maximum_size)
783
 
        self.assertEqual(65536,
784
 
            inv.parent_id_basename_to_file_id._root_node.maximum_size)
785
 
 
786
 
    def test_autopack_unchanged_chk_nodes(self):
787
 
        # at 20 unchanged commits, chk pages are packed that are split into
788
 
        # two groups such that the new pack being made doesn't have all its
789
 
        # pages in the source packs (though they are in the repository).
790
 
        # Use a memory backed repository, we don't need to hit disk for this
791
 
        tree = self.make_branch_and_memory_tree('tree', format='2a')
792
 
        tree.lock_write()
793
 
        self.addCleanup(tree.unlock)
794
 
        tree.add([''], ['TREE_ROOT'])
795
 
        for pos in range(20):
796
 
            tree.commit(str(pos))
797
 
 
798
 
    def test_pack_with_hint(self):
799
 
        tree = self.make_branch_and_memory_tree('tree', format='2a')
800
 
        tree.lock_write()
801
 
        self.addCleanup(tree.unlock)
802
 
        tree.add([''], ['TREE_ROOT'])
803
 
        # 1 commit to leave untouched
804
 
        tree.commit('1')
805
 
        to_keep = tree.branch.repository._pack_collection.names()
806
 
        # 2 to combine
807
 
        tree.commit('2')
808
 
        tree.commit('3')
809
 
        all = tree.branch.repository._pack_collection.names()
810
 
        combine = list(set(all) - set(to_keep))
811
 
        self.assertLength(3, all)
812
 
        self.assertLength(2, combine)
813
 
        tree.branch.repository.pack(hint=combine)
814
 
        final = tree.branch.repository._pack_collection.names()
815
 
        self.assertLength(2, final)
816
 
        self.assertFalse(combine[0] in final)
817
 
        self.assertFalse(combine[1] in final)
818
 
        self.assertSubset(to_keep, final)
819
 
 
820
 
    def test_stream_source_to_gc(self):
821
 
        source = self.make_repository('source', format='2a')
822
 
        target = self.make_repository('target', format='2a')
823
 
        stream = source._get_source(target._format)
824
 
        self.assertIsInstance(stream, groupcompress_repo.GroupCHKStreamSource)
825
 
 
826
 
    def test_stream_source_to_non_gc(self):
827
 
        source = self.make_repository('source', format='2a')
828
 
        target = self.make_repository('target', format='rich-root-pack')
829
 
        stream = source._get_source(target._format)
830
 
        # We don't want the child GroupCHKStreamSource
831
 
        self.assertIs(type(stream), repository.StreamSource)
832
 
 
833
 
    def test_get_stream_for_missing_keys_includes_all_chk_refs(self):
834
 
        source_builder = self.make_branch_builder('source',
835
 
                            format='2a')
836
 
        # We have to build a fairly large tree, so that we are sure the chk
837
 
        # pages will have split into multiple pages.
838
 
        entries = [('add', ('', 'a-root-id', 'directory', None))]
839
 
        for i in 'abcdefghijklmnopqrstuvwxyz123456789':
840
 
            for j in 'abcdefghijklmnopqrstuvwxyz123456789':
841
 
                fname = i + j
842
 
                fid = fname + '-id'
843
 
                content = 'content for %s\n' % (fname,)
844
 
                entries.append(('add', (fname, fid, 'file', content)))
845
 
        source_builder.start_series()
846
 
        source_builder.build_snapshot('rev-1', None, entries)
847
 
        # Now change a few of them, so we get a few new pages for the second
848
 
        # revision
849
 
        source_builder.build_snapshot('rev-2', ['rev-1'], [
850
 
            ('modify', ('aa-id', 'new content for aa-id\n')),
851
 
            ('modify', ('cc-id', 'new content for cc-id\n')),
852
 
            ('modify', ('zz-id', 'new content for zz-id\n')),
853
 
            ])
854
 
        source_builder.finish_series()
855
 
        source_branch = source_builder.get_branch()
856
 
        source_branch.lock_read()
857
 
        self.addCleanup(source_branch.unlock)
858
 
        target = self.make_repository('target', format='2a')
859
 
        source = source_branch.repository._get_source(target._format)
860
 
        self.assertIsInstance(source, groupcompress_repo.GroupCHKStreamSource)
861
 
 
862
 
        # On a regular pass, getting the inventories and chk pages for rev-2
863
 
        # would only get the newly created chk pages
864
 
        search = graph.SearchResult(set(['rev-2']), set(['rev-1']), 1,
865
 
                                    set(['rev-2']))
866
 
        simple_chk_records = []
867
 
        for vf_name, substream in source.get_stream(search):
868
 
            if vf_name == 'chk_bytes':
869
 
                for record in substream:
870
 
                    simple_chk_records.append(record.key)
871
 
            else:
872
 
                for _ in substream:
873
 
                    continue
874
 
        # 3 pages, the root (InternalNode), + 2 pages which actually changed
875
 
        self.assertEqual([('sha1:91481f539e802c76542ea5e4c83ad416bf219f73',),
876
 
                          ('sha1:4ff91971043668583985aec83f4f0ab10a907d3f',),
877
 
                          ('sha1:81e7324507c5ca132eedaf2d8414ee4bb2226187',),
878
 
                          ('sha1:b101b7da280596c71a4540e9a1eeba8045985ee0',)],
879
 
                         simple_chk_records)
880
 
        # Now, when we do a similar call using 'get_stream_for_missing_keys'
881
 
        # we should get a much larger set of pages.
882
 
        missing = [('inventories', 'rev-2')]
883
 
        full_chk_records = []
884
 
        for vf_name, substream in source.get_stream_for_missing_keys(missing):
885
 
            if vf_name == 'inventories':
886
 
                for record in substream:
887
 
                    self.assertEqual(('rev-2',), record.key)
888
 
            elif vf_name == 'chk_bytes':
889
 
                for record in substream:
890
 
                    full_chk_records.append(record.key)
891
 
            else:
892
 
                self.fail('Should not be getting a stream of %s' % (vf_name,))
893
 
        # We have 257 records now. This is because we have 1 root page, and 256
894
 
        # leaf pages in a complete listing.
895
 
        self.assertEqual(257, len(full_chk_records))
896
 
        self.assertSubset(simple_chk_records, full_chk_records)
897
 
 
898
 
    def test_inconsistency_fatal(self):
899
 
        repo = self.make_repository('repo', format='2a')
900
 
        self.assertTrue(repo.revisions._index._inconsistency_fatal)
901
 
        self.assertFalse(repo.texts._index._inconsistency_fatal)
902
 
        self.assertFalse(repo.inventories._index._inconsistency_fatal)
903
 
        self.assertFalse(repo.signatures._index._inconsistency_fatal)
904
 
        self.assertFalse(repo.chk_bytes._index._inconsistency_fatal)
905
 
 
906
 
 
907
 
class TestKnitPackStreamSource(tests.TestCaseWithMemoryTransport):
908
 
 
909
 
    def test_source_to_exact_pack_092(self):
910
 
        source = self.make_repository('source', format='pack-0.92')
911
 
        target = self.make_repository('target', format='pack-0.92')
912
 
        stream_source = source._get_source(target._format)
913
 
        self.assertIsInstance(stream_source, pack_repo.KnitPackStreamSource)
914
 
 
915
 
    def test_source_to_exact_pack_rich_root_pack(self):
916
 
        source = self.make_repository('source', format='rich-root-pack')
917
 
        target = self.make_repository('target', format='rich-root-pack')
918
 
        stream_source = source._get_source(target._format)
919
 
        self.assertIsInstance(stream_source, pack_repo.KnitPackStreamSource)
920
 
 
921
 
    def test_source_to_exact_pack_19(self):
922
 
        source = self.make_repository('source', format='1.9')
923
 
        target = self.make_repository('target', format='1.9')
924
 
        stream_source = source._get_source(target._format)
925
 
        self.assertIsInstance(stream_source, pack_repo.KnitPackStreamSource)
926
 
 
927
 
    def test_source_to_exact_pack_19_rich_root(self):
928
 
        source = self.make_repository('source', format='1.9-rich-root')
929
 
        target = self.make_repository('target', format='1.9-rich-root')
930
 
        stream_source = source._get_source(target._format)
931
 
        self.assertIsInstance(stream_source, pack_repo.KnitPackStreamSource)
932
 
 
933
 
    def test_source_to_remote_exact_pack_19(self):
934
 
        trans = self.make_smart_server('target')
935
 
        trans.ensure_base()
936
 
        source = self.make_repository('source', format='1.9')
937
 
        target = self.make_repository('target', format='1.9')
938
 
        target = repository.Repository.open(trans.base)
939
 
        stream_source = source._get_source(target._format)
940
 
        self.assertIsInstance(stream_source, pack_repo.KnitPackStreamSource)
941
 
 
942
 
    def test_stream_source_to_non_exact(self):
943
 
        source = self.make_repository('source', format='pack-0.92')
944
 
        target = self.make_repository('target', format='1.9')
945
 
        stream = source._get_source(target._format)
946
 
        self.assertIs(type(stream), repository.StreamSource)
947
 
 
948
 
    def test_stream_source_to_non_exact_rich_root(self):
949
 
        source = self.make_repository('source', format='1.9')
950
 
        target = self.make_repository('target', format='1.9-rich-root')
951
 
        stream = source._get_source(target._format)
952
 
        self.assertIs(type(stream), repository.StreamSource)
953
 
 
954
 
    def test_source_to_remote_non_exact_pack_19(self):
955
 
        trans = self.make_smart_server('target')
956
 
        trans.ensure_base()
957
 
        source = self.make_repository('source', format='1.9')
958
 
        target = self.make_repository('target', format='1.6')
959
 
        target = repository.Repository.open(trans.base)
960
 
        stream_source = source._get_source(target._format)
961
 
        self.assertIs(type(stream_source), repository.StreamSource)
962
 
 
963
 
    def test_stream_source_to_knit(self):
964
 
        source = self.make_repository('source', format='pack-0.92')
965
 
        target = self.make_repository('target', format='dirstate')
966
 
        stream = source._get_source(target._format)
967
 
        self.assertIs(type(stream), repository.StreamSource)
968
 
 
969
 
 
970
 
class TestDevelopment6FindParentIdsOfRevisions(TestCaseWithTransport):
971
 
    """Tests for _find_parent_ids_of_revisions."""
972
 
 
973
 
    def setUp(self):
974
 
        super(TestDevelopment6FindParentIdsOfRevisions, self).setUp()
975
 
        self.builder = self.make_branch_builder('source',
976
 
            format='development6-rich-root')
977
 
        self.builder.start_series()
978
 
        self.builder.build_snapshot('initial', None,
979
 
            [('add', ('', 'tree-root', 'directory', None))])
980
 
        self.repo = self.builder.get_branch().repository
981
 
        self.addCleanup(self.builder.finish_series)
982
 
 
983
 
    def assertParentIds(self, expected_result, rev_set):
984
 
        self.assertEqual(sorted(expected_result),
985
 
            sorted(self.repo._find_parent_ids_of_revisions(rev_set)))
986
 
 
987
 
    def test_simple(self):
988
 
        self.builder.build_snapshot('revid1', None, [])
989
 
        self.builder.build_snapshot('revid2', ['revid1'], [])
990
 
        rev_set = ['revid2']
991
 
        self.assertParentIds(['revid1'], rev_set)
992
 
 
993
 
    def test_not_first_parent(self):
994
 
        self.builder.build_snapshot('revid1', None, [])
995
 
        self.builder.build_snapshot('revid2', ['revid1'], [])
996
 
        self.builder.build_snapshot('revid3', ['revid2'], [])
997
 
        rev_set = ['revid3', 'revid2']
998
 
        self.assertParentIds(['revid1'], rev_set)
999
 
 
1000
 
    def test_not_null(self):
1001
 
        rev_set = ['initial']
1002
 
        self.assertParentIds([], rev_set)
1003
 
 
1004
 
    def test_not_null_set(self):
1005
 
        self.builder.build_snapshot('revid1', None, [])
1006
 
        rev_set = [_mod_revision.NULL_REVISION]
1007
 
        self.assertParentIds([], rev_set)
1008
 
 
1009
 
    def test_ghost(self):
1010
 
        self.builder.build_snapshot('revid1', None, [])
1011
 
        rev_set = ['ghost', 'revid1']
1012
 
        self.assertParentIds(['initial'], rev_set)
1013
 
 
1014
 
    def test_ghost_parent(self):
1015
 
        self.builder.build_snapshot('revid1', None, [])
1016
 
        self.builder.build_snapshot('revid2', ['revid1', 'ghost'], [])
1017
 
        rev_set = ['revid2', 'revid1']
1018
 
        self.assertParentIds(['ghost', 'initial'], rev_set)
1019
 
 
1020
 
    def test_righthand_parent(self):
1021
 
        self.builder.build_snapshot('revid1', None, [])
1022
 
        self.builder.build_snapshot('revid2a', ['revid1'], [])
1023
 
        self.builder.build_snapshot('revid2b', ['revid1'], [])
1024
 
        self.builder.build_snapshot('revid3', ['revid2a', 'revid2b'], [])
1025
 
        rev_set = ['revid3', 'revid2a']
1026
 
        self.assertParentIds(['revid1', 'revid2b'], rev_set)
1027
 
 
1028
 
 
1029
 
class TestWithBrokenRepo(TestCaseWithTransport):
1030
 
    """These tests seem to be more appropriate as interface tests?"""
1031
 
 
1032
 
    def make_broken_repository(self):
1033
 
        # XXX: This function is borrowed from Aaron's "Reconcile can fix bad
1034
 
        # parent references" branch which is due to land in bzr.dev soon.  Once
1035
 
        # it does, this duplication should be removed.
1036
 
        repo = self.make_repository('broken-repo')
1037
 
        cleanups = []
1038
 
        try:
1039
 
            repo.lock_write()
1040
 
            cleanups.append(repo.unlock)
1041
 
            repo.start_write_group()
1042
 
            cleanups.append(repo.commit_write_group)
1043
 
            # make rev1a: A well-formed revision, containing 'file1'
1044
 
            inv = inventory.Inventory(revision_id='rev1a')
1045
 
            inv.root.revision = 'rev1a'
1046
 
            self.add_file(repo, inv, 'file1', 'rev1a', [])
1047
 
            repo.texts.add_lines((inv.root.file_id, 'rev1a'), [], [])
1048
 
            repo.add_inventory('rev1a', inv, [])
1049
 
            revision = _mod_revision.Revision('rev1a',
1050
 
                committer='jrandom@example.com', timestamp=0,
1051
 
                inventory_sha1='', timezone=0, message='foo', parent_ids=[])
1052
 
            repo.add_revision('rev1a',revision, inv)
1053
 
 
1054
 
            # make rev1b, which has no Revision, but has an Inventory, and
1055
 
            # file1
1056
 
            inv = inventory.Inventory(revision_id='rev1b')
1057
 
            inv.root.revision = 'rev1b'
1058
 
            self.add_file(repo, inv, 'file1', 'rev1b', [])
1059
 
            repo.add_inventory('rev1b', inv, [])
1060
 
 
1061
 
            # make rev2, with file1 and file2
1062
 
            # file2 is sane
1063
 
            # file1 has 'rev1b' as an ancestor, even though this is not
1064
 
            # mentioned by 'rev1a', making it an unreferenced ancestor
1065
 
            inv = inventory.Inventory()
1066
 
            self.add_file(repo, inv, 'file1', 'rev2', ['rev1a', 'rev1b'])
1067
 
            self.add_file(repo, inv, 'file2', 'rev2', [])
1068
 
            self.add_revision(repo, 'rev2', inv, ['rev1a'])
1069
 
 
1070
 
            # make ghost revision rev1c
1071
 
            inv = inventory.Inventory()
1072
 
            self.add_file(repo, inv, 'file2', 'rev1c', [])
1073
 
 
1074
 
            # make rev3 with file2
1075
 
            # file2 refers to 'rev1c', which is a ghost in this repository, so
1076
 
            # file2 cannot have rev1c as its ancestor.
1077
 
            inv = inventory.Inventory()
1078
 
            self.add_file(repo, inv, 'file2', 'rev3', ['rev1c'])
1079
 
            self.add_revision(repo, 'rev3', inv, ['rev1c'])
1080
 
            return repo
1081
 
        finally:
1082
 
            for cleanup in reversed(cleanups):
1083
 
                cleanup()
1084
 
 
1085
 
    def add_revision(self, repo, revision_id, inv, parent_ids):
1086
 
        inv.revision_id = revision_id
1087
 
        inv.root.revision = revision_id
1088
 
        repo.texts.add_lines((inv.root.file_id, revision_id), [], [])
1089
 
        repo.add_inventory(revision_id, inv, parent_ids)
1090
 
        revision = _mod_revision.Revision(revision_id,
1091
 
            committer='jrandom@example.com', timestamp=0, inventory_sha1='',
1092
 
            timezone=0, message='foo', parent_ids=parent_ids)
1093
 
        repo.add_revision(revision_id,revision, inv)
1094
 
 
1095
 
    def add_file(self, repo, inv, filename, revision, parents):
1096
 
        file_id = filename + '-id'
1097
 
        entry = inventory.InventoryFile(file_id, filename, 'TREE_ROOT')
1098
 
        entry.revision = revision
1099
 
        entry.text_size = 0
1100
 
        inv.add(entry)
1101
 
        text_key = (file_id, revision)
1102
 
        parent_keys = [(file_id, parent) for parent in parents]
1103
 
        repo.texts.add_lines(text_key, parent_keys, ['line\n'])
1104
 
 
1105
 
    def test_insert_from_broken_repo(self):
1106
 
        """Inserting a data stream from a broken repository won't silently
1107
 
        corrupt the target repository.
1108
 
        """
1109
 
        broken_repo = self.make_broken_repository()
1110
 
        empty_repo = self.make_repository('empty-repo')
1111
 
        try:
1112
 
            empty_repo.fetch(broken_repo)
1113
 
        except (errors.RevisionNotPresent, errors.BzrCheckError):
1114
 
            # Test successful: compression parent not being copied leads to
1115
 
            # error.
1116
 
            return
1117
 
        empty_repo.lock_read()
1118
 
        self.addCleanup(empty_repo.unlock)
1119
 
        text = empty_repo.texts.get_record_stream(
1120
 
            [('file2-id', 'rev3')], 'topological', True).next()
1121
 
        self.assertEqual('line\n', text.get_bytes_as('fulltext'))
1122
 
 
1123
 
 
1124
 
class TestRepositoryPackCollection(TestCaseWithTransport):
1125
 
 
1126
 
    def get_format(self):
1127
 
        return bzrdir.format_registry.make_bzrdir('pack-0.92')
1128
 
 
1129
 
    def get_packs(self):
1130
 
        format = self.get_format()
1131
 
        repo = self.make_repository('.', format=format)
1132
 
        return repo._pack_collection
1133
 
 
1134
 
    def make_packs_and_alt_repo(self, write_lock=False):
1135
 
        """Create a pack repo with 3 packs, and access it via a second repo."""
1136
 
        tree = self.make_branch_and_tree('.', format=self.get_format())
1137
 
        tree.lock_write()
1138
 
        self.addCleanup(tree.unlock)
1139
 
        rev1 = tree.commit('one')
1140
 
        rev2 = tree.commit('two')
1141
 
        rev3 = tree.commit('three')
1142
 
        r = repository.Repository.open('.')
1143
 
        if write_lock:
1144
 
            r.lock_write()
1145
 
        else:
1146
 
            r.lock_read()
1147
 
        self.addCleanup(r.unlock)
1148
 
        packs = r._pack_collection
1149
 
        packs.ensure_loaded()
1150
 
        return tree, r, packs, [rev1, rev2, rev3]
1151
 
 
1152
 
    def test__clear_obsolete_packs(self):
1153
 
        packs = self.get_packs()
1154
 
        obsolete_pack_trans = packs.transport.clone('obsolete_packs')
1155
 
        obsolete_pack_trans.put_bytes('a-pack.pack', 'content\n')
1156
 
        obsolete_pack_trans.put_bytes('a-pack.rix', 'content\n')
1157
 
        obsolete_pack_trans.put_bytes('a-pack.iix', 'content\n')
1158
 
        obsolete_pack_trans.put_bytes('another-pack.pack', 'foo\n')
1159
 
        obsolete_pack_trans.put_bytes('not-a-pack.rix', 'foo\n')
1160
 
        res = packs._clear_obsolete_packs()
1161
 
        self.assertEqual(['a-pack', 'another-pack'], sorted(res))
1162
 
        self.assertEqual([], obsolete_pack_trans.list_dir('.'))
1163
 
 
1164
 
    def test__clear_obsolete_packs_preserve(self):
1165
 
        packs = self.get_packs()
1166
 
        obsolete_pack_trans = packs.transport.clone('obsolete_packs')
1167
 
        obsolete_pack_trans.put_bytes('a-pack.pack', 'content\n')
1168
 
        obsolete_pack_trans.put_bytes('a-pack.rix', 'content\n')
1169
 
        obsolete_pack_trans.put_bytes('a-pack.iix', 'content\n')
1170
 
        obsolete_pack_trans.put_bytes('another-pack.pack', 'foo\n')
1171
 
        obsolete_pack_trans.put_bytes('not-a-pack.rix', 'foo\n')
1172
 
        res = packs._clear_obsolete_packs(preserve=set(['a-pack']))
1173
 
        self.assertEqual(['a-pack', 'another-pack'], sorted(res))
1174
 
        self.assertEqual(['a-pack.iix', 'a-pack.pack', 'a-pack.rix'],
1175
 
                         sorted(obsolete_pack_trans.list_dir('.')))
1176
 
 
1177
 
    def test__max_pack_count(self):
1178
 
        """The maximum pack count is a function of the number of revisions."""
1179
 
        # no revisions - one pack, so that we can have a revision free repo
1180
 
        # without it blowing up
1181
 
        packs = self.get_packs()
1182
 
        self.assertEqual(1, packs._max_pack_count(0))
1183
 
        # after that the sum of the digits, - check the first 1-9
1184
 
        self.assertEqual(1, packs._max_pack_count(1))
1185
 
        self.assertEqual(2, packs._max_pack_count(2))
1186
 
        self.assertEqual(3, packs._max_pack_count(3))
1187
 
        self.assertEqual(4, packs._max_pack_count(4))
1188
 
        self.assertEqual(5, packs._max_pack_count(5))
1189
 
        self.assertEqual(6, packs._max_pack_count(6))
1190
 
        self.assertEqual(7, packs._max_pack_count(7))
1191
 
        self.assertEqual(8, packs._max_pack_count(8))
1192
 
        self.assertEqual(9, packs._max_pack_count(9))
1193
 
        # check the boundary cases with two digits for the next decade
1194
 
        self.assertEqual(1, packs._max_pack_count(10))
1195
 
        self.assertEqual(2, packs._max_pack_count(11))
1196
 
        self.assertEqual(10, packs._max_pack_count(19))
1197
 
        self.assertEqual(2, packs._max_pack_count(20))
1198
 
        self.assertEqual(3, packs._max_pack_count(21))
1199
 
        # check some arbitrary big numbers
1200
 
        self.assertEqual(25, packs._max_pack_count(112894))
1201
 
 
1202
 
    def test_repr(self):
1203
 
        packs = self.get_packs()
1204
 
        self.assertContainsRe(repr(packs),
1205
 
            'RepositoryPackCollection(.*Repository(.*))')
1206
 
 
1207
 
    def test__obsolete_packs(self):
1208
 
        tree, r, packs, revs = self.make_packs_and_alt_repo(write_lock=True)
1209
 
        names = packs.names()
1210
 
        pack = packs.get_pack_by_name(names[0])
1211
 
        # Schedule this one for removal
1212
 
        packs._remove_pack_from_memory(pack)
1213
 
        # Simulate a concurrent update by renaming the .pack file and one of
1214
 
        # the indices
1215
 
        packs.transport.rename('packs/%s.pack' % (names[0],),
1216
 
                               'obsolete_packs/%s.pack' % (names[0],))
1217
 
        packs.transport.rename('indices/%s.iix' % (names[0],),
1218
 
                               'obsolete_packs/%s.iix' % (names[0],))
1219
 
        # Now trigger the obsoletion, and ensure that all the remaining files
1220
 
        # are still renamed
1221
 
        packs._obsolete_packs([pack])
1222
 
        self.assertEqual([n + '.pack' for n in names[1:]],
1223
 
                         sorted(packs._pack_transport.list_dir('.')))
1224
 
        # names[0] should not be present in the index anymore
1225
 
        self.assertEqual(names[1:],
1226
 
            sorted(set([osutils.splitext(n)[0] for n in
1227
 
                        packs._index_transport.list_dir('.')])))
1228
 
 
1229
 
    def test_pack_distribution_zero(self):
1230
 
        packs = self.get_packs()
1231
 
        self.assertEqual([0], packs.pack_distribution(0))
1232
 
 
1233
 
    def test_ensure_loaded_unlocked(self):
1234
 
        packs = self.get_packs()
1235
 
        self.assertRaises(errors.ObjectNotLocked,
1236
 
                          packs.ensure_loaded)
1237
 
 
1238
 
    def test_pack_distribution_one_to_nine(self):
1239
 
        packs = self.get_packs()
1240
 
        self.assertEqual([1],
1241
 
            packs.pack_distribution(1))
1242
 
        self.assertEqual([1, 1],
1243
 
            packs.pack_distribution(2))
1244
 
        self.assertEqual([1, 1, 1],
1245
 
            packs.pack_distribution(3))
1246
 
        self.assertEqual([1, 1, 1, 1],
1247
 
            packs.pack_distribution(4))
1248
 
        self.assertEqual([1, 1, 1, 1, 1],
1249
 
            packs.pack_distribution(5))
1250
 
        self.assertEqual([1, 1, 1, 1, 1, 1],
1251
 
            packs.pack_distribution(6))
1252
 
        self.assertEqual([1, 1, 1, 1, 1, 1, 1],
1253
 
            packs.pack_distribution(7))
1254
 
        self.assertEqual([1, 1, 1, 1, 1, 1, 1, 1],
1255
 
            packs.pack_distribution(8))
1256
 
        self.assertEqual([1, 1, 1, 1, 1, 1, 1, 1, 1],
1257
 
            packs.pack_distribution(9))
1258
 
 
1259
 
    def test_pack_distribution_stable_at_boundaries(self):
1260
 
        """When there are multi-rev packs the counts are stable."""
1261
 
        packs = self.get_packs()
1262
 
        # in 10s:
1263
 
        self.assertEqual([10], packs.pack_distribution(10))
1264
 
        self.assertEqual([10, 1], packs.pack_distribution(11))
1265
 
        self.assertEqual([10, 10], packs.pack_distribution(20))
1266
 
        self.assertEqual([10, 10, 1], packs.pack_distribution(21))
1267
 
        # 100s
1268
 
        self.assertEqual([100], packs.pack_distribution(100))
1269
 
        self.assertEqual([100, 1], packs.pack_distribution(101))
1270
 
        self.assertEqual([100, 10, 1], packs.pack_distribution(111))
1271
 
        self.assertEqual([100, 100], packs.pack_distribution(200))
1272
 
        self.assertEqual([100, 100, 1], packs.pack_distribution(201))
1273
 
        self.assertEqual([100, 100, 10, 1], packs.pack_distribution(211))
1274
 
 
1275
 
    def test_plan_pack_operations_2009_revisions_skip_all_packs(self):
1276
 
        packs = self.get_packs()
1277
 
        existing_packs = [(2000, "big"), (9, "medium")]
1278
 
        # rev count - 2009 -> 2x1000 + 9x1
1279
 
        pack_operations = packs.plan_autopack_combinations(
1280
 
            existing_packs, [1000, 1000, 1, 1, 1, 1, 1, 1, 1, 1, 1])
1281
 
        self.assertEqual([], pack_operations)
1282
 
 
1283
 
    def test_plan_pack_operations_2010_revisions_skip_all_packs(self):
1284
 
        packs = self.get_packs()
1285
 
        existing_packs = [(2000, "big"), (9, "medium"), (1, "single")]
1286
 
        # rev count - 2010 -> 2x1000 + 1x10
1287
 
        pack_operations = packs.plan_autopack_combinations(
1288
 
            existing_packs, [1000, 1000, 10])
1289
 
        self.assertEqual([], pack_operations)
1290
 
 
1291
 
    def test_plan_pack_operations_2010_combines_smallest_two(self):
1292
 
        packs = self.get_packs()
1293
 
        existing_packs = [(1999, "big"), (9, "medium"), (1, "single2"),
1294
 
            (1, "single1")]
1295
 
        # rev count - 2010 -> 2x1000 + 1x10 (3)
1296
 
        pack_operations = packs.plan_autopack_combinations(
1297
 
            existing_packs, [1000, 1000, 10])
1298
 
        self.assertEqual([[2, ["single2", "single1"]]], pack_operations)
1299
 
 
1300
 
    def test_plan_pack_operations_creates_a_single_op(self):
1301
 
        packs = self.get_packs()
1302
 
        existing_packs = [(50, 'a'), (40, 'b'), (30, 'c'), (10, 'd'),
1303
 
                          (10, 'e'), (6, 'f'), (4, 'g')]
1304
 
        # rev count 150 -> 1x100 and 5x10
1305
 
        # The two size 10 packs do not need to be touched. The 50, 40, 30 would
1306
 
        # be combined into a single 120 size pack, and the 6 & 4 would
1307
 
        # becombined into a size 10 pack. However, if we have to rewrite them,
1308
 
        # we save a pack file with no increased I/O by putting them into the
1309
 
        # same file.
1310
 
        distribution = packs.pack_distribution(150)
1311
 
        pack_operations = packs.plan_autopack_combinations(existing_packs,
1312
 
                                                           distribution)
1313
 
        self.assertEqual([[130, ['a', 'b', 'c', 'f', 'g']]], pack_operations)
1314
 
 
1315
 
    def test_all_packs_none(self):
1316
 
        format = self.get_format()
1317
 
        tree = self.make_branch_and_tree('.', format=format)
1318
 
        tree.lock_read()
1319
 
        self.addCleanup(tree.unlock)
1320
 
        packs = tree.branch.repository._pack_collection
1321
 
        packs.ensure_loaded()
1322
 
        self.assertEqual([], packs.all_packs())
1323
 
 
1324
 
    def test_all_packs_one(self):
1325
 
        format = self.get_format()
1326
 
        tree = self.make_branch_and_tree('.', format=format)
1327
 
        tree.commit('start')
1328
 
        tree.lock_read()
1329
 
        self.addCleanup(tree.unlock)
1330
 
        packs = tree.branch.repository._pack_collection
1331
 
        packs.ensure_loaded()
1332
 
        self.assertEqual([
1333
 
            packs.get_pack_by_name(packs.names()[0])],
1334
 
            packs.all_packs())
1335
 
 
1336
 
    def test_all_packs_two(self):
1337
 
        format = self.get_format()
1338
 
        tree = self.make_branch_and_tree('.', format=format)
1339
 
        tree.commit('start')
1340
 
        tree.commit('continue')
1341
 
        tree.lock_read()
1342
 
        self.addCleanup(tree.unlock)
1343
 
        packs = tree.branch.repository._pack_collection
1344
 
        packs.ensure_loaded()
1345
 
        self.assertEqual([
1346
 
            packs.get_pack_by_name(packs.names()[0]),
1347
 
            packs.get_pack_by_name(packs.names()[1]),
1348
 
            ], packs.all_packs())
1349
 
 
1350
 
    def test_get_pack_by_name(self):
1351
 
        format = self.get_format()
1352
 
        tree = self.make_branch_and_tree('.', format=format)
1353
 
        tree.commit('start')
1354
 
        tree.lock_read()
1355
 
        self.addCleanup(tree.unlock)
1356
 
        packs = tree.branch.repository._pack_collection
1357
 
        packs.reset()
1358
 
        packs.ensure_loaded()
1359
 
        name = packs.names()[0]
1360
 
        pack_1 = packs.get_pack_by_name(name)
1361
 
        # the pack should be correctly initialised
1362
 
        sizes = packs._names[name]
1363
 
        rev_index = GraphIndex(packs._index_transport, name + '.rix', sizes[0])
1364
 
        inv_index = GraphIndex(packs._index_transport, name + '.iix', sizes[1])
1365
 
        txt_index = GraphIndex(packs._index_transport, name + '.tix', sizes[2])
1366
 
        sig_index = GraphIndex(packs._index_transport, name + '.six', sizes[3])
1367
 
        self.assertEqual(pack_repo.ExistingPack(packs._pack_transport,
1368
 
            name, rev_index, inv_index, txt_index, sig_index), pack_1)
1369
 
        # and the same instance should be returned on successive calls.
1370
 
        self.assertTrue(pack_1 is packs.get_pack_by_name(name))
1371
 
 
1372
 
    def test_reload_pack_names_new_entry(self):
1373
 
        tree, r, packs, revs = self.make_packs_and_alt_repo()
1374
 
        names = packs.names()
1375
 
        # Add a new pack file into the repository
1376
 
        rev4 = tree.commit('four')
1377
 
        new_names = tree.branch.repository._pack_collection.names()
1378
 
        new_name = set(new_names).difference(names)
1379
 
        self.assertEqual(1, len(new_name))
1380
 
        new_name = new_name.pop()
1381
 
        # The old collection hasn't noticed yet
1382
 
        self.assertEqual(names, packs.names())
1383
 
        self.assertTrue(packs.reload_pack_names())
1384
 
        self.assertEqual(new_names, packs.names())
1385
 
        # And the repository can access the new revision
1386
 
        self.assertEqual({rev4:(revs[-1],)}, r.get_parent_map([rev4]))
1387
 
        self.assertFalse(packs.reload_pack_names())
1388
 
 
1389
 
    def test_reload_pack_names_added_and_removed(self):
1390
 
        tree, r, packs, revs = self.make_packs_and_alt_repo()
1391
 
        names = packs.names()
1392
 
        # Now repack the whole thing
1393
 
        tree.branch.repository.pack()
1394
 
        new_names = tree.branch.repository._pack_collection.names()
1395
 
        # The other collection hasn't noticed yet
1396
 
        self.assertEqual(names, packs.names())
1397
 
        self.assertTrue(packs.reload_pack_names())
1398
 
        self.assertEqual(new_names, packs.names())
1399
 
        self.assertEqual({revs[-1]:(revs[-2],)}, r.get_parent_map([revs[-1]]))
1400
 
        self.assertFalse(packs.reload_pack_names())
1401
 
 
1402
 
    def test_reload_pack_names_preserves_pending(self):
1403
 
        # TODO: Update this to also test for pending-deleted names
1404
 
        tree, r, packs, revs = self.make_packs_and_alt_repo(write_lock=True)
1405
 
        # We will add one pack (via start_write_group + insert_record_stream),
1406
 
        # and remove another pack (via _remove_pack_from_memory)
1407
 
        orig_names = packs.names()
1408
 
        orig_at_load = packs._packs_at_load
1409
 
        to_remove_name = iter(orig_names).next()
1410
 
        r.start_write_group()
1411
 
        self.addCleanup(r.abort_write_group)
1412
 
        r.texts.insert_record_stream([versionedfile.FulltextContentFactory(
1413
 
            ('text', 'rev'), (), None, 'content\n')])
1414
 
        new_pack = packs._new_pack
1415
 
        self.assertTrue(new_pack.data_inserted())
1416
 
        new_pack.finish()
1417
 
        packs.allocate(new_pack)
1418
 
        packs._new_pack = None
1419
 
        removed_pack = packs.get_pack_by_name(to_remove_name)
1420
 
        packs._remove_pack_from_memory(removed_pack)
1421
 
        names = packs.names()
1422
 
        all_nodes, deleted_nodes, new_nodes, _ = packs._diff_pack_names()
1423
 
        new_names = set([x[0][0] for x in new_nodes])
1424
 
        self.assertEqual(names, sorted([x[0][0] for x in all_nodes]))
1425
 
        self.assertEqual(set(names) - set(orig_names), new_names)
1426
 
        self.assertEqual(set([new_pack.name]), new_names)
1427
 
        self.assertEqual([to_remove_name],
1428
 
                         sorted([x[0][0] for x in deleted_nodes]))
1429
 
        packs.reload_pack_names()
1430
 
        reloaded_names = packs.names()
1431
 
        self.assertEqual(orig_at_load, packs._packs_at_load)
1432
 
        self.assertEqual(names, reloaded_names)
1433
 
        all_nodes, deleted_nodes, new_nodes, _ = packs._diff_pack_names()
1434
 
        new_names = set([x[0][0] for x in new_nodes])
1435
 
        self.assertEqual(names, sorted([x[0][0] for x in all_nodes]))
1436
 
        self.assertEqual(set(names) - set(orig_names), new_names)
1437
 
        self.assertEqual(set([new_pack.name]), new_names)
1438
 
        self.assertEqual([to_remove_name],
1439
 
                         sorted([x[0][0] for x in deleted_nodes]))
1440
 
 
1441
 
    def test_autopack_obsoletes_new_pack(self):
1442
 
        tree, r, packs, revs = self.make_packs_and_alt_repo(write_lock=True)
1443
 
        packs._max_pack_count = lambda x: 1
1444
 
        packs.pack_distribution = lambda x: [10]
1445
 
        r.start_write_group()
1446
 
        r.revisions.insert_record_stream([versionedfile.FulltextContentFactory(
1447
 
            ('bogus-rev',), (), None, 'bogus-content\n')])
1448
 
        # This should trigger an autopack, which will combine everything into a
1449
 
        # single pack file.
1450
 
        new_names = r.commit_write_group()
1451
 
        names = packs.names()
1452
 
        self.assertEqual(1, len(names))
1453
 
        self.assertEqual([names[0] + '.pack'],
1454
 
                         packs._pack_transport.list_dir('.'))
1455
 
 
1456
 
    def test_autopack_reloads_and_stops(self):
1457
 
        tree, r, packs, revs = self.make_packs_and_alt_repo(write_lock=True)
1458
 
        # After we have determined what needs to be autopacked, trigger a
1459
 
        # full-pack via the other repo which will cause us to re-evaluate and
1460
 
        # decide we don't need to do anything
1461
 
        orig_execute = packs._execute_pack_operations
1462
 
        def _munged_execute_pack_ops(*args, **kwargs):
1463
 
            tree.branch.repository.pack()
1464
 
            return orig_execute(*args, **kwargs)
1465
 
        packs._execute_pack_operations = _munged_execute_pack_ops
1466
 
        packs._max_pack_count = lambda x: 1
1467
 
        packs.pack_distribution = lambda x: [10]
1468
 
        self.assertFalse(packs.autopack())
1469
 
        self.assertEqual(1, len(packs.names()))
1470
 
        self.assertEqual(tree.branch.repository._pack_collection.names(),
1471
 
                         packs.names())
1472
 
 
1473
 
    def test__save_pack_names(self):
1474
 
        tree, r, packs, revs = self.make_packs_and_alt_repo(write_lock=True)
1475
 
        names = packs.names()
1476
 
        pack = packs.get_pack_by_name(names[0])
1477
 
        packs._remove_pack_from_memory(pack)
1478
 
        packs._save_pack_names(obsolete_packs=[pack])
1479
 
        cur_packs = packs._pack_transport.list_dir('.')
1480
 
        self.assertEqual([n + '.pack' for n in names[1:]], sorted(cur_packs))
1481
 
        # obsolete_packs will also have stuff like .rix and .iix present.
1482
 
        obsolete_packs = packs.transport.list_dir('obsolete_packs')
1483
 
        obsolete_names = set([osutils.splitext(n)[0] for n in obsolete_packs])
1484
 
        self.assertEqual([pack.name], sorted(obsolete_names))
1485
 
 
1486
 
    def test__save_pack_names_already_obsoleted(self):
1487
 
        tree, r, packs, revs = self.make_packs_and_alt_repo(write_lock=True)
1488
 
        names = packs.names()
1489
 
        pack = packs.get_pack_by_name(names[0])
1490
 
        packs._remove_pack_from_memory(pack)
1491
 
        # We are going to simulate a concurrent autopack by manually obsoleting
1492
 
        # the pack directly.
1493
 
        packs._obsolete_packs([pack])
1494
 
        packs._save_pack_names(clear_obsolete_packs=True,
1495
 
                               obsolete_packs=[pack])
1496
 
        cur_packs = packs._pack_transport.list_dir('.')
1497
 
        self.assertEqual([n + '.pack' for n in names[1:]], sorted(cur_packs))
1498
 
        # Note that while we set clear_obsolete_packs=True, it should not
1499
 
        # delete a pack file that we have also scheduled for obsoletion.
1500
 
        obsolete_packs = packs.transport.list_dir('obsolete_packs')
1501
 
        obsolete_names = set([osutils.splitext(n)[0] for n in obsolete_packs])
1502
 
        self.assertEqual([pack.name], sorted(obsolete_names))
1503
 
 
1504
 
 
1505
 
 
1506
 
class TestPack(TestCaseWithTransport):
1507
 
    """Tests for the Pack object."""
1508
 
 
1509
 
    def assertCurrentlyEqual(self, left, right):
1510
 
        self.assertTrue(left == right)
1511
 
        self.assertTrue(right == left)
1512
 
        self.assertFalse(left != right)
1513
 
        self.assertFalse(right != left)
1514
 
 
1515
 
    def assertCurrentlyNotEqual(self, left, right):
1516
 
        self.assertFalse(left == right)
1517
 
        self.assertFalse(right == left)
1518
 
        self.assertTrue(left != right)
1519
 
        self.assertTrue(right != left)
1520
 
 
1521
 
    def test___eq____ne__(self):
1522
 
        left = pack_repo.ExistingPack('', '', '', '', '', '')
1523
 
        right = pack_repo.ExistingPack('', '', '', '', '', '')
1524
 
        self.assertCurrentlyEqual(left, right)
1525
 
        # change all attributes and ensure equality changes as we do.
1526
 
        left.revision_index = 'a'
1527
 
        self.assertCurrentlyNotEqual(left, right)
1528
 
        right.revision_index = 'a'
1529
 
        self.assertCurrentlyEqual(left, right)
1530
 
        left.inventory_index = 'a'
1531
 
        self.assertCurrentlyNotEqual(left, right)
1532
 
        right.inventory_index = 'a'
1533
 
        self.assertCurrentlyEqual(left, right)
1534
 
        left.text_index = 'a'
1535
 
        self.assertCurrentlyNotEqual(left, right)
1536
 
        right.text_index = 'a'
1537
 
        self.assertCurrentlyEqual(left, right)
1538
 
        left.signature_index = 'a'
1539
 
        self.assertCurrentlyNotEqual(left, right)
1540
 
        right.signature_index = 'a'
1541
 
        self.assertCurrentlyEqual(left, right)
1542
 
        left.name = 'a'
1543
 
        self.assertCurrentlyNotEqual(left, right)
1544
 
        right.name = 'a'
1545
 
        self.assertCurrentlyEqual(left, right)
1546
 
        left.transport = 'a'
1547
 
        self.assertCurrentlyNotEqual(left, right)
1548
 
        right.transport = 'a'
1549
 
        self.assertCurrentlyEqual(left, right)
1550
 
 
1551
 
    def test_file_name(self):
1552
 
        pack = pack_repo.ExistingPack('', 'a_name', '', '', '', '')
1553
 
        self.assertEqual('a_name.pack', pack.file_name())
1554
 
 
1555
 
 
1556
 
class TestNewPack(TestCaseWithTransport):
1557
 
    """Tests for pack_repo.NewPack."""
1558
 
 
1559
 
    def test_new_instance_attributes(self):
1560
 
        upload_transport = self.get_transport('upload')
1561
 
        pack_transport = self.get_transport('pack')
1562
 
        index_transport = self.get_transport('index')
1563
 
        upload_transport.mkdir('.')
1564
 
        collection = pack_repo.RepositoryPackCollection(
1565
 
            repo=None,
1566
 
            transport=self.get_transport('.'),
1567
 
            index_transport=index_transport,
1568
 
            upload_transport=upload_transport,
1569
 
            pack_transport=pack_transport,
1570
 
            index_builder_class=BTreeBuilder,
1571
 
            index_class=BTreeGraphIndex,
1572
 
            use_chk_index=False)
1573
 
        pack = pack_repo.NewPack(collection)
1574
 
        self.addCleanup(pack.abort) # Make sure the write stream gets closed
1575
 
        self.assertIsInstance(pack.revision_index, BTreeBuilder)
1576
 
        self.assertIsInstance(pack.inventory_index, BTreeBuilder)
1577
 
        self.assertIsInstance(pack._hash, type(osutils.md5()))
1578
 
        self.assertTrue(pack.upload_transport is upload_transport)
1579
 
        self.assertTrue(pack.index_transport is index_transport)
1580
 
        self.assertTrue(pack.pack_transport is pack_transport)
1581
 
        self.assertEqual(None, pack.index_sizes)
1582
 
        self.assertEqual(20, len(pack.random_name))
1583
 
        self.assertIsInstance(pack.random_name, str)
1584
 
        self.assertIsInstance(pack.start_time, float)
1585
 
 
1586
 
 
1587
 
class TestPacker(TestCaseWithTransport):
1588
 
    """Tests for the packs repository Packer class."""
1589
 
 
1590
 
    def test_pack_optimizes_pack_order(self):
1591
 
        builder = self.make_branch_builder('.', format="1.9")
1592
 
        builder.start_series()
1593
 
        builder.build_snapshot('A', None, [
1594
 
            ('add', ('', 'root-id', 'directory', None)),
1595
 
            ('add', ('f', 'f-id', 'file', 'content\n'))])
1596
 
        builder.build_snapshot('B', ['A'],
1597
 
            [('modify', ('f-id', 'new-content\n'))])
1598
 
        builder.build_snapshot('C', ['B'],
1599
 
            [('modify', ('f-id', 'third-content\n'))])
1600
 
        builder.build_snapshot('D', ['C'],
1601
 
            [('modify', ('f-id', 'fourth-content\n'))])
1602
 
        b = builder.get_branch()
1603
 
        b.lock_read()
1604
 
        builder.finish_series()
1605
 
        self.addCleanup(b.unlock)
1606
 
        # At this point, we should have 4 pack files available
1607
 
        # Because of how they were built, they correspond to
1608
 
        # ['D', 'C', 'B', 'A']
1609
 
        packs = b.repository._pack_collection.packs
1610
 
        packer = pack_repo.Packer(b.repository._pack_collection,
1611
 
                                  packs, 'testing',
1612
 
                                  revision_ids=['B', 'C'])
1613
 
        # Now, when we are copying the B & C revisions, their pack files should
1614
 
        # be moved to the front of the stack
1615
 
        # The new ordering moves B & C to the front of the .packs attribute,
1616
 
        # and leaves the others in the original order.
1617
 
        new_packs = [packs[1], packs[2], packs[0], packs[3]]
1618
 
        new_pack = packer.pack()
1619
 
        self.assertEqual(new_packs, packer.packs)
1620
 
 
1621
 
 
1622
 
class TestOptimisingPacker(TestCaseWithTransport):
1623
 
    """Tests for the OptimisingPacker class."""
1624
 
 
1625
 
    def get_pack_collection(self):
1626
 
        repo = self.make_repository('.')
1627
 
        return repo._pack_collection
1628
 
 
1629
 
    def test_open_pack_will_optimise(self):
1630
 
        packer = pack_repo.OptimisingPacker(self.get_pack_collection(),
1631
 
                                            [], '.test')
1632
 
        new_pack = packer.open_pack()
1633
 
        self.addCleanup(new_pack.abort) # ensure cleanup
1634
 
        self.assertIsInstance(new_pack, pack_repo.NewPack)
1635
 
        self.assertTrue(new_pack.revision_index._optimize_for_size)
1636
 
        self.assertTrue(new_pack.inventory_index._optimize_for_size)
1637
 
        self.assertTrue(new_pack.text_index._optimize_for_size)
1638
 
        self.assertTrue(new_pack.signature_index._optimize_for_size)
1639
 
 
1640
 
 
1641
 
class TestCrossFormatPacks(TestCaseWithTransport):
1642
 
 
1643
 
    def log_pack(self, hint=None):
1644
 
        self.calls.append(('pack', hint))
1645
 
        self.orig_pack(hint=hint)
1646
 
        if self.expect_hint:
1647
 
            self.assertTrue(hint)
1648
 
 
1649
 
    def run_stream(self, src_fmt, target_fmt, expect_pack_called):
1650
 
        self.expect_hint = expect_pack_called
1651
 
        self.calls = []
1652
 
        source_tree = self.make_branch_and_tree('src', format=src_fmt)
1653
 
        source_tree.lock_write()
1654
 
        self.addCleanup(source_tree.unlock)
1655
 
        tip = source_tree.commit('foo')
1656
 
        target = self.make_repository('target', format=target_fmt)
1657
 
        target.lock_write()
1658
 
        self.addCleanup(target.unlock)
1659
 
        source = source_tree.branch.repository._get_source(target._format)
1660
 
        self.orig_pack = target.pack
1661
 
        target.pack = self.log_pack
1662
 
        search = target.search_missing_revision_ids(
1663
 
            source_tree.branch.repository, tip)
1664
 
        stream = source.get_stream(search)
1665
 
        from_format = source_tree.branch.repository._format
1666
 
        sink = target._get_sink()
1667
 
        sink.insert_stream(stream, from_format, [])
1668
 
        if expect_pack_called:
1669
 
            self.assertLength(1, self.calls)
1670
 
        else:
1671
 
            self.assertLength(0, self.calls)
1672
 
 
1673
 
    def run_fetch(self, src_fmt, target_fmt, expect_pack_called):
1674
 
        self.expect_hint = expect_pack_called
1675
 
        self.calls = []
1676
 
        source_tree = self.make_branch_and_tree('src', format=src_fmt)
1677
 
        source_tree.lock_write()
1678
 
        self.addCleanup(source_tree.unlock)
1679
 
        tip = source_tree.commit('foo')
1680
 
        target = self.make_repository('target', format=target_fmt)
1681
 
        target.lock_write()
1682
 
        self.addCleanup(target.unlock)
1683
 
        source = source_tree.branch.repository
1684
 
        self.orig_pack = target.pack
1685
 
        target.pack = self.log_pack
1686
 
        target.fetch(source)
1687
 
        if expect_pack_called:
1688
 
            self.assertLength(1, self.calls)
1689
 
        else:
1690
 
            self.assertLength(0, self.calls)
1691
 
 
1692
 
    def test_sink_format_hint_no(self):
1693
 
        # When the target format says packing makes no difference, pack is not
1694
 
        # called.
1695
 
        self.run_stream('1.9', 'rich-root-pack', False)
1696
 
 
1697
 
    def test_sink_format_hint_yes(self):
1698
 
        # When the target format says packing makes a difference, pack is
1699
 
        # called.
1700
 
        self.run_stream('1.9', '2a', True)
1701
 
 
1702
 
    def test_sink_format_same_no(self):
1703
 
        # When the formats are the same, pack is not called.
1704
 
        self.run_stream('2a', '2a', False)
1705
 
 
1706
 
    def test_IDS_format_hint_no(self):
1707
 
        # When the target format says packing makes no difference, pack is not
1708
 
        # called.
1709
 
        self.run_fetch('1.9', 'rich-root-pack', False)
1710
 
 
1711
 
    def test_IDS_format_hint_yes(self):
1712
 
        # When the target format says packing makes a difference, pack is
1713
 
        # called.
1714
 
        self.run_fetch('1.9', '2a', True)
1715
 
 
1716
 
    def test_IDS_format_same_no(self):
1717
 
        # When the formats are the same, pack is not called.
1718
 
        self.run_fetch('2a', '2a', False)
 
437
        self.assertRaises(KeyError, repository._unescape_xml, 'foo&bar;')