def test_erase_removes_node_from_the_tree_and_clears_its_parent():
n = Node("foo")
s = Node("Bar")
n.insert(s)
n.erase("Bar")
assert_raises(RuntimeError, n.find_relative, "Bar")
assert_is_none(s.parent)
def _create_nested_namespaces(path):
assert not path.startswith(Node.PATH_SEPARATOR)
splitpath = Node.splitpath(path)
root = nodes.Namespace(name=splitpath[0])
node = root
for name in splitpath[1:]:
new_node = nodes.Namespace(name=name)
node.insert(new_node)
node = new_node
return root, node
def create(properties):
destination = properties.destination
field = Node.jointwo(properties.source_type, properties.source_field)
result = ExplicitReference(
name="er_{field}_{destination}".format(field=field.replace(Node.PATH_SEPARATOR, '_'),
destination=destination.replace(
Node.PATH_SEPARATOR, '_')),
properties=properties)
result.insert(ResourceReference(name=destination))
result.insert(FieldReference(name=field))
result.insert(StructureReference(name=properties.source_type))
return result
def create_tree_with_topological_ordering():
return SyntaxTree(
Node("ns").insert(
Node("S0"),
Node("A0").insert(
Node("R0").insert(refs.TypeReference("ns.A1")),
Node("R1").insert(refs.TypeReference("ns.S0"))), Node("A1")))
def test_path_of_detached_node_is_just_its_name():
root = Node("foo")
assert_equal("foo", root.path)
def test_lookup_by_path():
root = Node("foo")
root.insert(Node("bar").insert(Node("baz").insert(Node("Dig"))))
assert_equal("Dig", root.find("foo.bar.baz.Dig").name)
def test_node_is_looked_up_by_its_path():
root = Node("foo")
s = Node("Dig")
root.insert(Node("bar").insert(Node("baz").insert(s)))
assert_equal(s, root.find(s.path))
def test_reparanting_of_symbol_trows():
n = Node("foo")
s = Node("Baz")
n.insert(s)
a = Node("bar")
assert_raises(RuntimeError, a.insert, s)
def test_insertion_returns_self():
n = Node("n")
assert_equal(n, n.insert(Node("S")))
def create_tree_with_cycle():
return SyntaxTree(
Node("a").insert(
Node("b").insert(Structure("c").insert(refs.TypeReference("a.d"))),
Node("d").insert(refs.TypeReference("a.b"))))
def test_find_child_returns_child_if_found():
n = Node("foo")
s = Node("Bar")
n.insert(s)
assert_equal("Bar", n.find_relative("Bar").name)
def test_insertion_of_symbol_with_duplicate_name_trows():
n = Node("foo")
s = Node("Bar")
n.insert(s)
assert_raises(SymbolRedefinition, n.insert, Node("Bar"))
def test_children_returns_children():
n = Node("foo")
s = Node("Bar")
n.insert(s)
assert_equal([s], n.children)
def test_insertion_works_with_lookup():
n = Node("foo")
s = Node("Bar")
n.insert(s)
assert_equal("Bar", n.find("foo.Bar").name)
def test_lookup_of_nonexistent_symbol_throws():
n = Node("foo")
s = Node("Bar")
n.insert(s)
assert_raises(RuntimeError, n.find, "baz")
def test_path_contains_fully_path_with():
root = Node("foo")
s = Node("Dig")
root.insert(Node("bar").insert(Node("baz").insert(s)))
assert_equal("foo.bar.baz.Dig", s.path)
def test_set_name_resets_the_node_name():
n = Node("foo")
n.set_name("bar")
assert_equal("bar", n.name)
def test_find_child_throws_if_not_found():
n = Node("foo")
assert_raises(RuntimeError, n.find_relative, "Bar")
def create_basic_tree():
return SyntaxTree(
Node("a").insert(
Node("b").insert(Node("c"), Node("d"), Node("e")),
Node("f").insert(Node("g").insert(Node("h")))))
def test_get_with_default_returns_default_if_not_found():
n = Node("foo")
s = Node("Bar")
n.insert(s)
assert_is_none(n.get("foo.Baz", None))
def create_tree_with_type_refs():
return SyntaxTree(
Node("a").insert(
Node("b").insert(Node("d"), refs.TypeReference("a.c.e")),
Node("c").insert(Node("e"), refs.TypeReference("a.b.d"))))
def test_nodes_are_named():
v = Node(name="abc")
assert_equal("abc", v.name)
def test_get_with_default_returns_value_if_found():
n = Node("foo")
s = Node("Bar")
n.insert(s)
assert_equal(s, n.get("foo.Bar", None))
def test_insertion_returns_parent_node():
n = Node("foo")
assert_equal(n, n.insert(Node("Bar")))
