← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_knit.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2008-03-26 03:06:52 UTC
  • mfrom: (3287.5.10 integration)
  • Revision ID: pqm@pqm.ubuntu.com-20080326030652-vgwdkwda9mi8s200
Deprecate VersionedFile.get_parents. (Robert Collins)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_knit.py
554
554
            "version option 0 1 .%s :" % (utf8_revision_id,)
555
555
            ])
556
556
        index = self.get_knit_index(transport, "filename", "r")
557
 
        self.assertEqual([utf8_revision_id],
 
557
        self.assertEqual((utf8_revision_id,),
558
558
            index.get_parents_with_ghosts("version"))
559
559
 
560
560
    def test_read_ignore_corrupted_lines(self):
588
588
        self.assertEqual("1", index._version_list_to_index(["version"]))
589
589
        self.assertEqual((None, 3, 4), index.get_position("version"))
590
590
        self.assertEqual(["options3"], index.get_options("version"))
591
 
        self.assertEqual(["parent", "other"],
 
591
        self.assertEqual(("parent", "other"),
592
592
            index.get_parents_with_ghosts("version"))
593
593
 
594
594
    def test_read_compressed_parents(self):
599
599
            "c option 0 1 1 0 :",
600
600
            ])
601
601
        index = self.get_knit_index(transport, "filename", "r")
602
 
        self.assertEqual(["a"], index.get_parents("b"))
603
 
        self.assertEqual(["b", "a"], index.get_parents("c"))
 
602
        self.assertEqual({"b":("a",), "c":("b", "a")},
 
603
            index.get_parent_map(["b", "c"]))
604
604
 
605
605
    def test_write_utf8_version_id(self):
606
606
        unicode_revision_id = u"version-\N{CYRILLIC CAPITAL LETTER A}"
634
634
        self.assertEqual([], index.get_graph())
635
635
 
636
636
        index.add_version("a", ["option"], (None, 0, 1), ["b"])
637
 
        self.assertEqual([("a", ["b"])], index.get_graph())
 
637
        self.assertEqual([("a", ("b",))], index.get_graph())
638
638
 
639
639
        index.add_version("c", ["option"], (None, 0, 1), ["d"])
640
 
        self.assertEqual([("a", ["b"]), ("c", ["d"])],
 
640
        self.assertEqual([("a", ("b",)), ("c", ("d",))],
641
641
            sorted(index.get_graph()))
642
642
 
643
643
    def test_get_ancestry(self):
771
771
        self.assertEqual(1, index.num_versions())
772
772
        self.assertEqual((None, 0, 1), index.get_position("a"))
773
773
        self.assertEqual(["option"], index.get_options("a"))
774
 
        self.assertEqual(["b"], index.get_parents_with_ghosts("a"))
 
774
        self.assertEqual(("b",), index.get_parents_with_ghosts("a"))
775
775
 
776
776
        index.add_version("a", ["opt"], (None, 1, 2), ["c"])
777
777
        self.assertEqual(("append_bytes",
781
781
        self.assertEqual(1, index.num_versions())
782
782
        self.assertEqual((None, 1, 2), index.get_position("a"))
783
783
        self.assertEqual(["opt"], index.get_options("a"))
784
 
        self.assertEqual(["c"], index.get_parents_with_ghosts("a"))
 
784
        self.assertEqual(("c",), index.get_parents_with_ghosts("a"))
785
785
 
786
786
        index.add_version("b", ["option"], (None, 2, 3), ["a"])
787
787
        self.assertEqual(("append_bytes",
791
791
        self.assertEqual(2, index.num_versions())
792
792
        self.assertEqual((None, 2, 3), index.get_position("b"))
793
793
        self.assertEqual(["option"], index.get_options("b"))
794
 
        self.assertEqual(["a"], index.get_parents_with_ghosts("b"))
 
794
        self.assertEqual(("a",), index.get_parents_with_ghosts("b"))
795
795
 
796
796
    def test_add_versions(self):
797
797
        transport = MockTransport([
816
816
        self.assertEqual((None, 2, 3), index.get_position("b"))
817
817
        self.assertEqual(["opt"], index.get_options("a"))
818
818
        self.assertEqual(["option"], index.get_options("b"))
819
 
        self.assertEqual(["c"], index.get_parents_with_ghosts("a"))
820
 
        self.assertEqual(["a"], index.get_parents_with_ghosts("b"))
 
819
        self.assertEqual(("c",), index.get_parents_with_ghosts("a"))
 
820
        self.assertEqual(("a",), index.get_parents_with_ghosts("b"))
821
821
 
822
822
    def test_add_versions_random_id_is_accepted(self):
823
823
        transport = MockTransport([
902
902
        self.assertEqual(["opt1"], index.get_options("a"))
903
903
        self.assertEqual(["opt2", "opt3"], index.get_options("b"))
904
904
 
905
 
    def test_get_parents(self):
 
905
    def test_get_parent_map(self):
906
906
        transport = MockTransport([
907
907
            _KnitIndex.HEADER,
908
908
            "a option 0 1 :",
911
911
            ])
912
912
        index = self.get_knit_index(transport, "filename", "r")
913
913
 
914
 
        self.assertEqual([], index.get_parents("a"))
915
 
        self.assertEqual(["a", "c"], index.get_parents("b"))
916
 
        self.assertEqual(["b", "a"], index.get_parents("c"))
 
914
        self.assertEqual({
 
915
            "a":(),
 
916
            "b":("a", "c"),
 
917
            "c":("b", "a", "e"),
 
918
            }, index.get_parent_map(["a", "b", "c"]))
917
919
 
918
920
    def test_get_parents_with_ghosts(self):
919
921
        transport = MockTransport([
924
926
            ])
925
927
        index = self.get_knit_index(transport, "filename", "r")
926
928
 
927
 
        self.assertEqual([], index.get_parents_with_ghosts("a"))
928
 
        self.assertEqual(["a", "c"], index.get_parents_with_ghosts("b"))
929
 
        self.assertEqual(["b", "a", "e"],
 
929
        self.assertEqual((), index.get_parents_with_ghosts("a"))
 
930
        self.assertEqual(("a", "c"), index.get_parents_with_ghosts("b"))
 
931
        self.assertEqual(("b", "a", "e"),
930
932
            index.get_parents_with_ghosts("c"))
931
933
 
932
934
    def test_check_versions_present(self):
1221
1223
        """Store in knit with parents"""
1222
1224
        k = self.make_test_knit()
1223
1225
        self.add_stock_one_and_one_a(k)
1224
 
        self.assertEquals(k.get_parents('text-1'), [])
1225
 
        self.assertEquals(k.get_parents('text-1a'), ['text-1'])
 
1226
        self.assertEqual({'text-1':(), 'text-1a':('text-1',)},
 
1227
            k.get_parent_map(['text-1', 'text-1a']))
1226
1228
 
1227
1229
    def test_ancestry(self):
1228
1230
        """Store in knit with parents"""
1485
1487
        # and when reading it revid3 should now appear.
1486
1488
        knit = KnitVersionedFile('test', get_transport('.'), access_mode='r')
1487
1489
        self.assertEqual(['revid', 'revid2', 'revid3'], knit.versions())
1488
 
        self.assertEqual(['revid2'], knit.get_parents('revid3'))
 
1490
        self.assertEqual({'revid3':('revid2',)}, knit.get_parent_map(['revid3']))
1489
1491
 
1490
1492
    def test_delay_create(self):
1491
1493
        """Test that passing delay_create=True creates files late"""
1601
1603
            ]
1602
1604
        expected_data_list = [
1603
1605
            # version, options, length, parents
1604
 
            ('text-a', ['fulltext'], 122, []),
 
1606
            ('text-a', ['fulltext'], 122, ()),
1605
1607
           ]
1606
1608
        for version_id, parents, lines in test_data:
1607
1609
            k1.add_lines(version_id, parents, split_lines(lines))
1630
1632
            ]
1631
1633
        expected_data_list = [
1632
1634
            # version, options, length, parents
1633
 
            ('text-m', ['line-delta'], 84, ['text-b', 'text-d']),
 
1635
            ('text-m', ['line-delta'], 84, ('text-b', 'text-d')),
1634
1636
            ]
1635
1637
        for version_id, parents, lines in test_data:
1636
1638
            k1.add_lines(version_id, parents, split_lines(lines))
1660
1662
        original_versions = k1.versions
1661
1663
        k1.versions = lambda: reversed(original_versions())
1662
1664
        expected_data_list = [
1663
 
            ('text-a', ['fulltext'], 122, []),
1664
 
            ('text-b', ['line-delta'], 84, ['text-a'])]
 
1665
            ('text-a', ['fulltext'], 122, ()),
 
1666
            ('text-b', ['line-delta'], 84, ('text-a',))]
1665
1667
        # now check the fulltext is first and the delta second
1666
1668
        format, data_list, _ = k1.get_data_stream(['text-a', 'text-b'])
1667
1669
        self.assertEqual('knit-plain', format)
1673
1675
        format, data_list, _ = k1.get_data_stream([
1674
1676
            'text-m', 'text-b', 'text-a'])
1675
1677
        self.assertEqual([
1676
 
            ('text-a', ['fulltext'], 122, []),
1677
 
            ('text-b', ['line-delta'], 84, ['text-a']),
1678
 
            ('text-m', ['line-delta'], 84, ['text-b', 'text-d']),
 
1678
            ('text-a', ['fulltext'], 122, ()),
 
1679
            ('text-b', ['line-delta'], 84, ('text-a',)),
 
1680
            ('text-m', ['line-delta'], 84, ('text-b', 'text-d')),
1679
1681
            ], data_list)
1680
1682
 
1681
1683
    def test_get_stream_ghost_parent(self):
1688
1690
        # Expected data
1689
1691
        expected_data_list = [
1690
1692
            # version, options, length, parents
1691
 
            ('text-b', ['line-delta'], 84, ['text-a', 'text-ghost']),
 
1693
            ('text-b', ['line-delta'], 84, ('text-a', 'text-ghost')),
1692
1694
            ]
1693
1695
        
1694
1696
        format, data_list, reader_callable = k1.get_data_stream(['text-b'])
1716
1718
        # behaviour.
1717
1719
        expected_data_list = [
1718
1720
            # version, options, length, parents
1719
 
            ('text-d', ['line-delta'], 84, ['text-c']),
1720
 
            ('text-b', ['line-delta'], 84, ['text-a']),
 
1721
            ('text-d', ['line-delta'], 84, ('text-c',)),
 
1722
            ('text-b', ['line-delta'], 84, ('text-a',)),
1721
1723
            ]
1722
1724
        # Note that even though we request the revision IDs in a particular
1723
1725
        # order, the data stream may return them in any order it likes.  In this
1758
1760
        # behaviour.
1759
1761
        expected_data_list = [
1760
1762
            # version, options, length, parents
1761
 
            ('text-a', ['fulltext'], 122, []),
1762
 
            ('text-b', ['line-delta'], 84, ['text-a']),
1763
 
            ('text-m', ['line-delta'], 84, ['text-b', 'text-d']),
1764
 
            ('text-c', ['fulltext'], 121, []),
1765
 
            ('text-d', ['line-delta'], 84, ['text-c']),
 
1763
            ('text-a', ['fulltext'], 122, ()),
 
1764
            ('text-b', ['line-delta'], 84, ('text-a',)),
 
1765
            ('text-m', ['line-delta'], 84, ('text-b', 'text-d')),
 
1766
            ('text-c', ['fulltext'], 121, ()),
 
1767
            ('text-d', ['line-delta'], 84, ('text-c',)),
1766
1768
            ]
1767
1769
        format, data_list, reader_callable = k1.get_data_stream(
1768
1770
            ['text-a', 'text-b', 'text-c', 'text-d', 'text-m'])
2185
2187
            'a-3 fulltext 0 0 1 :'
2186
2188
            )
2187
2189
        self.assertEqual(['a-1', 'a-2', 'a-3'], idx._history)
2188
 
        self.assertEqual({'a-1':('a-1', ['fulltext'], 0, 0, [], 0),
2189
 
                          'a-2':('a-2', ['fulltext'], 0, 0, ['a-1'], 1),
2190
 
                          'a-3':('a-3', ['fulltext'], 0, 0, ['a-2'], 2),
 
2190
        self.assertEqual({'a-1':('a-1', ['fulltext'], 0, 0, (), 0),
 
2191
                          'a-2':('a-2', ['fulltext'], 0, 0, ('a-1',), 1),
 
2192
                          'a-3':('a-3', ['fulltext'], 0, 0, ('a-2',), 2),
2191
2193
                         }, idx._cache)
2192
2194
 
2193
2195
    def test_add_versions_fails_clean(self):
2211
2213
 
2212
2214
        def generate_failure():
2213
2215
            """Add some entries and then raise an exception"""
2214
 
            yield ('a-2', ['fulltext'], (None, 0, 0), ['a-1'])
2215
 
            yield ('a-3', ['fulltext'], (None, 0, 0), ['a-2'])
 
2216
            yield ('a-2', ['fulltext'], (None, 0, 0), ('a-1',))
 
2217
            yield ('a-3', ['fulltext'], (None, 0, 0), ('a-2',))
2216
2218
            raise StopEarly()
2217
2219
 
2218
2220
        # Assert the pre-condition
2219
2221
        self.assertEqual(['a-1'], idx._history)
2220
 
        self.assertEqual({'a-1':('a-1', ['fulltext'], 0, 0, [], 0)}, idx._cache)
 
2222
        self.assertEqual({'a-1':('a-1', ['fulltext'], 0, 0, (), 0)}, idx._cache)
2221
2223
 
2222
2224
        self.assertRaises(StopEarly, idx.add_versions, generate_failure())
2223
2225
 
2224
2226
        # And it shouldn't be modified
2225
2227
        self.assertEqual(['a-1'], idx._history)
2226
 
        self.assertEqual({'a-1':('a-1', ['fulltext'], 0, 0, [], 0)}, idx._cache)
 
2228
        self.assertEqual({'a-1':('a-1', ['fulltext'], 0, 0, (), 0)}, idx._cache)
2227
2229
 
2228
2230
    def test_knit_index_ignores_empty_files(self):
2229
2231
        # There was a race condition in older bzr, where a ^C at the right time
2385
2387
        self.assertEqual(['fulltext', 'no-eol'], index.get_options('tip'))
2386
2388
        self.assertEqual(['fulltext'], index.get_options('parent'))
2387
2389
 
2388
 
    def test_get_parents(self):
2389
 
        # get_parents ignores ghosts
2390
 
        index = self.two_graph_index()
2391
 
        self.assertEqual(('tail', ), index.get_parents('parent'))
2392
 
        # and errors on ghosts.
2393
 
        self.assertRaises(errors.RevisionNotPresent,
2394
 
            index.get_parents, 'ghost')
2395
 
 
2396
2390
    def test_get_parents_with_ghosts(self):
2397
2391
        index = self.two_graph_index()
2398
2392
        self.assertEqual(('tail', 'ghost'), index.get_parents_with_ghosts('parent'))
2660
2654
        self.assertEqual(['fulltext', 'no-eol'], index.get_options('tip'))
2661
2655
        self.assertEqual(['fulltext'], index.get_options('parent'))
2662
2656
 
2663
 
    def test_get_parents(self):
2664
 
        index = self.two_graph_index()
2665
 
        self.assertEqual((), index.get_parents('parent'))
2666
 
        # and errors on ghosts.
2667
 
        self.assertRaises(errors.RevisionNotPresent,
2668
 
            index.get_parents, 'ghost')
2669
 
 
2670
2657
    def test_get_parents_with_ghosts(self):
2671
2658
        index = self.two_graph_index()
2672
2659
        self.assertEqual((), index.get_parents_with_ghosts('parent'))
2929
2916
 
2930
2917
    def test_iter_parents(self):
2931
2918
        knit = self.make_knit_with_4_versions_2_dags()
2932
 
        self.assertIterParents(knit, ['a'], ['a'], [('a', [])])
 
2919
        self.assertIterParents(knit, ['a'], ['a'], [('a', ())])
2933
2920
        self.assertIterParents(knit, ['a', 'b'], ['a', 'b'],
2934
 
            [('a', []), ('b', [])])
 
2921
            [('a', ()), ('b', ())])
2935
2922
        self.assertIterParents(knit, ['a', 'b', 'c'], ['a', 'b', 'c'],
2936
 
            [('a', []), ('b', []), ('c', ['b', 'a'])])
 
2923
            [('a', ()), ('b', ()), ('c', ('b', 'a'))])
2937
2924
        self.assertIterParents(knit, ['a', 'b', 'c', 'd'],
2938
2925
            ['a', 'b', 'c', 'd'],
2939
 
            [('a', []), ('b', []), ('c', ['b', 'a']), ('d', ['e', 'f'])])
 
2926
            [('a', ()), ('b', ()), ('c', ('b', 'a')), ('d', ('e', 'f'))])
2940
2927
        self.assertIterParents(knit, ['c'], ['a', 'b', 'c'],
2941
 
            [('c', ['b', 'a'])])
 
2928
            [('c', ('b', 'a'))])
2942
2929
 
2943
2930
    def test_get_options(self):
2944
2931
        knit = self.make_knit_with_4_versions_2_dags()
2947
2934
 
2948
2935
    def test_get_parents_with_ghosts(self):
2949
2936
        knit = self.make_knit_with_4_versions_2_dags()
2950
 
        self.assertGetParentsWithGhosts(knit, ['a'], 'a', [])
2951
 
        self.assertGetParentsWithGhosts(knit, ['c'], 'c', ['b', 'a'])
2952
 
        self.assertGetParentsWithGhosts(knit, ['d'], 'd', ['e', 'f'])
 
2937
        self.assertGetParentsWithGhosts(knit, ['a'], 'a', ())
 
2938
        self.assertGetParentsWithGhosts(knit, ['c'], 'c', ('b', 'a'))
 
2939
        self.assertGetParentsWithGhosts(knit, ['d'], 'd', ('e', 'f'))
2953
2940
 
2954
2941
    def test_get_position(self):
2955
2942
        knit = self.make_knit_with_4_versions_2_dags()