/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_repository.py

First attempt to merge .dev and resolve the conflicts (but tests are 
failing)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_repository.py
1
 
# Copyright (C) 2006 Canonical Ltd
 
1
# Copyright (C) 2006, 2007, 2008 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
22
22
also see this file.
23
23
"""
24
24
 
 
25
import md5
25
26
from stat import S_ISDIR
26
27
from StringIO import StringIO
27
28
 
28
29
import bzrlib
29
 
import bzrlib.bzrdir as bzrdir
30
 
import bzrlib.errors as errors
31
30
from bzrlib.errors import (NotBranchError,
32
31
                           NoSuchFile,
33
32
                           UnknownFormatError,
34
33
                           UnsupportedFormatError,
35
34
                           )
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
 
35
from bzrlib import graph
 
36
from bzrlib.index import GraphIndex, InMemoryGraphIndex
 
37
from bzrlib.repository import RepositoryFormat
 
38
from bzrlib.smart import server
 
39
from bzrlib.tests import (
 
40
    TestCase,
 
41
    TestCaseWithTransport,
 
42
    TestSkipped,
 
43
    test_knit,
 
44
    )
 
45
from bzrlib.transport import (
 
46
    fakenfs,
 
47
    get_transport,
 
48
    )
40
49
from bzrlib.transport.memory import MemoryServer
41
 
from bzrlib import upgrade, workingtree
 
50
from bzrlib.util import bencode
 
51
from bzrlib import (
 
52
    bzrdir,
 
53
    errors,
 
54
    inventory,
 
55
    progress,
 
56
    repository,
 
57
    revision as _mod_revision,
 
58
    symbol_versioning,
 
59
    upgrade,
 
60
    workingtree,
 
61
    )
 
62
from bzrlib.repofmt import knitrepo, weaverepo, pack_repo
42
63
 
43
64
 
44
65
class TestDefaultFormat(TestCase):
45
66
 
46
67
    def test_get_set_default_format(self):
47
 
        private_default = repository._default_format.__class__
 
68
        old_default = bzrdir.format_registry.get('default')
 
69
        private_default = old_default().repository_format.__class__
48
70
        old_format = repository.RepositoryFormat.get_default_format()
49
71
        self.assertTrue(isinstance(old_format, private_default))
50
 
        repository.RepositoryFormat.set_default_format(SampleRepositoryFormat())
 
72
        def make_sample_bzrdir():
 
73
            my_bzrdir = bzrdir.BzrDirMetaFormat1()
 
74
            my_bzrdir.repository_format = SampleRepositoryFormat()
 
75
            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')
51
79
        # creating a repository should now create an instrumented dir.
52
80
        try:
53
81
            # the default branch format is used by the meta dir format
56
84
            result = dir.create_repository()
57
85
            self.assertEqual(result, 'A bzr repository dir')
58
86
        finally:
59
 
            repository.RepositoryFormat.set_default_format(old_format)
60
 
        self.assertEqual(old_format, repository.RepositoryFormat.get_default_format())
 
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(),
 
91
                              old_format.__class__)
61
92
 
62
93
 
63
94
class SampleRepositoryFormat(repository.RepositoryFormat):
98
129
            t = get_transport(url)
99
130
            found_format = repository.RepositoryFormat.find_format(dir)
100
131
            self.failUnless(isinstance(found_format, format.__class__))
101
 
        check_format(repository.RepositoryFormat7(), "bar")
 
132
        check_format(weaverepo.RepositoryFormat7(), "bar")
102
133
        
103
134
    def test_find_format_no_repository(self):
104
135
        dir = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
131
162
 
132
163
class TestFormat6(TestCaseWithTransport):
133
164
 
 
165
    def test_attribute__fetch_order(self):
 
166
        """Weaves need topological data insertion."""
 
167
        control = bzrdir.BzrDirFormat6().initialize(self.get_url())
 
168
        repo = weaverepo.RepositoryFormat6().initialize(control)
 
169
        self.assertEqual('topological', repo._fetch_order)
 
170
 
 
171
    def test_attribute__fetch_uses_deltas(self):
 
172
        """Weaves do not reuse deltas."""
 
173
        control = bzrdir.BzrDirFormat6().initialize(self.get_url())
 
174
        repo = weaverepo.RepositoryFormat6().initialize(control)
 
175
        self.assertEqual(False, repo._fetch_uses_deltas)
 
176
 
 
177
    def test_attribute__fetch_reconcile(self):
 
178
        """Weave repositories need a reconcile after fetch."""
 
179
        control = bzrdir.BzrDirFormat6().initialize(self.get_url())
 
180
        repo = weaverepo.RepositoryFormat6().initialize(control)
 
181
        self.assertEqual(True, repo._fetch_reconcile)
 
182
 
134
183
    def test_no_ancestry_weave(self):
135
184
        control = bzrdir.BzrDirFormat6().initialize(self.get_url())
136
 
        repo = repository.RepositoryFormat6().initialize(control)
 
185
        repo = weaverepo.RepositoryFormat6().initialize(control)
137
186
        # We no longer need to create the ancestry.weave file
138
187
        # since it is *never* used.
139
188
        self.assertRaises(NoSuchFile,
140
189
                          control.transport.get,
141
190
                          'ancestry.weave')
142
191
 
 
192
    def test_supports_external_lookups(self):
 
193
        control = bzrdir.BzrDirFormat6().initialize(self.get_url())
 
194
        repo = weaverepo.RepositoryFormat6().initialize(control)
 
195
        self.assertFalse(repo._format.supports_external_lookups)
 
196
 
143
197
 
144
198
class TestFormat7(TestCaseWithTransport):
145
 
    
 
199
 
 
200
    def test_attribute__fetch_order(self):
 
201
        """Weaves need topological data insertion."""
 
202
        control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
 
203
        repo = weaverepo.RepositoryFormat7().initialize(control)
 
204
        self.assertEqual('topological', repo._fetch_order)
 
205
 
 
206
    def test_attribute__fetch_uses_deltas(self):
 
207
        """Weaves do not reuse deltas."""
 
208
        control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
 
209
        repo = weaverepo.RepositoryFormat7().initialize(control)
 
210
        self.assertEqual(False, repo._fetch_uses_deltas)
 
211
 
 
212
    def test_attribute__fetch_reconcile(self):
 
213
        """Weave repositories need a reconcile after fetch."""
 
214
        control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
 
215
        repo = weaverepo.RepositoryFormat7().initialize(control)
 
216
        self.assertEqual(True, repo._fetch_reconcile)
 
217
 
146
218
    def test_disk_layout(self):
147
219
        control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
148
 
        repo = repository.RepositoryFormat7().initialize(control)
 
220
        repo = weaverepo.RepositoryFormat7().initialize(control)
149
221
        # in case of side effects of locking.
150
222
        repo.lock_write()
151
223
        repo.unlock()
164
236
                             'w\n'
165
237
                             'W\n',
166
238
                             t.get('inventory.weave').read())
 
239
        # Creating a file with id Foo:Bar results in a non-escaped file name on
 
240
        # disk.
 
241
        control.create_branch()
 
242
        tree = control.create_workingtree()
 
243
        tree.add(['foo'], ['Foo:Bar'], ['file'])
 
244
        tree.put_file_bytes_non_atomic('Foo:Bar', 'content\n')
 
245
        tree.commit('first post', rev_id='first')
 
246
        self.assertEqualDiff(
 
247
            '# bzr weave file v5\n'
 
248
            'i\n'
 
249
            '1 7fe70820e08a1aac0ef224d9c66ab66831cc4ab1\n'
 
250
            'n first\n'
 
251
            '\n'
 
252
            'w\n'
 
253
            '{ 0\n'
 
254
            '. content\n'
 
255
            '}\n'
 
256
            'W\n',
 
257
            t.get('weaves/74/Foo%3ABar.weave').read())
167
258
 
168
259
    def test_shared_disk_layout(self):
169
260
        control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
170
 
        repo = repository.RepositoryFormat7().initialize(control, shared=True)
 
261
        repo = weaverepo.RepositoryFormat7().initialize(control, shared=True)
171
262
        # we want:
172
263
        # format 'Bazaar-NG Repository format 7'
173
264
        # inventory.weave == empty_weave
190
281
    def test_creates_lockdir(self):
191
282
        """Make sure it appears to be controlled by a LockDir existence"""
192
283
        control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
193
 
        repo = repository.RepositoryFormat7().initialize(control, shared=True)
 
284
        repo = weaverepo.RepositoryFormat7().initialize(control, shared=True)
194
285
        t = control.get_repository_transport(None)
195
286
        # TODO: Should check there is a 'lock' toplevel directory, 
196
287
        # regardless of contents
206
297
        """repo format 7 actually locks on lockdir"""
207
298
        base_url = self.get_url()
208
299
        control = bzrdir.BzrDirMetaFormat1().initialize(base_url)
209
 
        repo = repository.RepositoryFormat7().initialize(control, shared=True)
 
300
        repo = weaverepo.RepositoryFormat7().initialize(control, shared=True)
210
301
        t = control.get_repository_transport(None)
211
302
        repo.lock_write()
212
303
        repo.unlock()
220
311
 
221
312
    def test_shared_no_tree_disk_layout(self):
222
313
        control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
223
 
        repo = repository.RepositoryFormat7().initialize(control, shared=True)
 
314
        repo = weaverepo.RepositoryFormat7().initialize(control, shared=True)
224
315
        repo.set_make_working_trees(False)
225
316
        # we want:
226
317
        # format 'Bazaar-NG Repository format 7'
244
335
                             'W\n',
245
336
                             t.get('inventory.weave').read())
246
337
 
 
338
    def test_supports_external_lookups(self):
 
339
        control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
 
340
        repo = weaverepo.RepositoryFormat7().initialize(control)
 
341
        self.assertFalse(repo._format.supports_external_lookups)
 
342
 
247
343
 
248
344
class TestFormatKnit1(TestCaseWithTransport):
249
345
    
 
346
    def test_attribute__fetch_order(self):
 
347
        """Knits need topological data insertion."""
 
348
        repo = self.make_repository('.',
 
349
                format=bzrdir.format_registry.get('knit')())
 
350
        self.assertEqual('topological', repo._fetch_order)
 
351
 
 
352
    def test_attribute__fetch_uses_deltas(self):
 
353
        """Knits reuse deltas."""
 
354
        repo = self.make_repository('.',
 
355
                format=bzrdir.format_registry.get('knit')())
 
356
        self.assertEqual(True, repo._fetch_uses_deltas)
 
357
 
250
358
    def test_disk_layout(self):
251
359
        control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
252
 
        repo = repository.RepositoryFormatKnit1().initialize(control)
 
360
        repo = knitrepo.RepositoryFormatKnit1().initialize(control)
253
361
        # in case of side effects of locking.
254
362
        repo.lock_write()
255
363
        repo.unlock()
266
374
        # self.assertEqualDiff('', t.get('lock').read())
267
375
        self.assertTrue(S_ISDIR(t.stat('knits').st_mode))
268
376
        self.check_knits(t)
 
377
        # Check per-file knits.
 
378
        branch = control.create_branch()
 
379
        tree = control.create_workingtree()
 
380
        tree.add(['foo'], ['Nasty-IdC:'], ['file'])
 
381
        tree.put_file_bytes_non_atomic('Nasty-IdC:', '')
 
382
        tree.commit('1st post', rev_id='foo')
 
383
        self.assertHasKnit(t, 'knits/e8/%254easty-%2549d%2543%253a',
 
384
            '\nfoo fulltext 0 81  :')
269
385
 
270
 
    def assertHasKnit(self, t, knit_name):
 
386
    def assertHasKnit(self, t, knit_name, extra_content=''):
271
387
        """Assert that knit_name exists on t."""
272
 
        self.assertEqualDiff('# bzr knit index 8\n',
 
388
        self.assertEqualDiff('# bzr knit index 8\n' + extra_content,
273
389
                             t.get(knit_name + '.kndx').read())
274
 
        # no default content
275
 
        self.assertTrue(t.has(knit_name + '.knit'))
276
390
 
277
391
    def check_knits(self, t):
278
392
        """check knit content for a repository."""
282
396
 
283
397
    def test_shared_disk_layout(self):
284
398
        control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
285
 
        repo = repository.RepositoryFormatKnit1().initialize(control, shared=True)
 
399
        repo = knitrepo.RepositoryFormatKnit1().initialize(control, shared=True)
286
400
        # we want:
287
401
        # format 'Bazaar-NG Knit Repository Format 1'
288
402
        # lock: is a directory
301
415
 
302
416
    def test_shared_no_tree_disk_layout(self):
303
417
        control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
304
 
        repo = repository.RepositoryFormatKnit1().initialize(control, shared=True)
 
418
        repo = knitrepo.RepositoryFormatKnit1().initialize(control, shared=True)
305
419
        repo.set_make_working_trees(False)
306
420
        # we want:
307
421
        # format 'Bazaar-NG Knit Repository Format 1'
322
436
        self.assertTrue(S_ISDIR(t.stat('knits').st_mode))
323
437
        self.check_knits(t)
324
438
 
325
 
 
326
 
class InterString(repository.InterRepository):
327
 
    """An inter-repository optimised code path for strings.
328
 
 
329
 
    This is for use during testing where we use strings as repositories
 
439
    def test_deserialise_sets_root_revision(self):
 
440
        """We must have a inventory.root.revision
 
441
 
 
442
        Old versions of the XML5 serializer did not set the revision_id for
 
443
        the whole inventory. So we grab the one from the expected text. Which
 
444
        is valid when the api is not being abused.
 
445
        """
 
446
        repo = self.make_repository('.',
 
447
                format=bzrdir.format_registry.get('knit')())
 
448
        inv_xml = '<inventory format="5">\n</inventory>\n'
 
449
        inv = repo.deserialise_inventory('test-rev-id', inv_xml)
 
450
        self.assertEqual('test-rev-id', inv.root.revision)
 
451
 
 
452
    def test_deserialise_uses_global_revision_id(self):
 
453
        """If it is set, then we re-use the global revision id"""
 
454
        repo = self.make_repository('.',
 
455
                format=bzrdir.format_registry.get('knit')())
 
456
        inv_xml = ('<inventory format="5" revision_id="other-rev-id">\n'
 
457
                   '</inventory>\n')
 
458
        # Arguably, the deserialise_inventory should detect a mismatch, and
 
459
        # raise an error, rather than silently using one revision_id over the
 
460
        # other.
 
461
        self.assertRaises(AssertionError, repo.deserialise_inventory,
 
462
            'test-rev-id', inv_xml)
 
463
        inv = repo.deserialise_inventory('other-rev-id', inv_xml)
 
464
        self.assertEqual('other-rev-id', inv.root.revision)
 
465
 
 
466
    def test_supports_external_lookups(self):
 
467
        repo = self.make_repository('.',
 
468
                format=bzrdir.format_registry.get('knit')())
 
469
        self.assertFalse(repo._format.supports_external_lookups)
 
470
 
 
471
 
 
472
class DummyRepository(object):
 
473
    """A dummy repository for testing."""
 
474
 
 
475
    _serializer = None
 
476
 
 
477
    def supports_rich_root(self):
 
478
        return False
 
479
 
 
480
 
 
481
class InterDummy(repository.InterRepository):
 
482
    """An inter-repository optimised code path for DummyRepository.
 
483
 
 
484
    This is for use during testing where we use DummyRepository as repositories
330
485
    so that none of the default regsitered inter-repository classes will
331
 
    match.
 
486
    MATCH.
332
487
    """
333
488
 
334
489
    @staticmethod
335
490
    def is_compatible(repo_source, repo_target):
336
 
        """InterString is compatible with strings-as-repos."""
337
 
        return isinstance(repo_source, str) and isinstance(repo_target, str)
 
491
        """InterDummy is compatible with DummyRepository."""
 
492
        return (isinstance(repo_source, DummyRepository) and 
 
493
            isinstance(repo_target, DummyRepository))
338
494
 
339
495
 
340
496
class TestInterRepository(TestCaseWithTransport):
346
502
        # This also tests that the default registered optimised interrepository
347
503
        # classes do not barf inappropriately when a surprising repository type
348
504
        # is handed to them.
349
 
        dummy_a = "Repository 1."
350
 
        dummy_b = "Repository 2."
 
505
        dummy_a = DummyRepository()
 
506
        dummy_b = DummyRepository()
351
507
        self.assertGetsDefaultInterRepository(dummy_a, dummy_b)
352
508
 
353
509
    def assertGetsDefaultInterRepository(self, repo_a, repo_b):
354
 
        """Asserts that InterRepository.get(repo_a, repo_b) -> the default."""
 
510
        """Asserts that InterRepository.get(repo_a, repo_b) -> the default.
 
511
        
 
512
        The effective default is now InterSameDataRepository because there is
 
513
        no actual sane default in the presence of incompatible data models.
 
514
        """
355
515
        inter_repo = repository.InterRepository.get(repo_a, repo_b)
356
 
        self.assertEqual(repository.InterRepository,
 
516
        self.assertEqual(repository.InterSameDataRepository,
357
517
                         inter_repo.__class__)
358
518
        self.assertEqual(repo_a, inter_repo.source)
359
519
        self.assertEqual(repo_b, inter_repo.target)
364
524
        # and that it is correctly selected when given a repository
365
525
        # pair that it returns true on for the is_compatible static method
366
526
        # check
367
 
        dummy_a = "Repository 1."
368
 
        dummy_b = "Repository 2."
369
 
        repository.InterRepository.register_optimiser(InterString)
 
527
        dummy_a = DummyRepository()
 
528
        dummy_b = DummyRepository()
 
529
        repo = self.make_repository('.')
 
530
        # hack dummies to look like repo somewhat.
 
531
        dummy_a._serializer = repo._serializer
 
532
        dummy_b._serializer = repo._serializer
 
533
        repository.InterRepository.register_optimiser(InterDummy)
370
534
        try:
371
 
            # we should get the default for something InterString returns False
 
535
            # we should get the default for something InterDummy returns False
372
536
            # to
373
 
            self.assertFalse(InterString.is_compatible(dummy_a, None))
374
 
            self.assertGetsDefaultInterRepository(dummy_a, None)
375
 
            # and we should get an InterString for a pair it 'likes'
376
 
            self.assertTrue(InterString.is_compatible(dummy_a, dummy_b))
 
537
            self.assertFalse(InterDummy.is_compatible(dummy_a, repo))
 
538
            self.assertGetsDefaultInterRepository(dummy_a, repo)
 
539
            # and we should get an InterDummy for a pair it 'likes'
 
540
            self.assertTrue(InterDummy.is_compatible(dummy_a, dummy_b))
377
541
            inter_repo = repository.InterRepository.get(dummy_a, dummy_b)
378
 
            self.assertEqual(InterString, inter_repo.__class__)
 
542
            self.assertEqual(InterDummy, inter_repo.__class__)
379
543
            self.assertEqual(dummy_a, inter_repo.source)
380
544
            self.assertEqual(dummy_b, inter_repo.target)
381
545
        finally:
382
 
            repository.InterRepository.unregister_optimiser(InterString)
 
546
            repository.InterRepository.unregister_optimiser(InterDummy)
383
547
        # now we should get the default InterRepository object again.
384
548
        self.assertGetsDefaultInterRepository(dummy_a, dummy_b)
385
549
 
389
553
    def test_is_compatible_and_registered(self):
390
554
        # InterWeaveRepo is compatible when either side
391
555
        # is a format 5/6/7 branch
392
 
        formats = [repository.RepositoryFormat5(),
393
 
                   repository.RepositoryFormat6(),
394
 
                   repository.RepositoryFormat7()]
395
 
        incompatible_formats = [repository.RepositoryFormat4(),
396
 
                                repository.RepositoryFormatKnit1(),
 
556
        from bzrlib.repofmt import knitrepo, weaverepo
 
557
        formats = [weaverepo.RepositoryFormat5(),
 
558
                   weaverepo.RepositoryFormat6(),
 
559
                   weaverepo.RepositoryFormat7()]
 
560
        incompatible_formats = [weaverepo.RepositoryFormat4(),
 
561
                                knitrepo.RepositoryFormatKnit1(),
397
562
                                ]
398
563
        repo_a = self.make_repository('a')
399
564
        repo_b = self.make_repository('b')
420
585
        t = get_transport(self.get_url('.'))
421
586
        t.mkdir('repository')
422
587
        repo_dir = bzrdir.BzrDirMetaFormat1().initialize('repository')
423
 
        repo = repository.RepositoryFormat7().initialize(repo_dir)
424
 
        target_format = repository.RepositoryFormatKnit1()
 
588
        repo = weaverepo.RepositoryFormat7().initialize(repo_dir)
 
589
        target_format = knitrepo.RepositoryFormatKnit1()
425
590
        converter = repository.CopyConverter(target_format)
426
591
        pb = bzrlib.ui.ui_factory.nested_progress_bar()
427
592
        try:
439
604
        self.assertRaises(KeyError, repository._unescape_xml, 'foo&bar;') 
440
605
 
441
606
 
442
 
class TestRepositoryFormatKnit2(TestCaseWithTransport):
 
607
class TestRepositoryFormatKnit3(TestCaseWithTransport):
 
608
 
 
609
    def test_attribute__fetch_order(self):
 
610
        """Knits need topological data insertion."""
 
611
        format = bzrdir.BzrDirMetaFormat1()
 
612
        format.repository_format = knitrepo.RepositoryFormatKnit3()
 
613
        repo = self.make_repository('.', format=format)
 
614
        self.assertEqual('topological', repo._fetch_order)
 
615
 
 
616
    def test_attribute__fetch_uses_deltas(self):
 
617
        """Knits reuse deltas."""
 
618
        format = bzrdir.BzrDirMetaFormat1()
 
619
        format.repository_format = knitrepo.RepositoryFormatKnit3()
 
620
        repo = self.make_repository('.', format=format)
 
621
        self.assertEqual(True, repo._fetch_uses_deltas)
443
622
 
444
623
    def test_convert(self):
445
624
        """Ensure the upgrade adds weaves for roots"""
446
625
        format = bzrdir.BzrDirMetaFormat1()
447
 
        format.repository_format = repository.RepositoryFormatKnit1()
 
626
        format.repository_format = knitrepo.RepositoryFormatKnit1()
448
627
        tree = self.make_branch_and_tree('.', format)
449
628
        tree.commit("Dull commit", rev_id="dull")
450
629
        revision_tree = tree.branch.repository.revision_tree('dull')
451
 
        self.assertRaises(errors.NoSuchFile, revision_tree.get_file_lines,
452
 
            revision_tree.inventory.root.file_id)
 
630
        revision_tree.lock_read()
 
631
        try:
 
632
            self.assertRaises(errors.NoSuchFile, revision_tree.get_file_lines,
 
633
                revision_tree.inventory.root.file_id)
 
634
        finally:
 
635
            revision_tree.unlock()
453
636
        format = bzrdir.BzrDirMetaFormat1()
454
 
        format.repository_format = repository.RepositoryFormatKnit2()
 
637
        format.repository_format = knitrepo.RepositoryFormatKnit3()
455
638
        upgrade.Convert('.', format)
456
639
        tree = workingtree.WorkingTree.open('.')
457
640
        revision_tree = tree.branch.repository.revision_tree('dull')
458
 
        revision_tree.get_file_lines(revision_tree.inventory.root.file_id)
 
641
        revision_tree.lock_read()
 
642
        try:
 
643
            revision_tree.get_file_lines(revision_tree.inventory.root.file_id)
 
644
        finally:
 
645
            revision_tree.unlock()
459
646
        tree.commit("Another dull commit", rev_id='dull2')
460
647
        revision_tree = tree.branch.repository.revision_tree('dull2')
 
648
        revision_tree.lock_read()
 
649
        self.addCleanup(revision_tree.unlock)
461
650
        self.assertEqual('dull', revision_tree.inventory.root.revision)
 
651
 
 
652
    def test_supports_external_lookups(self):
 
653
        format = bzrdir.BzrDirMetaFormat1()
 
654
        format.repository_format = knitrepo.RepositoryFormatKnit3()
 
655
        repo = self.make_repository('.', format=format)
 
656
        self.assertFalse(repo._format.supports_external_lookups)
 
657
 
 
658
 
 
659
class TestWithBrokenRepo(TestCaseWithTransport):
 
660
    """These tests seem to be more appropriate as interface tests?"""
 
661
 
 
662
    def make_broken_repository(self):
 
663
        # XXX: This function is borrowed from Aaron's "Reconcile can fix bad
 
664
        # parent references" branch which is due to land in bzr.dev soon.  Once
 
665
        # it does, this duplication should be removed.
 
666
        repo = self.make_repository('broken-repo')
 
667
        cleanups = []
 
668
        try:
 
669
            repo.lock_write()
 
670
            cleanups.append(repo.unlock)
 
671
            repo.start_write_group()
 
672
            cleanups.append(repo.commit_write_group)
 
673
            # make rev1a: A well-formed revision, containing 'file1'
 
674
            inv = inventory.Inventory(revision_id='rev1a')
 
675
            inv.root.revision = 'rev1a'
 
676
            self.add_file(repo, inv, 'file1', 'rev1a', [])
 
677
            repo.add_inventory('rev1a', inv, [])
 
678
            revision = _mod_revision.Revision('rev1a',
 
679
                committer='jrandom@example.com', timestamp=0,
 
680
                inventory_sha1='', timezone=0, message='foo', parent_ids=[])
 
681
            repo.add_revision('rev1a',revision, inv)
 
682
 
 
683
            # make rev1b, which has no Revision, but has an Inventory, and
 
684
            # file1
 
685
            inv = inventory.Inventory(revision_id='rev1b')
 
686
            inv.root.revision = 'rev1b'
 
687
            self.add_file(repo, inv, 'file1', 'rev1b', [])
 
688
            repo.add_inventory('rev1b', inv, [])
 
689
 
 
690
            # make rev2, with file1 and file2
 
691
            # file2 is sane
 
692
            # file1 has 'rev1b' as an ancestor, even though this is not
 
693
            # mentioned by 'rev1a', making it an unreferenced ancestor
 
694
            inv = inventory.Inventory()
 
695
            self.add_file(repo, inv, 'file1', 'rev2', ['rev1a', 'rev1b'])
 
696
            self.add_file(repo, inv, 'file2', 'rev2', [])
 
697
            self.add_revision(repo, 'rev2', inv, ['rev1a'])
 
698
 
 
699
            # make ghost revision rev1c
 
700
            inv = inventory.Inventory()
 
701
            self.add_file(repo, inv, 'file2', 'rev1c', [])
 
702
 
 
703
            # make rev3 with file2
 
704
            # file2 refers to 'rev1c', which is a ghost in this repository, so
 
705
            # file2 cannot have rev1c as its ancestor.
 
706
            inv = inventory.Inventory()
 
707
            self.add_file(repo, inv, 'file2', 'rev3', ['rev1c'])
 
708
            self.add_revision(repo, 'rev3', inv, ['rev1c'])
 
709
            return repo
 
710
        finally:
 
711
            for cleanup in reversed(cleanups):
 
712
                cleanup()
 
713
 
 
714
    def add_revision(self, repo, revision_id, inv, parent_ids):
 
715
        inv.revision_id = revision_id
 
716
        inv.root.revision = revision_id
 
717
        repo.add_inventory(revision_id, inv, parent_ids)
 
718
        revision = _mod_revision.Revision(revision_id,
 
719
            committer='jrandom@example.com', timestamp=0, inventory_sha1='',
 
720
            timezone=0, message='foo', parent_ids=parent_ids)
 
721
        repo.add_revision(revision_id,revision, inv)
 
722
 
 
723
    def add_file(self, repo, inv, filename, revision, parents):
 
724
        file_id = filename + '-id'
 
725
        entry = inventory.InventoryFile(file_id, filename, 'TREE_ROOT')
 
726
        entry.revision = revision
 
727
        entry.text_size = 0
 
728
        inv.add(entry)
 
729
        text_key = (file_id, revision)
 
730
        parent_keys = [(file_id, parent) for parent in parents]
 
731
        repo.texts.add_lines(text_key, parent_keys, ['line\n'])
 
732
 
 
733
    def test_insert_from_broken_repo(self):
 
734
        """Inserting a data stream from a broken repository won't silently
 
735
        corrupt the target repository.
 
736
        """
 
737
        broken_repo = self.make_broken_repository()
 
738
        empty_repo = self.make_repository('empty-repo')
 
739
        self.assertRaises(errors.RevisionNotPresent, empty_repo.fetch, broken_repo)
 
740
 
 
741
 
 
742
class TestRepositoryPackCollection(TestCaseWithTransport):
 
743
 
 
744
    def get_format(self):
 
745
        return bzrdir.format_registry.make_bzrdir('pack-0.92')
 
746
 
 
747
    def test__max_pack_count(self):
 
748
        """The maximum pack count is a function of the number of revisions."""
 
749
        format = self.get_format()
 
750
        repo = self.make_repository('.', format=format)
 
751
        packs = repo._pack_collection
 
752
        # no revisions - one pack, so that we can have a revision free repo
 
753
        # without it blowing up
 
754
        self.assertEqual(1, packs._max_pack_count(0))
 
755
        # after that the sum of the digits, - check the first 1-9
 
756
        self.assertEqual(1, packs._max_pack_count(1))
 
757
        self.assertEqual(2, packs._max_pack_count(2))
 
758
        self.assertEqual(3, packs._max_pack_count(3))
 
759
        self.assertEqual(4, packs._max_pack_count(4))
 
760
        self.assertEqual(5, packs._max_pack_count(5))
 
761
        self.assertEqual(6, packs._max_pack_count(6))
 
762
        self.assertEqual(7, packs._max_pack_count(7))
 
763
        self.assertEqual(8, packs._max_pack_count(8))
 
764
        self.assertEqual(9, packs._max_pack_count(9))
 
765
        # check the boundary cases with two digits for the next decade
 
766
        self.assertEqual(1, packs._max_pack_count(10))
 
767
        self.assertEqual(2, packs._max_pack_count(11))
 
768
        self.assertEqual(10, packs._max_pack_count(19))
 
769
        self.assertEqual(2, packs._max_pack_count(20))
 
770
        self.assertEqual(3, packs._max_pack_count(21))
 
771
        # check some arbitrary big numbers
 
772
        self.assertEqual(25, packs._max_pack_count(112894))
 
773
 
 
774
    def test_pack_distribution_zero(self):
 
775
        format = self.get_format()
 
776
        repo = self.make_repository('.', format=format)
 
777
        packs = repo._pack_collection
 
778
        self.assertEqual([0], packs.pack_distribution(0))
 
779
 
 
780
    def test_ensure_loaded_unlocked(self):
 
781
        format = self.get_format()
 
782
        repo = self.make_repository('.', format=format)
 
783
        self.assertRaises(errors.ObjectNotLocked,
 
784
                          repo._pack_collection.ensure_loaded)
 
785
 
 
786
    def test_pack_distribution_one_to_nine(self):
 
787
        format = self.get_format()
 
788
        repo = self.make_repository('.', format=format)
 
789
        packs = repo._pack_collection
 
790
        self.assertEqual([1],
 
791
            packs.pack_distribution(1))
 
792
        self.assertEqual([1, 1],
 
793
            packs.pack_distribution(2))
 
794
        self.assertEqual([1, 1, 1],
 
795
            packs.pack_distribution(3))
 
796
        self.assertEqual([1, 1, 1, 1],
 
797
            packs.pack_distribution(4))
 
798
        self.assertEqual([1, 1, 1, 1, 1],
 
799
            packs.pack_distribution(5))
 
800
        self.assertEqual([1, 1, 1, 1, 1, 1],
 
801
            packs.pack_distribution(6))
 
802
        self.assertEqual([1, 1, 1, 1, 1, 1, 1],
 
803
            packs.pack_distribution(7))
 
804
        self.assertEqual([1, 1, 1, 1, 1, 1, 1, 1],
 
805
            packs.pack_distribution(8))
 
806
        self.assertEqual([1, 1, 1, 1, 1, 1, 1, 1, 1],
 
807
            packs.pack_distribution(9))
 
808
 
 
809
    def test_pack_distribution_stable_at_boundaries(self):
 
810
        """When there are multi-rev packs the counts are stable."""
 
811
        format = self.get_format()
 
812
        repo = self.make_repository('.', format=format)
 
813
        packs = repo._pack_collection
 
814
        # in 10s:
 
815
        self.assertEqual([10], packs.pack_distribution(10))
 
816
        self.assertEqual([10, 1], packs.pack_distribution(11))
 
817
        self.assertEqual([10, 10], packs.pack_distribution(20))
 
818
        self.assertEqual([10, 10, 1], packs.pack_distribution(21))
 
819
        # 100s
 
820
        self.assertEqual([100], packs.pack_distribution(100))
 
821
        self.assertEqual([100, 1], packs.pack_distribution(101))
 
822
        self.assertEqual([100, 10, 1], packs.pack_distribution(111))
 
823
        self.assertEqual([100, 100], packs.pack_distribution(200))
 
824
        self.assertEqual([100, 100, 1], packs.pack_distribution(201))
 
825
        self.assertEqual([100, 100, 10, 1], packs.pack_distribution(211))
 
826
 
 
827
    def test_plan_pack_operations_2009_revisions_skip_all_packs(self):
 
828
        format = self.get_format()
 
829
        repo = self.make_repository('.', format=format)
 
830
        packs = repo._pack_collection
 
831
        existing_packs = [(2000, "big"), (9, "medium")]
 
832
        # rev count - 2009 -> 2x1000 + 9x1
 
833
        pack_operations = packs.plan_autopack_combinations(
 
834
            existing_packs, [1000, 1000, 1, 1, 1, 1, 1, 1, 1, 1, 1])
 
835
        self.assertEqual([], pack_operations)
 
836
 
 
837
    def test_plan_pack_operations_2010_revisions_skip_all_packs(self):
 
838
        format = self.get_format()
 
839
        repo = self.make_repository('.', format=format)
 
840
        packs = repo._pack_collection
 
841
        existing_packs = [(2000, "big"), (9, "medium"), (1, "single")]
 
842
        # rev count - 2010 -> 2x1000 + 1x10
 
843
        pack_operations = packs.plan_autopack_combinations(
 
844
            existing_packs, [1000, 1000, 10])
 
845
        self.assertEqual([], pack_operations)
 
846
 
 
847
    def test_plan_pack_operations_2010_combines_smallest_two(self):
 
848
        format = self.get_format()
 
849
        repo = self.make_repository('.', format=format)
 
850
        packs = repo._pack_collection
 
851
        existing_packs = [(1999, "big"), (9, "medium"), (1, "single2"),
 
852
            (1, "single1")]
 
853
        # rev count - 2010 -> 2x1000 + 1x10 (3)
 
854
        pack_operations = packs.plan_autopack_combinations(
 
855
            existing_packs, [1000, 1000, 10])
 
856
        self.assertEqual([[2, ["single2", "single1"]], [0, []]], pack_operations)
 
857
 
 
858
    def test_all_packs_none(self):
 
859
        format = self.get_format()
 
860
        tree = self.make_branch_and_tree('.', format=format)
 
861
        tree.lock_read()
 
862
        self.addCleanup(tree.unlock)
 
863
        packs = tree.branch.repository._pack_collection
 
864
        packs.ensure_loaded()
 
865
        self.assertEqual([], packs.all_packs())
 
866
 
 
867
    def test_all_packs_one(self):
 
868
        format = self.get_format()
 
869
        tree = self.make_branch_and_tree('.', format=format)
 
870
        tree.commit('start')
 
871
        tree.lock_read()
 
872
        self.addCleanup(tree.unlock)
 
873
        packs = tree.branch.repository._pack_collection
 
874
        packs.ensure_loaded()
 
875
        self.assertEqual([
 
876
            packs.get_pack_by_name(packs.names()[0])],
 
877
            packs.all_packs())
 
878
 
 
879
    def test_all_packs_two(self):
 
880
        format = self.get_format()
 
881
        tree = self.make_branch_and_tree('.', format=format)
 
882
        tree.commit('start')
 
883
        tree.commit('continue')
 
884
        tree.lock_read()
 
885
        self.addCleanup(tree.unlock)
 
886
        packs = tree.branch.repository._pack_collection
 
887
        packs.ensure_loaded()
 
888
        self.assertEqual([
 
889
            packs.get_pack_by_name(packs.names()[0]),
 
890
            packs.get_pack_by_name(packs.names()[1]),
 
891
            ], packs.all_packs())
 
892
 
 
893
    def test_get_pack_by_name(self):
 
894
        format = self.get_format()
 
895
        tree = self.make_branch_and_tree('.', format=format)
 
896
        tree.commit('start')
 
897
        tree.lock_read()
 
898
        self.addCleanup(tree.unlock)
 
899
        packs = tree.branch.repository._pack_collection
 
900
        packs.ensure_loaded()
 
901
        name = packs.names()[0]
 
902
        pack_1 = packs.get_pack_by_name(name)
 
903
        # the pack should be correctly initialised
 
904
        sizes = packs._names[name]
 
905
        rev_index = GraphIndex(packs._index_transport, name + '.rix', sizes[0])
 
906
        inv_index = GraphIndex(packs._index_transport, name + '.iix', sizes[1])
 
907
        txt_index = GraphIndex(packs._index_transport, name + '.tix', sizes[2])
 
908
        sig_index = GraphIndex(packs._index_transport, name + '.six', sizes[3])
 
909
        self.assertEqual(pack_repo.ExistingPack(packs._pack_transport,
 
910
            name, rev_index, inv_index, txt_index, sig_index), pack_1)
 
911
        # and the same instance should be returned on successive calls.
 
912
        self.assertTrue(pack_1 is packs.get_pack_by_name(name))
 
913
 
 
914
 
 
915
class TestPack(TestCaseWithTransport):
 
916
    """Tests for the Pack object."""
 
917
 
 
918
    def assertCurrentlyEqual(self, left, right):
 
919
        self.assertTrue(left == right)
 
920
        self.assertTrue(right == left)
 
921
        self.assertFalse(left != right)
 
922
        self.assertFalse(right != left)
 
923
 
 
924
    def assertCurrentlyNotEqual(self, left, right):
 
925
        self.assertFalse(left == right)
 
926
        self.assertFalse(right == left)
 
927
        self.assertTrue(left != right)
 
928
        self.assertTrue(right != left)
 
929
 
 
930
    def test___eq____ne__(self):
 
931
        left = pack_repo.ExistingPack('', '', '', '', '', '')
 
932
        right = pack_repo.ExistingPack('', '', '', '', '', '')
 
933
        self.assertCurrentlyEqual(left, right)
 
934
        # change all attributes and ensure equality changes as we do.
 
935
        left.revision_index = 'a'
 
936
        self.assertCurrentlyNotEqual(left, right)
 
937
        right.revision_index = 'a'
 
938
        self.assertCurrentlyEqual(left, right)
 
939
        left.inventory_index = 'a'
 
940
        self.assertCurrentlyNotEqual(left, right)
 
941
        right.inventory_index = 'a'
 
942
        self.assertCurrentlyEqual(left, right)
 
943
        left.text_index = 'a'
 
944
        self.assertCurrentlyNotEqual(left, right)
 
945
        right.text_index = 'a'
 
946
        self.assertCurrentlyEqual(left, right)
 
947
        left.signature_index = 'a'
 
948
        self.assertCurrentlyNotEqual(left, right)
 
949
        right.signature_index = 'a'
 
950
        self.assertCurrentlyEqual(left, right)
 
951
        left.name = 'a'
 
952
        self.assertCurrentlyNotEqual(left, right)
 
953
        right.name = 'a'
 
954
        self.assertCurrentlyEqual(left, right)
 
955
        left.transport = 'a'
 
956
        self.assertCurrentlyNotEqual(left, right)
 
957
        right.transport = 'a'
 
958
        self.assertCurrentlyEqual(left, right)
 
959
 
 
960
    def test_file_name(self):
 
961
        pack = pack_repo.ExistingPack('', 'a_name', '', '', '', '')
 
962
        self.assertEqual('a_name.pack', pack.file_name())
 
963
 
 
964
 
 
965
class TestNewPack(TestCaseWithTransport):
 
966
    """Tests for pack_repo.NewPack."""
 
967
 
 
968
    def test_new_instance_attributes(self):
 
969
        upload_transport = self.get_transport('upload')
 
970
        pack_transport = self.get_transport('pack')
 
971
        index_transport = self.get_transport('index')
 
972
        upload_transport.mkdir('.')
 
973
        pack = pack_repo.NewPack(upload_transport, index_transport,
 
974
            pack_transport)
 
975
        self.assertIsInstance(pack.revision_index, InMemoryGraphIndex)
 
976
        self.assertIsInstance(pack.inventory_index, InMemoryGraphIndex)
 
977
        self.assertIsInstance(pack._hash, type(md5.new()))
 
978
        self.assertTrue(pack.upload_transport is upload_transport)
 
979
        self.assertTrue(pack.index_transport is index_transport)
 
980
        self.assertTrue(pack.pack_transport is pack_transport)
 
981
        self.assertEqual(None, pack.index_sizes)
 
982
        self.assertEqual(20, len(pack.random_name))
 
983
        self.assertIsInstance(pack.random_name, str)
 
984
        self.assertIsInstance(pack.start_time, float)
 
985
 
 
986
 
 
987
class TestPacker(TestCaseWithTransport):
 
988
    """Tests for the packs repository Packer class."""
 
989
 
 
990
    # To date, this class has been factored out and nothing new added to it;
 
991
    # thus there are not yet any tests.
 
992
 
 
993
 
 
994
class TestInterDifferingSerializer(TestCaseWithTransport):
 
995
 
 
996
    def test_progress_bar(self):
 
997
        tree = self.make_branch_and_tree('tree')
 
998
        tree.commit('rev1', rev_id='rev-1')
 
999
        tree.commit('rev2', rev_id='rev-2')
 
1000
        tree.commit('rev3', rev_id='rev-3')
 
1001
        repo = self.make_repository('repo')
 
1002
        inter_repo = repository.InterDifferingSerializer(
 
1003
            tree.branch.repository, repo)
 
1004
        pb = progress.InstrumentedProgress(to_file=StringIO())
 
1005
        pb.never_throttle = True
 
1006
        inter_repo.fetch('rev-1', pb)
 
1007
        self.assertEqual('Transferring revisions', pb.last_msg)
 
1008
        self.assertEqual(1, pb.last_cnt)
 
1009
        self.assertEqual(1, pb.last_total)
 
1010
        inter_repo.fetch('rev-3', pb)
 
1011
        self.assertEqual(2, pb.last_cnt)
 
1012
        self.assertEqual(2, pb.last_total)