~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_knit.py

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

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()

442

444

        except _TestException, e:

443

445

            retry_exc = errors.RetryWithNewPacks(None, reload_occurred=False,

444

446

                                                 exc_info=sys.exc_info())

 

447

        # GZ 2010-08-10: Cycle with exc_info affects 3 tests

445

448

        return retry_exc

446

449

 

447

450

    def test_read_from_several_packs(self):

456

459

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

457

460

        writer.end()

458

461

        transport = self.get_transport()

459

 

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

 

462

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

460

463

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

461

464

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

462

465

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

472

475

 

473

476

    def test_set_writer(self):

474

477

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

475

 

        access = _DirectPackAccess({})

 

478

        access = pack_repo._DirectPackAccess({})

476

479

        transport = self.get_transport()

477

480

        packname = 'packfile'

478

481

        index = 'foo'

490

493

        transport = self.get_transport()

491

494

        reload_called, reload_func = self.make_reload_func()

492

495

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

493

 

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

 

496

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

494

497

                                   reload_func=reload_func)

495

498

        e = self.assertListRaises(errors.RetryWithNewPacks,

496

499

                                  access.get_raw_records, memos)

505

508

        memos = self.make_pack_file()

506

509

        transport = self.get_transport()

507

510

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

508

 

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

 

511

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

509

512

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

510

513

 

511

514

    def test_missing_file_raises_retry(self):

513

516

        transport = self.get_transport()

514

517

        reload_called, reload_func = self.make_reload_func()

515

518

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

516

 

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

517

 

                                   reload_func=reload_func)

 

519

        access = pack_repo._DirectPackAccess(

 

520

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

 

521

            reload_func=reload_func)

518

522

        e = self.assertListRaises(errors.RetryWithNewPacks,

519

523

                                  access.get_raw_records, memos)

520

524

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

528

532

        memos = self.make_pack_file()

529

533

        transport = self.get_transport()

530

534

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

531

 

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

 

535

        access = pack_repo._DirectPackAccess(

 

536

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

532

537

        e = self.assertListRaises(errors.NoSuchFile,

533

538

                                  access.get_raw_records, memos)

534

539

 

538

543

        failing_transport = MockReadvFailingTransport(

539

544

                                [transport.get_bytes('packname')])

540

545

        reload_called, reload_func = self.make_reload_func()

541

 

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

542

 

                                   reload_func=reload_func)

 

546

        access = pack_repo._DirectPackAccess(

 

547

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

 

548

            reload_func=reload_func)

543

549

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

544

550

        self.assertEqual(['1234567890'],

545

551

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

561

567

        failing_transport = MockReadvFailingTransport(

562

568

                                [transport.get_bytes('packname')])

563

569

        reload_called, reload_func = self.make_reload_func()

564

 

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

 

570

        access = pack_repo._DirectPackAccess(

 

571

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

565

572

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

566

573

        self.assertEqual(['1234567890'],

567

574

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

572

579

                                  access.get_raw_records, memos)

573

580

 

574

581

    def test_reload_or_raise_no_reload(self):

575

 

        access = _DirectPackAccess({}, reload_func=None)

 

582

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

576

583

        retry_exc = self.make_retry_exception()

577

584

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

578

585

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

579

586

 

580

587

    def test_reload_or_raise_reload_changed(self):

581

588

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

582

 

        access = _DirectPackAccess({}, reload_func=reload_func)

 

589

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

583

590

        retry_exc = self.make_retry_exception()

584

591

        access.reload_or_raise(retry_exc)

585

592

        self.assertEqual([1], reload_called)

589

596

 

590

597

    def test_reload_or_raise_reload_no_change(self):

591

598

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

592

 

        access = _DirectPackAccess({}, reload_func=reload_func)

 

599

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

593

600

        retry_exc = self.make_retry_exception()

594

601

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

595

602

        # reload_func() return False (no changes).

726

733

 

727

734

    def make_multiple_records(self):

728

735

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

729

 

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

 

736

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

730

737

        total_txt = []

731

738

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

732

739

                                        'foo\n'

735

742

                                        % (sha1sum,))

736

743

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

737

744

        total_txt.append(gz_txt)

738

 

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

 

745

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

739

746

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

740

747

                                        'baz\n'

741

748

                                        'end rev-id-2\n'

745

752

        return total_txt, record_1, record_2

746

753

 

747

754

    def test_valid_knit_data(self):

748

 

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

 

755

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

749

756

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

750

757

                                        'foo\n'

751

758

                                        'bar\n'

782

789

                         raw_contents)

783

790

 

784

791

    def test_not_enough_lines(self):

785

 

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

 

792

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

786

793

        # record says 2 lines data says 1

787

794

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

788

795

                                        'foo\n'

800

807

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

801

808

 

802

809

    def test_too_many_lines(self):

803

 

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

 

810

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

804

811

        # record says 1 lines data says 2

805

812

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

806

813

                                        'foo\n'

819

826

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

820

827

 

821

828

    def test_mismatched_version_id(self):

822

 

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

 

829

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

823

830

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

824

831

                                        'foo\n'

825

832

                                        'bar\n'

838

845

            knit._read_records_iter_raw(records))

839

846

 

840

847

    def test_uncompressed_data(self):

841

 

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

 

848

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

842

849

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

843

850

               'foo\n'

844

851

               'bar\n'

858

865

            knit._read_records_iter_raw(records))

859

866

 

860

867

    def test_corrupted_data(self):

861

 

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

 

868

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

862

869

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

863

870

                                        'foo\n'

864

871

                                        'bar\n'

1186

1193

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

1187

1194

        except TypeError, e:

1188

1195

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

1189

 

                           ' not exceptions.IndexError')

1190

 

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

 

1196

                           ' not exceptions.IndexError')):

1191

1197

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

1192

1198

                                  ' raising new style exceptions with python'

1193

1199

                                  ' >=2.5')

1206

1212

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

1207

1213

        except TypeError, e:

1208

1214

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

1209

 

                           ' not exceptions.ValueError')

1210

 

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

 

1215

                           ' not exceptions.ValueError')):

1211

1216

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

1212

1217

                                  ' raising new style exceptions with python'

1213

1218

                                  ' >=2.5')

1226

1231

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

1227

1232

        except TypeError, e:

1228

1233

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

1229

 

                           ' not exceptions.ValueError')

1230

 

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

 

1234

                           ' not exceptions.ValueError')):

1231

1235

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

1232

1236

                                  ' raising new style exceptions with python'

1233

1237

                                  ' >=2.5')

1244

1248

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

1245

1249

        except TypeError, e:

1246

1250

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

1247

 

                           ' not exceptions.ValueError')

1248

 

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

 

1251

                           ' not exceptions.ValueError')):

1249

1252

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

1250

1253

                                  ' raising new style exceptions with python'

1251

1254

                                  ' >=2.5')

1262

1265

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

1263

1266

        except TypeError, e:

1264

1267

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

1265

 

                           ' not exceptions.ValueError')

1266

 

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

 

1268

                           ' not exceptions.ValueError')):

1267

1269

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

1268

1270

                                  ' raising new style exceptions with python'

1269

1271

                                  ' >=2.5')

2438

2440

        key_basis = ('bar',)

2439

2441

        key_missing = ('missing',)

2440

2442

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

2441

 

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

 

2443

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

2442

2444

        sha1s = test.get_sha1s([key])

2443

2445

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

2444

2446

        self.assertEqual([], basis.calls)

2446

2448

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

2447

2449

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

2448

2450

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

2449

 

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

 

2451

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

2450

2452

        basis.calls = []

2451

2453

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

2452

2454

        self.assertEqual({key: key_sha1sum,

• Older »

Loggerhead is a web-based interface for Breezy
Version: 2.0.1