/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_selftest.py

• browse files at revision 3504.4.14
• compare with another revision
• compare with revision 0.200.231
• download diff
• download tarball
• view history from revision 3504.4.14

Show diffs side-by-side

added

removed

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,

103

108

                              'a test message\n')

104

109

 

105

110

 

 

111

class TestUnicodeFilename(TestCase):

 

112

 

 

113

    def test_probe_passes(self):

 

114

        """UnicodeFilename._probe passes."""

 

115

        # We can't test much more than that because the behaviour depends

 

116

        # on the platform.

 

117

        tests.UnicodeFilename._probe()

 

118

 

 

119

 

106

120

class TestTreeShape(TestCaseInTempDir):

107

121

 

108

122

    def test_unicode_paths(self):

 

123

        self.requireFeature(tests.UnicodeFilename)

 

124

 

109

125

        filename = u'hell\u00d8'

110

 

        try:

111

 

            self.build_tree_contents([(filename, 'contents of hello')])

112

 

        except UnicodeEncodeError:

113

 

            raise TestSkipped("can't build unicode working tree in "

114

 

                "filesystem encoding %s" % sys.getfilesystemencoding())

 

126

        self.build_tree_contents([(filename, 'contents of hello')])

115

127

        self.failUnlessExists(filename)

116

128

 

117

129

 

237

249

class TestRepositoryParameterisation(TestCase):

238

250

    """A group of tests that test the repository implementation test adapter."""

239

251

 

240

 

    def test_setting_vfs_transport(self):

241

 

        """The vfs_transport_factory can be set optionally."""

242

 

        from bzrlib.tests.repository_implementations import formats_to_scenarios

243

 

        scenarios = formats_to_scenarios(

244

 

            [("a", "b"), ("c", "d")],

245

 

            None,

246

 

            None,

247

 

            vfs_transport_factory="vfs")

248

 

        self.assertEqual([

249

 

            ('str',

250

 

             {'bzrdir_format': 'b',

251

 

              'repository_format': 'a',

252

 

              'transport_readonly_server': None,

253

 

              'transport_server': None,

254

 

              'vfs_transport_factory': 'vfs'}),

255

 

            ('str',

256

 

             {'bzrdir_format': 'd',

257

 

              'repository_format': 'c',

258

 

              'transport_readonly_server': None,

259

 

              'transport_server': None,

260

 

              'vfs_transport_factory': 'vfs'})],

261

 

            scenarios)

262

 

 

263

252

    def test_formats_to_scenarios(self):

264

253

        """The adapter can generate all the scenarios needed."""

265

254

        from bzrlib.tests.repository_implementations import formats_to_scenarios

266

 

        formats = [("c", "C"), (1, "D")]

 

255

        formats = [("(c)", remote.RemoteRepositoryFormat()),

 

256

                   ("(d)", repository.format_registry.get(

 

257

                        'Bazaar pack repository format 1 (needs bzr 0.92)\n'))]

267

258

        no_vfs_scenarios = formats_to_scenarios(formats, "server", "readonly",

268

259

            None)

269

260

        vfs_scenarios = formats_to_scenarios(formats, "server", "readonly",

270

261

            vfs_transport_factory="vfs")

271

 

        # no_vfs generate scenarios without vfs_transport_factor

 

262

        # no_vfs generate scenarios without vfs_transport_factory

272

263

        self.assertEqual([

273

 

            ('str',

274

 

             {'bzrdir_format': 'C',

275

 

              'repository_format': 'c',

 

264

            ('RemoteRepositoryFormat(c)',

 

265

             {'bzrdir_format': remote.RemoteBzrDirFormat(),

 

266

              'repository_format': remote.RemoteRepositoryFormat(),

276

267

              'transport_readonly_server': 'readonly',

277

268

              'transport_server': 'server'}),

278

 

            ('int',

279

 

             {'bzrdir_format': 'D',

280

 

              'repository_format': 1,

 

269

            ('RepositoryFormatKnitPack1(d)',

 

270

             {'bzrdir_format': bzrdir.BzrDirMetaFormat1(),

 

271

              'repository_format': pack_repo.RepositoryFormatKnitPack1(),

281

272

              'transport_readonly_server': 'readonly',

282

273

              'transport_server': 'server'})],

283

274

            no_vfs_scenarios)

284

275

        self.assertEqual([

285

 

            ('str',

286

 

             {'bzrdir_format': 'C',

287

 

              'repository_format': 'c',

 

276

            ('RemoteRepositoryFormat(c)',

 

277

             {'bzrdir_format': remote.RemoteBzrDirFormat(),

 

278

              'repository_format': remote.RemoteRepositoryFormat(),

288

279

              'transport_readonly_server': 'readonly',

289

280

              'transport_server': 'server',

290

281

              'vfs_transport_factory': 'vfs'}),

291

 

            ('int',

292

 

             {'bzrdir_format': 'D',

293

 

              'repository_format': 1,

 

282

            ('RepositoryFormatKnitPack1(d)',

 

283

             {'bzrdir_format': bzrdir.BzrDirMetaFormat1(),

 

284

              'repository_format': pack_repo.RepositoryFormatKnitPack1(),

294

285

              'transport_readonly_server': 'readonly',

295

286

              'transport_server': 'server',

296

287

              'vfs_transport_factory': 'vfs'})],

376

367

            adapter.formats_to_scenarios(formats))

377

368

 

378

369

 

379

 

class TestInterVersionedFileProviderAdapter(TestCase):

380

 

    """A group of tests that test the InterVersionedFile test adapter."""

381

 

 

382

 

    def test_scenarios(self):

383

 

        # check that constructor parameters are passed through to the adapted

384

 

        # test.

385

 

        from bzrlib.tests.interversionedfile_implementations \

386

 

            import InterVersionedFileTestProviderAdapter

387

 

        server1 = "a"

388

 

        server2 = "b"

389

 

        formats = [(str, "C1", "C2"), (int, "D1", "D2")]

390

 

        adapter = InterVersionedFileTestProviderAdapter(server1, server2, formats)

391

 

        self.assertEqual([

392

 

            ('str',

393

 

             {'interversionedfile_class':str,

394

 

              'transport_readonly_server': 'b',

395

 

              'transport_server': 'a',

396

 

              'versionedfile_factory': 'C1',

397

 

              'versionedfile_factory_to': 'C2'}),

398

 

            ('int',

399

 

             {'interversionedfile_class': int,

400

 

              'transport_readonly_server': 'b',

401

 

              'transport_server': 'a',

402

 

              'versionedfile_factory': 'D1',

403

 

              'versionedfile_factory_to': 'D2'})],

404

 

            adapter.scenarios)

405

 

 

406

 

 

407

 

class TestRevisionStoreProviderAdapter(TestCase):

408

 

    """A group of tests that test the RevisionStore test adapter."""

409

 

 

410

 

    def test_scenarios(self):

411

 

        # check that constructor parameters are passed through to the adapted

412

 

        # test.

413

 

        from bzrlib.tests.revisionstore_implementations \

414

 

            import RevisionStoreTestProviderAdapter

415

 

        # revision stores need a store factory - i.e. RevisionKnit

416

 

        #, a readonly and rw transport 

417

 

        # transport servers:

418

 

        server1 = "a"

419

 

        server2 = "b"

420

 

        store_factories = ["c", "d"]

421

 

        adapter = RevisionStoreTestProviderAdapter(server1, server2, store_factories)

422

 

        self.assertEqual([

423

 

            ('c',

424

 

             {'store_factory': 'c',

425

 

              'transport_readonly_server': 'b',

426

 

              'transport_server': 'a'}),

427

 

            ('d',

428

 

             {'store_factory': 'd',

429

 

              'transport_readonly_server': 'b',

430

 

              'transport_server': 'a'})],

431

 

            adapter.scenarios)

432

 

 

433

 

 

434

370

class TestWorkingTreeProviderAdapter(TestCase):

435

371

    """A group of tests that test the workingtree implementation test adapter."""

436

372

 

441

377

            import WorkingTreeTestProviderAdapter

442

378

        server1 = "a"

443

379

        server2 = "b"

444

 

        formats = [("c", "C"), ("d", "D")]

 

380

        formats = [workingtree.WorkingTreeFormat2(),

 

381

                   workingtree.WorkingTreeFormat3(),]

445

382

        adapter = WorkingTreeTestProviderAdapter(server1, server2, formats)

446

383

        self.assertEqual([

447

 

            ('str',

448

 

             {'bzrdir_format': 'C',

449

 

              'transport_readonly_server': 'b',

450

 

              'transport_server': 'a',

451

 

              'workingtree_format': 'c'}),

452

 

            ('str',

453

 

             {'bzrdir_format': 'D',

454

 

              'transport_readonly_server': 'b',

455

 

              'transport_server': 'a',

456

 

              '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]})],

457

394

            adapter.scenarios)

458

395

 

459

396

 

473

410

            return_parameter,

474

411

            revision_tree_from_workingtree

475

412

            )

476

 

        from bzrlib.workingtree import WorkingTreeFormat, WorkingTreeFormat3

477

413

        input_test = TestTreeProviderAdapter(

478

414

            "test_adapted_tests")

479

415

        server1 = "a"

480

416

        server2 = "b"

481

 

        formats = [("c", "C"), ("d", "D")]

 

417

        formats = [workingtree.WorkingTreeFormat2(),

 

418

                   workingtree.WorkingTreeFormat3(),]

482

419

        adapter = TreeTestProviderAdapter(server1, server2, formats)

483

420

        suite = adapter.adapt(input_test)

484

421

        tests = list(iter(suite))

487

424

        self.assertEqual(5, len(tests))

488

425

        # this must match the default format setp up in

489

426

        # TreeTestProviderAdapter.adapt

490

 

        default_format = WorkingTreeFormat3

491

 

        self.assertEqual(tests[0].workingtree_format, formats[0][0])

492

 

        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)

493

430

        self.assertEqual(tests[0].transport_server, server1)

494

431

        self.assertEqual(tests[0].transport_readonly_server, server2)

495

432

        self.assertEqual(tests[0]._workingtree_to_test_tree, return_parameter)

496

 

        self.assertEqual(tests[1].workingtree_format, formats[1][0])

497

 

        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)

498

435

        self.assertEqual(tests[1].transport_server, server1)

499

436

        self.assertEqual(tests[1].transport_readonly_server, server2)

500

437

        self.assertEqual(tests[1]._workingtree_to_test_tree, return_parameter)

1338

1275

    def _test_pass(self):

1339

1276

        pass

1340

1277

 

 

1278

class _TestException(Exception):

 

1279

    pass

1341

1280

 

1342

1281

class TestTestCase(TestCase):

1343

1282

    """Tests that test the core bzrlib TestCase."""

1501

1440

            ],

1502

1441

            result.calls)

1503

1442

 

 

1443

    def test_assert_list_raises_on_generator(self):

 

1444

        def generator_which_will_raise():

 

1445

            # This will not raise until after the first yield

 

1446

            yield 1

 

1447

            raise _TestException()

 

1448

 

 

1449

        e = self.assertListRaises(_TestException, generator_which_will_raise)

 

1450

        self.assertIsInstance(e, _TestException)

 

1451

 

 

1452

        e = self.assertListRaises(Exception, generator_which_will_raise)

 

1453

        self.assertIsInstance(e, _TestException)

 

1454

 

 

1455

    def test_assert_list_raises_on_plain(self):

 

1456

        def plain_exception():

 

1457

            raise _TestException()

 

1458

            return []

 

1459

 

 

1460

        e = self.assertListRaises(_TestException, plain_exception)

 

1461

        self.assertIsInstance(e, _TestException)

 

1462

 

 

1463

        e = self.assertListRaises(Exception, plain_exception)

 

1464

        self.assertIsInstance(e, _TestException)

 

1465

 

 

1466

    def test_assert_list_raises_assert_wrong_exception(self):

 

1467

        class _NotTestException(Exception):

 

1468

            pass

 

1469

 

 

1470

        def wrong_exception():

 

1471

            raise _NotTestException()

 

1472

 

 

1473

        def wrong_exception_generator():

 

1474

            yield 1

 

1475

            yield 2

 

1476

            raise _NotTestException()

 

1477

 

 

1478

        # Wrong exceptions are not intercepted

 

1479

        self.assertRaises(_NotTestException,

 

1480

            self.assertListRaises, _TestException, wrong_exception)

 

1481

        self.assertRaises(_NotTestException,

 

1482

            self.assertListRaises, _TestException, wrong_exception_generator)

 

1483

 

 

1484

    def test_assert_list_raises_no_exception(self):

 

1485

        def success():

 

1486

            return []

 

1487

 

 

1488

        def success_generator():

 

1489

            yield 1

 

1490

            yield 2

 

1491

 

 

1492

        self.assertRaises(AssertionError,

 

1493

            self.assertListRaises, _TestException, success)

 

1494

 

 

1495

        self.assertRaises(AssertionError,

 

1496

            self.assertListRaises, _TestException, success_generator)

 

1497

 

1504

1498

 

1505

1499

@symbol_versioning.deprecated_function(zero_eleven)

1506

1500

def sample_deprecated_function():

• Older »

Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0