def setUp(self):
"""Set up some temporary directories."""
self.tempdir = tempfile.TemporaryDirectory()
self.namespace_registry = NamespaceRegistry()
self.namespace_registry._load_cuba()
self.installer = OntologyInstallationManager(
namespace_registry=self.namespace_registry, path=self.tempdir.name)
def test_namespace_registry_load(self):
"""Test loading an installed namespaces."""
# no graph.xml found
self.namespace_registry.clear()
self.namespace_registry.load_graph_file(self.tempdir.name)
g = rdflib.Graph()
g.parse(CUBA_FILE, format="ttl")
self.assertTrue(isomorphic(g, self.namespace_registry._graph))
self.namespace_registry.clear()
self.graph = self.namespace_registry._graph
# graph.ttl found
self.graph.parse(RDF_FILE, format="ttl")
self.namespace_registry.bind(
"parser_test",
rdflib.URIRef("http://www.osp-core.com/"
"parser_test#"),
)
self.namespace_registry.update_namespaces()
self.namespace_registry.store(self.tempdir.name)
nr = NamespaceRegistry()
nr.load_graph_file(self.tempdir.name)
self.assertTrue(isomorphic(nr._graph, self.graph))
self.assertIn("parser_test", nr)
def setUp(self):
"""Set up Graph and Parser."""
self.namespace_registry = NamespaceRegistry()
self.graph = self.namespace_registry._graph
self.parser = Parser(parser_namespace_registry=self.namespace_registry)
with open(YML_FILE, "r") as file:
self.config_file = yaml.safe_load(file)
def setUp(self):
"""Set up the test."""
with open(YML_FILE, "r") as f:
self.yml_doc = yaml.safe_load(f)
self.ontology_doc = self.yml_doc["ontology"]
self.namespace_registry = NamespaceRegistry()
self.graph = self.namespace_registry._graph
self.parser = YMLParser(YML_FILE)
self.parser._ontology_doc = self.ontology_doc
class TestInstallation(unittest.TestCase):
"""Test the installation procedure."""
def setUp(self):
"""Set up some temporary directories."""
self.tempdir = tempfile.TemporaryDirectory()
self.namespace_registry = NamespaceRegistry()
self.namespace_registry._load_cuba()
self.installer = OntologyInstallationManager(
namespace_registry=self.namespace_registry, path=self.tempdir.name)
def tearDown(self):
"""Clean up temporary directories."""
self.tempdir.cleanup()
def copy_files(self):
"""Copy installed files.
Helper method.
"""
p1 = os.path.join(self.tempdir.name, os.path.basename(FILES[0]))
p2 = os.path.join(self.tempdir.name, os.path.basename(FILES[1]))
shutil.copyfile(FILES[0], p1)
shutil.copyfile(FILES[1], p2)
return p1, p2
def test_do_install(self):
"""Test performing the installation."""
# clear False
self.installer._install(FILES + ["invalid"],
lambda x: x[:-1],
clear=False)
self.assertIn("city", self.namespace_registry._namespaces)
self.assertIn("parser_test", self.namespace_registry._namespaces)
self.assertEqual(self.namespace_registry._namespaces["city"],
rdflib.term.URIRef('http://www.osp-core.com/city#'))
self.assertEqual(
self.namespace_registry._namespaces["parser_test"],
rdflib.term.URIRef('http://www.osp-core.com/parser_test#'))
self.assertEqual(
sorted(os.listdir(self.tempdir.name)),
sorted([
'city.yml', 'graph.xml', 'namespaces.txt', 'parser_test.xml',
'parser_test.yml'
]))
with open(os.path.join(self.tempdir.name, "namespaces.txt")) as f:
lines = set(map(lambda x: x.strip(), f))
self.assertIn("city\thttp://www.osp-core.com/city#", lines)
self.assertIn("cuba\thttp://www.osp-core.com/cuba#", lines)
self.assertIn("parser_test\thttp://www.osp-core.com/parser_test#",
lines)
g_old = self.namespace_registry._graph
# clear False
self.installer._install([FILES[0]], lambda x: x, clear=True)
self.assertNotIn("city", self.namespace_registry._namespaces)
self.assertIn("parser_test", self.namespace_registry._namespaces)
self.assertIsNot(g_old, self.namespace_registry._graph)
self.assertEqual(
self.namespace_registry._namespaces["parser_test"],
rdflib.term.URIRef('http://www.osp-core.com/parser_test#'))
self.assertEqual(
sorted(os.listdir(self.tempdir.name)),
sorted([
'graph.xml', 'namespaces.txt', 'parser_test.xml',
'parser_test.yml'
]))
with open(os.path.join(self.tempdir.name, "namespaces.txt")) as f:
lines = set(map(lambda x: x.strip(), f))
self.assertNotIn("city\thttp://www.osp-core.com/city#", lines)
self.assertIn("cuba\thttp://www.osp-core.com/cuba#", lines)
self.assertIn("parser_test\thttp://www.osp-core.com/parser_test#",
lines)
def test_get_new_packages(self):
"""Test getting new packages that need to be installed."""
o1, o2 = self.copy_files()
self.assertEqual(self.installer._get_new_packages(FILES), set())
os.remove(o1)
self.assertEqual(self.installer._get_new_packages(FILES), {FILES[0]})
def test_get_replaced_packages(self):
"""Test packages to install after installation with overwrite."""
o1, o2 = self.copy_files()
self.assertEqual(
set(self.installer._get_replaced_packages([FILES[0]])),
{FILES[0], o2})
self.assertRaises(FileNotFoundError,
self.installer._get_replaced_packages, ["invalid"])
def test_get_remaining_packages(self):
"""Test getting the remaining packages after un-installation."""
o1, o2 = self.copy_files()
self.assertRaises(ValueError, self.installer._get_remaining_packages,
["city", "invalid"])
self.assertRaises(ValueError, self.installer._get_remaining_packages,
["city.yml"])
self.assertEqual(self.installer._get_remaining_packages(FILES), [])
self.assertEqual(self.installer._get_remaining_packages([FILES[0]]),
[o2])
self.assertEqual(self.installer._get_remaining_packages([o2]), [o1])
os.remove(o2)
self.assertRaises(ValueError, self.installer._get_remaining_packages,
FILES)
def test_get_installed_packages(self):
"""Test getting the packages currently installed."""
o1, o2 = self.copy_files()
open(os.path.join(self.tempdir.name, "o3.xml"), "w").close()
self.assertEqual(self.installer.get_installed_packages(),
{"city", "parser_test"})
self.assertEqual(self.installer.get_installed_packages(True),
{("city", o2), ("parser_test", o1)})
def test_sort_for_installation(self):
"""Test sorting the packages to install by requirements."""
r = self.installer._sort_for_installation(["city", "parser_test"],
set())
self.assertEqual(r, ["city", "parser_test"])
r = self.installer._sort_for_installation(["parser_test", "city"],
set())
self.assertEqual(r, ["city", "parser_test"])
self.assertRaises(RuntimeError, self.installer._sort_for_installation,
["parser_test"], set())
def test_pico_migrate(self):
"""Test migration of installed ontologies."""
path = os.path.join(self.tempdir.name, ".osp_ontologies")
yml_dir = os.path.join(path, "yml", "installed")
os.makedirs(os.path.join(path, "yml", "installed"))
file = FILES[1]
dest = os.path.join(yml_dir, os.path.basename(file))
shutil.copyfile(file, dest)
pkl_file = os.path.join(path, "foo.bar.pkl")
open(pkl_file, "wb").close()
self.installer.namespace_registry._graph = rdflib.Graph()
pico_migrate(self.installer.namespace_registry, path)
self.assertEqual(sorted(os.listdir(path)),
sorted(['city.yml', 'graph.xml', 'namespaces.txt']))
class TestNamespaces(unittest.TestCase):
"""Test namespace registry and namespaces."""
def setUp(self):
"""Set up some temporary directories."""
self.tempdir = tempfile.TemporaryDirectory()
self.namespace_registry = NamespaceRegistry()
self.namespace_registry._load_cuba()
self.installer = OntologyInstallationManager(
namespace_registry=self.namespace_registry, path=self.tempdir.name)
self.graph = self.namespace_registry._graph
def tearDown(self):
"""Clean up all temporary directories."""
self.tempdir.cleanup()
def test_namespace_registry_load_cuba(self):
"""Test loading the CUBA namespace."""
g = rdflib.Graph()
g.parse(CUBA_FILE, format="ttl")
self.assertTrue(isomorphic(g, self.graph))
self.assertIn("cuba", self.namespace_registry._namespaces)
self.assertEqual(
self.namespace_registry._namespaces["cuba"],
rdflib.URIRef("http://www.osp-core.com/cuba#"),
)
def test_namespace_registry_store(self):
"""Test storing loaded namespaces."""
self.graph.parse(RDF_FILE, format="ttl")
self.namespace_registry.bind(
"parser_test",
rdflib.URIRef("http://www.osp-core.com"
"/parser_test#"),
)
self.namespace_registry.update_namespaces()
self.namespace_registry.store(self.tempdir.name)
self.assertItemsEqual(os.listdir(self.tempdir.name),
["graph.xml", "namespaces.txt"])
g = rdflib.Graph()
g.parse(os.path.join(self.tempdir.name, "graph.xml"), format="xml")
g1 = rdflib.Graph()
g1.parse(CUBA_FILE, format="ttl")
g1.parse(RDF_FILE, format="ttl")
self.assertTrue(isomorphic(g, g1))
with open(os.path.join(self.tempdir.name, "namespaces.txt")) as f:
lines = set(map(lambda x: x.strip(), f))
self.assertIn("cuba\thttp://www.osp-core.com/cuba#", lines)
self.assertIn("parser_test\thttp://www.osp-core.com/parser_test#",
lines)
def test_namespace_registry_load(self):
"""Test loading an installed namespaces."""
# no graph.xml found
self.namespace_registry.clear()
self.namespace_registry.load_graph_file(self.tempdir.name)
g = rdflib.Graph()
g.parse(CUBA_FILE, format="ttl")
self.assertTrue(isomorphic(g, self.namespace_registry._graph))
self.namespace_registry.clear()
self.graph = self.namespace_registry._graph
# graph.ttl found
self.graph.parse(RDF_FILE, format="ttl")
self.namespace_registry.bind(
"parser_test",
rdflib.URIRef("http://www.osp-core.com/"
"parser_test#"),
)
self.namespace_registry.update_namespaces()
self.namespace_registry.store(self.tempdir.name)
nr = NamespaceRegistry()
nr.load_graph_file(self.tempdir.name)
self.assertTrue(isomorphic(nr._graph, self.graph))
self.assertIn("parser_test", nr)
def test_namespace_registry_clear(self):
"""Test clearing a namespace registry."""
self.namespace_registry.clear()
self.assertIsNot(self.namespace_registry._graph, self.graph)
self.assertTrue(isomorphic(self.namespace_registry._graph, self.graph))
def test_namespace_registry_from_iri(self):
"""Test getting namespaces from iri."""
self.installer.install("city")
ns_iri = rdflib.URIRef("http://www.osp-core.com/city#")
city_iri = ns_iri + "City"
hasPart_iri = ns_iri + "hasPart"
self.modify_labels()
c = self.namespace_registry.from_iri(rdflib_cuba.Entity)
self.assertIsInstance(c, OntologyClass)
self.assertEqual(c.namespace.get_name(), "cuba")
self.assertEqual(c.name, "Entity")
r = self.namespace_registry.from_iri(rdflib_cuba.relationship)
self.assertIsInstance(r, OntologyRelationship)
self.assertEqual(r.namespace.get_name(), "cuba")
self.assertEqual(r.name, "relationship")
a = self.namespace_registry.from_iri(rdflib_cuba.attribute)
self.assertIsInstance(a, OntologyAttribute)
self.assertEqual(a.namespace.get_name(), "cuba")
self.assertEqual(a.name, "attribute")
c = self.namespace_registry.from_iri(city_iri)
self.assertIsInstance(c, OntologyClass)
self.assertEqual(c.namespace.get_name(), "city")
self.assertEqual(c.name, "City")
r = self.namespace_registry.from_iri(hasPart_iri)
self.assertIsInstance(r, OntologyRelationship)
self.assertEqual(r.namespace.get_name(), "city")
self.assertEqual(r.name, "hasPart")
import osp.core.namespaces
old_ns_reg = osp.core.ontology.namespace_registry.namespace_registry
try:
osp.core.ontology.namespace_registry.namespace_registry = (
self.namespace_registry)
from_iri = self.namespace_registry.from_iri
c = from_iri(rdflib_cuba.Entity)
self.assertIsInstance(c, OntologyClass)
self.assertEqual(c.namespace.get_name(), "cuba")
self.assertEqual(c.name, "Entity")
self.graph.add((ns_iri, rdflib_cuba._reference_by_label,
rdflib.Literal(True)))
self.namespace_registry.from_iri.cache_clear()
self.namespace_registry._get.cache_clear()
c = from_iri(city_iri)
self.assertIsInstance(c, OntologyClass)
self.assertEqual(c.namespace.get_name(), "city")
self.assertEqual(c.name, "City_T")
r = from_iri(hasPart_iri)
self.assertIsInstance(r, OntologyRelationship)
self.assertEqual(r.namespace.get_name(), "city")
self.assertEqual(r.name, "hasPart_T")
# undefined namespace
self.graph.add(
(rdflib.URIRef("a/b#c"), rdflib.RDF.type, rdflib.OWL.Class))
self.graph.add(
(rdflib.URIRef("d/e/f"), rdflib.RDF.type, rdflib.OWL.Class))
a = from_iri("a/b#c")
b = from_iri("d/e/f")
self.assertIsInstance(a, OntologyClass)
self.assertEqual(a.namespace.get_name(), "a/b#")
self.assertEqual(a.name, "c")
self.assertIsInstance(b, OntologyClass)
self.assertEqual(b.namespace.get_name(), "d/e/")
self.assertEqual(b.name, "f")
finally:
osp.core.ontology.namespace_registry = old_ns_reg
def test_namespace_registry_update_namespaces(self):
"""Test updateing the namespaces."""
self.namespace_registry.bind("a", rdflib.URIRef("aaa"))
self.namespace_registry.bind("b", rdflib.URIRef("bbb"))
self.namespace_registry.bind("c", rdflib.URIRef("ccc"))
self.namespace_registry.update_namespaces()
self.assertEqual(self.namespace_registry.a.get_name(), "a")
self.assertEqual(self.namespace_registry.a.get_iri(),
rdflib.URIRef("aaa"))
self.assertEqual(self.namespace_registry.b.get_name(), "b")
self.assertEqual(self.namespace_registry.b.get_iri(),
rdflib.URIRef("bbb"))
self.assertEqual(self.namespace_registry.c.get_name(), "c")
self.assertEqual(self.namespace_registry.c.get_iri(),
rdflib.URIRef("ccc"))
def test_namespace_registry_get(self):
"""Test getting namsepaces from namespace registry."""
self.installer.install("city")
self.assertIn("city", self.namespace_registry)
self.assertEqual(
self.namespace_registry._get("city").get_name(), "city")
self.assertEqual(
self.namespace_registry.get("city").get_name(), "city")
self.assertEqual(self.namespace_registry["city"].get_name(), "city")
self.assertEqual(self.namespace_registry.city.get_name(), "city")
self.assertRaises(KeyError, self.namespace_registry._get, "invalid")
self.assertEqual(self.namespace_registry.get("invalid"), None)
self.assertRaises(KeyError, self.namespace_registry.__getitem__,
"invalid")
self.assertRaises(AttributeError, getattr, self.namespace_registry,
"invalid")
self.assertEqual({x.get_name()
for x in self.namespace_registry}, {"cuba", "city"})
def modify_labels(self):
"""Modify the labels in the graph. Append a T.
Helper method.
"""
namespace = self.namespace_registry.city
triples = list()
for s, p, o in self.graph:
if s in namespace and p in (
rdflib.SKOS.prefLabel,
rdflib.RDFS.label,
):
# To test querying by label.
label_SKOS = f"{o}_T"
triples.append((
s,
rdflib.SKOS.prefLabel,
rdflib.Literal(label_SKOS, lang="en"),
))
# To test RDFS labels and special characters.
label_RDFS = f"{o}-$"
triples.append((
s,
rdflib.RDFS.label,
rdflib.Literal(label_RDFS, lang="en"),
))
# To test non-english languages.
label_RDFS_jp = f"{o}_T_jp"
triples.append((
s,
rdflib.RDFS.label,
rdflib.Literal(label_RDFS_jp, lang="jp"),
))
label_SKOS_aa = f"{o}_T_aa_SKOS"
triples.append((
s,
rdflib.SKOS.prefLabel,
rdflib.Literal(label_SKOS_aa, lang="aa"),
))
# To test undefined languages.
label_RDFS_unk = f"{o}_T_unknown_lang"
triples.append(
(s, rdflib.RDFS.label, rdflib.Literal(label_RDFS_unk)))
# To test labels that coincide in different languages.
label_RDFS_es = f"{o}_T_cosa"
label_RDFS_it = f"{o}_T_cosa"
for label, lang in (
(label_RDFS_es, "es"),
(label_RDFS_it, "it"),
):
triples.append((
s,
rdflib.RDFS.label,
rdflib.Literal(label, lang=lang),
))
else:
triples.append((s, p, o))
# Test different concepts with same label, and querying by language.
triples.append((
rdflib.URIRef(str(namespace._iri) + "City"),
rdflib.RDFS.label,
rdflib.Literal("Burro", lang="it"),
))
triples.append((
rdflib.URIRef(str(namespace._iri) + "Street"),
rdflib.RDFS.label,
rdflib.Literal("Burro", lang="es"),
))
self.graph.remove((None, None, None))
for t in triples:
self.graph.add(t)
def test_namespace_get(self):
"""Test getting entities from namespace."""
self.installer.install("city")
self.modify_labels()
namespace = self.namespace_registry.city
# dot
self.assertIsInstance(namespace.City, OntologyClass)
self.assertEqual(namespace.City.name, "City")
self.assertEqual(namespace.City._iri_suffix, "City")
self.assertIsInstance(namespace.hasPart, OntologyRelationship)
self.assertEqual(namespace.hasPart.name, "hasPart")
self.assertEqual(namespace.hasPart._iri_suffix, "hasPart")
self.assertIsInstance(namespace.coordinates, OntologyAttribute)
self.assertEqual(namespace.coordinates.name, "coordinates")
self.assertEqual(namespace.coordinates._iri_suffix, "coordinates")
# item
self.assertIsInstance(namespace["City_T"], OntologyClass)
self.assertEqual(namespace["City_T"].name, "City")
self.assertEqual(namespace["City_T"]._iri_suffix, "City")
self.assertIsInstance(namespace["City_T", "en"], OntologyClass)
self.assertEqual(namespace["City_T", "en"].name, "City")
self.assertEqual(namespace["City_T", "en"]._iri_suffix, "City")
self.assertIsInstance(namespace["hasPart_T"], OntologyRelationship)
self.assertEqual(namespace["hasPart_T"].name, "hasPart")
self.assertEqual(namespace["hasPart_T"]._iri_suffix, "hasPart")
self.assertIsInstance(namespace["coordinates_T"], OntologyAttribute)
self.assertEqual(namespace["coordinates_T"].name, "coordinates")
self.assertEqual(namespace["coordinates_T"]._iri_suffix, "coordinates")
# get
self.assertIsInstance(namespace.get("City"), OntologyClass)
self.assertEqual(namespace.get("City").name, "City")
self.assertEqual(namespace.get("City")._iri_suffix, "City")
self.assertIsInstance(namespace.get("hasPart"), OntologyRelationship)
self.assertEqual(namespace.get("hasPart").name, "hasPart")
self.assertEqual(namespace.get("hasPart")._iri_suffix, "hasPart")
self.assertIsInstance(namespace.get("coordinates"), OntologyAttribute)
self.assertEqual(namespace.get("coordinates").name, "coordinates")
self.assertEqual(
namespace.get("coordinates")._iri_suffix, "coordinates")
self.assertRaises(AttributeError, namespace.__getattr__, "CITY")
self.assertRaises(KeyError, namespace.__getitem__, "HAS_PART_T")
self.assertRaises(KeyError, namespace.__getitem__, "HAS_PART")
self.assertEqual(namespace.get("COORDINATES"), None)
# reference by label
namespace._reference_by_label = True
# The above line is artificial (the user is not expected to change
# this private variable at runtime). Therefore, the cache for the
# `_get_from_label` method needs to be cleared for the test, as it
# produces different results depending on the value of
# `_reference_by_label`.
namespace._get_from_label.cache_clear()
# dot
self.assertIsInstance(namespace.City_T, OntologyClass)
self.assertEqual(namespace.City_T.name, "City_T")
self.assertEqual(namespace.City_T._iri_suffix, "City")
self.assertIsInstance(namespace.hasPart_T, OntologyRelationship)
self.assertEqual(namespace.hasPart_T.name, "hasPart_T")
self.assertEqual(namespace.hasPart_T._iri_suffix, "hasPart")
self.assertIsInstance(namespace.coordinates_T, OntologyAttribute)
self.assertEqual(namespace.coordinates_T.name, "coordinates_T")
self.assertEqual(namespace.coordinates_T._iri_suffix, "coordinates")
# item
self.assertIsInstance(namespace["City_T"], OntologyClass)
self.assertEqual(namespace["City_T"].name, "City_T")
self.assertEqual(namespace["City_T"]._iri_suffix, "City")
self.assertIsInstance(namespace["City_T", "en"], OntologyClass)
self.assertEqual(namespace["City_T", "en"].name, "City_T")
self.assertEqual(namespace["City_T", "en"]._iri_suffix, "City")
self.assertIsInstance(namespace["hasPart_T"], OntologyRelationship)
self.assertEqual(namespace["hasPart_T"].name, "hasPart_T")
self.assertEqual(namespace["hasPart_T"]._iri_suffix, "hasPart")
self.assertIsInstance(namespace["coordinates_T"], OntologyAttribute)
self.assertEqual(namespace["coordinates_T"].name, "coordinates_T")
self.assertEqual(namespace["coordinates_T"]._iri_suffix, "coordinates")
# get
self.assertIsInstance(namespace.get("City_T"), OntologyClass)
self.assertEqual(namespace.get("City_T").name, "City_T")
self.assertEqual(namespace.get("City_T")._iri_suffix, "City")
self.assertIsInstance(namespace.get("hasPart_T"), OntologyRelationship)
self.assertEqual(namespace.get("hasPart_T").name, "hasPart_T")
self.assertEqual(namespace.get("hasPart_T")._iri_suffix, "hasPart")
self.assertIsInstance(namespace.get("coordinates_T"),
OntologyAttribute)
self.assertEqual(namespace.get("coordinates_T").name, "coordinates_T")
self.assertEqual(
namespace.get("coordinates_T")._iri_suffix, "coordinates")
self.assertRaises(AttributeError, namespace.__getattr__, "CITY")
self.assertRaises(KeyError, namespace.__getitem__, "HAS_PART_T")
self.assertRaises(KeyError, namespace.__getitem__, "HAS_PART")
self.assertEqual(namespace.get("COORDINATES"), None)
self.assertRaises(AttributeError, namespace.__getattr__, "City")
self.assertRaises(KeyError, namespace.__getitem__, "City")
self.assertEqual(namespace.get("coordinates"), None)
# Special characters and RDFS labels.
# RDFS label (special characters)
self.assertIsInstance(getattr(namespace, "City-$"), OntologyClass)
self.assertEqual(getattr(namespace, "City-$").name, "City-$")
self.assertEqual(getattr(namespace, "City-$")._iri_suffix, "City")
# Language.
# Refer to the label in non-english language.
self.assertIsInstance(namespace.City_T_jp, OntologyClass)
self.assertEqual(namespace.City_T_jp.name, "City_T_jp")
self.assertEqual(namespace.City_T._iri_suffix, "City")
# Labels with unknown languages.
self.assertEqual(namespace["City_T_unknown_lang"].name,
"City_T_unknown_lang")
# Coincident label in different languages.
self.assertIsInstance(namespace.City_T_cosa, OntologyClass)
self.assertEqual(namespace.City_T_cosa.name, "City_T_cosa")
self.assertEqual(namespace.City_T._iri_suffix, "City")
# Different concepts with the same label.
self.assertRaises(AttributeError, namespace.__getattr__, "Burro")
# Same word with different concept in different languages.
self.assertEqual(namespace["Burro", "it"], namespace.City_T)
self.assertEqual(namespace["Burro", "es"], namespace.Street_T)
def test_namespace_str(self):
"""Test converting namespace object to string."""
self.installer.install("city")
namespace = self.namespace_registry.city
self.assertEqual(str(namespace),
"city (http://www.osp-core.com/city#)")
self.assertEqual(repr(namespace),
"<city: http://www.osp-core.com/city#>")
def test_get_default_rel(self):
"""Test getting the default relationship."""
# default rel defined as flag in entity name
self.installer.install("city")
namespace = self.namespace_registry.city
self.assertEqual(namespace.get_default_rel().name, "hasPart")
onto_def_rel = os.path.join(os.path.dirname(__file__),
"default_rel_across_namespace_valid.yml")
self.installer.install(onto_def_rel)
namespace = self.namespace_registry.default_rel_test_namespace_valid
self.assertEqual(namespace.get_default_rel(), cuba.activeRelationship)
onto_def_rel = os.path.join(
os.path.dirname(__file__),
"default_rel_across_namespace_two_definitions.yml",
)
self.assertRaises(ValueError, self.installer.install, onto_def_rel)
onto_def_rel = os.path.join(
os.path.dirname(__file__),
"default_rel_across_namespace_uninstalled_entity.yml",
)
self.assertRaises(ValueError, self.installer.install, onto_def_rel)
# Now this will be checked at installation time.
onto_def_rel = os.path.join(
os.path.dirname(__file__),
"default_rel_across_namespace_uninstalled_namespace.yml",
)
self.assertRaises(ValueError, self.installer.install, onto_def_rel)
def test_contains(self):
"""Test containment."""
self.installer.install("city")
namespace = self.namespace_registry.city
self.assertIn("City", namespace)
self.assertIn("hasPart", namespace)
def test_iter(self):
"""Test the __iter__() magic method."""
self.installer.install("city")
namespace = self.namespace_registry.city
entities = set(namespace)
self.assertIn(namespace.encloses, entities)
self.assertIn(namespace.City, entities)
self.assertIn(namespace.name, entities)
self.assertEqual(len(entities), 32)
def test_get_namespace_from_iri(self):
"""Test getting namespace object from IRI."""
self.installer.install("city")
ns_iri = rdflib.URIRef("http://www.osp-core.com/city#")
namespace = self.namespace_registry.namespace_from_iri(ns_iri)
self.assertEqual(namespace.get_name(), "city")
self.assertEqual(namespace.get_iri(), ns_iri)
ns_iri = rdflib.URIRef("http://www.random_namespace.com#")
namespace = self.namespace_registry.namespace_from_iri(ns_iri)
self.assertEqual(namespace.get_name(),
"http://www.random_namespace.com#")
self.assertEqual(namespace.get_iri(), ns_iri)
def test_get_namespace_name_and_iri(self):
"""Test getting namespace name and IRI."""
self.installer.install("city")
self.assertEqual(
self.namespace_registry._get_namespace_name_and_iri(
rdflib.URIRef("http://www.osp-core.com/city#City")),
("city", rdflib.URIRef("http://www.osp-core.com/city#")),
)
self.assertEqual(
self.namespace_registry._get_namespace_name_and_iri(
rdflib.URIRef("http://www.random_namespace.com#Bla")),
(
"http://www.random_namespace.com#",
rdflib.URIRef("http://www.random_namespace.com#"),
),
)
self.assertEqual(
self.namespace_registry._get_namespace_name_and_iri(
rdflib.URIRef("http://www.random_namespace.com/Bla")),
(
"http://www.random_namespace.com/",
rdflib.URIRef("http://www.random_namespace.com/"),
),
)
def test_get_reference_by_label(self):
"""Test getting the reference style."""
self.installer.install("city")
ns_iri = rdflib.URIRef("http://www.osp-core.com/city#")
self.assertFalse(
self.namespace_registry._get_reference_by_label(ns_iri))
self.graph.add(
(ns_iri, rdflib_cuba._reference_by_label, rdflib.Literal(True)))
self.assertTrue(
self.namespace_registry._get_reference_by_label(ns_iri))
def test_get_entity_name(self):
"""Test getting the name of an entity."""
self.installer.install("city")
self.modify_labels()
ns_iri = rdflib.URIRef("http://www.osp-core.com/city#")
iri = rdflib.URIRef("http://www.osp-core.com/city#City")
self.assertEqual(self.namespace_registry._get_entity_name(iri, ns_iri),
"City")
self.graph.add(
(ns_iri, rdflib_cuba._reference_by_label, rdflib.Literal(True)))
self.assertEqual(self.namespace_registry._get_entity_name(iri, ns_iri),
"City_T")
def test_autocompletion_ipython(self):
"""Checks that all the expected ontology entities are in __dir__.
The check is done just for the `cuba` namespace.
"""
expected = {
"activeRelationship",
"passiveRelationship",
"relationship",
"attribute",
"path",
"Entity",
"File",
"Nothing",
"Wrapper",
}
self.assertSetEqual(set(dir(cuba)) & expected, expected)
class TestInstallation(unittest.TestCase):
"""Test the installation procedure."""
_rdf_file: tempfile.NamedTemporaryFile
"""RDF file that does NOT contain an ontology."""
_yml_file: tempfile.NamedTemporaryFile
"""YML configuration file for the previous file."""
@classmethod
def setUpClass(cls):
"""Create additional ontology files."""
cls._rdf_file = tempfile.NamedTemporaryFile(delete=False,
suffix=".ttl",
mode="w")
cls._rdf_file.write("@prefix ns1: <none:> .\n"
"ns1:a ns1:meaningless ns1:triple .\n\n")
cls._rdf_file.close()
cls._yml_file = tempfile.NamedTemporaryFile(delete=False,
suffix=".yml",
mode="w")
cls._yml_file.write(f"identifier: test_pkg\n"
f"ontology_file: {cls._rdf_file.name}\n"
f"format: ttl\n"
f"reference_by_label: False\n"
f"namespaces: \n"
f' none: "none:"\n'
f"active_relationships: []\n")
cls._yml_file.close()
@classmethod
def tearDownClass(cls):
"""Delete extra ontology files created during class setup."""
Path(cls._rdf_file.name).unlink()
Path(cls._yml_file.name).unlink()
def setUp(self):
"""Set up some temporary directories."""
self.tempdir = tempfile.TemporaryDirectory()
self.namespace_registry = NamespaceRegistry()
self.namespace_registry._load_cuba()
self.installer = OntologyInstallationManager(
namespace_registry=self.namespace_registry, path=self.tempdir.name)
def tearDown(self):
"""Clean up temporary directories."""
self.tempdir.cleanup()
def copy_files(self):
"""Copy installed files.
Helper method.
"""
p1 = os.path.join(self.tempdir.name, os.path.basename(FILES[0]))
p2 = os.path.join(self.tempdir.name, os.path.basename(FILES[1]))
shutil.copyfile(FILES[0], p1)
shutil.copyfile(FILES[1], p2)
return p1, p2
def test_do_install(self):
"""Test performing the installation."""
# clear False
self.installer._install(FILES + ["invalid"],
lambda x: x[:-1],
clear=False)
self.assertIn("city", self.namespace_registry._namespaces)
self.assertIn("parser_test", self.namespace_registry._namespaces)
self.assertEqual(
self.namespace_registry._namespaces["city"],
URIRef("http://www.osp-core.com/city#"),
)
self.assertEqual(
self.namespace_registry._namespaces["parser_test"],
URIRef("http://www.osp-core.com/parser_test#"),
)
self.assertEqual(
sorted(os.listdir(self.tempdir.name)),
sorted([
"city.yml",
"graph.xml",
"namespaces.txt",
"parser_test.xml",
"parser_test.yml",
]),
)
with open(os.path.join(self.tempdir.name, "namespaces.txt")) as f:
lines = set(map(lambda x: x.strip(), f))
self.assertIn("city\thttp://www.osp-core.com/city#", lines)
self.assertIn("cuba\thttp://www.osp-core.com/cuba#", lines)
self.assertIn("parser_test\thttp://www.osp-core.com/parser_test#",
lines)
g_old = self.namespace_registry._graph
# clear False
self.installer._install([FILES[0]], lambda x: x, clear=True)
self.assertNotIn("city", self.namespace_registry._namespaces)
self.assertIn("parser_test", self.namespace_registry._namespaces)
self.assertIsNot(g_old, self.namespace_registry._graph)
self.assertEqual(
self.namespace_registry._namespaces["parser_test"],
URIRef("http://www.osp-core.com/parser_test#"),
)
self.assertEqual(
sorted(os.listdir(self.tempdir.name)),
sorted([
"graph.xml",
"namespaces.txt",
"parser_test.xml",
"parser_test.yml",
]),
)
with open(os.path.join(self.tempdir.name, "namespaces.txt")) as f:
lines = set(map(lambda x: x.strip(), f))
self.assertNotIn("city\thttp://www.osp-core.com/city#", lines)
self.assertIn("cuba\thttp://www.osp-core.com/cuba#", lines)
self.assertIn("parser_test\thttp://www.osp-core.com/parser_test#",
lines)
def test_conflicting_labels(self):
"""Tests that ontologies with conflicting labels fail to be installed.
An example of such an ontology is the FOAF ontology, which has the same
label for multiple IRIs. An error is only raised on installation if the
reference_by_label option is set to Tue in the yml file.
"""
FOAF = """
identifier: foaf_TEST
ontology_file: http://xmlns.com/foaf/spec/index.rdf
reference_by_label: True
namespaces:
foaf_TEST: "http://xmlns.com/foaf/0.1/"
active_relationships: []
"""
foaf_file = tempfile.NamedTemporaryFile(delete=False, suffix=".yml")
foaf_file.close()
with open(foaf_file.name, "w") as file:
file.write(FOAF)
self.assertRaises(
KeyError,
self.installer._install,
[foaf_file.name],
lambda files: [foaf_file.name],
clear=False,
)
os.remove(foaf_file.name)
def test_get_new_packages(self):
"""Test getting new packages that need to be installed."""
o1, o2 = self.copy_files()
self.assertEqual(self.installer._get_new_packages(FILES), set())
os.remove(o1)
self.assertEqual(self.installer._get_new_packages(FILES), {FILES[0]})
def test_get_replaced_packages(self):
"""Test packages to install after installation with overwrite."""
o1, o2 = self.copy_files()
self.assertEqual(
set(self.installer._get_replaced_packages([FILES[0]])),
{FILES[0], o2},
)
self.assertRaises(
FileNotFoundError,
self.installer._get_replaced_packages,
["invalid"],
)
def test_get_remaining_packages(self):
"""Test getting the remaining packages after un-installation."""
o1, o2 = self.copy_files()
self.assertRaises(
ValueError,
self.installer._get_remaining_packages,
["city", "invalid"],
)
self.assertRaises(ValueError, self.installer._get_remaining_packages,
["city.yml"])
self.assertEqual(self.installer._get_remaining_packages(FILES), [])
self.assertEqual(self.installer._get_remaining_packages([FILES[0]]),
[o2])
self.assertEqual(self.installer._get_remaining_packages([o2]), [o1])
os.remove(o2)
self.assertRaises(ValueError, self.installer._get_remaining_packages,
FILES)
def test_get_installed_packages(self):
"""Test getting the packages currently installed."""
o1, o2 = self.copy_files()
open(os.path.join(self.tempdir.name, "o3.xml"), "w").close()
self.assertEqual(self.installer.get_installed_packages(),
{"city", "parser_test"})
self.assertEqual(
self.installer.get_installed_packages(True),
{("city", o2), ("parser_test", o1)},
)
def test_sort_for_installation(self):
"""Test sorting the packages to install by requirements."""
r = self.installer._sort_for_installation(["city", "parser_test"],
set())
self.assertEqual(r, ["city", "parser_test"])
r = self.installer._sort_for_installation(["parser_test", "city"],
set())
self.assertEqual(r, ["city", "parser_test"])
# Test unsatisfiable requirements
with tempfile.TemporaryDirectory():
with open("ontology_file.yml", "w") as file:
file.write(FILE_WITH_UNSATISFIABLE_REQUIREMENTS)
self.assertRaises(
RuntimeError,
self.installer._sort_for_installation,
[file.name],
set(),
)
def test_pico_migrate(self):
"""Test migration of installed ontologies."""
path = os.path.join(self.tempdir.name, ".osp_ontologies")
yml_dir = os.path.join(path, "yml", "installed")
os.makedirs(os.path.join(path, "yml", "installed"))
file = FILES[1]
dest = os.path.join(yml_dir, os.path.basename(file))
shutil.copyfile(file, dest)
pkl_file = os.path.join(path, "foo.bar.pkl")
open(pkl_file, "wb").close()
pico_migrate(self.installer.namespace_registry, path)
self.assertEqual(
sorted(os.listdir(path)),
sorted(["city.yml", "graph.xml", "namespaces.txt"]),
)
def test_empty_file(self):
"""Tests installing an RDF file NOT containing an ontology."""
def install_empty_file():
"""Install an RDF file that contains no ontology information."""
self.installer._install([self._yml_file.name],
lambda x: (x for x in x),
clear=False)
self.assertRaises(RuntimeError, install_empty_file)
def test_dcterms(self):
"""Test DCMI Metadata Terms installation."""
def count_warnings_by_class(
records: Iterable[logging.LogRecord],
classes: Union[Type, Tuple[Type, ...]],
) -> int:
"""Given log records, count their "classes" if attached.
For each record, checks if it has a `warning_class` attribute,
and checks whether its value is a subclass of the classes
provided.
"""
return sum(
bool(
issubclass(record.warning_class, classes) if hasattr(
record, "warning_class") else False)
for record in records)
original_warning_setting = warning_settings.rdf_properties_warning
try:
warning_settings.rdf_properties_warning = False
with self.assertLogs(logger=logger) as captured:
logger.warning("At least one log entry is needed for "
"`assertLogs`.")
self.installer._install(
["dcterms", "dcmitype"],
lambda x: (x for x in x),
clear=True,
)
self.assertEqual(
count_warnings_by_class(captured.records,
(RDFPropertiesWarning, )),
0,
)
warning_settings.rdf_properties_warning = True
with self.assertLogs(logger=logger) as captured:
logger.warning("At least one log entry is needed for "
"`assertLogs`.")
self.installer._install(
["dcterms", "dcmitype"],
lambda x: (x for x in x),
clear=True,
)
self.assertEqual(
count_warnings_by_class(captured.records,
(RDFPropertiesWarning, )),
1, # dcmi-type has no properties
)
finally:
warning_settings.rdf_properties_warning = original_warning_setting
class TestNamespaces(unittest.TestCase):
"""Test namespace registry and namespaces."""
def setUp(self):
"""Set up some temporary directories."""
self.tempdir = tempfile.TemporaryDirectory()
self.namespace_registry = NamespaceRegistry()
self.namespace_registry._load_cuba()
self.installer = OntologyInstallationManager(
namespace_registry=self.namespace_registry, path=self.tempdir.name)
self.graph = self.namespace_registry._graph
def tearDown(self):
"""Clean up all temporary directories."""
self.tempdir.cleanup()
def test_namespace_registry_load_cuba(self):
"""Test loading the CUBA namespace."""
g = rdflib.Graph()
g.parse(CUBA_FILE, format="ttl")
self.assertTrue(isomorphic(g, self.graph))
self.assertIn("cuba", self.namespace_registry._namespaces)
self.assertEqual(self.namespace_registry._namespaces["cuba"],
rdflib.URIRef("http://www.osp-core.com/cuba#"))
def test_namespace_registry_store(self):
"""Test storing loaded namespaces."""
self.graph.parse(RDF_FILE, format="ttl")
self.graph.bind("parser_test",
rdflib.URIRef("http://www.osp-core.com/parser_test#"))
self.namespace_registry.update_namespaces()
self.namespace_registry.store(self.tempdir.name)
self.assertEqual(os.listdir(self.tempdir.name),
["graph.xml", "namespaces.txt"])
g = rdflib.Graph()
g.parse(os.path.join(self.tempdir.name, "graph.xml"), format="xml")
g1 = rdflib.Graph()
g1.parse(CUBA_FILE, format="ttl")
g1.parse(RDF_FILE, format="ttl")
self.assertTrue(isomorphic(g, g1))
with open(os.path.join(self.tempdir.name, "namespaces.txt")) as f:
lines = set(map(lambda x: x.strip(), f))
self.assertIn("cuba\thttp://www.osp-core.com/cuba#", lines)
self.assertIn("parser_test\thttp://www.osp-core.com/parser_test#",
lines)
def test_namespace_registry_load(self):
"""Test loading an installed namespaces."""
# no graph.xml found
self.namespace_registry.clear()
self.namespace_registry.load(self.tempdir.name)
g = rdflib.Graph()
g.parse(CUBA_FILE, format="ttl")
self.assertTrue(isomorphic(g, self.namespace_registry._graph))
self.namespace_registry.clear()
self.graph = self.namespace_registry._graph
# graph.ttl found
self.graph.parse(RDF_FILE, format="ttl")
self.graph.bind("parser_test",
rdflib.URIRef("http://www.osp-core.com/parser_test#"))
self.namespace_registry.update_namespaces()
self.namespace_registry.store(self.tempdir.name)
nr = NamespaceRegistry()
nr.load(self.tempdir.name)
self.assertTrue(isomorphic(nr._graph, self.graph))
self.assertIn("parser_test", nr)
def test_namespace_registry_clear(self):
"""Test clearing a namespace registry."""
self.namespace_registry.clear()
self.assertIsNot(self.namespace_registry._graph, self.graph)
self.assertTrue(isomorphic(self.namespace_registry._graph, self.graph))
def test_namespace_registry_from_iri(self):
"""Test getting namespaces from iri."""
self.installer.install("city")
ns_iri = rdflib.URIRef("http://www.osp-core.com/city#")
city_iri = ns_iri + "City"
hasPart_iri = ns_iri + "hasPart"
self.modify_labels()
c = self.namespace_registry.from_iri(rdflib_cuba.Entity)
self.assertIsInstance(c, OntologyClass)
self.assertEqual(c.namespace.get_name(), "cuba")
self.assertEqual(c.name, "Entity")
r = self.namespace_registry.from_iri(rdflib_cuba.relationship)
self.assertIsInstance(r, OntologyRelationship)
self.assertEqual(r.namespace.get_name(), "cuba")
self.assertEqual(r.name, "relationship")
a = self.namespace_registry.from_iri(rdflib_cuba.attribute)
self.assertIsInstance(a, OntologyAttribute)
self.assertEqual(a.namespace.get_name(), "cuba")
self.assertEqual(a.name, "attribute")
c = self.namespace_registry.from_iri(city_iri)
self.assertIsInstance(c, OntologyClass)
self.assertEqual(c.namespace.get_name(), "city")
self.assertEqual(c.name, "City")
r = self.namespace_registry.from_iri(hasPart_iri)
self.assertIsInstance(r, OntologyRelationship)
self.assertEqual(r.namespace.get_name(), "city")
self.assertEqual(r.name, "hasPart")
from osp.core.namespaces import from_iri
import osp.core.namespaces
old_ns_reg = osp.core.namespaces._namespace_registry
try:
osp.core.namespaces._namespace_registry = self.namespace_registry
c = from_iri(rdflib_cuba.Entity)
self.assertIsInstance(c, OntologyClass)
self.assertEqual(c.namespace.get_name(), "cuba")
self.assertEqual(c.name, "Entity")
self.graph.add((ns_iri, rdflib_cuba._reference_by_label,
rdflib.Literal(True)))
c = self.namespace_registry.from_iri(city_iri)
self.assertIsInstance(c, OntologyClass)
self.assertEqual(c.namespace.get_name(), "city")
self.assertEqual(c.name, "City_T")
r = self.namespace_registry.from_iri(hasPart_iri)
self.assertIsInstance(r, OntologyRelationship)
self.assertEqual(r.namespace.get_name(), "city")
self.assertEqual(r.name, "hasPart_T")
# undefined namespace
self.graph.add(
(rdflib.URIRef("a/b#c"), rdflib.RDF.type, rdflib.OWL.Class))
self.graph.add(
(rdflib.URIRef("d/e/f"), rdflib.RDF.type, rdflib.OWL.Class))
a = from_iri("a/b#c")
b = from_iri("d/e/f")
self.assertIsInstance(a, OntologyClass)
self.assertEqual(a.namespace.get_name(), "a/b#")
self.assertEqual(a.name, "c")
self.assertIsInstance(b, OntologyClass)
self.assertEqual(b.namespace.get_name(), "d/e/")
self.assertEqual(b.name, "f")
finally:
osp.core.namespaces._namespace_registry = old_ns_reg
def test_namespace_registry_update_namespaces(self):
"""Test updateing the namespaces."""
self.graph.bind("a", rdflib.URIRef("aaa"))
self.graph.bind("b", rdflib.URIRef("bbb"))
self.graph.bind("c", rdflib.URIRef("ccc"))
self.namespace_registry.update_namespaces()
self.assertEqual(self.namespace_registry.a.get_name(), "a")
self.assertEqual(self.namespace_registry.a.get_iri(),
rdflib.URIRef("aaa"))
self.assertEqual(self.namespace_registry.b.get_name(), "b")
self.assertEqual(self.namespace_registry.b.get_iri(),
rdflib.URIRef("bbb"))
self.assertEqual(self.namespace_registry.c.get_name(), "c")
self.assertEqual(self.namespace_registry.c.get_iri(),
rdflib.URIRef("ccc"))
def test_namespace_registry_get(self):
"""Test getting namsepaces from namespace registry."""
self.installer.install("city")
self.assertIn("city", self.namespace_registry)
self.assertEqual(
self.namespace_registry._get("city").get_name(), "city")
self.assertEqual(
self.namespace_registry.get("city").get_name(), "city")
self.assertEqual(self.namespace_registry["city"].get_name(), "city")
self.assertEqual(self.namespace_registry.city.get_name(), "city")
self.assertRaises(KeyError, self.namespace_registry._get, "invalid")
self.assertEqual(self.namespace_registry.get("invalid"), None)
self.assertRaises(KeyError, self.namespace_registry.__getitem__,
"invalid")
self.assertRaises(AttributeError, getattr, self.namespace_registry,
"invalid")
self.assertEqual({x.get_name()
for x in self.namespace_registry},
{'xml', 'rdf', 'rdfs', 'xsd', 'cuba', 'owl', 'city'})
def modify_labels(self):
"""Modify the labels in the graph. Append a T.
Helper method.
"""
triples = list()
for s, p, o in self.graph:
if (s.startswith("http://www.osp-core.com/city#")
and p == rdflib.SKOS.prefLabel):
triples.append((s, p, rdflib.Literal(f"{o}_T", lang="en")))
else:
triples.append((s, p, o))
self.graph.remove((None, None, None))
for t in triples:
self.graph.add(t)
def test_namespace_get(self):
"""Test getting entities from namespace."""
self.installer.install("city")
self.modify_labels()
namespace = self.namespace_registry.city
# dot
self.assertIsInstance(namespace.City, OntologyClass)
self.assertEqual(namespace.City.name, "City")
self.assertEqual(namespace.City._iri_suffix, "City")
self.assertIsInstance(namespace.hasPart, OntologyRelationship)
self.assertEqual(namespace.hasPart.name, "hasPart")
self.assertEqual(namespace.hasPart._iri_suffix, "hasPart")
self.assertIsInstance(namespace.coordinates, OntologyAttribute)
self.assertEqual(namespace.coordinates.name, "coordinates")
self.assertEqual(namespace.coordinates._iri_suffix, "coordinates")
# item
self.assertIsInstance(namespace["City_T"][0], OntologyClass)
self.assertEqual(namespace["City_T"][0].name, "City")
self.assertEqual(namespace["City_T"][0]._iri_suffix, "City")
self.assertIsInstance(namespace["City_T", "en"][0], OntologyClass)
self.assertEqual(namespace["City_T", "en"][0].name, "City")
self.assertEqual(namespace["City_T", "en"][0]._iri_suffix, "City")
self.assertIsInstance(namespace["hasPart_T"][0], OntologyRelationship)
self.assertEqual(namespace["hasPart_T"][0].name, "hasPart")
self.assertEqual(namespace["hasPart_T"][0]._iri_suffix, "hasPart")
self.assertIsInstance(namespace["coordinates_T"][0], OntologyAttribute)
self.assertEqual(namespace["coordinates_T"][0].name, "coordinates")
self.assertEqual(namespace["coordinates_T"][0]._iri_suffix,
"coordinates")
# get
self.assertIsInstance(namespace.get("City"), OntologyClass)
self.assertEqual(namespace.get("City").name, "City")
self.assertEqual(namespace.get("City")._iri_suffix, "City")
self.assertIsInstance(namespace.get("hasPart"), OntologyRelationship)
self.assertEqual(namespace.get("hasPart").name, "hasPart")
self.assertEqual(namespace.get("hasPart")._iri_suffix, "hasPart")
self.assertIsInstance(namespace.get("coordinates"), OntologyAttribute)
self.assertEqual(namespace.get("coordinates").name, "coordinates")
self.assertEqual(
namespace.get("coordinates")._iri_suffix, "coordinates")
self.assertRaises(AttributeError, namespace.__getattr__, "CITY")
self.assertRaises(KeyError, namespace.__getitem__, "HAS_PART_T")
self.assertRaises(KeyError, namespace.__getitem__, "HAS_PART")
self.assertEqual(namespace.get("COORDINATES"), None)
# reference by label
namespace._reference_by_label = True
# dot
self.assertIsInstance(namespace.City_T, OntologyClass)
self.assertEqual(namespace.City_T.name, "City_T")
self.assertEqual(namespace.City_T._iri_suffix, "City")
self.assertIsInstance(namespace.hasPart_T, OntologyRelationship)
self.assertEqual(namespace.hasPart_T.name, "hasPart_T")
self.assertEqual(namespace.hasPart_T._iri_suffix, "hasPart")
self.assertIsInstance(namespace.coordinates_T, OntologyAttribute)
self.assertEqual(namespace.coordinates_T.name, "coordinates_T")
self.assertEqual(namespace.coordinates_T._iri_suffix, "coordinates")
# item
self.assertIsInstance(namespace["City_T"][0], OntologyClass)
self.assertEqual(namespace["City_T"][0].name, "City_T")
self.assertEqual(namespace["City_T"][0]._iri_suffix, "City")
self.assertIsInstance(namespace["City_T", "en"][0], OntologyClass)
self.assertEqual(namespace["City_T", "en"][0].name, "City_T")
self.assertEqual(namespace["City_T", "en"][0]._iri_suffix, "City")
self.assertIsInstance(namespace["hasPart_T"][0], OntologyRelationship)
self.assertEqual(namespace["hasPart_T"][0].name, "hasPart_T")
self.assertEqual(namespace["hasPart_T"][0]._iri_suffix, "hasPart")
self.assertIsInstance(namespace["coordinates_T"][0], OntologyAttribute)
self.assertEqual(namespace["coordinates_T"][0].name, "coordinates_T")
self.assertEqual(namespace["coordinates_T"][0]._iri_suffix,
"coordinates")
# get
self.assertIsInstance(namespace.get("City_T"), OntologyClass)
self.assertEqual(namespace.get("City_T").name, "City_T")
self.assertEqual(namespace.get("City_T")._iri_suffix, "City")
self.assertIsInstance(namespace.get("hasPart_T"), OntologyRelationship)
self.assertEqual(namespace.get("hasPart_T").name, "hasPart_T")
self.assertEqual(namespace.get("hasPart_T")._iri_suffix, "hasPart")
self.assertIsInstance(namespace.get("coordinates_T"),
OntologyAttribute)
self.assertEqual(namespace.get("coordinates_T").name, "coordinates_T")
self.assertEqual(
namespace.get("coordinates_T")._iri_suffix, "coordinates")
self.assertRaises(AttributeError, namespace.__getattr__, "CITY")
self.assertRaises(KeyError, namespace.__getitem__, "HAS_PART_T")
self.assertRaises(KeyError, namespace.__getitem__, "HAS_PART")
self.assertEqual(namespace.get("COORDINATES"), None)
self.assertRaises(AttributeError, namespace.__getattr__, "City")
self.assertRaises(KeyError, namespace.__getitem__, "City")
self.assertEqual(namespace.get("coordinates"), None)
def test_namespace_str(self):
"""Test converting namespace object to string."""
self.installer.install("city")
namespace = self.namespace_registry.city
self.assertEqual(str(namespace),
"city (http://www.osp-core.com/city#)")
self.assertEqual(repr(namespace),
"<city: http://www.osp-core.com/city#>")
def test_get_default_rel(self):
"""Test getting the default relationship."""
# default rel defined as flag in entity name
self.installer.install("city")
namespace = self.namespace_registry.city
self.assertEqual(namespace.get_default_rel().name, "hasPart")
onto_def_rel = os.path.join(os.path.dirname(__file__),
'default_rel_across_namespace_valid.yml')
self.installer.install(onto_def_rel)
namespace = self.namespace_registry.default_rel_test_namespace_valid
self.assertEqual(namespace.get_default_rel(), cuba.activeRelationship)
onto_def_rel = os.path.join(
os.path.dirname(__file__),
'default_rel_across_namespace_two_definitions.yml')
self.assertRaises(ValueError, self.installer.install, onto_def_rel)
onto_def_rel = os.path.join(
os.path.dirname(__file__),
'default_rel_across_namespace_uninstalled_entity.yml')
self.assertRaises(ValueError, self.installer.install, onto_def_rel)
onto_def_rel = os.path.join(
os.path.dirname(__file__),
'default_rel_across_namespace_uninstalled_namespace.yml')
self.assertRaises(ValueError, self.installer.install, onto_def_rel)
def test_contains(self):
"""Test containment."""
self.installer.install("city")
namespace = self.namespace_registry.city
self.assertIn("City", namespace)
self.assertIn("hasPart", namespace)
def test_iter(self):
"""Test the __iter__() magic method."""
self.installer.install("city")
namespace = self.namespace_registry.city
entities = set(namespace)
self.assertIn(namespace.encloses, entities)
self.assertIn(namespace.City, entities)
self.assertIn(namespace.name, entities)
self.assertEqual(len(entities), 32)
def test_get_namespace_from_iri(self):
"""Test getting namespace object from IRI."""
self.installer.install("city")
ns_iri = rdflib.URIRef("http://www.osp-core.com/city#")
namespace = self.namespace_registry.namespace_from_iri(ns_iri)
self.assertEqual(namespace.get_name(), "city")
self.assertEqual(namespace.get_iri(), ns_iri)
ns_iri = rdflib.URIRef("http://www.random_namespace.com#")
namespace = self.namespace_registry.namespace_from_iri(ns_iri)
self.assertEqual(namespace.get_name(),
"http://www.random_namespace.com#")
self.assertEqual(namespace.get_iri(), ns_iri)
def test_get_namespace_name_and_iri(self):
"""Test getting namespace name and IRI."""
self.installer.install("city")
self.assertEqual(
self.namespace_registry._get_namespace_name_and_iri(
rdflib.URIRef("http://www.osp-core.com/city#City")),
("city", rdflib.URIRef("http://www.osp-core.com/city#")))
self.assertEqual(
self.namespace_registry._get_namespace_name_and_iri(
rdflib.URIRef("http://www.random_namespace.com#Bla")),
("http://www.random_namespace.com#",
rdflib.URIRef("http://www.random_namespace.com#")))
self.assertEqual(
self.namespace_registry._get_namespace_name_and_iri(
rdflib.URIRef("http://www.random_namespace.com/Bla")),
("http://www.random_namespace.com/",
rdflib.URIRef("http://www.random_namespace.com/")))
def test_get_reference_by_label(self):
"""Test getting the reference style."""
self.installer.install("city")
ns_iri = rdflib.URIRef("http://www.osp-core.com/city#")
self.assertFalse(
self.namespace_registry._get_reference_by_label(ns_iri))
self.graph.add(
(ns_iri, rdflib_cuba._reference_by_label, rdflib.Literal(True)))
self.assertTrue(
self.namespace_registry._get_reference_by_label(ns_iri))
def test_get_entity_name(self):
"""Test getting the name of an entity."""
self.installer.install("city")
self.modify_labels()
ns_iri = rdflib.URIRef("http://www.osp-core.com/city#")
iri = rdflib.URIRef("http://www.osp-core.com/city#City")
self.assertEqual(self.namespace_registry._get_entity_name(iri, ns_iri),
"City")
self.graph.add(
(ns_iri, rdflib_cuba._reference_by_label, rdflib.Literal(True)))
self.assertEqual(self.namespace_registry._get_entity_name(iri, ns_iri),
"City_T")