← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_repository.py

Clean up the lock.py code to use less indenting, and conform to better coding practise.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_repository.py
69
69
            self.assertEqual(result, 'A bzr repository dir')
70
70
        finally:
71
71
            bzrdir.format_registry.remove('default')
72
 
            bzrdir.format_registry.remove('sample')
73
72
            bzrdir.format_registry.register('default', old_default, '')
74
73
        self.assertIsInstance(repository.RepositoryFormat.get_default_format(),
75
74
                              old_format.__class__)
337
336
        self.assertTrue(S_ISDIR(t.stat('knits').st_mode))
338
337
        self.check_knits(t)
339
338
 
340
 
 
341
 
class DummyRepository(object):
342
 
    """A dummy repository for testing."""
343
 
 
344
 
    _serializer = None
345
 
 
346
 
    def supports_rich_root(self):
347
 
        return False
348
 
 
349
 
 
350
 
class InterDummy(repository.InterRepository):
351
 
    """An inter-repository optimised code path for DummyRepository.
352
 
 
353
 
    This is for use during testing where we use DummyRepository as repositories
 
339
class InterString(repository.InterRepository):
 
340
    """An inter-repository optimised code path for strings.
 
341
 
 
342
    This is for use during testing where we use strings as repositories
354
343
    so that none of the default regsitered inter-repository classes will
355
344
    match.
356
345
    """
357
346
 
358
347
    @staticmethod
359
348
    def is_compatible(repo_source, repo_target):
360
 
        """InterDummy is compatible with DummyRepository."""
361
 
        return (isinstance(repo_source, DummyRepository) and 
362
 
            isinstance(repo_target, DummyRepository))
 
349
        """InterString is compatible with strings-as-repos."""
 
350
        return isinstance(repo_source, str) and isinstance(repo_target, str)
363
351
 
364
352
 
365
353
class TestInterRepository(TestCaseWithTransport):
371
359
        # This also tests that the default registered optimised interrepository
372
360
        # classes do not barf inappropriately when a surprising repository type
373
361
        # is handed to them.
374
 
        dummy_a = DummyRepository()
375
 
        dummy_b = DummyRepository()
 
362
        dummy_a = "Repository 1."
 
363
        dummy_b = "Repository 2."
376
364
        self.assertGetsDefaultInterRepository(dummy_a, dummy_b)
377
365
 
378
366
    def assertGetsDefaultInterRepository(self, repo_a, repo_b):
379
 
        """Asserts that InterRepository.get(repo_a, repo_b) -> the default.
380
 
        
381
 
        The effective default is now InterSameDataRepository because there is
382
 
        no actual sane default in the presence of incompatible data models.
383
 
        """
 
367
        """Asserts that InterRepository.get(repo_a, repo_b) -> the default."""
384
368
        inter_repo = repository.InterRepository.get(repo_a, repo_b)
385
 
        self.assertEqual(repository.InterSameDataRepository,
 
369
        self.assertEqual(repository.InterRepository,
386
370
                         inter_repo.__class__)
387
371
        self.assertEqual(repo_a, inter_repo.source)
388
372
        self.assertEqual(repo_b, inter_repo.target)
393
377
        # and that it is correctly selected when given a repository
394
378
        # pair that it returns true on for the is_compatible static method
395
379
        # check
396
 
        dummy_a = DummyRepository()
397
 
        dummy_b = DummyRepository()
398
 
        repo = self.make_repository('.')
399
 
        # hack dummies to look like repo somewhat.
400
 
        dummy_a._serializer = repo._serializer
401
 
        dummy_b._serializer = repo._serializer
402
 
        repository.InterRepository.register_optimiser(InterDummy)
 
380
        dummy_a = "Repository 1."
 
381
        dummy_b = "Repository 2."
 
382
        repository.InterRepository.register_optimiser(InterString)
403
383
        try:
404
 
            # we should get the default for something InterDummy returns False
 
384
            # we should get the default for something InterString returns False
405
385
            # to
406
 
            self.assertFalse(InterDummy.is_compatible(dummy_a, repo))
407
 
            self.assertGetsDefaultInterRepository(dummy_a, repo)
408
 
            # and we should get an InterDummy for a pair it 'likes'
409
 
            self.assertTrue(InterDummy.is_compatible(dummy_a, dummy_b))
 
386
            self.assertFalse(InterString.is_compatible(dummy_a, None))
 
387
            self.assertGetsDefaultInterRepository(dummy_a, None)
 
388
            # and we should get an InterString for a pair it 'likes'
 
389
            self.assertTrue(InterString.is_compatible(dummy_a, dummy_b))
410
390
            inter_repo = repository.InterRepository.get(dummy_a, dummy_b)
411
 
            self.assertEqual(InterDummy, inter_repo.__class__)
 
391
            self.assertEqual(InterString, inter_repo.__class__)
412
392
            self.assertEqual(dummy_a, inter_repo.source)
413
393
            self.assertEqual(dummy_b, inter_repo.target)
414
394
        finally:
415
 
            repository.InterRepository.unregister_optimiser(InterDummy)
 
395
            repository.InterRepository.unregister_optimiser(InterString)
416
396
        # now we should get the default InterRepository object again.
417
397
        self.assertGetsDefaultInterRepository(dummy_a, dummy_b)
418
398