def test_add_edge_as_object_w_cases(jelm_pair_case: NetwokCaseTemplate):
def add_edge_as_obj(el: Jelm):
el.add_object({"type": "edge", "source": "n1", "target": "n2"})
return el
def assert_edge_as_obj_added(el: Jelm):
n = el.get_node("n1")
assert "n2" in n.neighbors.keys()
assert "n1" in el.get_node("n2").neighbors
assert "n2" in n.target_neighbors.keys()
def catch_edge_as_obj_add(el: Jelm, e):
assert isinstance(e, KeyError)
assert ("n1" not in el.nodes.keys()) or ("n2" not in el.nodes.keys())
jelm_pair_case.evaluate_fun(
altering_function=add_edge_as_obj,
assert_alteration=assert_edge_as_obj_added,
catch_alteration_exception=catch_edge_as_obj_add,
)
def test_attribute_filter2(jelm_pair_case: NetwokCaseTemplate):
def filter_none(el: Jelm):
el.attribute_filter(lambda x: True)
return el
jelm_pair_case.evaluate_fun(non_altering_function=filter_none)
def test_add_edge_jelm_object_w_cases(jelm_pair_case: NetwokCaseTemplate):
def add_edge_jelm_obj(el: Jelm):
el.add_object(Edge(source="n1", target="n2", id="fing"))
return el
def assert_edge_jelm_obj_added(el: Jelm):
n = el.get_node("n1")
assert "n2" in n.neighbors.keys()
assert "n1" in el.get_node("n2").neighbors
assert "n2" in n.target_neighbors.keys()
edge_ids = [e.id for e in n.neighbors["n2"]]
assert "fing" in edge_ids
def catch_edge_jelm_obj_add(el: Jelm, e):
assert isinstance(e, KeyError)
assert ("n1" not in el.nodes.keys()) or ("n2" not in el.nodes.keys())
jelm_pair_case.evaluate_fun(
altering_function=add_edge_jelm_obj,
assert_alteration=assert_edge_jelm_obj_added,
catch_alteration_exception=catch_edge_jelm_obj_add,
)
def test_json_reads_dumps_w_cases(jelm_pair_case: NetwokCaseTemplate):
def io_fun(_el: Jelm):
_dump = _el.json_dumps()
return reads_json(_dump)
jelm_pair_case.evaluate_fun(non_altering_function=io_fun)
def test_neighborhood_w_cases(jelm_pair_case: NetwokCaseTemplate):
def get_whole_graph(el: Jelm):
return el.get_neighborhood(el.nodes.keys())
jelm_pair_case.evaluate_fun(non_altering_function=get_whole_graph)
def check_drop(el: Jelm):
nel = el.get_neighborhood(["n1", "n2"])
def test_init_w_cases(jelm_pair_case: NetwokCaseTemplate):
def transform_init(el):
el_from_nodes = Jelm(metadata=el.metadata, nodes=el.nodes)
assert el_from_nodes == el
return el_from_nodes
jelm_pair_case.evaluate_fun(non_altering_function=transform_init)
def test_jelm_repr(jelm_pair_case: NetwokCaseTemplate):
def repr_check(el: Jelm):
repr_string = el.__repr__()
assert "jelm" in repr_string
assert str(len(el.nodes.keys())) in repr_string
return el
jelm_pair_case.evaluate_fun(non_altering_function=repr_check)
def test_json_read_dump_w_cases(tmp_path, jelm_pair_case: NetwokCaseTemplate):
d = tmp_path / "sub3"
d.mkdir()
p = d / "fing3.jelm"
fp = os.fspath(p)
def io_fun(_el: Jelm):
_el.json_dump(fp)
return read_json(fp)
jelm_pair_case.evaluate_fun(non_altering_function=io_fun)
def test_neighbors(jelm_pair_case: NetwokCaseTemplate):
def neighbor_check(el: Jelm):
for nid, n in el.nodes.items():
for nid2 in n.neighbors.keys():
assert nid in el.get_node(nid2).neighbors.keys()
for nid3 in n.target_neighbors.keys():
assert nid in el.get_node(nid3).source_neighbors.keys()
return el
jelm_pair_case.evaluate_fun(non_altering_function=neighbor_check)
def test_add_node_as_object_w_cases(jelm_pair_case: NetwokCaseTemplate):
def add_node_as_obj(el: Jelm):
el.add_object({"type": "node", "id": "n10"})
return el
def assert_node_as_obj_added(el: Jelm):
assert isinstance(el.get_node("n10"), Node)
def catch_node_as_obj_add(el: Jelm, e):
assert isinstance(e, ValueError)
assert isinstance(el.get_node("n10"), Node)
jelm_pair_case.evaluate_fun(
altering_function=add_node_as_obj,
assert_alteration=assert_node_as_obj_added,
catch_alteration_exception=catch_node_as_obj_add,
)
def test_eq(jelm_pair_case: NetwokCaseTemplate):
jelm_pair_case.evaluate_fun(non_altering_function=lambda x: x)
assert not (10 == Jelm())
assert not ("fing" == Jelm())