/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to breezy/tests/test_index.py

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

Show diffs side-by-side

added

removed

breezy/tests/test_index.py

32

32

    def test_bad_index_format_signature(self):

33

33

        error = _mod_index.BadIndexFormatSignature("foo", "bar")

34

34

        self.assertEqual("foo is not an index of type bar.",

35

 

            str(error))

 

35

                         str(error))

36

36

 

37

37

    def test_bad_index_data(self):

38

38

        error = _mod_index.BadIndexData("foo")

39

39

        self.assertEqual("Error in data for index foo.",

40

 

            str(error))

 

40

                         str(error))

41

41

 

42

42

    def test_bad_index_duplicate_key(self):

43

43

        error = _mod_index.BadIndexDuplicateKey("foo", "bar")

44

44

        self.assertEqual("The key 'foo' is already in index 'bar'.",

45

 

            str(error))

 

45

                         str(error))

46

46

 

47

47

    def test_bad_index_key(self):

48

48

        error = _mod_index.BadIndexKey("foo")

49

49

        self.assertEqual("The key 'foo' is not a valid key.",

50

 

            str(error))

 

50

                         str(error))

51

51

 

52

52

    def test_bad_index_options(self):

53

53

        error = _mod_index.BadIndexOptions("foo")

54

54

        self.assertEqual("Could not parse options for index foo.",

55

 

            str(error))

 

55

                         str(error))

56

56

 

57

57

    def test_bad_index_value(self):

58

58

        error = _mod_index.BadIndexValue("foo")

59

59

        self.assertEqual("The value 'foo' is not a valid value.",

60

 

            str(error))

 

60

                         str(error))

61

61

 

62

62

 

63

63

class TestGraphIndexBuilder(tests.TestCaseWithMemoryTransport):

192

192

            b"\n", contents)

193

193

 

194

194

    def test_build_index_reference_lists_with_2_element_keys(self):

195

 

        builder = _mod_index.GraphIndexBuilder(reference_lists=1, key_elements=2)

 

195

        builder = _mod_index.GraphIndexBuilder(

 

196

            reference_lists=1, key_elements=2)

196

197

        builder.add_node((b'key', b'key2'), b'data', ([], ))

197

198

        stream = builder.finish()

198

199

        contents = stream.read()

308

309

        builder = _mod_index.GraphIndexBuilder()

309

310

        for bad_char in bytearray(b'\t\n\x0b\x0c\r\x00 '):

310

311

            self.assertRaises(_mod_index.BadIndexKey, builder.add_node,

311

 

                (b'a%skey' % int2byte(bad_char), ), b'data')

312

 

        self.assertRaises(_mod_index.BadIndexKey, builder.add_node,

313

 

                (), b'data')

314

 

        self.assertRaises(_mod_index.BadIndexKey, builder.add_node,

315

 

                b'not-a-tuple', b'data')

 

312

                              (b'a%skey' % int2byte(bad_char), ), b'data')

 

313

        self.assertRaises(_mod_index.BadIndexKey, builder.add_node,

 

314

                          (), b'data')

 

315

        self.assertRaises(_mod_index.BadIndexKey, builder.add_node,

 

316

                          b'not-a-tuple', b'data')

316

317

        # not enough length

317

318

        self.assertRaises(_mod_index.BadIndexKey, builder.add_node,

318

 

                (), b'data')

 

319

                          (), b'data')

319

320

        # too long

320

321

        self.assertRaises(_mod_index.BadIndexKey, builder.add_node,

321

 

                (b'primary', b'secondary'), b'data')

 

322

                          (b'primary', b'secondary'), b'data')

322

323

        # secondary key elements get checked too:

323

324

        builder = _mod_index.GraphIndexBuilder(key_elements=2)

324

325

        for bad_char in bytearray(b'\t\n\x0b\x0c\r\x00 '):

325

326

            self.assertRaises(_mod_index.BadIndexKey, builder.add_node,

326

 

                (b'prefix', b'a%skey' % int2byte(bad_char)), b'data')

 

327

                              (b'prefix', b'a%skey' % int2byte(bad_char)), b'data')

327

328

 

328

329

    def test_add_node_bad_data(self):

329

330

        builder = _mod_index.GraphIndexBuilder()

330

331

        self.assertRaises(_mod_index.BadIndexValue, builder.add_node, (b'akey', ),

331

 

            b'data\naa')

 

332

                          b'data\naa')

332

333

        self.assertRaises(_mod_index.BadIndexValue, builder.add_node, (b'akey', ),

333

 

            b'data\x00aa')

 

334

                          b'data\x00aa')

334

335

 

335

336

    def test_add_node_bad_mismatched_ref_lists_length(self):

336

337

        builder = _mod_index.GraphIndexBuilder()

337

338

        self.assertRaises(_mod_index.BadIndexValue, builder.add_node, (b'akey', ),

338

 

            b'data aa', ([], ))

 

339

                          b'data aa', ([], ))

339

340

        builder = _mod_index.GraphIndexBuilder(reference_lists=1)

340

341

        self.assertRaises(_mod_index.BadIndexValue, builder.add_node, (b'akey', ),

341

 

            b'data aa')

342

 

        self.assertRaises(_mod_index.BadIndexValue, builder.add_node, (b'akey', ),

343

 

            b'data aa', (), )

344

 

        self.assertRaises(_mod_index.BadIndexValue, builder.add_node, (b'akey', ),

345

 

            b'data aa', ([], []))

 

342

                          b'data aa')

 

343

        self.assertRaises(_mod_index.BadIndexValue, builder.add_node, (b'akey', ),

 

344

                          b'data aa', (), )

 

345

        self.assertRaises(_mod_index.BadIndexValue, builder.add_node, (b'akey', ),

 

346

                          b'data aa', ([], []))

346

347

        builder = _mod_index.GraphIndexBuilder(reference_lists=2)

347

348

        self.assertRaises(_mod_index.BadIndexValue, builder.add_node, (b'akey', ),

348

 

            b'data aa')

349

 

        self.assertRaises(_mod_index.BadIndexValue, builder.add_node, (b'akey', ),

350

 

            b'data aa', ([], ))

351

 

        self.assertRaises(_mod_index.BadIndexValue, builder.add_node, (b'akey', ),

352

 

            b'data aa', ([], [], []))

 

349

                          b'data aa')

 

350

        self.assertRaises(_mod_index.BadIndexValue, builder.add_node, (b'akey', ),

 

351

                          b'data aa', ([], ))

 

352

        self.assertRaises(_mod_index.BadIndexValue, builder.add_node, (b'akey', ),

 

353

                          b'data aa', ([], [], []))

353

354

 

354

355

    def test_add_node_bad_key_in_reference_lists(self):

355

356

        # first list, first key - trivial

356

357

        builder = _mod_index.GraphIndexBuilder(reference_lists=1)

357

358

        self.assertRaises(_mod_index.BadIndexKey, builder.add_node, (b'akey', ),

358

 

            b'data aa', ([(b'a key', )], ))

 

359

                          b'data aa', ([(b'a key', )], ))

359

360

        # references keys must be tuples too

360

361

        self.assertRaises(_mod_index.BadIndexKey, builder.add_node, (b'akey', ),

361

 

            b'data aa', (['not-a-tuple'], ))

 

362

                          b'data aa', (['not-a-tuple'], ))

362

363

        # not enough length

363

364

        self.assertRaises(_mod_index.BadIndexKey, builder.add_node, (b'akey', ),

364

 

            b'data aa', ([()], ))

 

365

                          b'data aa', ([()], ))

365

366

        # too long

366

367

        self.assertRaises(_mod_index.BadIndexKey, builder.add_node, (b'akey', ),

367

 

            b'data aa', ([(b'primary', b'secondary')], ))

 

368

                          b'data aa', ([(b'primary', b'secondary')], ))

368

369

        # need to check more than the first key in the list

369

370

        self.assertRaises(_mod_index.BadIndexKey, builder.add_node, (b'akey', ),

370

 

            b'data aa', ([(b'agoodkey', ), (b'that is a bad key', )], ))

 

371

                          b'data aa', ([(b'agoodkey', ), (b'that is a bad key', )], ))

371

372

        # and if there is more than one list it should be getting checked

372

373

        # too

373

374

        builder = _mod_index.GraphIndexBuilder(reference_lists=2)

374

375

        self.assertRaises(_mod_index.BadIndexKey, builder.add_node, (b'akey', ),

375

 

            b'data aa', ([], ['a bad key']))

 

376

                          b'data aa', ([], ['a bad key']))

376

377

 

377

378

    def test_add_duplicate_key(self):

378

379

        builder = _mod_index.GraphIndexBuilder()

384

385

        builder = _mod_index.GraphIndexBuilder(key_elements=2)

385

386

        builder.add_node((b'key', b'key'), b'data')

386

387

        self.assertRaises(_mod_index.BadIndexDuplicateKey, builder.add_node,

387

 

            (b'key', b'key'), b'data')

 

388

                          (b'key', b'key'), b'data')

388

389

 

389

390

    def test_add_key_after_referencing_key(self):

390

391

        builder = _mod_index.GraphIndexBuilder(reference_lists=1)

392

393

        builder.add_node((b'reference', ), b'data', ([],))

393

394

 

394

395

    def test_add_key_after_referencing_key_2_elements(self):

395

 

        builder = _mod_index.GraphIndexBuilder(reference_lists=1, key_elements=2)

396

 

        builder.add_node((b'k', b'ey'), b'data', ([(b'reference', b'tokey')], ))

 

396

        builder = _mod_index.GraphIndexBuilder(

 

397

            reference_lists=1, key_elements=2)

 

398

        builder.add_node((b'k', b'ey'), b'data',

 

399

                         ([(b'reference', b'tokey')], ))

397

400

        builder.add_node((b'reference', b'tokey'), b'data', ([],))

398

401

 

399

402

    def test_set_optimize(self):

400

 

        builder = _mod_index.GraphIndexBuilder(reference_lists=1, key_elements=2)

 

403

        builder = _mod_index.GraphIndexBuilder(

 

404

            reference_lists=1, key_elements=2)

401

405

        builder.set_optimize(for_size=True)

402

406

        self.assertTrue(builder._optimize_for_size)

403

407

        builder.set_optimize(for_size=False)

407

411

class TestGraphIndex(tests.TestCaseWithMemoryTransport):

408

412

 

409

413

    def make_key(self, number):

410

 

        return ((b'%d' % number) + b'X'*100,)

 

414

        return ((b'%d' % number) + b'X' * 100,)

411

415

 

412

416

    def make_value(self, number):

413

 

        return (b'%d' % number) + b'Y'*100

 

417

        return (b'%d' % number) + b'Y' * 100

414

418

 

415

419

    def make_nodes(self, count=64):

416

420

        # generate a big enough index that we only read some of it on a typical

417

421

        # bisection lookup.

418

422

        nodes = []

419

423

        for counter in range(count):

420

 

            nodes.append((self.make_key(counter), self.make_value(counter), ()))

 

424

            nodes.append(

 

425

                (self.make_key(counter), self.make_value(counter), ()))

421

426

        return nodes

422

427

 

423

428

    def make_index(self, ref_lists=0, key_elements=1, nodes=[]):

424

 

        builder = _mod_index.GraphIndexBuilder(ref_lists, key_elements=key_elements)

 

429

        builder = _mod_index.GraphIndexBuilder(

 

430

            ref_lists, key_elements=key_elements)

425

431

        for key, value, references in nodes:

426

432

            builder.add_node(key, value, references)

427

433

        stream = builder.finish()

431

437

 

432

438

    def make_index_with_offset(self, ref_lists=0, key_elements=1, nodes=[],

433

439

                               offset=0):

434

 

        builder = _mod_index.GraphIndexBuilder(ref_lists, key_elements=key_elements)

 

440

        builder = _mod_index.GraphIndexBuilder(

 

441

            ref_lists, key_elements=key_elements)

435

442

        for key, value, references in nodes:

436

443

            builder.add_node(key, value, references)

437

444

        content = builder.finish().read()

438

445

        size = len(content)

439

446

        trans = self.get_transport()

440

 

        trans.put_bytes('index', (b' '*offset) + content)

 

447

        trans.put_bytes('index', (b' ' * offset) + content)

441

448

        return _mod_index.GraphIndex(trans, 'index', size, offset=offset)

442

449

 

443

450

    def test_clear_cache(self):

465

472

    def test_side_effect_buffering_with_offset(self):

466

473

        nodes = self.make_nodes(20)

467

474

        index = self.make_index_with_offset(offset=1234567, nodes=nodes)

468

 

        index._transport.recommended_page_size = lambda:64*1024

 

475

        index._transport.recommended_page_size = lambda: 64 * 1024

469

476

        subset_nodes = [nodes[0][0], nodes[10][0], nodes[19][0]]

470

477

        entries = [n[1] for n in index.iter_entries(subset_nodes)]

471

478

        self.assertEqual(sorted(subset_nodes), sorted(entries))

507

514

        # and the result should be that the key cannot be present, because this

508

515

        # is a trivial index.

509

516

        self.assertEqual([((index._size // 2, (b'missing', )), False)],

510

 

            result)

 

517

                         result)

511

518

        # And this should have caused the file to be fully buffered

512

519

        self.assertIsNot(None, index._nodes)

513

520

        self.assertEqual([], index._parsed_byte_map)

538

545

        # and the result should be that the key cannot be present, because this

539

546

        # is a trivial index.

540

547

        self.assertEqual([((start_lookup, (b'40missing', )), False)],

541

 

            result)

 

548

                         result)

542

549

        # And this should not have caused the file to be fully buffered

543

550

        self.assertIs(None, index._nodes)

544

551

        # And the regions of the file that have been parsed should be in the

556

563

        # in the middle of the observed data from a 4K read - the smallest transport

557

564

        # will do today with this api.

558

565

        self.assertEqual([((index._size // 2, (b'40', )), False)],

559

 

            result)

 

566

                         result)

560

567

        # and we should have a parse map that includes the header and the

561

568

        # region that was parsed after trimming.

562

569

        self.assertEqual([(0, 4008), (5046, 8996)], index._parsed_byte_map)

563

570

        self.assertEqual([((), self.make_key(26)),

564

571

                          (self.make_key(31), self.make_key(48))],

565

 

            index._parsed_key_map)

 

572

                         index._parsed_key_map)

566

573

 

567

574

    def test_parsing_data_handles_parsed_contained_regions(self):

568

575

        # the following patten creates a parsed region that is wholly within a

586

593

        self.assertEqual([(0, 4045), (11759, 15707)], index._parsed_byte_map)

587

594

        self.assertEqual([((), self.make_key(116)),

588

595

                          (self.make_key(35), self.make_key(51))],

589

 

            index._parsed_key_map)

 

596

                         index._parsed_key_map)

590

597

        # now ask for two keys, right before and after the parsed region

591

598

        result = index._lookup_keys_via_location(

592

599

            [(11450, self.make_key(34)), (15707, self.make_key(52))])

604

611

        # bisection lookup.

605

612

        index = self.make_index(nodes=self.make_nodes(64))

606

613

        # lookup the keys in the middle of the file

607

 

        result =index._lookup_keys_via_location(

 

614

        result = index._lookup_keys_via_location(

608

615

            [(index._size // 2, (b'40', ))])

609

616

        # check the parse map, this determines the test validity

610

617

        self.assertEqual([(0, 4008), (5046, 8996)], index._parsed_byte_map)

611

618

        self.assertEqual([((), self.make_key(26)),

612

619

                          (self.make_key(31), self.make_key(48))],

613

 

            index._parsed_key_map)

 

620

                         index._parsed_key_map)

614

621

        # reset the transport log

615

622

        del index._transport._activity[:]

616

623

        # now looking up a key in the portion of the file already parsed should

620

627

        result = index._lookup_keys_via_location(

621

628

            [(4000, (b'40', ))])

622

629

        self.assertEqual([((4000, (b'40', )), False)],

623

 

            result)

 

630

                         result)

624

631

        self.assertEqual([], index._transport._activity)

625

632

 

626

633

    def test_lookup_present_key_answers_without_io_when_map_permits(self):

628

635

        # bisection lookup.

629

636

        index = self.make_index(nodes=self.make_nodes(64))

630

637

        # lookup the keys in the middle of the file

631

 

        result =index._lookup_keys_via_location(

 

638

        result = index._lookup_keys_via_location(

632

639

            [(index._size // 2, (b'40', ))])

633

640

        # check the parse map, this determines the test validity

634

641

        self.assertEqual([(0, 4008), (5046, 8996)], index._parsed_byte_map)

635

642

        self.assertEqual([((), self.make_key(26)),

636

643

                          (self.make_key(31), self.make_key(48))],

637

 

            index._parsed_key_map)

 

644

                         index._parsed_key_map)

638

645

        # reset the transport log

639

646

        del index._transport._activity[:]

640

647

        # now looking up a key in the portion of the file already parsed should

655

662

        index = self.make_index(nodes=self.make_nodes(64))

656

663

        # ask for the key in the middle, but a key that is located in the

657

664

        # unparsed region before the middle.

658

 

        result =index._lookup_keys_via_location(

 

665

        result = index._lookup_keys_via_location(

659

666

            [(index._size // 2, (b'30', ))])

660

667

        # check the parse map, this determines the test validity

661

668

        self.assertEqual([(0, 4008), (5046, 8996)], index._parsed_byte_map)

662

669

        self.assertEqual([((), self.make_key(26)),

663

670

                          (self.make_key(31), self.make_key(48))],

664

 

            index._parsed_key_map)

 

671

                         index._parsed_key_map)

665

672

        self.assertEqual([((index._size // 2, (b'30', )), -1)],

666

 

            result)

 

673

                         result)

667

674

 

668

675

    def test_lookup_key_above_probed_area(self):

669

676

        # generate a big enough index that we only read some of it on a typical

671

678

        index = self.make_index(nodes=self.make_nodes(64))

672

679

        # ask for the key in the middle, but a key that is located in the

673

680

        # unparsed region after the middle.

674

 

        result =index._lookup_keys_via_location(

 

681

        result = index._lookup_keys_via_location(

675

682

            [(index._size // 2, (b'50', ))])

676

683

        # check the parse map, this determines the test validity

677

684

        self.assertEqual([(0, 4008), (5046, 8996)], index._parsed_byte_map)

678

685

        self.assertEqual([((), self.make_key(26)),

679

686

                          (self.make_key(31), self.make_key(48))],

680

 

            index._parsed_key_map)

 

687

                         index._parsed_key_map)

681

688

        self.assertEqual([((index._size // 2, (b'50', )), +1)],

682

 

            result)

 

689

                         result)

683

690

 

684

691

    def test_lookup_key_resolves_references(self):

685

692

        # generate a big enough index that we only read some of it on a typical

687

694

        nodes = []

688

695

        for counter in range(99):

689

696

            nodes.append((self.make_key(counter), self.make_value(counter),

690

 

                ((self.make_key(counter + 20),),)  ))

 

697

                          ((self.make_key(counter + 20),),)))

691

698

        index = self.make_index(ref_lists=1, nodes=nodes)

692

699

        # lookup a key in the middle that does not exist, so that when we can

693

700

        # check that the referred-to-keys are not accessed automatically.

700

707

        self.assertEqual([(0, 4027), (10198, 14028)], index._parsed_byte_map)

701

708

        self.assertEqual([((), self.make_key(17)),

702

709

                          (self.make_key(44), self.make_key(5))],

703

 

            index._parsed_key_map)

 

710

                         index._parsed_key_map)

704

711

        # and check the transport activity likewise.

705

712

        self.assertEqual(

706

713

            [('readv', 'index', [(index_center, 800), (0, 200)], True,

707

 

                                  index_size)],

 

714

              index_size)],

708

715

            index._transport._activity)

709

716

        # reset the transport log for testing the reference lookup

710

717

        del index._transport._activity[:]

717

724

               ((self.make_key(65),),)))],

718

725

            result)

719

726

        self.assertEqual([('readv', 'index', [(15093, 800)], True, index_size)],

720

 

            index._transport._activity)

 

727

                         index._transport._activity)

721

728

 

722

729

    def test_lookup_key_can_buffer_all(self):

723

730

        nodes = []

724

731

        for counter in range(64):

725

732

            nodes.append((self.make_key(counter), self.make_value(counter),

726

 

                ((self.make_key(counter + 20),),)  ))

 

733

                          ((self.make_key(counter + 20),),)))

727

734

        index = self.make_index(ref_lists=1, nodes=nodes)

728

735

        # lookup a key in the middle that does not exist, so that when we can

729

736

        # check that the referred-to-keys are not accessed automatically.

735

742

        self.assertEqual([(0, 3890), (6444, 10274)], index._parsed_byte_map)

736

743

        self.assertEqual([((), self.make_key(25)),

737

744

                          (self.make_key(37), self.make_key(52))],

738

 

            index._parsed_key_map)

 

745

                         index._parsed_key_map)

739

746

        # and check the transport activity likewise.

740

747

        self.assertEqual(

741

748

            [('readv', 'index', [(index_center, 800), (0, 200)], True,

742

 

                                  index_size)],

 

749

              index_size)],

743

750

            index._transport._activity)

744

751

        # reset the transport log for testing the reference lookup

745

752

        del index._transport._activity[:]

762

769

    def test_iter_all_entries_simple(self):

763

770

        index = self.make_index(nodes=[((b'name', ), b'data', ())])

764

771

        self.assertEqual([(index, (b'name', ), b'data')],

765

 

            list(index.iter_all_entries()))

 

772

                         list(index.iter_all_entries()))

766

773

 

767

774

    def test_iter_all_entries_simple_2_elements(self):

768

775

        index = self.make_index(key_elements=2,

769

 

            nodes=[((b'name', b'surname'), b'data', ())])

 

776

                                nodes=[((b'name', b'surname'), b'data', ())])

770

777

        self.assertEqual([(index, (b'name', b'surname'), b'data')],

771

 

            list(index.iter_all_entries()))

 

778

                         list(index.iter_all_entries()))

772

779

 

773

780

    def test_iter_all_entries_references_resolved(self):

774

781

        index = self.make_index(1, nodes=[

775

782

            ((b'name', ), b'data', ([(b'ref', )], )),

776

783

            ((b'ref', ), b'refdata', ([], ))])

777

784

        self.assertEqual({(index, (b'name', ), b'data', (((b'ref',),),)),

778

 

            (index, (b'ref', ), b'refdata', ((), ))},

779

 

            set(index.iter_all_entries()))

 

785

                          (index, (b'ref', ), b'refdata', ((), ))},

 

786

                         set(index.iter_all_entries()))

780

787

 

781

788

    def test_iter_entries_buffers_once(self):

782

789

        index = self.make_index(nodes=self.make_nodes(2))

825

832

            ((b'name', ), b'data', ([(b'ref', ), (b'ref', )], )),

826

833

            ((b'ref', ), b'refdata', ([], ))])

827

834

        self.assertEqual({(index, (b'name', ), b'data', (((b'ref',), (b'ref',)),)),

828

 

            (index, (b'ref', ), b'refdata', ((), ))},

829

 

            set(index.iter_entries([(b'name',), (b'ref',)])))

 

835

                          (index, (b'ref', ), b'refdata', ((), ))},

 

836

                         set(index.iter_entries([(b'name',), (b'ref',)])))

830

837

 

831

838

    def test_iter_entries_references_2_refs_resolved(self):

832

839

        index = self.make_index(2, nodes=[

833

840

            ((b'name', ), b'data', ([(b'ref', )], [(b'ref', )])),

834

841

            ((b'ref', ), b'refdata', ([], []))])

835

842

        self.assertEqual({(index, (b'name', ), b'data', (((b'ref',),), ((b'ref',),))),

836

 

            (index, (b'ref', ), b'refdata', ((), ()))},

837

 

            set(index.iter_entries([(b'name',), (b'ref',)])))

 

843

                          (index, (b'ref', ), b'refdata', ((), ()))},

 

844

                         set(index.iter_entries([(b'name',), (b'ref',)])))

838

845

 

839

846

    def test_iteration_absent_skipped(self):

840

847

        index = self.make_index(1, nodes=[

841

848

            ((b'name', ), b'data', ([(b'ref', )], ))])

842

849

        self.assertEqual({(index, (b'name', ), b'data', (((b'ref',),),))},

843

 

            set(index.iter_all_entries()))

 

850

                         set(index.iter_all_entries()))

844

851

        self.assertEqual({(index, (b'name', ), b'data', (((b'ref',),),))},

845

 

            set(index.iter_entries([(b'name', )])))

 

852

                         set(index.iter_entries([(b'name', )])))

846

853

        self.assertEqual([], list(index.iter_entries([(b'ref', )])))

847

854

 

848

855

    def test_iteration_absent_skipped_2_element_keys(self):

849

856

        index = self.make_index(1, key_elements=2, nodes=[

850

857

            ((b'name', b'fin'), b'data', ([(b'ref', b'erence')], ))])

851

858

        self.assertEqual([(index, (b'name', b'fin'), b'data', (((b'ref', b'erence'),),))],

852

 

            list(index.iter_all_entries()))

 

859

                         list(index.iter_all_entries()))

853

860

        self.assertEqual([(index, (b'name', b'fin'), b'data', (((b'ref', b'erence'),),))],

854

 

            list(index.iter_entries([(b'name', b'fin')])))

 

861

                         list(index.iter_entries([(b'name', b'fin')])))

855

862

        self.assertEqual([], list(index.iter_entries([(b'ref', b'erence')])))

856

863

 

857

864

    def test_iter_all_keys(self):

859

866

            ((b'name', ), b'data', ([(b'ref', )], )),

860

867

            ((b'ref', ), b'refdata', ([], ))])

861

868

        self.assertEqual({(index, (b'name', ), b'data', (((b'ref',),),)),

862

 

            (index, (b'ref', ), b'refdata', ((), ))},

863

 

            set(index.iter_entries([(b'name', ), (b'ref', )])))

 

869

                          (index, (b'ref', ), b'refdata', ((), ))},

 

870

                         set(index.iter_entries([(b'name', ), (b'ref', )])))

864

871

 

865

872

    def test_iter_nothing_empty(self):

866

873

        index = self.make_index()

878

885

    def test_iter_key_prefix_1_element_key_None(self):

879

886

        index = self.make_index()

880

887

        self.assertRaises(_mod_index.BadIndexKey, list,

881

 

            index.iter_entries_prefix([(None, )]))

 

888

                          index.iter_entries_prefix([(None, )]))

882

889

 

883

890

    def test_iter_key_prefix_wrong_length(self):

884

891

        index = self.make_index()

885

892

        self.assertRaises(_mod_index.BadIndexKey, list,

886

 

            index.iter_entries_prefix([(b'foo', None)]))

 

893

                          index.iter_entries_prefix([(b'foo', None)]))

887

894

        index = self.make_index(key_elements=2)

888

895

        self.assertRaises(_mod_index.BadIndexKey, list,

889

 

            index.iter_entries_prefix([(b'foo', )]))

 

896

                          index.iter_entries_prefix([(b'foo', )]))

890

897

        self.assertRaises(_mod_index.BadIndexKey, list,

891

 

            index.iter_entries_prefix([(b'foo', None, None)]))

 

898

                          index.iter_entries_prefix([(b'foo', None, None)]))

892

899

 

893

900

    def test_iter_key_prefix_1_key_element_no_refs(self):

894

 

        index = self.make_index( nodes=[

 

901

        index = self.make_index(nodes=[

895

902

            ((b'name', ), b'data', ()),

896

903

            ((b'ref', ), b'refdata', ())])

897

904

        self.assertEqual({(index, (b'name', ), b'data'),

898

 

            (index, (b'ref', ), b'refdata')},

899

 

            set(index.iter_entries_prefix([(b'name', ), (b'ref', )])))

 

905

                          (index, (b'ref', ), b'refdata')},

 

906

                         set(index.iter_entries_prefix([(b'name', ), (b'ref', )])))

900

907

 

901

908

    def test_iter_key_prefix_1_key_element_refs(self):

902

909

        index = self.make_index(1, nodes=[

903

910

            ((b'name', ), b'data', ([(b'ref', )], )),

904

911

            ((b'ref', ), b'refdata', ([], ))])

905

912

        self.assertEqual({(index, (b'name', ), b'data', (((b'ref',),),)),

906

 

            (index, (b'ref', ), b'refdata', ((), ))},

907

 

            set(index.iter_entries_prefix([(b'name', ), (b'ref', )])))

 

913

                          (index, (b'ref', ), b'refdata', ((), ))},

 

914

                         set(index.iter_entries_prefix([(b'name', ), (b'ref', )])))

908

915

 

909

916

    def test_iter_key_prefix_2_key_element_no_refs(self):

910

917

        index = self.make_index(key_elements=2, nodes=[

912

919

            ((b'name', b'fin2'), b'beta', ()),

913

920

            ((b'ref', b'erence'), b'refdata', ())])

914

921

        self.assertEqual({(index, (b'name', b'fin1'), b'data'),

915

 

            (index, (b'ref', b'erence'), b'refdata')},

916

 

            set(index.iter_entries_prefix([(b'name', b'fin1'), (b'ref', b'erence')])))

 

922

                          (index, (b'ref', b'erence'), b'refdata')},

 

923

                         set(index.iter_entries_prefix([(b'name', b'fin1'), (b'ref', b'erence')])))

917

924

        self.assertEqual({(index, (b'name', b'fin1'), b'data'),

918

 

            (index, (b'name', b'fin2'), b'beta')},

919

 

            set(index.iter_entries_prefix([(b'name', None)])))

 

925

                          (index, (b'name', b'fin2'), b'beta')},

 

926

                         set(index.iter_entries_prefix([(b'name', None)])))

920

927

 

921

928

    def test_iter_key_prefix_2_key_element_refs(self):

922

929

        index = self.make_index(1, key_elements=2, nodes=[

924

931

            ((b'name', b'fin2'), b'beta', ([], )),

925

932

            ((b'ref', b'erence'), b'refdata', ([], ))])

926

933

        self.assertEqual({(index, (b'name', b'fin1'), b'data', (((b'ref', b'erence'),),)),

927

 

            (index, (b'ref', b'erence'), b'refdata', ((), ))},

928

 

            set(index.iter_entries_prefix([(b'name', b'fin1'), (b'ref', b'erence')])))

 

934

                          (index, (b'ref', b'erence'), b'refdata', ((), ))},

 

935

                         set(index.iter_entries_prefix([(b'name', b'fin1'), (b'ref', b'erence')])))

929

936

        self.assertEqual({(index, (b'name', b'fin1'), b'data', (((b'ref', b'erence'),),)),

930

 

            (index, (b'name', b'fin2'), b'beta', ((), ))},

931

 

            set(index.iter_entries_prefix([(b'name', None)])))

 

937

                          (index, (b'name', b'fin2'), b'beta', ((), ))},

 

938

                         set(index.iter_entries_prefix([(b'name', None)])))

932

939

 

933

940

    def test_key_count_empty(self):

934

941

        index = self.make_index()

1045

1052

            ])

1046

1053

        parent_map = {}

1047

1054

        missing_keys = set()

1048

 

        search_keys = index._find_ancestors([key1], 0, parent_map, missing_keys)

 

1055

        search_keys = index._find_ancestors(

 

1056

            [key1], 0, parent_map, missing_keys)

1049

1057

        self.assertEqual({key1: (key2,)}, parent_map)

1050

1058

        self.assertEqual(set(), missing_keys)

1051

1059

        self.assertEqual({key2}, search_keys)

1102

1110

class TestCombinedGraphIndex(tests.TestCaseWithMemoryTransport):

1103

1111

 

1104

1112

    def make_index(self, name, ref_lists=0, key_elements=1, nodes=[]):

1105

 

        builder = _mod_index.GraphIndexBuilder(ref_lists, key_elements=key_elements)

 

1113

        builder = _mod_index.GraphIndexBuilder(

 

1114

            ref_lists, key_elements=key_elements)

1106

1115

        for key, value, references in nodes:

1107

1116

            builder.add_node(key, value, references)

1108

1117

        stream = builder.finish()

1128

1137

 

1129

1138

        # total_reloads, num_changed, num_unchanged

1130

1139

        reload_counter = [0, 0, 0]

 

1140

 

1131

1141

        def reload():

1132

1142

            reload_counter[0] += 1

1133

1143

            new_indices = [idx3]

1192

1202

        idx1 = self.make_index('name', nodes=[((b'name', ), b'data', ())])

1193

1203

        idx = _mod_index.CombinedGraphIndex([idx1])

1194

1204

        self.assertEqual([(idx1, (b'name', ), b'data')],

1195

 

            list(idx.iter_all_entries()))

 

1205

                         list(idx.iter_all_entries()))

1196

1206

 

1197

1207

    def test_iter_all_entries_two_indices(self):

1198

1208

        idx1 = self.make_index('name1', nodes=[((b'name', ), b'data', ())])

1218

1228

 

1219

1229

    def test_iter_key_prefix_2_key_element_refs(self):

1220

1230

        idx1 = self.make_index('1', 1, key_elements=2, nodes=[

1221

 

                ((b'name', b'fin1'), b'data', ([(b'ref', b'erence')], ))])

 

1231

            ((b'name', b'fin1'), b'data', ([(b'ref', b'erence')], ))])

1222

1232

        idx2 = self.make_index('2', 1, key_elements=2, nodes=[

1223

 

                ((b'name', b'fin2'), b'beta', ([], )),

1224

 

                ((b'ref', b'erence'), b'refdata', ([], ))])

 

1233

            ((b'name', b'fin2'), b'beta', ([], )),

 

1234

            ((b'ref', b'erence'), b'refdata', ([], ))])

1225

1235

        idx = _mod_index.CombinedGraphIndex([idx1, idx2])

1226

1236

        self.assertEqual({(idx1, (b'name', b'fin1'), b'data',

1227

 

                               (((b'ref', b'erence'),),)),

1228

 

                              (idx2, (b'ref', b'erence'), b'refdata', ((), ))},

 

1237

                           (((b'ref', b'erence'),),)),

 

1238

                          (idx2, (b'ref', b'erence'), b'refdata', ((), ))},

1229

1239

                         set(idx.iter_entries_prefix([(b'name', b'fin1'),

1230

 

                                                        (b'ref', b'erence')])))

 

1240

                                                      (b'ref', b'erence')])))

1231

1241

        self.assertEqual({(idx1, (b'name', b'fin1'), b'data',

1232

 

                               (((b'ref', b'erence'),),)),

1233

 

                              (idx2, (b'name', b'fin2'), b'beta', ((), ))},

 

1242

                           (((b'ref', b'erence'),),)),

 

1243

                          (idx2, (b'name', b'fin2'), b'beta', ((), ))},

1234

1244

                         set(idx.iter_entries_prefix([(b'name', None)])))

1235

1245

 

1236

1246

    def test_iter_nothing_empty(self):

1245

1255

    def test_iter_all_keys(self):

1246

1256

        idx1 = self.make_index('1', 1, nodes=[((b'name', ), b'data',

1247

1257

                                               ([(b'ref', )], ))])

1248

 

        idx2 = self.make_index('2', 1, nodes=[((b'ref', ), b'refdata', ((), ))])

 

1258

        idx2 = self.make_index(

 

1259

            '2', 1, nodes=[((b'ref', ), b'refdata', ((), ))])

1249

1260

        idx = _mod_index.CombinedGraphIndex([idx1, idx2])

1250

1261

        self.assertEqual({(idx1, (b'name', ), b'data', (((b'ref', ), ), )),

1251

 

                              (idx2, (b'ref', ), b'refdata', ((), ))},

 

1262

                          (idx2, (b'ref', ), b'refdata', ((), ))},

1252

1263

                         set(idx.iter_entries([(b'name', ), (b'ref', )])))

1253

1264

 

1254

1265

    def test_iter_all_keys_dup_entry(self):

1255

1266

        idx1 = self.make_index('1', 1, nodes=[((b'name', ), b'data',

1256

 

                                                 ([(b'ref', )], )),

1257

 

                                                ((b'ref', ), b'refdata', ([], ))])

1258

 

        idx2 = self.make_index('2', 1, nodes=[((b'ref', ), b'refdata', ([], ))])

 

1267

                                               ([(b'ref', )], )),

 

1268

                                              ((b'ref', ), b'refdata', ([], ))])

 

1269

        idx2 = self.make_index(

 

1270

            '2', 1, nodes=[((b'ref', ), b'refdata', ([], ))])

1259

1271

        idx = _mod_index.CombinedGraphIndex([idx1, idx2])

1260

1272

        self.assertEqual({(idx1, (b'name', ), b'data', (((b'ref',),),)),

1261

 

                              (idx1, (b'ref', ), b'refdata', ((), ))},

 

1273

                          (idx1, (b'ref', ), b'refdata', ((), ))},

1262

1274

                         set(idx.iter_entries([(b'name', ), (b'ref', )])))

1263

1275

 

1264

1276

    def test_iter_missing_entry_empty(self):

1361

1373

 

1362

1374

    def test_iter_entries_reloads_and_fails(self):

1363

1375

        index, reload_counter = self.make_combined_index_with_missing(

1364

 

                                    ['1', '2', '3'])

 

1376

            ['1', '2', '3'])

1365

1377

        self.assertListRaises(errors.NoSuchFile, index.iter_entries, [('3',)])

1366

1378

        self.assertEqual([2, 1, 1], reload_counter)

1367

1379

 

1391

1403

 

1392

1404

    def test_iter_all_entries_reloads_and_fails(self):

1393

1405

        index, reload_counter = self.make_combined_index_with_missing(

1394

 

                                    ['1', '2', '3'])

 

1406

            ['1', '2', '3'])

1395

1407

        self.assertListRaises(errors.NoSuchFile, index.iter_all_entries)

1396

1408

 

1397

1409

    def test_iter_entries_prefix_reloads(self):

1415

1427

        index, reload_counter = self.make_combined_index_with_missing()

1416

1428

        index._reload_func = None

1417

1429

        self.assertListRaises(errors.NoSuchFile, index.iter_entries_prefix,

1418

 

                                                 [(b'1',)])

 

1430

                              [(b'1',)])

1419

1431

 

1420

1432

    def test_iter_entries_prefix_reloads_and_fails(self):

1421

1433

        index, reload_counter = self.make_combined_index_with_missing(

1422

 

                                    ['1', '2', '3'])

 

1434

            ['1', '2', '3'])

1423

1435

        self.assertListRaises(errors.NoSuchFile, index.iter_entries_prefix,

1424

 

                                                 [(b'1',)])

1425

 

 

 

1436

                              [(b'1',)])

1426

1437

 

1427

1438

    def make_index_with_simple_nodes(self, name, num_nodes=1):

1428

1439

        """Make an index named after 'name', with keys named after 'name' too.

1431

1442

        """

1432

1443

        nodes = [

1433

1444

            ((('index-%s-key-%s' % (name, n)).encode('ascii'),), b'', ())

1434

 

            for n in range(1, num_nodes+1)]

 

1445

            for n in range(1, num_nodes + 1)]

1435

1446

        return self.make_index('index-%s' % name, 0, nodes=nodes)

1436

1447

 

1437

1448

    def test_reorder_after_iter_entries(self):

1570

1581

class TestInMemoryGraphIndex(tests.TestCaseWithMemoryTransport):

1571

1582

 

1572

1583

    def make_index(self, ref_lists=0, key_elements=1, nodes=[]):

1573

 

        result = _mod_index.InMemoryGraphIndex(ref_lists, key_elements=key_elements)

 

1584

        result = _mod_index.InMemoryGraphIndex(

 

1585

            ref_lists, key_elements=key_elements)

1574

1586

        result.add_nodes(nodes)

1575

1587

        return result

1576

1588

 

1587

1599

    def test_add_nodes(self):

1588

1600

        index = self.make_index(1)

1589

1601

        index.add_nodes([((b'name', ), b'data', ([],))])

1590

 

        index.add_nodes([((b'name2', ), b'', ([],)), ((b'name3', ), b'', ([(b'r', )],))])

 

1602

        index.add_nodes([((b'name2', ), b'', ([],)),

 

1603

                         ((b'name3', ), b'', ([(b'r', )],))])

1591

1604

        self.assertEqual({

1592

1605

            (index, (b'name', ), b'data', ((),)),

1593

1606

            (index, (b'name2', ), b'', ((),)),

1601

1614

    def test_iter_all_entries_simple(self):

1602

1615

        index = self.make_index(nodes=[((b'name', ), b'data')])

1603

1616

        self.assertEqual([(index, (b'name', ), b'data')],

1604

 

            list(index.iter_all_entries()))

 

1617

                         list(index.iter_all_entries()))

1605

1618

 

1606

1619

    def test_iter_all_entries_references(self):

1607

1620

        index = self.make_index(1, nodes=[

1608

1621

            ((b'name', ), b'data', ([(b'ref', )], )),

1609

1622

            ((b'ref', ), b'refdata', ([], ))])

1610

1623

        self.assertEqual({(index, (b'name', ), b'data', (((b'ref', ),),)),

1611

 

            (index, (b'ref', ), b'refdata', ((), ))},

1612

 

            set(index.iter_all_entries()))

 

1624

                          (index, (b'ref', ), b'refdata', ((), ))},

 

1625

                         set(index.iter_all_entries()))

1613

1626

 

1614

1627

    def test_iteration_absent_skipped(self):

1615

1628

        index = self.make_index(1, nodes=[

1616

1629

            ((b'name', ), b'data', ([(b'ref', )], ))])

1617

1630

        self.assertEqual({(index, (b'name', ), b'data', (((b'ref',),),))},

1618

 

            set(index.iter_all_entries()))

 

1631

                         set(index.iter_all_entries()))

1619

1632

        self.assertEqual({(index, (b'name', ), b'data', (((b'ref',),),))},

1620

 

            set(index.iter_entries([(b'name', )])))

 

1633

                         set(index.iter_entries([(b'name', )])))

1621

1634

        self.assertEqual([], list(index.iter_entries([(b'ref', )])))

1622

1635

 

1623

1636

    def test_iter_all_keys(self):

1625

1638

            ((b'name', ), b'data', ([(b'ref', )], )),

1626

1639

            ((b'ref', ), b'refdata', ([], ))])

1627

1640

        self.assertEqual({(index, (b'name', ), b'data', (((b'ref',),),)),

1628

 

            (index, (b'ref', ), b'refdata', ((), ))},

1629

 

            set(index.iter_entries([(b'name', ), (b'ref', )])))

 

1641

                          (index, (b'ref', ), b'refdata', ((), ))},

 

1642

                         set(index.iter_entries([(b'name', ), (b'ref', )])))

1630

1643

 

1631

1644

    def test_iter_key_prefix_1_key_element_no_refs(self):

1632

 

        index = self.make_index( nodes=[

 

1645

        index = self.make_index(nodes=[

1633

1646

            ((b'name', ), b'data'),

1634

1647

            ((b'ref', ), b'refdata')])

1635

1648

        self.assertEqual({(index, (b'name', ), b'data'),

1636

 

            (index, (b'ref', ), b'refdata')},

1637

 

            set(index.iter_entries_prefix([(b'name', ), (b'ref', )])))

 

1649

                          (index, (b'ref', ), b'refdata')},

 

1650

                         set(index.iter_entries_prefix([(b'name', ), (b'ref', )])))

1638

1651

 

1639

1652

    def test_iter_key_prefix_1_key_element_refs(self):

1640

1653

        index = self.make_index(1, nodes=[

1641

1654

            ((b'name', ), b'data', ([(b'ref', )], )),

1642

1655

            ((b'ref', ), b'refdata', ([], ))])

1643

1656

        self.assertEqual({(index, (b'name', ), b'data', (((b'ref',),),)),

1644

 

            (index, (b'ref', ), b'refdata', ((), ))},

1645

 

            set(index.iter_entries_prefix([(b'name', ), (b'ref', )])))

 

1657

                          (index, (b'ref', ), b'refdata', ((), ))},

 

1658

                         set(index.iter_entries_prefix([(b'name', ), (b'ref', )])))

1646

1659

 

1647

1660

    def test_iter_key_prefix_2_key_element_no_refs(self):

1648

1661

        index = self.make_index(key_elements=2, nodes=[

1650

1663

            ((b'name', b'fin2'), b'beta'),

1651

1664

            ((b'ref', b'erence'), b'refdata')])

1652

1665

        self.assertEqual({(index, (b'name', b'fin1'), b'data'),

1653

 

            (index, (b'ref', b'erence'), b'refdata')},

1654

 

            set(index.iter_entries_prefix([(b'name', b'fin1'), (b'ref', b'erence')])))

 

1666

                          (index, (b'ref', b'erence'), b'refdata')},

 

1667

                         set(index.iter_entries_prefix([(b'name', b'fin1'), (b'ref', b'erence')])))

1655

1668

        self.assertEqual({(index, (b'name', b'fin1'), b'data'),

1656

 

            (index, (b'name', b'fin2'), b'beta')},

1657

 

            set(index.iter_entries_prefix([(b'name', None)])))

 

1669

                          (index, (b'name', b'fin2'), b'beta')},

 

1670

                         set(index.iter_entries_prefix([(b'name', None)])))

1658

1671

 

1659

1672

    def test_iter_key_prefix_2_key_element_refs(self):

1660

1673

        index = self.make_index(1, key_elements=2, nodes=[

1662

1675

            ((b'name', b'fin2'), b'beta', ([], )),

1663

1676

            ((b'ref', b'erence'), b'refdata', ([], ))])

1664

1677

        self.assertEqual({(index, (b'name', b'fin1'), b'data', (((b'ref', b'erence'),),)),

1665

 

            (index, (b'ref', b'erence'), b'refdata', ((), ))},

1666

 

            set(index.iter_entries_prefix([(b'name', b'fin1'), (b'ref', b'erence')])))

 

1678

                          (index, (b'ref', b'erence'), b'refdata', ((), ))},

 

1679

                         set(index.iter_entries_prefix([(b'name', b'fin1'), (b'ref', b'erence')])))

1667

1680

        self.assertEqual({(index, (b'name', b'fin1'), b'data', (((b'ref', b'erence'),),)),

1668

 

            (index, (b'name', b'fin2'), b'beta', ((), ))},

1669

 

            set(index.iter_entries_prefix([(b'name', None)])))

 

1681

                          (index, (b'name', b'fin2'), b'beta', ((), ))},

 

1682

                         set(index.iter_entries_prefix([(b'name', None)])))

1670

1683

 

1671

1684

    def test_iter_nothing_empty(self):

1672

1685

        index = self.make_index()

1701

1714

 

1702

1715

    def make_index(self, ref_lists=1, key_elements=2, nodes=[],

1703

1716

                   add_callback=False):

1704

 

        result = _mod_index.InMemoryGraphIndex(ref_lists, key_elements=key_elements)

 

1717

        result = _mod_index.InMemoryGraphIndex(

 

1718

            ref_lists, key_elements=key_elements)

1705

1719

        result.add_nodes(nodes)

1706

1720

        if add_callback:

1707

1721

            add_nodes_callback = result.add_nodes

1716

1730

        index, adapter = self.make_index(add_callback=True)

1717

1731

        adapter.add_node((b'key',), b'value', (((b'ref',),),))

1718

1732

        self.assertEqual({(index, (b'prefix', b'key'), b'value',

1719

 

                               (((b'prefix', b'ref'),),))},

1720

 

            set(index.iter_all_entries()))

 

1733

                           (((b'prefix', b'ref'),),))},

 

1734

                         set(index.iter_all_entries()))

1721

1735

 

1722

1736

    def test_add_nodes(self):

1723

1737

        index, adapter = self.make_index(add_callback=True)

1738

1752

    def test_construct_with_callback(self):

1739

1753

        idx = _mod_index.InMemoryGraphIndex()

1740

1754

        adapter = _mod_index.GraphIndexPrefixAdapter(idx, (b'prefix', ), 1,

1741

 

                                                idx.add_nodes)

 

1755

                                                     idx.add_nodes)

1742

1756

 

1743

1757

    def test_iter_all_entries_cross_prefix_map_errors(self):

1744

1758

        index, adapter = self.make_index(nodes=[

1745

1759

            ((b'prefix', b'key1'), b'data1', (((b'prefixaltered', b'key2'),),))])

1746

 

        self.assertRaises(_mod_index.BadIndexData, list, adapter.iter_all_entries())

 

1760

        self.assertRaises(_mod_index.BadIndexData, list,

 

1761

                          adapter.iter_all_entries())

1747

1762

 

1748

1763

    def test_iter_all_entries(self):

1749

1764

        index, adapter = self.make_index(nodes=[

1751

1766

            ((b'prefix', b'key1'), b'data1', ((), )),

1752

1767

            ((b'prefix', b'key2'), b'data2', (((b'prefix', b'key1'),),))])

1753

1768

        self.assertEqual({(index, (b'key1', ), b'data1', ((),)),

1754

 

            (index, (b'key2', ), b'data2', (((b'key1',),),))},

1755

 

            set(adapter.iter_all_entries()))

 

1769

                          (index, (b'key2', ), b'data2', (((b'key1',),),))},

 

1770

                         set(adapter.iter_all_entries()))

1756

1771

 

1757

1772

    def test_iter_entries(self):

1758

1773

        index, adapter = self.make_index(nodes=[

1761

1776

            ((b'prefix', b'key2'), b'data2', (((b'prefix', b'key1'),),))])

1762

1777

        # ask for many - get all

1763

1778

        self.assertEqual({(index, (b'key1', ), b'data1', ((),)),

1764

 

            (index, (b'key2', ), b'data2', (((b'key1', ),),))},

1765

 

            set(adapter.iter_entries([(b'key1', ), (b'key2', )])))

 

1779

                          (index, (b'key2', ), b'data2', (((b'key1', ),),))},

 

1780

                         set(adapter.iter_entries([(b'key1', ), (b'key2', )])))

1766

1781

        # ask for one, get one

1767

1782

        self.assertEqual({(index, (b'key1', ), b'data1', ((),))},

1768

 

            set(adapter.iter_entries([(b'key1', )])))

 

1783

                         set(adapter.iter_entries([(b'key1', )])))

1769

1784

        # ask for missing, get none

1770

1785

        self.assertEqual(set(),

1771

 

            set(adapter.iter_entries([(b'key3', )])))

 

1786

                         set(adapter.iter_entries([(b'key3', )])))

1772

1787

 

1773

1788

    def test_iter_entries_prefix(self):

1774

1789

        index, adapter = self.make_index(key_elements=3, nodes=[

1777

1792

            ((b'prefix', b'prefix2', b'key2'), b'data2', (((b'prefix', b'prefix2', b'key1'),),))])

1778

1793

        # ask for a prefix, get the results for just that prefix, adjusted.

1779

1794

        self.assertEqual({(index, (b'prefix2', b'key1', ), b'data1', ((),)),

1780

 

            (index, (b'prefix2', b'key2', ), b'data2', (((b'prefix2', b'key1', ),),))},

1781

 

            set(adapter.iter_entries_prefix([(b'prefix2', None)])))

 

1795

                          (index, (b'prefix2', b'key2', ), b'data2', (((b'prefix2', b'key1', ),),))},

 

1796

                         set(adapter.iter_entries_prefix([(b'prefix2', None)])))

1782

1797

 

1783

1798

    def test_key_count_no_matching_keys(self):

1784

1799

        index, adapter = self.make_index(nodes=[

1795

1810

    def test_validate(self):

1796

1811

        index, adapter = self.make_index()

1797

1812

        calls = []

 

1813

 

1798

1814

        def validate():

1799

1815

            calls.append('called')

1800

1816

        index.validate = validate

• Older »

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