def test_meta_knowledge_graph_of_complex_graph_data():
"""
Test generate meta knowledge graph operation.
"""
input_args = {
"filename": [
os.path.join(RESOURCE_DIR, "complex_graph_nodes.tsv"),
os.path.join(RESOURCE_DIR, "complex_graph_edges.tsv"),
],
"format":
"tsv",
}
transformer = Transformer()
transformer.transform(input_args)
output_filename = os.path.join(TARGET_DIR,
"test_meta_knowledge_graph-1.json")
generate_meta_knowledge_graph(
graph=transformer.store.graph,
name="Complex Test Graph",
filename=output_filename,
edge_facet_properties=["aggregator_knowledge_source"])
data = json.load(open(output_filename))
assert data["name"] == "Complex Test Graph"
print(f"\n{json.dumps(data, indent=4)}")
def test_clique_merge():
"""
Test for clique merge.
"""
input_args = {
"filename": [
os.path.join(RESOURCE_DIR, "cm_nodes.csv"),
os.path.join(RESOURCE_DIR, "cm_edges.csv"),
],
"format": "csv",
}
t = Transformer()
t.transform(input_args)
updated_graph, clique_graph = clique_merge(
target_graph=t.store.graph, prefix_prioritization_map=prefix_prioritization_map
)
leaders = NxGraph.get_node_attributes(updated_graph, "clique_leader")
leader_list = list(leaders.keys())
leader_list.sort()
assert len(leader_list) == 2
n1 = updated_graph.nodes()[leader_list[0]]
assert n1["election_strategy"] == "PREFIX_PRIORITIZATION"
assert "NCBIGene:100302240" in n1["same_as"]
assert "ENSEMBL:ENSG00000284458" in n1["same_as"]
n2 = updated_graph.nodes()[leader_list[1]]
assert n2["election_strategy"] == "PREFIX_PRIORITIZATION"
assert "NCBIGene:8202" in n2["same_as"]
assert "OMIM:601937" in n2["same_as"]
assert "ENSEMBL:ENSG00000124151" not in n2["same_as"]
def test_validate_by_stream_inspector():
"""
Test generate the validate function by streaming
graph data through a graph Transformer.process() Inspector
"""
input_args = {
"filename": [
os.path.join(RESOURCE_DIR, "graph_nodes.tsv"),
os.path.join(RESOURCE_DIR, "graph_edges.tsv"),
],
"format": "tsv",
"aggregator_knowledge_source": True,
}
Validator.set_biolink_model("1.8.2")
# Validator assumes the currently set Biolink Release
validator = Validator()
transformer = Transformer(stream=True)
transformer.transform(
input_args=input_args,
output_args={
"format": "null"
}, # streaming processing throws the graph data away
# ... Second, we inject the Inspector into the transform() call,
# for the underlying Transformer.process() to use...
inspector=validator,
)
validator.write_report()
e = validator.get_errors()
assert len(e) == 0
def test_transformer_infores_basic_formatting():
input_args = {
"filename": [
os.path.join(RESOURCE_DIR, "test_infores_coercion_nodes.tsv"),
os.path.join(RESOURCE_DIR, "test_infores_coercion_edges.tsv"),
],
"format":
"tsv",
"provided_by":
True,
"aggregator_knowledge_source":
"true",
}
t = Transformer()
t.transform(input_args=input_args)
n1 = t.store.graph.nodes()["FlyBase:FBgn0000008"]
assert "provided_by" in n1
assert len(n1["provided_by"]) == 1
assert "infores:flybase-monarch-version-202012" in n1["provided_by"]
n2 = t.store.graph.nodes()["GO:0005912"]
assert "provided_by" in n2
assert len(n2["provided_by"]) == 1
assert "infores:gene-ontology-monarch-version-202012" in n2["provided_by"]
et = list(
t.store.graph.get_edge("FlyBase:FBgn0000008",
"GO:0005912").values())[0]
assert ("infores:gene-ontology-monarch-version-202012"
in et["aggregator_knowledge_source"])
def test_generate_classical_meta_knowledge_graph():
"""
Test generate meta knowledge graph operation.
"""
input_args = {
'filename': [
os.path.join(RESOURCE_DIR, 'graph_nodes.tsv'),
os.path.join(RESOURCE_DIR, 'graph_edges.tsv'),
],
'format':
'tsv',
}
transformer = Transformer()
transformer.transform(input_args)
output_filename = os.path.join(TARGET_DIR,
'test_meta_knowledge_graph-1.json')
generate_meta_knowledge_graph(transformer.store.graph, 'Test Graph',
output_filename)
data = json.load(open(output_filename))
assert data['name'] == 'Test Graph'
assert 'NCBIGene' in data['nodes']['biolink:Gene']['id_prefixes']
assert 'REACT' in data['nodes']['biolink:Pathway']['id_prefixes']
assert 'HP' in data['nodes']['biolink:PhenotypicFeature']['id_prefixes']
assert data['nodes']['biolink:Gene']['count'] == 178
assert len(data['nodes']) == 8
assert len(data['edges']) == 13
def test_summarize_graph_inspector():
"""
Test for Inspector sourced graph stats, and comparing the resulting stats.
"""
input_args = {
'filename': [
os.path.join(RESOURCE_DIR, 'graph_nodes.tsv'),
os.path.join(RESOURCE_DIR, 'graph_edges.tsv'),
],
'format':
'tsv',
}
transformer = Transformer(stream=True)
inspector = GraphSummary('Test Graph Summary - Streamed')
transformer.transform(input_args=input_args, inspector=inspector)
output_filename = os.path.join(TARGET_DIR,
'test_graph-summary-from-inspection.json')
with open(output_filename, 'w') as gsh:
inspector.save(output_filename)
data = json.load(open(output_filename))
assert data['name'] == 'Test Graph Summary - Streamed'
assert 'NCBIGene' in data['nodes']['biolink:Gene']['id_prefixes']
assert 'REACT' in data['nodes']['biolink:Pathway']['id_prefixes']
assert 'HP' in data['nodes']['biolink:PhenotypicFeature']['id_prefixes']
assert data['nodes']['biolink:Gene']['count'] == 178
assert len(data['nodes']) == 8
assert len(data['edges']) == 13
def test_generate_streaming_meta_knowledge_graph_direct():
"""
Test generate meta knowledge graph operation...
MetaKnowledgeGraph as direct Transformer.transform Inspector
"""
input_args = {
'filename': [
os.path.join(RESOURCE_DIR, 'graph_nodes.tsv'),
os.path.join(RESOURCE_DIR, 'graph_edges.tsv'),
],
'format':
'tsv',
}
transformer = Transformer(stream=True)
mkg = MetaKnowledgeGraph('Test Graph - Streamed')
transformer.transform(input_args=input_args, inspector=mkg)
assert mkg.get_name() == 'Test Graph - Streamed'
assert mkg.get_total_nodes_count() == 512
assert mkg.get_number_of_categories() == 8
assert mkg.get_total_edges_count() == 540
assert mkg.get_edge_mapping_count() == 13
assert 'NCBIGene' in mkg.get_category('biolink:Gene').get_id_prefixes()
assert 'REACT' in mkg.get_category('biolink:Pathway').get_id_prefixes()
assert 'HP' in mkg.get_category(
'biolink:PhenotypicFeature').get_id_prefixes()
assert mkg.get_category('biolink:Gene').get_count() == 178
def test_clique_merge():
"""
Test for clique merge.
"""
input_args = {
'filename': [
os.path.join(RESOURCE_DIR, 'cm_nodes.csv'),
os.path.join(RESOURCE_DIR, 'cm_edges.csv'),
],
'format':
'csv',
}
t = Transformer()
t.transform(input_args)
updated_graph, clique_graph = clique_merge(
target_graph=t.store.graph,
prefix_prioritization_map=prefix_prioritization_map)
leaders = NxGraph.get_node_attributes(updated_graph, 'clique_leader')
leader_list = list(leaders.keys())
leader_list.sort()
assert len(leader_list) == 2
n1 = updated_graph.nodes()[leader_list[0]]
assert n1['election_strategy'] == 'PREFIX_PRIORITIZATION'
assert 'NCBIGene:100302240' in n1['same_as']
assert 'ENSEMBL:ENSG00000284458' in n1['same_as']
n2 = updated_graph.nodes()[leader_list[1]]
assert n2['election_strategy'] == 'PREFIX_PRIORITIZATION'
assert 'NCBIGene:8202' in n2['same_as']
assert 'OMIM:601937' in n2['same_as']
assert 'ENSEMBL:ENSG00000124151' not in n2['same_as']
def test_transformer_infores_parser_prefix_rewrite():
input_args = {
"filename": [
os.path.join(RESOURCE_DIR, "test_infores_coercion_nodes.tsv"),
os.path.join(RESOURCE_DIR, "test_infores_coercion_edges.tsv"),
],
"format":
"tsv",
"provided_by": (r"\(.+\)", "", "Monarch"),
"aggregator_knowledge_source": (r"\(.+\)", "", "Monarch"),
}
t = Transformer()
t.transform(input_args=input_args)
n1 = t.store.graph.nodes()["FlyBase:FBgn0000008"]
assert "provided_by" in n1
assert len(n1["provided_by"]) == 1
assert "infores:monarch-flybase" in n1["provided_by"]
n2 = t.store.graph.nodes()["GO:0005912"]
assert "provided_by" in n2
assert len(n2["provided_by"]) == 1
assert "infores:monarch-gene-ontology" in n2["provided_by"]
et = list(
t.store.graph.get_edge("FlyBase:FBgn0000008",
"GO:0005912").values())[0]
assert "infores:monarch-gene-ontology" in et["aggregator_knowledge_source"]
irc = t.get_infores_catalog()
assert len(irc) == 2
assert "Gene Ontology (Monarch version 202012)" in irc
assert ("infores:monarch-gene-ontology"
in irc["Gene Ontology (Monarch version 202012)"])
def test_transformer_infores_suppression():
input_args = {
"filename": [
os.path.join(RESOURCE_DIR, "test_infores_coercion_nodes.tsv"),
os.path.join(RESOURCE_DIR, "test_infores_coercion_edges.tsv"),
],
"format":
"tsv",
"provided_by":
"False",
"aggregator_knowledge_source":
False,
}
t = Transformer()
t.transform(input_args=input_args)
n1 = t.store.graph.nodes()["FlyBase:FBgn0000008"]
assert "provided_by" not in n1
n2 = t.store.graph.nodes()["GO:0005912"]
assert "provided_by" not in n2
et = list(
t.store.graph.get_edge("FlyBase:FBgn0000008",
"GO:0005912").values())[0]
assert "aggregator_knowledge_source" not in et
def test_generate_classical_meta_knowledge_graph():
"""
Test generate meta knowledge graph operation.
"""
input_args = {
"filename": [
os.path.join(RESOURCE_DIR, "graph_nodes.tsv"),
os.path.join(RESOURCE_DIR, "graph_edges.tsv"),
],
"format":
"tsv",
}
transformer = Transformer()
transformer.transform(input_args)
output_filename = os.path.join(TARGET_DIR,
"test_meta_knowledge_graph-1.json")
generate_meta_knowledge_graph(
graph=transformer.store.graph,
name="Test Graph",
filename=output_filename,
edge_facet_properties=["aggregator_knowledge_source"])
data = json.load(open(output_filename))
assert data["name"] == "Test Graph"
_check_mkg_json_contents(data)
def test_validate_incorrect_edge(edge):
"""
Test basic validation of an edge, where the edge is invalid.
"""
t = Transformer()
s = Source(t)
assert not s.validate_edge(edge)
assert len(t.get_errors()) > 0
t.write_report()
def test_validate_correct_edge(edge):
"""
Test basic validation of an edge, where the edge is valid.
"""
t = Transformer()
s = Source(t)
e = s.validate_edge(edge)
assert e is not None
assert len(t.get_errors()) == 0
t.write_report()
def test_incorrect_edge_filters(edge):
"""
Test filtering of an edge
"""
t = Transformer()
s = Source(t)
filters = {"some_field": {"bad_edge_filter": 1}}
s.set_edge_filters(filters)
s.check_edge_filter(edge)
assert len(t.get_errors("Error")) > 0
t.write_report()
def test_validate_incorrect_node(node):
"""
Test basic validation of a node, where the node is invalid.
"""
t = Transformer()
s = Source(t)
result = s.validate_node(node)
if len(t.get_errors("Error")) > 0:
assert result is None
else:
assert result is not None
t.write_report()
def test_validate_json():
"""
Validate against a valid representative Biolink Model compliant JSON.
"""
input_args = {
"filename": [os.path.join(RESOURCE_DIR, "valid.json")],
"format": "json",
}
t = Transformer()
t.transform(input_args)
validator = Validator()
validator.validate(t.store.graph)
assert len(validator.get_errors()) == 0
def test_incorrect_nodes():
"""
Test basic validation of a node, where the node is invalid.
"""
t = Transformer()
s = TsvSource(t)
g = s.parse(filename=os.path.join(RESOURCE_DIR, "incomplete_nodes.tsv"),
format="tsv")
nodes = []
for rec in g:
if rec:
nodes.append(rec)
t.write_report()
def test_validate_json():
"""
Validate against a valid representative Biolink Model compliant JSON.
"""
input_args = {
'filename': [os.path.join(RESOURCE_DIR, 'valid.json')],
'format': 'json'
}
t = Transformer()
t.transform(input_args)
validator = Validator()
e = validator.validate(t.store.graph)
assert len(e) == 0
def test_meta_knowledge_graph_multiple_category_and_predicate_parsing():
"""
Test meta knowledge graph parsing multiple categories
"""
input_args = {
'filename': [
os.path.join(RESOURCE_DIR, 'graph_multi_category_nodes.tsv'),
os.path.join(RESOURCE_DIR, 'graph_multi_category_edges.tsv'),
],
'format':
'tsv',
}
t = Transformer(stream=True)
mkg = MetaKnowledgeGraph(name='Test Graph - Multiple Node Categories')
t.transform(input_args=input_args, inspector=mkg)
assert mkg.get_name() == 'Test Graph - Multiple Node Categories'
assert mkg.get_total_nodes_count() == 10
# unique set, including (shared) parent
# classes (not including category 'unknown' )
assert mkg.get_number_of_categories() == 7
assert mkg.get_node_count_by_category("biolink:Disease") == 1
assert mkg.get_node_count_by_category("biolink:BiologicalEntity") == 5
assert mkg.get_node_count_by_category(
"biolink:AnatomicalEntityEntity") == 0
# sums up all the counts of node mappings across
# all categories (not including category 'unknown')
assert mkg.get_total_node_counts_across_categories() == 35
# only counts 'valid' edges for which
# subject and object nodes are in the nodes file
assert mkg.get_total_edges_count() == 8
# total number of distinct predicates
assert mkg.get_predicate_count() == 2
# counts edges with a given predicate
# (ignoring edges with unknown subject or object identifiers)
assert mkg.get_edge_count_by_predicate("biolink:has_phenotype") == 4
assert mkg.get_edge_count_by_predicate("biolink:involved_in") == 0
assert mkg.get_edge_mapping_count() == 25
assert mkg.get_total_edge_counts_across_mappings() == 100
def test_rdf_transform3():
"""
Test parsing an RDF N-triple and round-trip.
"""
input_args1 = {
"filename": [os.path.join(RESOURCE_DIR, "rdf", "test1.nt")],
"format": "nt",
}
t1 = Transformer()
t1.transform(input_args1)
assert t1.store.graph.number_of_nodes() == 2
assert t1.store.graph.number_of_edges() == 1
output_args1 = {
"filename": os.path.join(TARGET_DIR, "test1-export.nt"),
"format": "nt",
}
t1.save(output_args1)
input_args2 = {
"filename": [os.path.join(TARGET_DIR, "test1-export.nt")],
"format": "nt",
}
t2 = Transformer()
t2.transform(input_args2)
assert t2.store.graph.number_of_nodes() == 2
assert t2.store.graph.number_of_edges() == 1
n1t1 = t1.store.graph.nodes()["ENSEMBL:ENSG0000000000001"]
n1t2 = t2.store.graph.nodes()["ENSEMBL:ENSG0000000000001"]
n1t3 = t2.store.graph.nodes()["ENSEMBL:ENSG0000000000001"]
assert n1t1["type"] == n1t2["type"] == n1t3["type"] == "SO:0000704"
assert len(n1t1["category"]) == len(n1t2["category"]) == len(
n1t3["category"]) == 4
assert ("biolink:Gene" in n1t1["category"]
and "biolink:Gene" in n1t2["category"]
and "biolink:Gene" in n1t3["category"])
assert ("biolink:GenomicEntity" in n1t1["category"]
and "biolink:GenomicEntity" in n1t2["category"]
and "biolink:GenomicEntity" in n1t3["category"])
assert ("biolink:NamedThing" in n1t1["category"]
and "biolink:NamedThing" in n1t2["category"]
and "biolink:NamedThing" in n1t3["category"])
assert n1t1["name"] == n1t2["name"] == n1t3["name"] == "Test Gene 123"
assert (n1t1["description"] == n1t2["description"] == n1t3["description"]
== "This is a Test Gene 123")
assert ("Test Dataset" in n1t1["provided_by"]
and "Test Dataset" in n1t2["provided_by"]
and "Test Dataset" in n1t3["provided_by"])
def _stream_transform(query):
"""
Transform an input to an output via Transformer where streaming is enabled.
"""
t1 = Transformer(stream=True)
t1.transform(query[0], query[1])
output = query[1]
if output["format"] in {"tsv", "csv", "jsonl"}:
input_args = {
"filename": [
f"{output['filename']}_nodes.{output['format']}",
f"{output['filename']}_edges.{output['format']}",
],
"format":
output["format"],
}
elif output["format"] in {"neo4j"}:
input_args = {
"uri": DEFAULT_NEO4J_URL,
"username": DEFAULT_NEO4J_USERNAME,
"password": DEFAULT_NEO4J_PASSWORD,
"format": "neo4j",
}
else:
input_args = {
"filename": [f"{output['filename']}"],
"format": output["format"]
}
t2 = Transformer()
t2.transform(input_args)
assert t2.store.graph.number_of_nodes() == query[2]
assert t2.store.graph.number_of_edges() == query[3]
def _stream_transform(query):
"""
Transform an input to an output via Transformer where streaming is enabled.
"""
t1 = Transformer(stream=True)
t1.transform(query[0], query[1])
output = query[1]
if output['format'] in {'tsv', 'csv', 'jsonl'}:
input_args = {
'filename': [
f"{output['filename']}_nodes.{output['format']}",
f"{output['filename']}_edges.{output['format']}",
],
'format':
output['format'],
}
elif output['format'] in {'neo4j'}:
input_args = {
'uri': DEFAULT_NEO4J_URL,
'username': DEFAULT_NEO4J_USERNAME,
'password': DEFAULT_NEO4J_PASSWORD,
'format': 'neo4j',
}
else:
input_args = {
'filename': [f"{output['filename']}"],
'format': output['format']
}
t2 = Transformer()
t2.transform(input_args)
assert t2.store.graph.number_of_nodes() == query[2]
assert t2.store.graph.number_of_edges() == query[3]
def test_rdf_transform3():
"""
Test parsing an RDF N-triple and round-trip.
"""
input_args1 = {
'filename': [os.path.join(RESOURCE_DIR, 'rdf', 'test1.nt')],
'format': 'nt'
}
t1 = Transformer()
t1.transform(input_args1)
assert t1.store.graph.number_of_nodes() == 2
assert t1.store.graph.number_of_edges() == 1
output_args1 = {
'filename': os.path.join(TARGET_DIR, 'test1-export.nt'),
'format': 'nt'
}
t1.save(output_args1)
input_args2 = {
'filename': [os.path.join(TARGET_DIR, 'test1-export.nt')],
'format': 'nt'
}
t2 = Transformer()
t2.transform(input_args2)
assert t2.store.graph.number_of_nodes() == 2
assert t2.store.graph.number_of_edges() == 1
n1t1 = t1.store.graph.nodes()['ENSEMBL:ENSG0000000000001']
n1t2 = t2.store.graph.nodes()['ENSEMBL:ENSG0000000000001']
n1t3 = t2.store.graph.nodes()['ENSEMBL:ENSG0000000000001']
assert n1t1['type'] == n1t2['type'] == n1t3['type'] == 'SO:0000704'
assert len(n1t1['category']) == len(n1t2['category']) == len(
n1t3['category']) == 4
assert ('biolink:Gene' in n1t1['category']
and 'biolink:Gene' in n1t2['category']
and 'biolink:Gene' in n1t3['category'])
assert ('biolink:GenomicEntity' in n1t1['category']
and 'biolink:GenomicEntity' in n1t2['category']
and 'biolink:GenomicEntity' in n1t3['category'])
assert ('biolink:NamedThing' in n1t1['category']
and 'biolink:NamedThing' in n1t2['category']
and 'biolink:NamedThing' in n1t3['category'])
assert n1t1['name'] == n1t2['name'] == n1t3['name'] == 'Test Gene 123'
assert (n1t1['description'] == n1t2['description'] == n1t3['description']
== 'This is a Test Gene 123')
assert ('Test Dataset' in n1t1['provided_by']
and 'Test Dataset' in n1t2['provided_by']
and 'Test Dataset' in n1t3['provided_by'])
def test_rdf_transform_with_filters1(query):
"""
Test RDF transform with filters.
"""
input_args = {
"filename": [os.path.join(RESOURCE_DIR, "rdf", "test3.nt")],
"format": "nt",
"node_filters": query[0],
"edge_filters": query[1],
}
t = Transformer()
t.transform(input_args)
assert t.store.graph.number_of_edges() == query[3]
def test_rdf_transform_with_filters1(query):
"""
Test RDF transform with filters.
"""
input_args = {
'filename': [os.path.join(RESOURCE_DIR, 'rdf', 'test3.nt')],
'format': 'nt',
'node_filters': query[0],
'edge_filters': query[1],
}
t = Transformer()
t.transform(input_args)
assert t.store.graph.number_of_nodes() == query[2]
assert t.store.graph.number_of_edges() == query[3]
def test_read_trapi_json1():
"""
Read from a JSON using TrapiSource.
"""
t = Transformer()
s = TrapiSource(t)
g = s.parse(os.path.join(RESOURCE_DIR, "rsa_sample.json"))
nodes = {}
edges = {}
for rec in g:
if rec:
if len(rec) == 4:
edges[(rec[0], rec[1])] = rec[3]
else:
nodes[rec[0]] = rec[1]
assert len(nodes.keys()) == 4
assert len(edges.keys()) == 3
n = nodes["HGNC:11603"]
assert n["id"] == "HGNC:11603"
assert n["name"] == "TBX4"
assert n["category"] == ["biolink:Gene"]
e = edges["HGNC:11603", "MONDO:0005002"]
assert e["subject"] == "HGNC:11603"
assert e["object"] == "MONDO:0005002"
assert e["predicate"] == "biolink:related_to"
def test_read_tsv():
"""
Read a TSV using TsvSource.
"""
t = Transformer()
s = TsvSource(t)
g = s.parse(filename=os.path.join(RESOURCE_DIR, "test_nodes.tsv"),
format="tsv")
nodes = []
for rec in g:
if rec:
nodes.append(rec)
assert len(nodes) == 3
nodes.sort()
n1 = nodes.pop()[-1]
assert n1["id"] == "CURIE:456"
assert n1["name"] == "Disease 456"
assert "biolink:Disease" in n1["category"]
assert "biolink:NamedThing" in n1["category"]
assert n1["description"] == '"Node of type Disease, CURIE:456"'
g = s.parse(filename=os.path.join(RESOURCE_DIR, "test_edges.tsv"),
format="tsv")
edges = []
for rec in g:
if rec:
edges.append(rec)
e1 = edges.pop()[-1]
assert "id" in e1
assert e1["subject"] == "CURIE:123"
assert e1["object"] == "CURIE:456"
assert e1["predicate"] == "biolink:related_to"
assert e1["relation"] == "biolink:related_to"
assert "PMID:1" in e1["publications"]
def test_read_jsonl1():
"""
Read from JSON Lines using JsonlSource.
"""
t = Transformer()
s = JsonlSource(t)
g = s.parse(os.path.join(RESOURCE_DIR, "valid_nodes.jsonl"))
nodes = {}
for rec in g:
if rec:
nodes[rec[0]] = rec[1]
g = s.parse(os.path.join(RESOURCE_DIR, "valid_edges.jsonl"))
edges = {}
for rec in g:
if rec:
edges[(rec[0], rec[1])] = rec[3]
assert len(nodes.keys()) == 7
assert len(edges.keys()) == 5
n = nodes["MONDO:0017148"]
assert "id" in n and n["id"] == "MONDO:0017148"
assert n["name"] == "heritable pulmonary arterial hypertension"
assert n["category"][0] == "biolink:Disease"
n2 = nodes["PUBCHEM.COMPOUND:10429502"]
assert "id" in n2 and n2["id"] == "PUBCHEM.COMPOUND:10429502"
assert n2["name"] == "16|A-Methyl Prednisolone"
e = edges[("HGNC:11603", "MONDO:0017148")]
assert e["subject"] == "HGNC:11603"
assert e["object"] == "MONDO:0017148"
assert e["predicate"] == "biolink:related_to"
assert e["relation"] == "RO:0004013"
def test_write_graph_no_edge_identifier():
"""
Write a graph via GraphSink.
"""
t = Transformer()
s = GraphSink(t)
s.write_node({
"id": "A",
"name": "Node A",
"category": ["biolink:NamedThing"]
})
s.write_node({
"id": "B",
"name": "Node B",
"category": ["biolink:NamedThing"]
})
s.write_node({
"id": "C",
"name": "Node C",
"category": ["biolink:NamedThing"]
})
s.write_edge({
"subject": "A",
"predicate": "biolink:related_to",
"object": "B",
"relation": "biolink:related_to",
})
assert s.graph.number_of_nodes() == 3
assert s.graph.number_of_edges() == 1
def test_write_neo2(clean_database, query):
"""
Test writing a graph to a Neo4j instance.
"""
graph = query[0]
t = Transformer()
sink = NeoSink(
owner=t,
uri=DEFAULT_NEO4J_URL,
username=DEFAULT_NEO4J_USERNAME,
password=DEFAULT_NEO4J_PASSWORD,
)
for n, data in graph.nodes(data=True):
sink.write_node(data)
for u, v, k, data in graph.edges(data=True, keys=True):
sink.write_edge(data)
sink.finalize()
nr = sink.session.run("MATCH (n) RETURN count(n)")
[node_counts] = [x for x in nr][0]
assert node_counts >= query[1]
er = sink.session.run("MATCH ()-[p]->() RETURN count(p)")
[edge_counts] = [x for x in er][0]
assert edge_counts >= query[2]
