← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_fetch.py

  • Committer: John Arbash Meinel
  • Date: 2008-10-30 00:55:00 UTC
  • mto: (3815.2.5 prepare-1.9)
  • mto: This revision was merged to the branch mainline in revision 3811.
  • Revision ID: john@arbash-meinel.com-20081030005500-r5cej1cxflqhs3io
Switch so that we are using a simple timestamp as the first action.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_fetch.py
24
24
    errors,
25
25
    merge,
26
26
    repository,
 
27
    versionedfile,
27
28
    )
28
29
from bzrlib.branch import Branch
29
30
from bzrlib.bzrdir import BzrDir
146
147
        branch = self.make_branch('branch', format=knit2_format)
147
148
        branch.pull(tree.branch, stop_revision='rev1')
148
149
        repo = branch.repository
149
 
        root_knit = repo.weave_store.get_weave('tree-root',
150
 
                                                repo.get_transaction())
151
 
        # Make sure fetch retrieved only what we requested
152
 
        self.assertTrue('rev1' in root_knit)
153
 
        self.assertTrue('rev2' not in root_knit)
 
150
        repo.lock_read()
 
151
        try:
 
152
            # Make sure fetch retrieved only what we requested
 
153
            self.assertEqual({('tree-root', 'rev1'):()},
 
154
                repo.texts.get_parent_map(
 
155
                    [('tree-root', 'rev1'), ('tree-root', 'rev2')]))
 
156
        finally:
 
157
            repo.unlock()
154
158
        branch.pull(tree.branch)
155
 
        root_knit = repo.weave_store.get_weave('tree-root',
156
 
                                                repo.get_transaction())
157
159
        # Make sure that the next revision in the root knit was retrieved,
158
160
        # even though the text, name, parent_id, etc., were unchanged.
159
 
        self.assertTrue('rev2' in root_knit)
 
161
        repo.lock_read()
 
162
        try:
 
163
            # Make sure fetch retrieved only what we requested
 
164
            self.assertEqual({('tree-root', 'rev2'):(('tree-root', 'rev1'),)},
 
165
                repo.texts.get_parent_map([('tree-root', 'rev2')]))
 
166
        finally:
 
167
            repo.unlock()
160
168
 
161
169
    def test_fetch_incompatible(self):
162
170
        knit_tree = self.make_branch_and_tree('knit', format='knit')
163
171
        knit3_tree = self.make_branch_and_tree('knit3',
164
172
            format='dirstate-with-subtree')
165
173
        knit3_tree.commit('blah')
166
 
        self.assertRaises(errors.IncompatibleRepositories,
167
 
                          knit_tree.branch.fetch, knit3_tree.branch)
 
174
        e = self.assertRaises(errors.IncompatibleRepositories,
 
175
                              knit_tree.branch.fetch, knit3_tree.branch)
 
176
        self.assertContainsRe(str(e),
 
177
            r"(?m).*/knit.*\nis not compatible with\n.*/knit3/.*\n"
 
178
            r"different rich-root support")
168
179
 
169
180
 
170
181
class TestMergeFetch(TestCaseWithTransport):
286
297
        # twice?
287
298
        self.assertEqual(1, self._count_log_matches('/ce/id.kndx', http_logs))
288
299
        self.assertEqual(1, self._count_log_matches('/ce/id.knit', http_logs))
289
 
        # XXX: This *should* be '1', but more intrusive fetch changes are
290
 
        # needed to drop this back to 1.
291
 
        self.assertEqual(2, self._count_log_matches('inventory.kndx', http_logs))
 
300
        self.assertEqual(1, self._count_log_matches('inventory.kndx', http_logs))
292
301
        # this r-h check test will prevent regressions, but it currently already 
293
302
        # passes, before the patch to cache-rh is applied :[
294
303
        self.assertTrue(1 >= self._count_log_matches('revision-history',
321
330
        self.assertEqual(4, len(http_logs))
322
331
 
323
332
 
 
333
class TestKnitToPackFetch(TestCaseWithTransport):
 
334
 
 
335
    def find_get_record_stream(self, calls):
 
336
        """In a list of calls, find 'get_record_stream' calls.
 
337
 
 
338
        This also ensures that there is only one get_record_stream call.
 
339
        """
 
340
        get_record_call = None
 
341
        for call in calls:
 
342
            if call[0] == 'get_record_stream':
 
343
                self.assertIs(None, get_record_call,
 
344
                              "there should only be one call to"
 
345
                              " get_record_stream")
 
346
                get_record_call = call
 
347
        self.assertIsNot(None, get_record_call,
 
348
                         "there should be exactly one call to "
 
349
                         " get_record_stream")
 
350
        return get_record_call
 
351
 
 
352
    def test_fetch_with_deltas_no_delta_closure(self):
 
353
        tree = self.make_branch_and_tree('source', format='dirstate')
 
354
        target = self.make_repository('target', format='pack-0.92')
 
355
        self.build_tree(['source/file'])
 
356
        tree.set_root_id('root-id')
 
357
        tree.add('file', 'file-id')
 
358
        tree.commit('one', rev_id='rev-one')
 
359
        source = tree.branch.repository
 
360
        source.texts = versionedfile.RecordingVersionedFilesDecorator(
 
361
                        source.texts)
 
362
        source.signatures = versionedfile.RecordingVersionedFilesDecorator(
 
363
                        source.signatures)
 
364
        source.revisions = versionedfile.RecordingVersionedFilesDecorator(
 
365
                        source.revisions)
 
366
        source.inventories = versionedfile.RecordingVersionedFilesDecorator(
 
367
                        source.inventories)
 
368
        # precondition
 
369
        self.assertTrue(target._fetch_uses_deltas)
 
370
        target.fetch(source, revision_id='rev-one')
 
371
        self.assertEqual(('get_record_stream', [('file-id', 'rev-one')],
 
372
                          target._fetch_order, False),
 
373
                         self.find_get_record_stream(source.texts.calls))
 
374
        self.assertEqual(('get_record_stream', [('rev-one',)],
 
375
                          target._fetch_order, False),
 
376
                         self.find_get_record_stream(source.inventories.calls))
 
377
        # Because of bugs in the old fetch code, revisions could accidentally
 
378
        # have deltas present in knits. However, it was never intended, so we
 
379
        # always for include_delta_closure=True, to make sure we get fulltexts.
 
380
        # bug #261339
 
381
        self.assertEqual(('get_record_stream', [('rev-one',)],
 
382
                          target._fetch_order, True),
 
383
                         self.find_get_record_stream(source.revisions.calls))
 
384
        # XXX: Signatures is special, and slightly broken. The
 
385
        # standard item_keys_introduced_by actually does a lookup for every
 
386
        # signature to see if it exists, rather than waiting to do them all at
 
387
        # once at the end. The fetch code then does an all-at-once and just
 
388
        # allows for some of them to be missing.
 
389
        # So we know there will be extra calls, but the *last* one is the one
 
390
        # we care about.
 
391
        signature_calls = source.signatures.calls[-1:]
 
392
        self.assertEqual(('get_record_stream', [('rev-one',)],
 
393
                          target._fetch_order, True),
 
394
                         self.find_get_record_stream(signature_calls))
 
395
 
 
396
    def test_fetch_no_deltas_with_delta_closure(self):
 
397
        tree = self.make_branch_and_tree('source', format='dirstate')
 
398
        target = self.make_repository('target', format='pack-0.92')
 
399
        self.build_tree(['source/file'])
 
400
        tree.set_root_id('root-id')
 
401
        tree.add('file', 'file-id')
 
402
        tree.commit('one', rev_id='rev-one')
 
403
        source = tree.branch.repository
 
404
        source.texts = versionedfile.RecordingVersionedFilesDecorator(
 
405
                        source.texts)
 
406
        source.signatures = versionedfile.RecordingVersionedFilesDecorator(
 
407
                        source.signatures)
 
408
        source.revisions = versionedfile.RecordingVersionedFilesDecorator(
 
409
                        source.revisions)
 
410
        source.inventories = versionedfile.RecordingVersionedFilesDecorator(
 
411
                        source.inventories)
 
412
        target._fetch_uses_deltas = False
 
413
        target.fetch(source, revision_id='rev-one')
 
414
        self.assertEqual(('get_record_stream', [('file-id', 'rev-one')],
 
415
                          target._fetch_order, True),
 
416
                         self.find_get_record_stream(source.texts.calls))
 
417
        self.assertEqual(('get_record_stream', [('rev-one',)],
 
418
                          target._fetch_order, True),
 
419
                         self.find_get_record_stream(source.inventories.calls))
 
420
        self.assertEqual(('get_record_stream', [('rev-one',)],
 
421
                          target._fetch_order, True),
 
422
                         self.find_get_record_stream(source.revisions.calls))
 
423
        # XXX: Signatures is special, and slightly broken. The
 
424
        # standard item_keys_introduced_by actually does a lookup for every
 
425
        # signature to see if it exists, rather than waiting to do them all at
 
426
        # once at the end. The fetch code then does an all-at-once and just
 
427
        # allows for some of them to be missing.
 
428
        # So we know there will be extra calls, but the *last* one is the one
 
429
        # we care about.
 
430
        signature_calls = source.signatures.calls[-1:]
 
431
        self.assertEqual(('get_record_stream', [('rev-one',)],
 
432
                          target._fetch_order, True),
 
433
                         self.find_get_record_stream(signature_calls))
 
434
 
 
435
 
324
436
class Test1To2Fetch(TestCaseWithTransport):
325
437
    """Tests for Model1To2 failure modes"""
326
438
 
350
462
        self.do_fetch_order_test('B', 'A')
351
463
 
352
464
    def get_parents(self, file_id, revision_id):
353
 
        transaction = self.repo.get_transaction()
354
 
        vf = self.repo.weave_store.get_weave(file_id, transaction)
355
 
        return vf.get_parents_with_ghosts(revision_id)
 
465
        self.repo.lock_read()
 
466
        try:
 
467
            parent_map = self.repo.texts.get_parent_map([(file_id, revision_id)])
 
468
            return parent_map[(file_id, revision_id)]
 
469
        finally:
 
470
            self.repo.unlock()
356
471
 
357
472
    def test_fetch_ghosts(self):
358
473
        self.make_tree_and_repo()
366
481
        self.tree.commit('second commit', rev_id='second-id')
367
482
        self.repo.fetch(self.tree.branch.repository, 'second-id')
368
483
        root_id = self.tree.get_root_id()
369
 
        self.assertEqual(['left-parent', 'ghost-parent', 'not-ghost-parent'],
370
 
                         self.get_parents(root_id, 'second-id'))
 
484
        self.assertEqual(
 
485
            ((root_id, 'left-parent'), (root_id, 'ghost-parent'),
 
486
             (root_id, 'not-ghost-parent')),
 
487
            self.get_parents(root_id, 'second-id'))
371
488
 
372
489
    def make_two_commits(self, change_root, fetch_twice):
373
490
        self.make_tree_and_repo()
381
498
 
382
499
    def test_fetch_changed_root(self):
383
500
        self.make_two_commits(change_root=True, fetch_twice=False)
384
 
        self.assertEqual([], self.get_parents('unique-id', 'second-id'))
 
501
        self.assertEqual((), self.get_parents('unique-id', 'second-id'))
385
502
 
386
503
    def test_two_fetch_changed_root(self):
387
504
        self.make_two_commits(change_root=True, fetch_twice=True)
388
 
        self.assertEqual([], self.get_parents('unique-id', 'second-id'))
 
505
        self.assertEqual((), self.get_parents('unique-id', 'second-id'))
389
506
 
390
507
    def test_two_fetches(self):
391
508
        self.make_two_commits(change_root=False, fetch_twice=True)
392
 
        self.assertEqual(['first-id'],
393
 
                         self.get_parents('TREE_ROOT', 'second-id'))
 
509
        self.assertEqual((('TREE_ROOT', 'first-id'),),
 
510
            self.get_parents('TREE_ROOT', 'second-id'))