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_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_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_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_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_solitary_loop(self):
map_ = RevisionMap(
lambda: [
Revision("a", "a"),
]
)
self._assert_raises_revision_map_loop(map_, "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_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_revision_map_solitary_dependency_loop(self):
map_ = RevisionMap(
lambda: [
Revision("a", (), dependencies="a"),
]
)
self._assert_raises_revision_map_dep_loop(map_, "a")
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_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 test_repr_revs(self):
map_ = RevisionMap(lambda: [
Revision('a', ()),
Revision('b', ('a', )),
Revision('c', (), dependencies=('a', 'b')),
])
c = map_._revision_map['c']
eq_(repr(c), "Revision('c', None, dependencies=('a', 'b'))")
def setUp(self):
self.map = RevisionMap(lambda: [
Revision("a", ()),
Revision("b1", ("a", )),
Revision("b2", ("a", )),
Revision("c", ("b1", "b2")),
Revision("d", ("c", )),
])
def setUp(self):
self.map = RevisionMap(lambda: [
Revision("base1", ()),
Revision("a1", "base1"),
Revision("b1", "a1"),
Revision("c2", (), dependencies="a1"),
Revision("c3", "c2"),
])
def setUp(self):
self.map = RevisionMap(lambda: [
Revision('a', ()),
Revision('b1', ('a', )),
Revision('b2', ('a', )),
Revision('c', ('b1', 'b2')),
Revision('d', ('c', )),
])
def test_repr_revs(self):
map_ = RevisionMap(lambda: [
Revision("a", ()),
Revision("b", ("a", )),
Revision("c", (), dependencies=("a", "b")),
])
c = map_._revision_map["c"]
eq_(repr(c), "Revision('c', None, dependencies=('a', 'b'))")
def test_revision_map_merge_point_dep_loop(self):
map_ = RevisionMap(lambda: [
Revision("a", ()),
Revision("b1", "a"),
Revision("b2", "a"),
Revision("c", ("b1", "b2"), dependencies="c"),
])
self._assert_raises_revision_map_dep_loop(map_, "c")
def test_revision_map_branch_point_dep_loop(self):
map_ = RevisionMap(lambda: [
Revision("a", ()),
Revision("b", "a", dependencies="b"),
Revision("c1", "b"),
Revision("c2", "b"),
])
self._assert_raises_revision_map_dep_loop(map_, "b")
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_revision_map_upper_simple_cycle(self):
map_ = RevisionMap(lambda: [
Revision("a", ()),
Revision("b", "a"),
Revision("c", ("b", "e")),
Revision("d", "c"),
Revision("e", "d"),
])
self._assert_raises_revision_map_cycle(map_, ["a", "b", "c", "d", "e"])
def test_get_revision_heads_multiple(self):
map_ = RevisionMap(lambda: [
Revision('a', ()),
Revision('b', ('a', )),
Revision('c1', ('b', )),
Revision('c2', ('b', )),
])
assert_raises_message(MultipleHeads, "Multiple heads are present",
map_.get_revision, "heads")
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('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 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_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"],
)
