def test_get_revision_base_single(self): map_ = RevisionMap(lambda: [ Revision('a', ()), Revision('b', ('a', )), Revision('c', ('b', )), ]) eq_(map_.get_revision('base'), None)
def setUp(self): """ Structure:: base1 -----> a1a -> b1a +----> a1b -> b1b | +-----------+ | v base3 -> a3 -> b3 ^ | +-----------+ | base2 -> a2 -> b2 -> c2 -> d2 """ self.map = RevisionMap(lambda: [ Revision("base1", (), branch_labels="b_1"), Revision("a1a", ("base1", )), Revision("a1b", ("base1", )), Revision("b1a", ("a1a", )), Revision("b1b", ("a1b", ), dependencies="a3"), Revision("base2", (), branch_labels="b_2"), Revision("a2", ("base2", )), Revision("b2", ("a2", )), Revision("c2", ("b2", ), dependencies="a3"), Revision("d2", ("c2", )), Revision("base3", (), branch_labels="b_3"), Revision("a3", ("base3", )), Revision("b3", ("a3", )), ])
def test_get_revision_base_single(self): map_ = RevisionMap(lambda: [ Revision("a", ()), Revision("b", ("a", )), Revision("c", ("b", )), ]) eq_(map_.get_revision("base"), None)
def test_get_revision_head_single(self): map_ = RevisionMap(lambda: [ Revision("a", ()), Revision("b", ("a", )), Revision("c", ("b", )), ]) eq_(map_.get_revision("head"), map_._revision_map["c"])
def test_get_revision_head_single(self): map_ = RevisionMap(lambda: [ Revision('a', ()), Revision('b', ('a', )), Revision('c', ('b', )), ]) eq_(map_.get_revision('head'), map_._revision_map['c'])
def test_invalid_datatype(self): map_ = RevisionMap( lambda: [ Revision("a", ()), Revision("b", ("a",)), Revision("c", ("b",)), ] ) assert_raises_message( RevisionError, "revision identifier b'12345' is not a string; " "ensure database driver settings are correct", map_.get_revisions, b'12345' ) assert_raises_message( RevisionError, "revision identifier b'12345' is not a string; " "ensure database driver settings are correct", map_.get_revision, b'12345' ) assert_raises_message( RevisionError, r"revision identifier \(b'12345',\) is not a string; " "ensure database driver settings are correct", map_.get_revision, (b'12345', ) ) map_.get_revision(("a", )) map_.get_revision("a")
def test_revision_map_no_loop_w_overlapping_substrings_dependencies(self): r1 = Revision("user_foo", None) r2 = Revision("user", None, dependencies="user_foo") self.map = RevisionMap(lambda: [r1, r2]) self._assert_iteration("heads", None, ["user", "user_foo"])
def test_get_revision_head_single(self): map_ = RevisionMap( lambda: [ Revision('a', ()), Revision('b', ('a',)), Revision('c', ('b',)), ] ) eq_(map_.get_revision('head'), map_._revision_map['c'])
def test_get_revision_head_single(self): map_ = RevisionMap( lambda: [ Revision("a", ()), Revision("b", ("a",)), Revision("c", ("b",)), ] ) eq_(map_.get_revision("head"), map_._revision_map["c"])
def test_get_revision_base_single(self): map_ = RevisionMap( lambda: [ Revision('a', ()), Revision('b', ('a',)), Revision('c', ('b',)), ] ) eq_(map_.get_revision('base'), None)
def test_iterate_tolerates_dupe_targets(self): map_ = RevisionMap(lambda: [ Revision('a', ()), Revision('b', ('a', )), Revision('c', ('b', )), ]) eq_([r.revision for r in map_._iterate_revisions(('c', 'c'), 'a')], ['c', 'b', 'a'])
def test_get_revision_base_single(self): map_ = RevisionMap( lambda: [ Revision("a", ()), Revision("b", ("a",)), Revision("c", ("b",)), ] ) eq_(map_.get_revision("base"), None)
def test_revision_dupe_head(self): r1 = Revision("user_foo", None) r2 = Revision("user", "user_foo", dependencies="user_foo") self.map = RevisionMap(lambda: [r1, r2]) self._assert_iteration("heads", None, ["user", "user_foo"]) eq_(self.map._topological_sort([r1, r2], [r2]), ["user", "user_foo"])
def test_add_revision_one_head(self): map_ = RevisionMap(lambda: [ Revision('a', ()), Revision('b', ('a', )), Revision('c', ('b', )), ]) eq_(map_.heads, ('c', )) map_.add_revision(Revision('d', ('c', ))) eq_(map_.heads, ('d', ))
def test_add_revision_one_head(self): map_ = RevisionMap(lambda: [ Revision("a", ()), Revision("b", ("a", )), Revision("c", ("b", )), ]) eq_(map_.heads, ("c", )) map_.add_revision(Revision("d", ("c", ))) eq_(map_.heads, ("d", ))
def setUp(self): self.map = RevisionMap(lambda: [ Revision("a1", ()), Revision("a2", "a1"), Revision("a3", "a2"), Revision("b1", ()), Revision("b2", "b1", dependencies="a3"), Revision("b3", "b2"), Revision("b4", "b3", dependencies="a3"), Revision("b5", "b4"), ])
def setUp(self): self.map = RevisionMap(lambda: [ Revision('a', (), branch_labels='abranch'), Revision('b', ('a',)), Revision('somelongername', ('b',)), Revision('c', ('somelongername',)), Revision('d', ()), Revision('e', ('d',), branch_labels=['ebranch']), Revision('someothername', ('e',)), Revision('f', ('someothername',)), ])
def setUp(self): self.map = RevisionMap(lambda: [ Revision("a", (), branch_labels="abranch"), Revision("b", ("a", )), Revision("somelongername", ("b", )), Revision("c", ("somelongername", )), Revision("d", ()), Revision("e", ("d", ), branch_labels=["ebranch"]), Revision("someothername", ("e", )), Revision("f", ("someothername", )), ])
def test_add_revision_two_head(self): map_ = RevisionMap(lambda: [ Revision('a', ()), Revision('b', ('a', )), Revision('c1', ('b', )), Revision('c2', ('b', )), ]) eq_(map_.heads, ('c1', 'c2')) map_.add_revision(Revision('d1', ('c1', ))) eq_(map_.heads, ('c2', 'd1'))
def test_iterate_tolerates_dupe_targets(self): map_ = RevisionMap(lambda: [ Revision("a", ()), Revision("b", ("a", )), Revision("c", ("b", )), ]) eq_( [r.revision for r in map_._iterate_revisions(("c", "c"), "a")], ["c", "b", "a"], )
def test_add_revision_two_head(self): map_ = RevisionMap(lambda: [ Revision("a", ()), Revision("b", ("a", )), Revision("c1", ("b", )), Revision("c2", ("b", )), ]) eq_(map_.heads, ("c1", "c2")) map_.add_revision(Revision("d1", ("c1", ))) eq_(map_.heads, ("c2", "d1"))
def test_add_revision_one_head(self): map_ = RevisionMap( lambda: [ Revision('a', ()), Revision('b', ('a',)), Revision('c', ('b',)), ] ) eq_(map_.heads, ('c', )) map_.add_revision(Revision('d', ('c', ))) eq_(map_.heads, ('d', ))
def test_add_revision_one_head(self): map_ = RevisionMap( lambda: [ Revision("a", ()), Revision("b", ("a",)), Revision("c", ("b",)), ] ) eq_(map_.heads, ("c",)) map_.add_revision(Revision("d", ("c",))) eq_(map_.heads, ("d",))
def setUp(self): self.map = RevisionMap(lambda: [ Revision('base1', ()), Revision('a1', 'base1'), Revision('a2', 'base1'), Revision('b1', 'a1'), Revision('c1', 'b1'), ]) # intentionally make a broken map self.map._revision_map['fake'] = self.map._revision_map['a2'] self.map._revision_map['b1'].dependencies = 'fake' self.map._revision_map['b1']._resolved_dependencies = ('fake', )
def setUp(self): self.map = RevisionMap(lambda: [ Revision("base1", ()), Revision("a1", "base1"), Revision("a2", "base1"), Revision("b1", "a1"), Revision("c1", "b1"), ]) # intentionally make a broken map self.map._revision_map["fake"] = self.map._revision_map["a2"] self.map._revision_map["b1"].dependencies = "fake" self.map._revision_map["b1"]._resolved_dependencies = ("fake", )
def test_iterate_tolerates_dupe_targets(self): map_ = RevisionMap( lambda: [ Revision("a", ()), Revision("b", ("a",)), Revision("c", ("b",)), ] ) eq_( [r.revision for r in map_._iterate_revisions(("c", "c"), "a")], ["c", "b", "a"], )
def test_add_revision_two_head(self): map_ = RevisionMap( lambda: [ Revision('a', ()), Revision('b', ('a',)), Revision('c1', ('b',)), Revision('c2', ('b',)), ] ) eq_(map_.heads, ('c1', 'c2')) map_.add_revision(Revision('d1', ('c1', ))) eq_(map_.heads, ('c2', 'd1'))
def test_add_revision_two_head(self): map_ = RevisionMap( lambda: [ Revision("a", ()), Revision("b", ("a",)), Revision("c1", ("b",)), Revision("c2", ("b",)), ] ) eq_(map_.heads, ("c1", "c2")) map_.add_revision(Revision("d1", ("c1",))) eq_(map_.heads, ("c2", "d1"))
def test_filter_for_lineage_labeled_head_across_merge(self): fn = lambda: [ Revision('a', ()), Revision('b', ('a', )), Revision('c1', ('b', ), branch_labels='c1branch'), Revision('c2', ('b', )), Revision('d', ('c1', 'c2')), ] map_ = RevisionMap(fn) c1 = map_.get_revision('c1') c2 = map_.get_revision('c2') d = map_.get_revision('d') eq_(map_.filter_for_lineage([c1, c2, d], "c1branch@head"), [c1, c2, d])
def test_get_revisions_heads_multiple(self): map_ = RevisionMap(lambda: [ Revision("a", ()), Revision("b", ("a", )), Revision("c1", ("b", )), Revision("c2", ("b", )), ]) eq_( map_.get_revisions("heads"), ( map_._revision_map["c1"], map_._revision_map["c2"], ), )
def setUp(self): self.map = RevisionMap(lambda: [ Revision("a", ()), Revision("b1", ("a", )), Revision("b2", ("a", )), Revision("cb1", ("b1", )), Revision("cb2", ("b2", )), Revision("d1cb1", ("cb1", )), # head Revision("d2cb1", ("cb1", )), # head Revision("d1cb2", ("cb2", )), Revision("d2cb2", ("cb2", )), Revision("d3cb2", ("cb2", )), # head Revision("d1d2cb2", ("d1cb2", "d2cb2")), # head + merge point ])
def setUp(self): self.map = RevisionMap(lambda: [ Revision('a', ()), Revision('b1', ('a', )), Revision('b2', ('a', )), Revision('cb1', ('b1', )), Revision('cb2', ('b2', )), Revision('d1cb1', ('cb1', )), # head Revision('d2cb1', ('cb1', )), # head Revision('d1cb2', ('cb2', )), Revision('d2cb2', ('cb2', )), Revision('d3cb2', ('cb2', )), # head Revision('d1d2cb2', ('d1cb2', 'd2cb2')) # head + merge point ])
def test_filter_for_lineage_labeled_head_across_merge(self): def fn(): return [ Revision("a", ()), Revision("b", ("a",)), Revision("c1", ("b",), branch_labels="c1branch"), Revision("c2", ("b",)), Revision("d", ("c1", "c2")), ] map_ = RevisionMap(fn) c1 = map_.get_revision("c1") c2 = map_.get_revision("c2") d = map_.get_revision("d") eq_(map_.filter_for_lineage([c1, c2, d], "c1branch@head"), [c1, c2, d])
def test_filter_for_lineage_labeled_head_across_merge(self): def fn(): return [ Revision("a", ()), Revision("b", ("a", )), Revision("c1", ("b", ), branch_labels="c1branch"), Revision("c2", ("b", )), Revision("d", ("c1", "c2")), ] map_ = RevisionMap(fn) c1 = map_.get_revision("c1") c2 = map_.get_revision("c2") d = map_.get_revision("d") eq_(map_.filter_for_lineage([c1, c2, d], "c1branch@head"), [c1, c2, d])
def test_iterate_tolerates_dupe_targets(self): map_ = RevisionMap(lambda: [ Revision("a", ()), Revision("b", ("a", )), Revision("c", ("b", )), ]) eq_( [ r.revision for r in map_.iterate_revisions( ("c", "c"), "a", inclusive=False) ], # Not inclusive so should not traverse a ["c", "b"], )
def setUp(self): """ Structure:: base1 -----> a1a -> b1a +----> a1b -> b1b | +-----------+ | v base3 -> a3 -> b3 ^ | +-----------+ | base2 -> a2 -> b2 -> c2 -> d2 """ self.map = RevisionMap( lambda: [ Revision("base1", (), branch_labels="b_1"), Revision("a1a", ("base1",)), Revision("a1b", ("base1",)), Revision("b1a", ("a1a",)), Revision("b1b", ("a1b",), dependencies="a3"), Revision("base2", (), branch_labels="b_2"), Revision("a2", ("base2",)), Revision("b2", ("a2",)), Revision("c2", ("b2",), dependencies="a3"), Revision("d2", ("c2",)), Revision("base3", (), branch_labels="b_3"), Revision("a3", ("base3",)), Revision("b3", ("a3",)), ] )
def test_revision_map_solitary_dependency_loop(self): map_ = RevisionMap( lambda: [ Revision("a", (), dependencies="a"), ] ) self._assert_raises_revision_map_dep_loop(map_, "a")
def test_revision_map_head_dep_loop(self): map_ = RevisionMap(lambda: [ Revision("a", ()), Revision("b", "a"), Revision("c", "b", dependencies="c"), ]) self._assert_raises_revision_map_dep_loop(map_, "c")
def test_revision_map_base_loop(self): map_ = RevisionMap(lambda: [ Revision("a", "a"), Revision("b", "a"), Revision("c", "b"), ]) self._assert_raises_revision_map_loop(map_, "a")
def test_revision_map_simple_dep_cycle(self): map_ = RevisionMap(lambda: [ Revision("a", (), dependencies="c"), Revision("b", "a"), Revision("c", "b"), ]) self._assert_raises_revision_map_dep_cycle(map_, ["a", "b", "c"])
def setUp(self): """ base1 -----> a1a -> b1a +----> a1b -> b1b | +-----------+ | v base3 -> a3 -> b3 ^ | +-----------+ | base2 -> a2 -> b2 -> c2 -> d2 """ self.map = RevisionMap(lambda: [ Revision('base1', (), branch_labels='b_1'), Revision('a1a', ('base1', )), Revision('a1b', ('base1', )), Revision('b1a', ('a1a', )), Revision('b1b', ('a1b', ), dependencies='a3'), Revision('base2', (), branch_labels='b_2'), Revision('a2', ('base2', )), Revision('b2', ('a2', )), Revision('c2', ('b2', ), dependencies='a3'), Revision('d2', ('c2', )), Revision('base3', (), branch_labels='b_3'), Revision('a3', ('base3', )), Revision('b3', ('a3', )), ])
def test_revision_map_solitary_loop(self): map_ = RevisionMap( lambda: [ Revision("a", "a"), ] ) self._assert_raises_revision_map_loop(map_, "a")
def test_iterate_tolerates_dupe_targets(self): map_ = RevisionMap( lambda: [ Revision('a', ()), Revision('b', ('a',)), Revision('c', ('b',)), ] ) eq_( [ r.revision for r in map_._iterate_revisions(('c', 'c'), 'a') ], ['c', 'b', 'a'] )
def test_filter_for_lineage_labeled_head_across_merge(self): fn = lambda: [ Revision('a', ()), Revision('b', ('a', )), Revision('c1', ('b', ), branch_labels='c1branch'), Revision('c2', ('b', )), Revision('d', ('c1', 'c2')), ] map_ = RevisionMap(fn) c1 = map_.get_revision('c1') c2 = map_.get_revision('c2') d = map_.get_revision('d') eq_( map_.filter_for_lineage([c1, c2, d], "c1branch@head"), [c1, c2, d] )
def setUp(self): self.map = RevisionMap( lambda: [ Revision("a", (), branch_labels="abranch"), Revision("b", ("a",)), Revision("somelongername", ("b",)), Revision("c", ("somelongername",)), Revision("d", ()), Revision("e", ("d",), branch_labels=["ebranch"]), Revision("someothername", ("e",)), Revision("f", ("someothername",)), ] )
def setUp(self): self.map = RevisionMap( lambda: [ Revision("base1", ()), Revision("a1", "base1"), Revision("a2", "base1"), Revision("b1", "a1"), Revision("c1", "b1"), ] ) # intentionally make a broken map self.map._revision_map["fake"] = self.map._revision_map["a2"] self.map._revision_map["b1"].dependencies = "fake" self.map._revision_map["b1"]._resolved_dependencies = ("fake",)
def setUp(self): self.map = RevisionMap( lambda: [ Revision('base1', ()), Revision('a1', 'base1'), Revision('a2', 'base1'), Revision('b1', 'a1'), Revision('c1', 'b1'), ] ) # intentionally make a broken map self.map._revision_map['fake'] = self.map._revision_map['a2'] self.map._revision_map['b1'].dependencies = 'fake' self.map._revision_map['b1']._resolved_dependencies = ('fake', )
def setUp(self): self.map = RevisionMap( lambda: [ Revision('a', ()), Revision('b1', ('a',)), Revision('b2', ('a',)), Revision('cb1', ('b1',)), Revision('cb2', ('b2',)), Revision('d1cb1', ('cb1',)), # head Revision('d2cb1', ('cb1',)), # head Revision('d1cb2', ('cb2',)), Revision('d2cb2', ('cb2',)), Revision('d3cb2', ('cb2',)), # head Revision('d1d2cb2', ('d1cb2', 'd2cb2')) # head + merge point ] )
def setUp(self): self.map = RevisionMap( lambda: [ Revision("a", ()), Revision("b1", ("a",)), Revision("b2", ("a",)), Revision("cb1", ("b1",)), Revision("cb2", ("b2",)), Revision("d1cb1", ("cb1",)), # head Revision("d2cb1", ("cb1",)), # head Revision("d1cb2", ("cb2",)), Revision("d2cb2", ("cb2",)), Revision("d3cb2", ("cb2",)), # head Revision("d1d2cb2", ("d1cb2", "d2cb2")), # head + merge point ] )
def setUp(self): self.map = RevisionMap( lambda: [ Revision("base1", ()), Revision("base2", ()), Revision("base3", ()), Revision("a1a", ("base1",)), Revision("a1b", ("base1",)), Revision("a2", ("base2",)), Revision("a3", ("base3",)), Revision("b1a", ("a1a",)), Revision("b1b", ("a1b",)), Revision("b2", ("a2",)), Revision("b3", ("a3",)), Revision("c2", ("b2",)), Revision("d2", ("c2",)), Revision("mergeb3d2", ("b3", "d2")), ] )
def setUp(self): self.map = RevisionMap( lambda: [ Revision("a1", ()), Revision("a2", ("a1",)), Revision("a3", ("a2",)), Revision("b1", ("a3",)), Revision("b2", ("a3",)), Revision("cb1", ("b1",)), Revision("cb2", ("b2",)), Revision("db1", ("cb1",)), Revision("db2", ("cb2",)), Revision("e1b1", ("db1",)), Revision("fe1b1", ("e1b1",)), Revision("e2b1", ("db1",)), Revision("e2b2", ("db2",)), Revision("merge", ("e2b1", "e2b2")), ] )
class DepResolutionFailedTest(DownIterateTest): def setUp(self): self.map = RevisionMap( lambda: [ Revision("base1", ()), Revision("a1", "base1"), Revision("a2", "base1"), Revision("b1", "a1"), Revision("c1", "b1"), ] ) # intentionally make a broken map self.map._revision_map["fake"] = self.map._revision_map["a2"] self.map._revision_map["b1"].dependencies = "fake" self.map._revision_map["b1"]._resolved_dependencies = ("fake",) def test_failure_message(self): iter_ = self.map.iterate_revisions("c1", "base1") assert_raises_message( RevisionError, "Dependency resolution failed;", list, iter_ )
def setUp(self): self.map = RevisionMap( lambda: [ Revision('a1', ()), Revision('a2', ('a1',)), Revision('a3', ('a2',)), Revision('b1', ('a3',)), Revision('b2', ('a3',)), Revision('cb1', ('b1',)), Revision('cb2', ('b2',)), Revision('db1', ('cb1',)), Revision('db2', ('cb2',)), Revision('e1b1', ('db1',)), Revision('fe1b1', ('e1b1',)), Revision('e2b1', ('db1',)), Revision('e2b2', ('db2',)), Revision("merge", ('e2b1', 'e2b2')) ] )
def setUp(self): self.map = RevisionMap( lambda: [ Revision('base1', ()), Revision('base2', ()), Revision('base3', ()), Revision('a1a', ('base1',)), Revision('a1b', ('base1',)), Revision('a2', ('base2',)), Revision('a3', ('base3',)), Revision('b1a', ('a1a',)), Revision('b1b', ('a1b',)), Revision('b2', ('a2',)), Revision('b3', ('a3',)), Revision('c2', ('b2',)), Revision('d2', ('c2',)), Revision('mergeb3d2', ('b3', 'd2')) ] )
class DepResolutionFailedTest(DownIterateTest): def setUp(self): self.map = RevisionMap( lambda: [ Revision('base1', ()), Revision('a1', 'base1'), Revision('a2', 'base1'), Revision('b1', 'a1'), Revision('c1', 'b1'), ] ) # intentionally make a broken map self.map._revision_map['fake'] = self.map._revision_map['a2'] self.map._revision_map['b1'].dependencies = 'fake' self.map._revision_map['b1']._resolved_dependencies = ('fake', ) def test_failure_message(self): iter_ = self.map.iterate_revisions("c1", "base1") assert_raises_message( RevisionError, "Dependency resolution failed;", list, iter_ )
def setUp(self): """ base1 -----> a1a -> b1a +----> a1b -> b1b | +-----------+ | v base3 -> a3 -> b3 ^ | +-----------+ | base2 -> a2 -> b2 -> c2 -> d2 """ self.map = RevisionMap( lambda: [ Revision('base1', (), branch_labels='b_1'), Revision('a1a', ('base1',)), Revision('a1b', ('base1',)), Revision('b1a', ('a1a',)), Revision('b1b', ('a1b', ), dependencies='a3'), Revision('base2', (), branch_labels='b_2'), Revision('a2', ('base2',)), Revision('b2', ('a2',)), Revision('c2', ('b2', ), dependencies='a3'), Revision('d2', ('c2',)), Revision('base3', (), branch_labels='b_3'), Revision('a3', ('base3',)), Revision('b3', ('a3',)), ] )
class MultipleBaseCrossDependencyTestOne(DownIterateTest): def setUp(self): """ base1 -----> a1a -> b1a +----> a1b -> b1b | +-----------+ | v base3 -> a3 -> b3 ^ | +-----------+ | base2 -> a2 -> b2 -> c2 -> d2 """ self.map = RevisionMap( lambda: [ Revision('base1', (), branch_labels='b_1'), Revision('a1a', ('base1',)), Revision('a1b', ('base1',)), Revision('b1a', ('a1a',)), Revision('b1b', ('a1b', ), dependencies='a3'), Revision('base2', (), branch_labels='b_2'), Revision('a2', ('base2',)), Revision('b2', ('a2',)), Revision('c2', ('b2', ), dependencies='a3'), Revision('d2', ('c2',)), Revision('base3', (), branch_labels='b_3'), Revision('a3', ('base3',)), Revision('b3', ('a3',)), ] ) def test_what_are_the_heads(self): eq_(self.map.heads, ("b1a", "b1b", "d2", "b3")) def test_heads_to_base(self): self._assert_iteration( "heads", "base", [ 'b1a', 'a1a', 'b1b', 'a1b', 'd2', 'c2', 'b2', 'a2', 'base2', 'b3', 'a3', 'base3', 'base1' ] ) def test_heads_to_base_downgrade(self): self._assert_iteration( "heads", "base", [ 'b1a', 'a1a', 'b1b', 'a1b', 'd2', 'c2', 'b2', 'a2', 'base2', 'b3', 'a3', 'base3', 'base1' ], select_for_downgrade=True ) def test_same_branch_wrong_direction(self): assert_raises_message( RevisionError, r"Revision d2 is not an ancestor of revision b2", list, self.map._iterate_revisions('b2', 'd2') ) def test_different_branch_not_wrong_direction(self): self._assert_iteration( "b3", "d2", [] ) def test_we_need_head2_upgrade(self): # the 2 branch relies on the 3 branch self._assert_iteration( "b_2@head", "base", ['d2', 'c2', 'b2', 'a2', 'base2', 'a3', 'base3'] ) def test_we_need_head2_downgrade(self): # the 2 branch relies on the 3 branch, but # on the downgrade side, don't need to touch the 3 branch self._assert_iteration( "b_2@head", "b_2@base", ['d2', 'c2', 'b2', 'a2', 'base2'], select_for_downgrade=True ) def test_we_need_head3_upgrade(self): # the 3 branch can be upgraded alone. self._assert_iteration( "b_3@head", "base", ['b3', 'a3', 'base3'] ) def test_we_need_head3_downgrade(self): # the 3 branch can be upgraded alone. self._assert_iteration( "b_3@head", "base", ['b3', 'a3', 'base3'], select_for_downgrade=True ) def test_we_need_head1_upgrade(self): # the 1 branch relies on the 3 branch self._assert_iteration( "b1b@head", "base", ['b1b', 'a1b', 'base1', 'a3', 'base3'] ) def test_we_need_head1_downgrade(self): # going down we don't need a3-> base3, as long # as we are limiting the base target self._assert_iteration( "b1b@head", "b1b@base", ['b1b', 'a1b', 'base1'], select_for_downgrade=True ) def test_we_need_base2_upgrade(self): # consider a downgrade to b_2@base - we # want to run through all the "2"s alone, and we're done. self._assert_iteration( "heads", "b_2@base", ['d2', 'c2', 'b2', 'a2', 'base2'] ) def test_we_need_base2_downgrade(self): # consider a downgrade to b_2@base - we # want to run through all the "2"s alone, and we're done. self._assert_iteration( "heads", "b_2@base", ['d2', 'c2', 'b2', 'a2', 'base2'], select_for_downgrade=True ) def test_we_need_base3_upgrade(self): self._assert_iteration( "heads", "b_3@base", ['b1b', 'd2', 'c2', 'b3', 'a3', 'base3'] ) def test_we_need_base3_downgrade(self): # consider a downgrade to b_3@base - due to the a3 dependency, we # need to downgrade everything dependent on a3 # as well, which means b1b and c2. Then we can downgrade # the 3s. self._assert_iteration( "heads", "b_3@base", ['b1b', 'd2', 'c2', 'b3', 'a3', 'base3'], select_for_downgrade=True )
class BranchTravellingTest(DownIterateTest): """test the order of revs when going along multiple branches. We want depth-first along branches, but then we want to terminate all branches at their branch point before continuing to the nodes preceding that branch. """ def setUp(self): self.map = RevisionMap( lambda: [ Revision('a1', ()), Revision('a2', ('a1',)), Revision('a3', ('a2',)), Revision('b1', ('a3',)), Revision('b2', ('a3',)), Revision('cb1', ('b1',)), Revision('cb2', ('b2',)), Revision('db1', ('cb1',)), Revision('db2', ('cb2',)), Revision('e1b1', ('db1',)), Revision('fe1b1', ('e1b1',)), Revision('e2b1', ('db1',)), Revision('e2b2', ('db2',)), Revision("merge", ('e2b1', 'e2b2')) ] ) def test_iterate_one_branch_both_to_merge(self): # test that when we hit a merge point, implicit base will # ensure all branches that supply the merge point are filled in self._assert_iteration( "merge", "db1", ['merge', 'e2b1', 'db1', 'e2b2', 'db2', 'cb2', 'b2'], implicit_base=True ) def test_three_branches_end_in_single_branch(self): self._assert_iteration( ["merge", "fe1b1"], "a3", ['merge', 'e2b1', 'e2b2', 'db2', 'cb2', 'b2', 'fe1b1', 'e1b1', 'db1', 'cb1', 'b1', 'a3'] ) def test_two_branches_to_root(self): # here we want 'a3' as a "stop" branch point, but *not* # 'db1', as we don't have multiple traversals on db1 self._assert_iteration( "merge", "a1", ['merge', 'e2b1', 'db1', 'cb1', 'b1', # e2b1 branch 'e2b2', 'db2', 'cb2', 'b2', # e2b2 branch 'a3', # both terminate at a3 'a2', 'a1' # finish out ] # noqa ) def test_two_branches_end_in_branch(self): self._assert_iteration( "merge", "b1", # 'b1' is local to 'e2b1' # branch so that is all we get ['merge', 'e2b1', 'db1', 'cb1', 'b1', ] # noqa ) def test_two_branches_end_behind_branch(self): self._assert_iteration( "merge", "a2", ['merge', 'e2b1', 'db1', 'cb1', 'b1', # e2b1 branch 'e2b2', 'db2', 'cb2', 'b2', # e2b2 branch 'a3', # both terminate at a3 'a2' ] # noqa ) def test_three_branches_to_root(self): # in this case, both "a3" and "db1" are stop points self._assert_iteration( ["merge", "fe1b1"], "a1", ['merge', 'e2b1', # e2b1 branch 'e2b2', 'db2', 'cb2', 'b2', # e2b2 branch 'fe1b1', 'e1b1', # fe1b1 branch 'db1', # fe1b1 and e2b1 branches terminate at db1 'cb1', 'b1', # e2b1 branch continued....might be nicer # if this was before the e2b2 branch... 'a3', # e2b1 and e2b2 branches terminate at a3 'a2', 'a1' # finish out ] # noqa ) def test_three_branches_end_multiple_bases(self): # in this case, both "a3" and "db1" are stop points self._assert_iteration( ["merge", "fe1b1"], ["cb1", "cb2"], [ 'merge', 'e2b1', 'e2b2', 'db2', 'cb2', 'fe1b1', 'e1b1', 'db1', 'cb1' ] ) def test_three_branches_end_multiple_bases_exclusive(self): self._assert_iteration( ["merge", "fe1b1"], ["cb1", "cb2"], [ 'merge', 'e2b1', 'e2b2', 'db2', 'fe1b1', 'e1b1', 'db1', ], inclusive=False ) def test_detect_invalid_head_selection(self): # db1 is an ancestor of fe1b1 assert_raises_message( RevisionError, "Requested revision fe1b1 overlaps " "with other requested revisions", list, self.map._iterate_revisions(["db1", "b2", "fe1b1"], ()) ) def test_three_branches_end_multiple_bases_exclusive_blank(self): self._assert_iteration( ["e2b1", "b2", "fe1b1"], (), [ 'e2b1', 'b2', 'fe1b1', 'e1b1', 'db1', 'cb1', 'b1', 'a3', 'a2', 'a1' ], inclusive=False ) def test_iterate_to_symbolic_base(self): self._assert_iteration( ["fe1b1"], "base", ['fe1b1', 'e1b1', 'db1', 'cb1', 'b1', 'a3', 'a2', 'a1'], inclusive=False ) def test_ancestor_nodes(self): merge = self.map.get_revision("merge") eq_( set( rev.revision for rev in self.map._get_ancestor_nodes([merge], check=True) ), set(['a1', 'e2b2', 'e2b1', 'cb2', 'merge', 'a3', 'a2', 'b1', 'b2', 'db1', 'db2', 'cb1']) )
class MultipleBaseTest(DownIterateTest): def setUp(self): self.map = RevisionMap( lambda: [ Revision('base1', ()), Revision('base2', ()), Revision('base3', ()), Revision('a1a', ('base1',)), Revision('a1b', ('base1',)), Revision('a2', ('base2',)), Revision('a3', ('base3',)), Revision('b1a', ('a1a',)), Revision('b1b', ('a1b',)), Revision('b2', ('a2',)), Revision('b3', ('a3',)), Revision('c2', ('b2',)), Revision('d2', ('c2',)), Revision('mergeb3d2', ('b3', 'd2')) ] ) def test_heads_to_base(self): self._assert_iteration( "heads", "base", [ 'b1a', 'a1a', 'b1b', 'a1b', 'mergeb3d2', 'b3', 'a3', 'base3', 'd2', 'c2', 'b2', 'a2', 'base2', 'base1' ] ) def test_heads_to_base_exclusive(self): self._assert_iteration( "heads", "base", [ 'b1a', 'a1a', 'b1b', 'a1b', 'mergeb3d2', 'b3', 'a3', 'base3', 'd2', 'c2', 'b2', 'a2', 'base2', 'base1', ], inclusive=False ) def test_heads_to_blank(self): self._assert_iteration( "heads", None, [ 'b1a', 'a1a', 'b1b', 'a1b', 'mergeb3d2', 'b3', 'a3', 'base3', 'd2', 'c2', 'b2', 'a2', 'base2', 'base1' ] ) def test_detect_invalid_base_selection(self): assert_raises_message( RevisionError, "Requested revision a2 overlaps with " "other requested revisions", list, self.map._iterate_revisions(["c2"], ["a2", "b2"]) ) def test_heads_to_revs_plus_implicit_base_exclusive(self): self._assert_iteration( "heads", ["c2"], [ 'b1a', 'a1a', 'b1b', 'a1b', 'mergeb3d2', 'b3', 'a3', 'base3', 'd2', 'base1' ], inclusive=False, implicit_base=True ) def test_heads_to_revs_base_exclusive(self): self._assert_iteration( "heads", ["c2"], [ 'mergeb3d2', 'd2' ], inclusive=False ) def test_heads_to_revs_plus_implicit_base_inclusive(self): self._assert_iteration( "heads", ["c2"], [ 'b1a', 'a1a', 'b1b', 'a1b', 'mergeb3d2', 'b3', 'a3', 'base3', 'd2', 'c2', 'base1' ], implicit_base=True ) def test_specific_path_one(self): self._assert_iteration( "b3", "base3", ['b3', 'a3', 'base3'] ) def test_specific_path_two_implicit_base(self): self._assert_iteration( ["b3", "b2"], "base3", ['b3', 'a3', 'b2', 'a2', 'base2'], inclusive=False, implicit_base=True )