/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_selftest.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2008-07-17 07:02:54 UTC
  • mfrom: (3543.1.10 249256-tree-from-remote)
  • Revision ID: pqm@pqm.ubuntu.com-20080717070254-h8qltle17foj2pao
(mbp,mwh) #249256 fix branching from hpss

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_selftest.py
1
 
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
 
1
# Copyright (C) 2005, 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
30
30
    errors,
31
31
    memorytree,
32
32
    osutils,
 
33
    remote,
33
34
    repository,
34
35
    symbol_versioning,
35
36
    tests,
 
37
    workingtree,
36
38
    )
37
39
from bzrlib.progress import _BaseProgressBar
38
 
from bzrlib.repofmt import weaverepo
 
40
from bzrlib.repofmt import (
 
41
    pack_repo,
 
42
    weaverepo,
 
43
    )
39
44
from bzrlib.symbol_versioning import (
40
45
    one_zero,
41
46
    zero_eleven,
244
249
class TestRepositoryParameterisation(TestCase):
245
250
    """A group of tests that test the repository implementation test adapter."""
246
251
 
247
 
    def test_setting_vfs_transport(self):
248
 
        """The vfs_transport_factory can be set optionally."""
249
 
        from bzrlib.tests.repository_implementations import formats_to_scenarios
250
 
        scenarios = formats_to_scenarios(
251
 
            [("(one)", "a", "b"), ("(two)", "c", "d")],
252
 
            None,
253
 
            None,
254
 
            vfs_transport_factory="vfs")
255
 
        self.assertEqual([
256
 
            ('str(one)',
257
 
             {'bzrdir_format': 'b',
258
 
              'repository_format': 'a',
259
 
              'transport_readonly_server': None,
260
 
              'transport_server': None,
261
 
              'vfs_transport_factory': 'vfs'}),
262
 
            ('str(two)',
263
 
             {'bzrdir_format': 'd',
264
 
              'repository_format': 'c',
265
 
              'transport_readonly_server': None,
266
 
              'transport_server': None,
267
 
              'vfs_transport_factory': 'vfs'})],
268
 
            scenarios)
269
 
 
270
252
    def test_formats_to_scenarios(self):
271
253
        """The adapter can generate all the scenarios needed."""
272
254
        from bzrlib.tests.repository_implementations import formats_to_scenarios
273
 
        formats = [("(c)", "c", "C"), ("(d)", 1, "D")]
 
255
        formats = [("(c)", remote.RemoteRepositoryFormat()),
 
256
                   ("(d)", repository.format_registry.get(
 
257
                        'Bazaar pack repository format 1 (needs bzr 0.92)\n'))]
274
258
        no_vfs_scenarios = formats_to_scenarios(formats, "server", "readonly",
275
259
            None)
276
260
        vfs_scenarios = formats_to_scenarios(formats, "server", "readonly",
277
261
            vfs_transport_factory="vfs")
278
 
        # no_vfs generate scenarios without vfs_transport_factor
 
262
        # no_vfs generate scenarios without vfs_transport_factory
279
263
        self.assertEqual([
280
 
            ('str(c)',
281
 
             {'bzrdir_format': 'C',
282
 
              'repository_format': 'c',
 
264
            ('RemoteRepositoryFormat(c)',
 
265
             {'bzrdir_format': remote.RemoteBzrDirFormat(),
 
266
              'repository_format': remote.RemoteRepositoryFormat(),
283
267
              'transport_readonly_server': 'readonly',
284
268
              'transport_server': 'server'}),
285
 
            ('int(d)',
286
 
             {'bzrdir_format': 'D',
287
 
              'repository_format': 1,
 
269
            ('RepositoryFormatKnitPack1(d)',
 
270
             {'bzrdir_format': bzrdir.BzrDirMetaFormat1(),
 
271
              'repository_format': pack_repo.RepositoryFormatKnitPack1(),
288
272
              'transport_readonly_server': 'readonly',
289
273
              'transport_server': 'server'})],
290
274
            no_vfs_scenarios)
291
275
        self.assertEqual([
292
 
            ('str(c)',
293
 
             {'bzrdir_format': 'C',
294
 
              'repository_format': 'c',
 
276
            ('RemoteRepositoryFormat(c)',
 
277
             {'bzrdir_format': remote.RemoteBzrDirFormat(),
 
278
              'repository_format': remote.RemoteRepositoryFormat(),
295
279
              'transport_readonly_server': 'readonly',
296
280
              'transport_server': 'server',
297
281
              'vfs_transport_factory': 'vfs'}),
298
 
            ('int(d)',
299
 
             {'bzrdir_format': 'D',
300
 
              'repository_format': 1,
 
282
            ('RepositoryFormatKnitPack1(d)',
 
283
             {'bzrdir_format': bzrdir.BzrDirMetaFormat1(),
 
284
              'repository_format': pack_repo.RepositoryFormatKnitPack1(),
301
285
              'transport_readonly_server': 'readonly',
302
286
              'transport_server': 'server',
303
287
              'vfs_transport_factory': 'vfs'})],
393
377
            import WorkingTreeTestProviderAdapter
394
378
        server1 = "a"
395
379
        server2 = "b"
396
 
        formats = [("c", "C"), ("d", "D")]
 
380
        formats = [workingtree.WorkingTreeFormat2(),
 
381
                   workingtree.WorkingTreeFormat3(),]
397
382
        adapter = WorkingTreeTestProviderAdapter(server1, server2, formats)
398
383
        self.assertEqual([
399
 
            ('str',
400
 
             {'bzrdir_format': 'C',
401
 
              'transport_readonly_server': 'b',
402
 
              'transport_server': 'a',
403
 
              'workingtree_format': 'c'}),
404
 
            ('str',
405
 
             {'bzrdir_format': 'D',
406
 
              'transport_readonly_server': 'b',
407
 
              'transport_server': 'a',
408
 
              'workingtree_format': 'd'})],
 
384
            ('WorkingTreeFormat2',
 
385
             {'bzrdir_format': formats[0]._matchingbzrdir,
 
386
              'transport_readonly_server': 'b',
 
387
              'transport_server': 'a',
 
388
              'workingtree_format': formats[0]}),
 
389
            ('WorkingTreeFormat3',
 
390
             {'bzrdir_format': formats[1]._matchingbzrdir,
 
391
              'transport_readonly_server': 'b',
 
392
              'transport_server': 'a',
 
393
              'workingtree_format': formats[1]})],
409
394
            adapter.scenarios)
410
395
 
411
396
 
425
410
            return_parameter,
426
411
            revision_tree_from_workingtree
427
412
            )
428
 
        from bzrlib.workingtree import WorkingTreeFormat, WorkingTreeFormat3
429
413
        input_test = TestTreeProviderAdapter(
430
414
            "test_adapted_tests")
431
415
        server1 = "a"
432
416
        server2 = "b"
433
 
        formats = [("c", "C"), ("d", "D")]
 
417
        formats = [workingtree.WorkingTreeFormat2(),
 
418
                   workingtree.WorkingTreeFormat3(),]
434
419
        adapter = TreeTestProviderAdapter(server1, server2, formats)
435
420
        suite = adapter.adapt(input_test)
436
421
        tests = list(iter(suite))
439
424
        self.assertEqual(5, len(tests))
440
425
        # this must match the default format setp up in
441
426
        # TreeTestProviderAdapter.adapt
442
 
        default_format = WorkingTreeFormat3
443
 
        self.assertEqual(tests[0].workingtree_format, formats[0][0])
444
 
        self.assertEqual(tests[0].bzrdir_format, formats[0][1])
 
427
        default_format = workingtree.WorkingTreeFormat3
 
428
        self.assertEqual(tests[0].workingtree_format, formats[0])
 
429
        self.assertEqual(tests[0].bzrdir_format, formats[0]._matchingbzrdir)
445
430
        self.assertEqual(tests[0].transport_server, server1)
446
431
        self.assertEqual(tests[0].transport_readonly_server, server2)
447
432
        self.assertEqual(tests[0]._workingtree_to_test_tree, return_parameter)
448
 
        self.assertEqual(tests[1].workingtree_format, formats[1][0])
449
 
        self.assertEqual(tests[1].bzrdir_format, formats[1][1])
 
433
        self.assertEqual(tests[1].workingtree_format, formats[1])
 
434
        self.assertEqual(tests[1].bzrdir_format, formats[1]._matchingbzrdir)
450
435
        self.assertEqual(tests[1].transport_server, server1)
451
436
        self.assertEqual(tests[1].transport_readonly_server, server2)
452
437
        self.assertEqual(tests[1]._workingtree_to_test_tree, return_parameter)