/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to breezy/tests/test_index.py

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

Show diffs side-by-side

added

removed

breezy/tests/test_index.py

16

16

 

17

17

"""Tests for indices."""

18

18

 

19

 

from breezy import (

 

19

from .. import (

20

20

    errors,

21

21

    index,

22

22

    tests,

738

738

        index = self.make_index(1, nodes=[

739

739

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

740

740

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

741

 

        self.assertEqual(set([(index, ('name', ), 'data', ((('ref',),),)),

742

 

            (index, ('ref', ), 'refdata', ((), ))]),

 

741

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

 

742

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

743

743

            set(index.iter_all_entries()))

744

744

 

745

745

    def test_iter_entries_buffers_once(self):

746

746

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

747

747

        # reset the transport log

748

748

        del index._transport._activity[:]

749

 

        self.assertEqual(set([(index, self.make_key(1), self.make_value(1))]),

 

749

        self.assertEqual({(index, self.make_key(1), self.make_value(1))},

750

750

                         set(index.iter_entries([self.make_key(1)])))

751

751

        # We should have requested reading the header bytes

752

752

        # But not needed any more than that because it would have triggered a

788

788

        index = self.make_index(1, nodes=[

789

789

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

790

790

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

791

 

        self.assertEqual(set([(index, ('name', ), 'data', ((('ref',),('ref',)),)),

792

 

            (index, ('ref', ), 'refdata', ((), ))]),

 

791

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

 

792

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

793

793

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

794

794

 

795

795

    def test_iter_entries_references_2_refs_resolved(self):

796

796

        index = self.make_index(2, nodes=[

797

797

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

798

798

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

799

 

        self.assertEqual(set([(index, ('name', ), 'data', ((('ref',),), (('ref',),))),

800

 

            (index, ('ref', ), 'refdata', ((), ()))]),

 

799

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

 

800

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

801

801

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

802

802

 

803

803

    def test_iteration_absent_skipped(self):

804

804

        index = self.make_index(1, nodes=[

805

805

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

806

 

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

 

806

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

807

807

            set(index.iter_all_entries()))

808

 

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

 

808

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

809

809

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

810

810

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

811

811

 

812

812

    def test_iteration_absent_skipped_2_element_keys(self):

813

813

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

814

814

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

815

 

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

 

815

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

816

816

            set(index.iter_all_entries()))

817

 

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

 

817

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

818

818

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

819

819

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

820

820

 

822

822

        index = self.make_index(1, nodes=[

823

823

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

824

824

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

825

 

        self.assertEqual(set([(index, ('name', ), 'data', ((('ref',),),)),

826

 

            (index, ('ref', ), 'refdata', ((), ))]),

 

825

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

 

826

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

827

827

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

828

828

 

829

829

    def test_iter_nothing_empty(self):

858

858

        index = self.make_index( nodes=[

859

859

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

860

860

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

861

 

        self.assertEqual(set([(index, ('name', ), 'data'),

862

 

            (index, ('ref', ), 'refdata')]),

 

861

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

 

862

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

863

863

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

864

864

 

865

865

    def test_iter_key_prefix_1_key_element_refs(self):

866

866

        index = self.make_index(1, nodes=[

867

867

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

868

868

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

869

 

        self.assertEqual(set([(index, ('name', ), 'data', ((('ref',),),)),

870

 

            (index, ('ref', ), 'refdata', ((), ))]),

 

869

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

 

870

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

871

871

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

872

872

 

873

873

    def test_iter_key_prefix_2_key_element_no_refs(self):

875

875

            (('name', 'fin1'), 'data', ()),

876

876

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

877

877

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

878

 

        self.assertEqual(set([(index, ('name', 'fin1'), 'data'),

879

 

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

 

878

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

 

879

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

880

880

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

881

 

        self.assertEqual(set([(index, ('name', 'fin1'), 'data'),

882

 

            (index, ('name', 'fin2'), 'beta')]),

 

881

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

 

882

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

883

883

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

884

884

 

885

885

    def test_iter_key_prefix_2_key_element_refs(self):

887

887

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

888

888

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

889

889

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

890

 

        self.assertEqual(set([(index, ('name', 'fin1'), 'data', ((('ref', 'erence'),),)),

891

 

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

 

890

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

 

891

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

892

892

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

893

 

        self.assertEqual(set([(index, ('name', 'fin1'), 'data', ((('ref', 'erence'),),)),

894

 

            (index, ('name', 'fin2'), 'beta', ((), ))]),

 

893

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

 

894

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

895

895

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

896

896

 

897

897

    def test_key_count_empty(self):

984

984

        missing_key = ('missing',)

985

985

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

986

986

            (('key',), 'value', ([missing_key],))])

987

 

        self.assertEqual(set([missing_key]), index.external_references(0))

 

987

        self.assertEqual({missing_key}, index.external_references(0))

988

988

 

989

989

    def test_external_references_multiple_ref_lists(self):

990

990

        missing_key = ('missing',)

991

991

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

992

992

            (('key',), 'value', ([], [missing_key]))])

993

993

        self.assertEqual(set([]), index.external_references(0))

994

 

        self.assertEqual(set([missing_key]), index.external_references(1))

 

994

        self.assertEqual({missing_key}, index.external_references(1))

995

995

 

996

996

    def test_external_references_two_records(self):

997

997

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

1012

1012

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

1013

1013

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

1014

1014

        self.assertEqual(set(), missing_keys)

1015

 

        self.assertEqual(set([key2]), search_keys)

 

1015

        self.assertEqual({key2}, search_keys)

1016

1016

        search_keys = index._find_ancestors(search_keys, 0, parent_map,

1017

1017

                                            missing_keys)

1018

1018

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

1032

1032

        search_keys = index._find_ancestors([key2, key3], 0, parent_map,

1033

1033

                                            missing_keys)

1034

1034

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

1035

 

        self.assertEqual(set([key3]), missing_keys)

 

1035

        self.assertEqual({key3}, missing_keys)

1036

1036

        self.assertEqual(set(), search_keys)

1037

1037

 

1038

1038

    def test__find_ancestors_dont_search_known(self):

1187

1187

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

1188

1188

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

1189

1189

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

1190

 

        self.assertEqual(set([(idx1, ('name', 'fin1'), 'data',

 

1190

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

1191

1191

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

1192

 

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

 

1192

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

1193

1193

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

1194

1194

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

1195

 

        self.assertEqual(set([(idx1, ('name', 'fin1'), 'data',

 

1195

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

1196

1196

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

1197

 

                              (idx2, ('name', 'fin2'), 'beta', ((), ))]),

 

1197

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

1198

1198

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

1199

1199

 

1200

1200

    def test_iter_nothing_empty(self):

1211

1211

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

1212

1212

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

1213

1213

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

1214

 

        self.assertEqual(set([(idx1, ('name', ), 'data', ((('ref', ), ), )),

1215

 

                              (idx2, ('ref', ), 'refdata', ((), ))]),

 

1214

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

 

1215

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

1216

1216

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

1217

1217

 

1218

1218

    def test_iter_all_keys_dup_entry(self):

1221

1221

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

1222

1222

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

1223

1223

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

1224

 

        self.assertEqual(set([(idx1, ('name', ), 'data', ((('ref',),),)),

1225

 

                              (idx1, ('ref', ), 'refdata', ((), ))]),

 

1224

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

 

1225

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

1226

1226

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

1227

1227

 

1228

1228

    def test_iter_missing_entry_empty(self):

1491

1491

        # eventually converge

1492

1492

        parent_map, missing_keys = c_index.find_ancestry([key4], 0)

1493

1493

        self.assertEqual({}, parent_map)

1494

 

        self.assertEqual(set([key4]), missing_keys)

 

1494

        self.assertEqual({key4}, missing_keys)

1495

1495

 

1496

1496

    def test_find_ancestors_no_indexes(self):

1497

1497

        c_index = index.CombinedGraphIndex([])

1498

1498

        key1 = ('key-1',)

1499

1499

        parent_map, missing_keys = c_index.find_ancestry([key1], 0)

1500

1500

        self.assertEqual({}, parent_map)

1501

 

        self.assertEqual(set([key1]), missing_keys)

 

1501

        self.assertEqual({key1}, missing_keys)

1502

1502

 

1503

1503

    def test_find_ancestors_ghost_parent(self):

1504

1504

        key1 = ('key-1',)

1518

1518

        parent_map, missing_keys = c_index.find_ancestry([key4], 0)

1519

1519

        self.assertEqual({key4: (key2, key3), key2: (key1,), key1: ()},

1520

1520

                         parent_map)

1521

 

        self.assertEqual(set([key3]), missing_keys)

 

1521

        self.assertEqual({key3}, missing_keys)

1522

1522

 

1523

1523

    def test__find_ancestors_empty_index(self):

1524

1524

        idx = self.make_index('test', ref_lists=1, key_elements=1, nodes=[])

1528

1528

                                          missing_keys)

1529

1529

        self.assertEqual(set(), search_keys)

1530

1530

        self.assertEqual({}, parent_map)

1531

 

        self.assertEqual(set([('one',), ('two',)]), missing_keys)

 

1531

        self.assertEqual({('one',), ('two',)}, missing_keys)

1532

1532

 

1533

1533

 

1534

1534

class TestInMemoryGraphIndex(tests.TestCaseWithMemoryTransport):

1542

1542

        index = self.make_index(0)

1543

1543

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

1544

1544

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

1545

 

        self.assertEqual(set([

 

1545

        self.assertEqual({

1546

1546

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

1547

1547

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

1548

1548

            (index, ('name3', ), ''),

1549

 

            ]), set(index.iter_all_entries()))

 

1549

            }, set(index.iter_all_entries()))

1550

1550

 

1551

1551

    def test_add_nodes(self):

1552

1552

        index = self.make_index(1)

1553

1553

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

1554

1554

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

1555

 

        self.assertEqual(set([

 

1555

        self.assertEqual({

1556

1556

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

1557

1557

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

1558

1558

            (index, ('name3', ), '', ((('r', ), ), )),

1559

 

            ]), set(index.iter_all_entries()))

 

1559

            }, set(index.iter_all_entries()))

1560

1560

 

1561

1561

    def test_iter_all_entries_empty(self):

1562

1562

        index = self.make_index()

1571

1571

        index = self.make_index(1, nodes=[

1572

1572

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

1573

1573

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

1574

 

        self.assertEqual(set([(index, ('name', ), 'data', ((('ref', ),),)),

1575

 

            (index, ('ref', ), 'refdata', ((), ))]),

 

1574

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

 

1575

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

1576

1576

            set(index.iter_all_entries()))

1577

1577

 

1578

1578

    def test_iteration_absent_skipped(self):

1579

1579

        index = self.make_index(1, nodes=[

1580

1580

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

1581

 

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

 

1581

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

1582

1582

            set(index.iter_all_entries()))

1583

 

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

 

1583

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

1584

1584

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

1585

1585

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

1586

1586

 

1588

1588

        index = self.make_index(1, nodes=[

1589

1589

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

1590

1590

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

1591

 

        self.assertEqual(set([(index, ('name', ), 'data', ((('ref',),),)),

1592

 

            (index, ('ref', ), 'refdata', ((), ))]),

 

1591

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

 

1592

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

1593

1593

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

1594

1594

 

1595

1595

    def test_iter_key_prefix_1_key_element_no_refs(self):

1596

1596

        index = self.make_index( nodes=[

1597

1597

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

1598

1598

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

1599

 

        self.assertEqual(set([(index, ('name', ), 'data'),

1600

 

            (index, ('ref', ), 'refdata')]),

 

1599

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

 

1600

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

1601

1601

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

1602

1602

 

1603

1603

    def test_iter_key_prefix_1_key_element_refs(self):

1604

1604

        index = self.make_index(1, nodes=[

1605

1605

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

1606

1606

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

1607

 

        self.assertEqual(set([(index, ('name', ), 'data', ((('ref',),),)),

1608

 

            (index, ('ref', ), 'refdata', ((), ))]),

 

1607

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

 

1608

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

1609

1609

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

1610

1610

 

1611

1611

    def test_iter_key_prefix_2_key_element_no_refs(self):

1613

1613

            (('name', 'fin1'), 'data'),

1614

1614

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

1615

1615

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

1616

 

        self.assertEqual(set([(index, ('name', 'fin1'), 'data'),

1617

 

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

 

1616

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

 

1617

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

1618

1618

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

1619

 

        self.assertEqual(set([(index, ('name', 'fin1'), 'data'),

1620

 

            (index, ('name', 'fin2'), 'beta')]),

 

1619

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

 

1620

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

1621

1621

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

1622

1622

 

1623

1623

    def test_iter_key_prefix_2_key_element_refs(self):

1625

1625

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

1626

1626

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

1627

1627

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

1628

 

        self.assertEqual(set([(index, ('name', 'fin1'), 'data', ((('ref', 'erence'),),)),

1629

 

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

 

1628

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

 

1629

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

1630

1630

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

1631

 

        self.assertEqual(set([(index, ('name', 'fin1'), 'data', ((('ref', 'erence'),),)),

1632

 

            (index, ('name', 'fin2'), 'beta', ((), ))]),

 

1631

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

 

1632

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

1633

1633

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

1634

1634

 

1635

1635

    def test_iter_nothing_empty(self):

1679

1679

    def test_add_node(self):

1680

1680

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

1681

1681

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

1682

 

        self.assertEqual(set([(index, ('prefix', 'key'), 'value',

1683

 

                               ((('prefix', 'ref'),),))]),

 

1682

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

 

1683

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

1684

1684

            set(index.iter_all_entries()))

1685

1685

 

1686

1686

    def test_add_nodes(self):

1689

1689

            (('key',), 'value', ((('ref',),),)),

1690

1690

            (('key2',), 'value2', ((),)),

1691

1691

            ))

1692

 

        self.assertEqual(set([

 

1692

        self.assertEqual({

1693

1693

            (index, ('prefix', 'key2'), 'value2', ((),)),

1694

1694

            (index, ('prefix', 'key'), 'value', ((('prefix', 'ref'),),))

1695

 

            ]),

 

1695

            },

1696

1696

            set(index.iter_all_entries()))

1697

1697

 

1698

1698

    def test_construct(self):

1714

1714

            (('notprefix', 'key1'), 'data', ((), )),

1715

1715

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

1716

1716

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

1717

 

        self.assertEqual(set([(index, ('key1', ), 'data1', ((),)),

1718

 

            (index, ('key2', ), 'data2', ((('key1',),),))]),

 

1717

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

 

1718

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

1719

1719

            set(adapter.iter_all_entries()))

1720

1720

 

1721

1721

    def test_iter_entries(self):

1724

1724

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

1725

1725

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

1726

1726

        # ask for many - get all

1727

 

        self.assertEqual(set([(index, ('key1', ), 'data1', ((),)),

1728

 

            (index, ('key2', ), 'data2', ((('key1', ),),))]),

 

1727

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

 

1728

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

1729

1729

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

1730

1730

        # ask for one, get one

1731

 

        self.assertEqual(set([(index, ('key1', ), 'data1', ((),))]),

 

1731

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

1732

1732

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

1733

1733

        # ask for missing, get none

1734

1734

        self.assertEqual(set(),

1740

1740

            (('prefix', 'prefix2', 'key1'), 'data1', ((), )),

1741

1741

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

1742

1742

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

1743

 

        self.assertEqual(set([(index, ('prefix2', 'key1', ), 'data1', ((),)),

1744

 

            (index, ('prefix2', 'key2', ), 'data2', ((('prefix2', 'key1', ),),))]),

 

1743

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

 

1744

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

1745

1745

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

1746

1746

 

1747

1747

    def test_key_count_no_matching_keys(self):

• Older »

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