/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_knit.py

• browse files at revision 5725.1.4
• compare with another revision
• compare with revision 5200.3.2
• download diff
• download tarball
• view history from revision 5725.1.4

Show diffs side-by-side

added

removed

bzrlib/tests/test_knit.py

40

40

    KnitVersionedFiles,

41

41

    PlainKnitContent,

42

42

    _VFContentMapGenerator,

43

 

    _DirectPackAccess,

44

43

    _KndxIndex,

45

44

    _KnitGraphIndex,

46

45

    _KnitKeyAccess,

47

46

    make_file_factory,

48

47

    )

49

48

from bzrlib.patiencediff import PatienceSequenceMatcher

50

 

from bzrlib.repofmt import pack_repo

 

49

from bzrlib.repofmt import (

 

50

    knitpack_repo,

 

51

    pack_repo,

 

52

    )

51

53

from bzrlib.tests import (

52

54

    TestCase,

53

55

    TestCaseWithMemoryTransport,

325

327

            transport.append_bytes(packname, bytes)

326

328

        writer = pack.ContainerWriter(write_data)

327

329

        writer.begin()

328

 

        access = _DirectPackAccess({})

 

330

        access = pack_repo._DirectPackAccess({})

329

331

        access.set_writer(writer, index, (transport, packname))

330

332

        return access, writer

331

333

 

397

399

        collection = repo._pack_collection

398

400

        collection.ensure_loaded()

399

401

        orig_packs = collection.packs

400

 

        packer = pack_repo.Packer(collection, orig_packs, '.testpack')

 

402

        packer = knitpack_repo.KnitPacker(collection, orig_packs, '.testpack')

401

403

        new_pack = packer.pack()

402

404

        # forget about the new pack

403

405

        collection.reset()

456

458

        memos.extend(access.add_raw_records([('key', 5)], 'alpha'))

457

459

        writer.end()

458

460

        transport = self.get_transport()

459

 

        access = _DirectPackAccess({"FOO":(transport, 'packfile'),

 

461

        access = pack_repo._DirectPackAccess({"FOO":(transport, 'packfile'),

460

462

            "FOOBAR":(transport, 'pack2'),

461

463

            "BAZ":(transport, 'pack3')})

462

464

        self.assertEqual(['1234567890', '12345', 'alpha'],

472

474

 

473

475

    def test_set_writer(self):

474

476

        """The writer should be settable post construction."""

475

 

        access = _DirectPackAccess({})

 

477

        access = pack_repo._DirectPackAccess({})

476

478

        transport = self.get_transport()

477

479

        packname = 'packfile'

478

480

        index = 'foo'

490

492

        transport = self.get_transport()

491

493

        reload_called, reload_func = self.make_reload_func()

492

494

        # Note that the index key has changed from 'foo' to 'bar'

493

 

        access = _DirectPackAccess({'bar':(transport, 'packname')},

 

495

        access = pack_repo._DirectPackAccess({'bar':(transport, 'packname')},

494

496

                                   reload_func=reload_func)

495

497

        e = self.assertListRaises(errors.RetryWithNewPacks,

496

498

                                  access.get_raw_records, memos)

505

507

        memos = self.make_pack_file()

506

508

        transport = self.get_transport()

507

509

        # Note that the index key has changed from 'foo' to 'bar'

508

 

        access = _DirectPackAccess({'bar':(transport, 'packname')})

 

510

        access = pack_repo._DirectPackAccess({'bar':(transport, 'packname')})

509

511

        e = self.assertListRaises(KeyError, access.get_raw_records, memos)

510

512

 

511

513

    def test_missing_file_raises_retry(self):

513

515

        transport = self.get_transport()

514

516

        reload_called, reload_func = self.make_reload_func()

515

517

        # Note that the 'filename' has been changed to 'different-packname'

516

 

        access = _DirectPackAccess({'foo':(transport, 'different-packname')},

517

 

                                   reload_func=reload_func)

 

518

        access = pack_repo._DirectPackAccess(

 

519

            {'foo':(transport, 'different-packname')},

 

520

            reload_func=reload_func)

518

521

        e = self.assertListRaises(errors.RetryWithNewPacks,

519

522

                                  access.get_raw_records, memos)

520

523

        # The file has gone missing, so we assume we need to reload

528

531

        memos = self.make_pack_file()

529

532

        transport = self.get_transport()

530

533

        # Note that the 'filename' has been changed to 'different-packname'

531

 

        access = _DirectPackAccess({'foo':(transport, 'different-packname')})

 

534

        access = pack_repo._DirectPackAccess(

 

535

            {'foo': (transport, 'different-packname')})

532

536

        e = self.assertListRaises(errors.NoSuchFile,

533

537

                                  access.get_raw_records, memos)

534

538

 

538

542

        failing_transport = MockReadvFailingTransport(

539

543

                                [transport.get_bytes('packname')])

540

544

        reload_called, reload_func = self.make_reload_func()

541

 

        access = _DirectPackAccess({'foo':(failing_transport, 'packname')},

542

 

                                   reload_func=reload_func)

 

545

        access = pack_repo._DirectPackAccess(

 

546

            {'foo': (failing_transport, 'packname')},

 

547

            reload_func=reload_func)

543

548

        # Asking for a single record will not trigger the Mock failure

544

549

        self.assertEqual(['1234567890'],

545

550

            list(access.get_raw_records(memos[:1])))

561

566

        failing_transport = MockReadvFailingTransport(

562

567

                                [transport.get_bytes('packname')])

563

568

        reload_called, reload_func = self.make_reload_func()

564

 

        access = _DirectPackAccess({'foo':(failing_transport, 'packname')})

 

569

        access = pack_repo._DirectPackAccess(

 

570

            {'foo':(failing_transport, 'packname')})

565

571

        # Asking for a single record will not trigger the Mock failure

566

572

        self.assertEqual(['1234567890'],

567

573

            list(access.get_raw_records(memos[:1])))

572

578

                                  access.get_raw_records, memos)

573

579

 

574

580

    def test_reload_or_raise_no_reload(self):

575

 

        access = _DirectPackAccess({}, reload_func=None)

 

581

        access = pack_repo._DirectPackAccess({}, reload_func=None)

576

582

        retry_exc = self.make_retry_exception()

577

583

        # Without a reload_func, we will just re-raise the original exception

578

584

        self.assertRaises(_TestException, access.reload_or_raise, retry_exc)

579

585

 

580

586

    def test_reload_or_raise_reload_changed(self):

581

587

        reload_called, reload_func = self.make_reload_func(return_val=True)

582

 

        access = _DirectPackAccess({}, reload_func=reload_func)

 

588

        access = pack_repo._DirectPackAccess({}, reload_func=reload_func)

583

589

        retry_exc = self.make_retry_exception()

584

590

        access.reload_or_raise(retry_exc)

585

591

        self.assertEqual([1], reload_called)

589

595

 

590

596

    def test_reload_or_raise_reload_no_change(self):

591

597

        reload_called, reload_func = self.make_reload_func(return_val=False)

592

 

        access = _DirectPackAccess({}, reload_func=reload_func)

 

598

        access = pack_repo._DirectPackAccess({}, reload_func=reload_func)

593

599

        retry_exc = self.make_retry_exception()

594

600

        # If reload_occurred is False, then we consider it an error to have

595

601

        # reload_func() return False (no changes).

726

732

 

727

733

    def make_multiple_records(self):

728

734

        """Create the content for multiple records."""

729

 

        sha1sum = osutils.sha('foo\nbar\n').hexdigest()

 

735

        sha1sum = osutils.sha_string('foo\nbar\n')

730

736

        total_txt = []

731

737

        gz_txt = self.create_gz_content('version rev-id-1 2 %s\n'

732

738

                                        'foo\n'

735

741

                                        % (sha1sum,))

736

742

        record_1 = (0, len(gz_txt), sha1sum)

737

743

        total_txt.append(gz_txt)

738

 

        sha1sum = osutils.sha('baz\n').hexdigest()

 

744

        sha1sum = osutils.sha_string('baz\n')

739

745

        gz_txt = self.create_gz_content('version rev-id-2 1 %s\n'

740

746

                                        'baz\n'

741

747

                                        'end rev-id-2\n'

745

751

        return total_txt, record_1, record_2

746

752

 

747

753

    def test_valid_knit_data(self):

748

 

        sha1sum = osutils.sha('foo\nbar\n').hexdigest()

 

754

        sha1sum = osutils.sha_string('foo\nbar\n')

749

755

        gz_txt = self.create_gz_content('version rev-id-1 2 %s\n'

750

756

                                        'foo\n'

751

757

                                        'bar\n'

782

788

                         raw_contents)

783

789

 

784

790

    def test_not_enough_lines(self):

785

 

        sha1sum = osutils.sha('foo\n').hexdigest()

 

791

        sha1sum = osutils.sha_string('foo\n')

786

792

        # record says 2 lines data says 1

787

793

        gz_txt = self.create_gz_content('version rev-id-1 2 %s\n'

788

794

                                        'foo\n'

800

806

        self.assertEqual([(('rev-id-1',),  gz_txt, sha1sum)], raw_contents)

801

807

 

802

808

    def test_too_many_lines(self):

803

 

        sha1sum = osutils.sha('foo\nbar\n').hexdigest()

 

809

        sha1sum = osutils.sha_string('foo\nbar\n')

804

810

        # record says 1 lines data says 2

805

811

        gz_txt = self.create_gz_content('version rev-id-1 1 %s\n'

806

812

                                        'foo\n'

819

825

        self.assertEqual([(('rev-id-1',), gz_txt, sha1sum)], raw_contents)

820

826

 

821

827

    def test_mismatched_version_id(self):

822

 

        sha1sum = osutils.sha('foo\nbar\n').hexdigest()

 

828

        sha1sum = osutils.sha_string('foo\nbar\n')

823

829

        gz_txt = self.create_gz_content('version rev-id-1 2 %s\n'

824

830

                                        'foo\n'

825

831

                                        'bar\n'

838

844

            knit._read_records_iter_raw(records))

839

845

 

840

846

    def test_uncompressed_data(self):

841

 

        sha1sum = osutils.sha('foo\nbar\n').hexdigest()

 

847

        sha1sum = osutils.sha_string('foo\nbar\n')

842

848

        txt = ('version rev-id-1 2 %s\n'

843

849

               'foo\n'

844

850

               'bar\n'

858

864

            knit._read_records_iter_raw(records))

859

865

 

860

866

    def test_corrupted_data(self):

861

 

        sha1sum = osutils.sha('foo\nbar\n').hexdigest()

 

867

        sha1sum = osutils.sha_string('foo\nbar\n')

862

868

        gz_txt = self.create_gz_content('version rev-id-1 2 %s\n'

863

869

                                        'foo\n'

864

870

                                        'bar\n'

1186

1192

            self.assertRaises(errors.KnitCorrupt, index.keys)

1187

1193

        except TypeError, e:

1188

1194

            if (str(e) == ('exceptions must be strings, classes, or instances,'

1189

 

                           ' not exceptions.IndexError')

1190

 

                and sys.version_info[0:2] >= (2,5)):

 

1195

                           ' not exceptions.IndexError')):

1191

1196

                self.knownFailure('Pyrex <0.9.5 fails with TypeError when'

1192

1197

                                  ' raising new style exceptions with python'

1193

1198

                                  ' >=2.5')

1206

1211

            self.assertRaises(errors.KnitCorrupt, index.keys)

1207

1212

        except TypeError, e:

1208

1213

            if (str(e) == ('exceptions must be strings, classes, or instances,'

1209

 

                           ' not exceptions.ValueError')

1210

 

                and sys.version_info[0:2] >= (2,5)):

 

1214

                           ' not exceptions.ValueError')):

1211

1215

                self.knownFailure('Pyrex <0.9.5 fails with TypeError when'

1212

1216

                                  ' raising new style exceptions with python'

1213

1217

                                  ' >=2.5')

1226

1230

            self.assertRaises(errors.KnitCorrupt, index.keys)

1227

1231

        except TypeError, e:

1228

1232

            if (str(e) == ('exceptions must be strings, classes, or instances,'

1229

 

                           ' not exceptions.ValueError')

1230

 

                and sys.version_info[0:2] >= (2,5)):

 

1233

                           ' not exceptions.ValueError')):

1231

1234

                self.knownFailure('Pyrex <0.9.5 fails with TypeError when'

1232

1235

                                  ' raising new style exceptions with python'

1233

1236

                                  ' >=2.5')

1244

1247

            self.assertRaises(errors.KnitCorrupt, index.keys)

1245

1248

        except TypeError, e:

1246

1249

            if (str(e) == ('exceptions must be strings, classes, or instances,'

1247

 

                           ' not exceptions.ValueError')

1248

 

                and sys.version_info[0:2] >= (2,5)):

 

1250

                           ' not exceptions.ValueError')):

1249

1251

                self.knownFailure('Pyrex <0.9.5 fails with TypeError when'

1250

1252

                                  ' raising new style exceptions with python'

1251

1253

                                  ' >=2.5')

1262

1264

            self.assertRaises(errors.KnitCorrupt, index.keys)

1263

1265

        except TypeError, e:

1264

1266

            if (str(e) == ('exceptions must be strings, classes, or instances,'

1265

 

                           ' not exceptions.ValueError')

1266

 

                and sys.version_info[0:2] >= (2,5)):

 

1267

                           ' not exceptions.ValueError')):

1267

1268

                self.knownFailure('Pyrex <0.9.5 fails with TypeError when'

1268

1269

                                  ' raising new style exceptions with python'

1269

1270

                                  ' >=2.5')

2438

2439

        key_basis = ('bar',)

2439

2440

        key_missing = ('missing',)

2440

2441

        test.add_lines(key, (), ['foo\n'])

2441

 

        key_sha1sum = osutils.sha('foo\n').hexdigest()

 

2442

        key_sha1sum = osutils.sha_string('foo\n')

2442

2443

        sha1s = test.get_sha1s([key])

2443

2444

        self.assertEqual({key: key_sha1sum}, sha1s)

2444

2445

        self.assertEqual([], basis.calls)

2446

2447

        # directly (rather than via text reconstruction) so that remote servers

2447

2448

        # etc don't have to answer with full content.

2448

2449

        basis.add_lines(key_basis, (), ['foo\n', 'bar\n'])

2449

 

        basis_sha1sum = osutils.sha('foo\nbar\n').hexdigest()

 

2450

        basis_sha1sum = osutils.sha_string('foo\nbar\n')

2450

2451

        basis.calls = []

2451

2452

        sha1s = test.get_sha1s([key, key_missing, key_basis])

2452

2453

        self.assertEqual({key: key_sha1sum,

• Older »

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