def test_refresh(self):
"""Test refreshing CUDS objects."""
c = city.City(name="Freiburg")
p1 = city.Citizen(name="Peter")
p2 = city.Citizen(name="Anna")
p3 = city.Citizen(name="Julia")
c.add(p1, p2, p3, rel=city.hasInhabitant)
p1.add(p3, rel=city.hasChild)
p2.add(p3, rel=city.hasChild)
with TransportSessionClient(SqliteSession, URI, path=DB) \
as session:
wrapper = city.CityWrapper(session=session)
cw = wrapper.add(c)
p1w, p2w, p3w = cw.get(p1.uid, p2.uid, p3.uid)
session.commit()
self.assertEqual(cw.name, "Freiburg")
self.assertEqual(p1w.name, "Peter")
self.assertEqual(p2w.name, "Anna")
self.assertEqual(p3w.name, "Julia")
self.assertEqual(session._expired, {wrapper.uid})
update_db(DB, c, p1, p2, p3)
session.refresh(cw, p1w, p2w, p3w)
self.assertEqual(cw.name, "Paris")
self.assertEqual(p1w.name, "Maria")
self.assertEqual(set(cw.get()), {p1w})
self.assertEqual(p2w.get(), list())
self.assertFalse(hasattr(p3w, "name"))
self.assertNotIn(p3w.uid, session._registry)
def test_expiring(self):
"""Test expring CUDS objects."""
c = city.City(name="Freiburg")
p1 = city.Citizen(name="Peter")
p2 = city.Citizen(name="Anna")
p3 = city.Citizen(name="Julia")
c.add(p1, p2, p3, rel=city.hasInhabitant)
p1.add(p3, rel=city.hasChild)
p2.add(p3, rel=city.hasChild)
with SqliteSession(DB) as session:
wrapper = city.CityWrapper(session=session)
cw = wrapper.add(c)
p1w, p2w, p3w = cw.get(p1.uid, p2.uid, p3.uid)
session.commit()
# p1w is no longer expired after the following assert
self.assertEqual(p1w.name, "Peter")
self.assertEqual(p2w.name, "Anna")
update_db(DB, c, p1, p2, p3)
self.assertEqual(p2w.name, "Anna")
self.assertEqual(cw.name, "Paris") # expires outdated neighbor p2w
self.assertEqual(p2w.name, "Jacob")
self.assertEqual(p1w.name, "Peter")
session.expire_all()
self.assertEqual(p1w.name, "Maria")
self.assertEqual(set(cw.get()), {p1w})
self.assertEqual(p2w.get(), list())
self.assertFalse(hasattr(p3w, "name"))
self.assertNotIn(p3w.uid, session._registry)
def test_clear_database(self):
"""Test clearing the database."""
# db is empty (no error occurs)
with SqliteSession(DB) as session:
wrapper = city.CityWrapper(session=session)
session._clear_database()
with SqliteSession(DB) as session:
wrapper = city.CityWrapper(session=session)
wrapper.session.commit()
session._clear_database()
# db is not empty
c = city.City(name="Freiburg")
p1 = city.Citizen(name="Peter")
p2 = city.Citizen(name="Anna")
p3 = city.Citizen(name="Julia")
c.add(p1, p2, p3, rel=city.hasInhabitant)
p1.add(p3, rel=city.hasChild)
p2.add(p3, rel=city.hasChild)
with SqliteSession(DB) as session:
wrapper = city.CityWrapper(session=session)
wrapper.add(c)
session.commit()
session._clear_database()
check_db_cleared(self, DB)
def test_recursive_store(self):
"""Test if _recursive_store correctly stores cuds_objects correctly.
It should correct dangling and one-way connections.
"""
c = city.City(name="Freiburg")
p1 = city.Citizen()
p2 = city.Citizen()
p3 = city.Citizen()
p4 = city.Citizen()
with CoreSession() as session:
w = city.CityWrapper(session=session)
cw = w.add(c)
c.add(p1, p2, p3, rel=city.hasInhabitant)
p3.add(p1, p2, rel=city.isChildOf)
p3.add(p4, rel=city.hasChild)
cw = w._recursive_store(c, cw)
p1w, p2w, p3w = cw.get(p1.uid, p2.uid, p3.uid)
p4w = p3w.get(p4.uid)
self.assertEqual(w.get(rel=city.hasPart), [cw])
self.assertEqual(set(cw.get(rel=city.hasInhabitant)),
{p1w, p2w, p3w})
self.assertEqual(set(cw.get(rel=city.isPartOf)), {w})
self.assertEqual(p3w.get(rel=city.INVERSE_OF_hasInhabitant), [cw])
self.assertEqual(set(p3w.get(rel=city.isChildOf)), {p1w, p2w})
self.assertEqual(p3w.get(rel=city.hasChild), [p4w])
def test_load_by_oclass(self):
"""Test loading by oclass."""
c = city.City(name="Freiburg")
p1 = city.Citizen(name="Peter")
p2 = city.Citizen(name="Anna")
p3 = city.Citizen(name="Julia")
c.add(p1, p2, p3, rel=city.hasInhabitant)
p1.add(p3, rel=city.hasChild)
p2.add(p3, rel=city.hasChild)
with SqliteSession(DB) as session:
wrapper = city.CityWrapper(session=session)
wrapper.add(c)
session.commit()
with SqliteSession(DB) as session:
wrapper = city.CityWrapper(session=session)
cs = wrapper.get(c.uid)
r = session.load_by_oclass(city.City)
self.assertIs(next(r), cs)
r = session.load_by_oclass(city.Citizen)
self.assertEqual(set(r), {p1, p2, p3})
r = session.load_by_oclass(city.Person)
self.assertEqual(set(r), {p1, p2, p3})
with SqliteSession(DB) as session:
wrapper = city.CityWrapper(session=session)
cs = wrapper.get(c.uid)
r = session.load_by_oclass(city.Street)
self.assertRaises(StopIteration, next, r)
def test_iter(self):
"""Tests the iter() method when no ontology class is provided."""
c = city.City(name="a city")
n = city.Neighborhood(name="a neighborhood")
p = city.Citizen(name="John Smith")
q = city.Citizen(name="Jane Doe")
c.add(n)
c.add(p, q, rel=city.hasInhabitant)
elements = set(list(c.iter()))
self.assertEqual(elements, {n, p, q})
# return_rel=True
get_p_uid, get_p_rel = next(c.iter(p.uid, return_rel=True))
self.assertEqual(get_p_uid, p)
self.assertEqual(get_p_rel, city.hasInhabitant)
result = c.iter(rel=city.encloses, return_rel=True)
self.assertEqual(
set(result),
set([
(p, city.hasInhabitant),
(q, city.hasInhabitant),
(n, city.hasPart),
]),
)
def test_load_by_iri(self):
"""Test if it is possible to load objects by their IRIs."""
c = city.City(name="Freiburg")
p1 = city.Citizen(name="Peter")
p2 = city.Citizen(name="Anna")
p3 = city.Citizen(name="Julia")
c.add(p1, p2, p3, rel=city.hasInhabitant)
p1.add(p3, rel=city.hasChild)
p2.add(p3, rel=city.hasChild)
with SqliteSession(DB) as session:
wrapper = city.CityWrapper(session=session)
wrapper.add(c)
session.commit()
with SqliteSession(DB) as session:
wrapper = city.CityWrapper(session=session)
cs = wrapper.get(c.uid)
r = session.load_from_iri(cs.iri)
self.assertIs(next(r), cs)
r = session.load_from_iri(p1.iri, p2.iri, p3.iri)
self.assertEqual(set(r), {p1, p2, p3})
with SqliteSession(DB) as session:
wrapper = city.CityWrapper(session=session)
cs = wrapper.get(c.uid)
r = session.load_from_iri(iri_from_uid(uuid.UUID(int=1)))
self.assertEqual(set(r), {None})
def test_expiring(self):
"""Test expiring with transport + db session."""
c = city.City(name="Freiburg")
p1 = city.Citizen(name="Peter")
p2 = city.Citizen(name="Anna")
p3 = city.Citizen(name="Julia")
c.add(p1, p2, p3, rel=city.hasInhabitant)
p1.add(p3, rel=city.hasChild)
p2.add(p3, rel=city.hasChild)
with TransportSessionClient(SqliteSession, URI, path=DB)\
as session:
wrapper = city.CityWrapper(session=session)
cw = wrapper.add(c)
p1w, p2w, p3w = cw.get(p1.uid, p2.uid, p3.uid)
session.commit()
# p1w is no longer expired after the following assert
self.assertEqual(p1w.name, "Peter")
update_db(DB, c, p1, p2, p3)
self.assertEqual(cw.name, "Paris")
self.assertEqual(p1w.name, "Peter")
session.expire_all()
self.assertEqual(p1w.name, "Maria")
self.assertEqual(set(cw.get()), {p1w})
self.assertEqual(p2w.get(), list())
self.assertFalse(hasattr(p3w, "name"))
self.assertNotIn(p3w.uid, session._registry)
def test_init(self):
"""Test if first level of children are loaded automatically."""
c = city.City(name="Freiburg")
p1 = city.Citizen(name="Peter")
p2 = city.Citizen(name="Anna")
p3 = city.Citizen(name="Julia")
c.add(p1, p2, p3, rel=city.hasInhabitant)
p1.add(p3, rel=city.hasChild)
p2.add(p3, rel=city.hasChild)
with SqliteSession(DB) as session:
wrapper = city.CityWrapper(session=session)
wrapper.add(c)
session.commit()
with TransportSessionClient(SqliteSession, URI, path=DB) \
as session:
wrapper = city.CityWrapper(session=session)
self.assertEqual(set(session._registry.keys()),
{c.uid, wrapper.uid})
self.assertEqual(wrapper.get(c.uid).name, "Freiburg")
self.assertEqual(
session._registry.get(c.uid)._neighbors[city.hasInhabitant],
{p1.uid: p1.oclasses, p2.uid: p2.oclasses,
p3.uid: p3.oclasses})
self.assertEqual(
session._registry.get(c.uid)._neighbors[city.isPartOf],
{wrapper.uid: wrapper.oclasses})
def test_create_recycle(self):
"""Test creation of cuds_objects for different session."""
default_session = CoreSession()
osp.core.cuds.Cuds._session = default_session
a = city.City(name="Freiburg")
self.assertIs(a.session, default_session)
with TestWrapperSession() as session:
w = city.CityWrapper(session=session)
with EngineContext(session):
b = create_recycle(oclass=city.City,
kwargs={"name": "Offenburg"},
uid=a.uid,
session=session,
fix_neighbors=False)
self.assertEqual(b.name, "Offenburg")
self.assertEqual(b.uid, a.uid)
self.assertEqual(set(default_session._registry.keys()), {a.uid})
self.assertIs(default_session._registry.get(a.uid), a)
self.assertEqual(set(session._registry.keys()), {b.uid, w.uid})
self.assertIs(session._registry.get(b.uid), b)
self.assertEqual(session._buffers, [[{
w.uid: w
}, dict(), dict()], [{
b.uid: b
}, dict(), dict()]])
x = city.Citizen()
x = b.add(x, rel=city.hasInhabitant)
c = create_recycle(oclass=city.City,
kwargs={"name": "Emmendingen"},
session=session,
uid=a.uid,
fix_neighbors=False)
self.assertIs(b, c)
self.assertEqual(c.name, "Emmendingen")
self.assertEqual(c.get(rel=cuba.relationship), [])
self.assertNotEqual(x.get(rel=cuba.relationship), [])
self.assertEqual(set(default_session._registry.keys()),
{a.uid, x.uid})
self.assertIs(default_session._registry.get(a.uid), a)
self.assertEqual(session._buffers, [[{
w.uid: w,
x.uid: x
}, {
c.uid: c
}, dict()], [dict(), dict(), dict()]])
x = city.Citizen()
x = c.add(x, rel=city.hasInhabitant)
c = create_recycle(oclass=city.City,
kwargs={"name": "Karlsruhe"},
session=session,
uid=a.uid,
fix_neighbors=True)
self.assertEqual(x.get(rel=cuba.relationship), [])
def test_validate_tree_against_schema(self):
"""Test validation of CUDS tree against schema.yml."""
schema_file = os.path.join(os.path.dirname(__file__),
'test_validation_schema_city.yml')
schema_file_with_missing_entity = os.path.join(
os.path.dirname(__file__),
'test_validation_schema_city_with_missing_entity.yml')
schema_file_with_missing_relationship = os.path.join(
os.path.dirname(__file__),
'test_validation_schema_city_with_missing_relationship.yml')
schema_file_with_optional_subtree = os.path.join(
os.path.dirname(__file__),
'test_validation_schema_city_with_optional_subtree.yml')
c = city.City(name='freiburg')
# empty city is not valid
self.assertRaises(ConsistencyError, validate_tree_against_schema, c,
schema_file)
# unless I do not specify relationships for it
validate_tree_against_schema(c, schema_file_with_missing_relationship)
# but it at least should be a city,
# even when no relationships are defined
wrong_object = cuba.File(path='some path')
self.assertRaises(ConsistencyError, validate_tree_against_schema,
wrong_object, schema_file_with_missing_relationship)
# with opional inhabitants an empty city is ok
validate_tree_against_schema(c, schema_file_with_optional_subtree)
# but the optional subtree should follow its own constraints
# (here a citizen needs to work in a city)
c.add(city.Citizen(name='peter'), rel=city.hasInhabitant)
self.assertRaises(CardinalityError, validate_tree_against_schema, c,
schema_file_with_optional_subtree)
c.add(city.Neighborhood(name='some hood'))
c.add(city.Citizen(name='peter'), rel=city.hasInhabitant)
# street of neighborhood violated
self.assertRaises(CardinalityError, validate_tree_against_schema, c,
schema_file)
c.get(oclass=city.Neighborhood)[0].add(city.Street(name='abc street'))
# now the city is valid and validation should pass
validate_tree_against_schema(c, schema_file)
# entity that was defined is completely missing in cuds tree
self.assertRaises(ConsistencyError, validate_tree_against_schema, c,
schema_file_with_missing_entity)
def test_change_oclass(self):
"""Check utility method to change oclass."""
c = city.City(name="Freiburg")
p1 = city.Citizen(name="Tim")
p2 = city.Citizen(name="Tom")
c.add(p1, p2, rel=city.hasInhabitant)
change_oclass(c, city.PopulatedPlace, {"name": "Umkirch"})
self.assertEqual(c.oclass, city.PopulatedPlace)
self.assertEqual(p1._neighbors[city.INVERSE_OF_hasInhabitant],
{c.uid: [city.PopulatedPlace]})
self.assertEqual(p2._neighbors[city.INVERSE_OF_hasInhabitant],
{c.uid: [city.PopulatedPlace]})
def test_insert(self):
"""Test inserting in the sqlite table."""
c = city.City(name="Freiburg")
p1 = city.Citizen(name="Peter")
p2 = city.Citizen(name="Georg")
c.add(p1, p2, rel=city.hasInhabitant)
with DataspaceSession(URI) as session:
wrapper = city.CityWrapper(session=session)
wrapper.add(c)
session.commit()
check_state(self, c, p1, p2, db=DB)
def test_delete_cuds_object_recursively(self):
"""Test the delete_cuds_object_recursively function."""
with TestWrapperSession() as session:
wrapper = city.CityWrapper(session=session)
a = city.City(name="freiburg", session=session)
b = city.Citizen(name="peter", session=session)
branch(wrapper, branch(a, b, rel=city.hasInhabitant))
self.maxDiff = None
session._reset_buffers(BufferContext.USER)
delete_cuds_object_recursively(a)
self.assertEqual(
session._buffers,
[
[{}, {
wrapper.uid: wrapper
}, {
a.uid: a,
b.uid: b
}],
[{}, {}, {}],
],
)
self.assertEqual(wrapper.get(rel=cuba.relationship), [])
self.assertEqual(a.get(rel=cuba.relationship), [])
self.assertEqual(b.get(rel=cuba.relationship), [])
def test_text_turtle_cuds_triples(self):
"""Test exporting the `text/turtle` mime type from a cuds object.
This test uses the city ontology.
"""
# Exporting
c = city.City(name="Freiburg", coordinates=[47, 7])
p1 = city.Citizen(name="Peter")
p2 = city.Citizen(name="Anne")
c.add(p1, rel=city.hasInhabitant)
c.add(p2, rel=city.hasInhabitant)
exported_file = io.StringIO()
export_cuds(c, file=exported_file, format="text/turtle")
exported_file.seek(0)
cuds = import_cuds(exported_file, format="text/turtle")
self.assertIs(type(cuds), Cuds)
def test_serializable(self):
"""Test function to make Cuds objects json serializable."""
p = city.Citizen(age=23, name="Peter", uid=uuid.UUID(int=123))
c = city.City(name="Freiburg", uid=uuid.UUID(int=1))
c1 = city.Person(uid=uuid.UUID(int=2))
c2 = city.Person(uid=uuid.UUID(int=3))
p.add(c, rel=city.INVERSE_OF_hasInhabitant)
p.add(c1, c2, rel=city.hasChild)
assertJsonLdEqual(self, CUDS_DICT, serializable(p))
assertJsonLdEqual(self, [CUDS_DICT], serializable([p]))
assertJsonLdEqual(self, None, serializable(None))
assertJsonLdEqual(self, [None, None], serializable([None, None]))
assertJsonLdEqual(self,
{"UUID": "00000000-0000-0000-0000-000000000001"},
serializable(uuid.UUID(int=1)))
assertJsonLdEqual(self, [{
"UUID": "00000000-0000-0000-0000-000000000001"
}, {
"UUID": "00000000-0000-0000-0000-000000000002"
}], serializable([uuid.UUID(int=1), uuid.UUID(int=2)]))
assertJsonLdEqual(self, {"ENTITY": "city.Citizen"},
serializable(city.Citizen))
assertJsonLdEqual(self, [{
"ENTITY": "city.Citizen"
}, {
"ENTITY": "city.City"
}], serializable([city.Citizen, city.City]))
assertJsonLdEqual(self, [1, 1.2, "hallo"],
serializable([1, 1.2, "hallo"]))
def test_creation(self):
"""Test the instantiation and type of the objects."""
if not RUN_PERFORMANCE_TEST:
return
print("Test cuds object creation")
for i in range(self.iterations):
city.Citizen(name='citizen ' + str(i))
def test_add_rel(self):
"""Test the instantiation and type of the objects."""
if not RUN_PERFORMANCE_TEST:
return
print("Test adding with a general relationship")
for i in range(self.iterations):
self.c.add(city.Citizen(name='citizen ' + str(i)),
rel=city.hasInhabitant)
def test_update(self):
"""Test updating the sqlite table."""
c = city.City(name="Paris")
p1 = city.Citizen(name="Peter")
c.add(p1, rel=city.hasInhabitant)
with SqliteSession(DB) as session:
wrapper = city.CityWrapper(session=session)
cw = wrapper.add(c)
session.commit()
p2 = city.Citizen(name="Georg")
cw.add(p2, rel=city.hasInhabitant)
cw.name = "Freiburg"
session.commit()
check_state(self, c, p1, p2)
def test_create_from_cuds_object(self):
"""Test copying cuds_objects to different session."""
default_session = CoreSession()
Cuds._session = default_session
a = city.City(name="Freiburg")
self.assertIs(a.session, default_session)
with TestWrapperSession() as session:
w = city.CityWrapper(session=session)
with EngineContext(session):
b = create_from_cuds_object(a, session)
self.assertEqual(b.name, "Freiburg")
self.assertEqual(b.uid, a.uid)
self.assertEqual(set(default_session._registry.keys()), {a.uid})
self.assertIs(default_session._registry.get(a.uid), a)
self.assertEqual(set(session._registry.keys()), {b.uid, w.uid})
self.assertIs(session._registry.get(b.uid), b)
self.assertEqual(
session._buffers,
[[dict(), dict(), dict()], [{
b.uid: b
}, dict(), dict()]],
)
b.name = "Emmendingen"
x = city.Citizen(age=54, name="Franz", session=default_session)
b.add(x, rel=city.hasInhabitant)
y = city.Citizen(age=21, name="Rolf", session=default_session)
a.add(y, rel=city.hasInhabitant)
c = create_from_cuds_object(a, session)
self.assertIs(b, c)
self.assertEqual(c.name, "Freiburg")
self.assertEqual(len(c.get(rel=cuba.relationship)), 1)
self.assertEqual(c._neighbors[city.hasInhabitant],
{y.uid: [city.Citizen]})
self.assertEqual(set(default_session._registry.keys()),
{a.uid, x.uid, y.uid})
self.assertIs(default_session._registry.get(a.uid), a)
self.assertEqual(
session._buffers,
[[{
x.uid: x
}, {
c.uid: c
}, dict()], [dict(), dict(), dict()]],
)
def test_branch(self):
"""Test the branch function."""
x = branch(
branch(city.City(name="Freiburg"),
city.Citizen(name="Peter"),
city.Citizen(name="Maria"),
rel=city.hasInhabitant), city.Neighborhood(name="Herdern"),
city.Neighborhood(name="Vauban"))
self.assertEqual(x.name, "Freiburg")
self.assertEqual({"Herdern", "Vauban"},
set(
map(lambda x: x.name,
x.get(oclass=city.Neighborhood))))
self.assertEqual({"Peter", "Maria"},
set(
map(lambda x: x.name,
x.get(rel=city.hasInhabitant))))
def _benchmark_set_up(self):
self.citizen = city.Citizen(name="Lukas", age=93)
self.city = city.City(name="Freiburg", coordinates=[108, 49])
self.address = city.Address(postalCode=79111)
self.things = itertools.cycle((self.citizen, self.city, self.address))
self.attributes = itertools.cycle(
(("age",), ("coordinates",), ("postalCode",))
)
def _benchmark_set_up(self):
self.city = city.City(name="Freiburg")
self.citizens = tuple(
city.Citizen(name=f"citizen {i}") for i in range(self.size)
)
self.uids = tuple(citizen.uid for citizen in self.citizens)
for citizen in self.citizens:
self.city.add(citizen, rel=city.hasInhabitant)
def fill_db(self, c, random_uid=True):
"""Fill the database with data."""
for i in range(self.iterations):
j = i * 9
uids = iter([None for i in range(9)])
if not random_uid:
uids = iter(range(j * 9 + 1, (j + 1) * 9 + 1))
c.add(city.Citizen(uid=next(uids)), rel=city.hasInhabitant)
c.add(city.Citizen(uid=next(uids)), rel=city.encloses)
c.add(city.Citizen(uid=next(uids)), rel=city.hasPart)
c.add(city.Neighborhood(name="", uid=next(uids)),
rel=city.hasInhabitant)
c.add(city.Neighborhood(name="", uid=next(uids)),
rel=city.encloses)
c.add(city.Neighborhood(name="", uid=next(uids)), rel=city.hasPart)
c.add(city.Street(name="", uid=next(uids)), rel=city.hasInhabitant)
c.add(city.Street(name="", uid=next(uids)), rel=city.encloses)
c = c.add(city.Street(name="", uid=next(uids)), rel=city.hasPart)
def test_delete(self):
"""Test to delete cuds_objects from the sqlite table."""
c = city.City(name="Freiburg")
p1 = city.Citizen(name="Peter")
p2 = city.Citizen(name="Georg")
p3 = city.Citizen(name="Hans")
c.add(p1, p2, p3, rel=city.hasInhabitant)
with DataspaceSession(URI) as session:
wrapper = city.CityWrapper(session=session)
cw = wrapper.add(c)
session.commit()
cw.remove(p3.uid)
session.prune()
session.commit()
check_state(self, c, p1, p2, db=DB)
def get_test_city():
"""Set up a test City for the tests."""
c = city.City(name="Freiburg", coordinates=[1, 2])
p1 = city.Citizen(name="Rainer")
p2 = city.Citizen(name="Carlos")
p3 = city.Citizen(name="Maria")
n1 = city.Neighborhood(name="Zähringen", coordinates=[2, 3])
n2 = city.Neighborhood(name="St. Georgen", coordinates=[3, 4])
s1 = city.Street(name="Lange Straße", coordinates=[4, 5])
c.add(p1, p2, p3, rel=city.hasInhabitant)
p1.add(p3, rel=city.hasChild)
p2.add(p3, rel=city.hasChild)
c.add(n1, n2)
n1.add(s1)
n2.add(s1)
s1.add(p2, p3, rel=city.hasInhabitant)
return [c, p1, p2, p3, n1, n2, s1]
def test_update_throws_exception(self):
"""Tests the update() method for unusual behaviors.
- Update an element that wasn't added before
"""
c = city.City(name="a city")
n = city.Neighborhood(name="a neighborhood")
c.add(n)
p = city.Citizen()
self.assertRaises(ValueError, c.update, p)
def test_load_missing(self):
"""Test if missing objects are loaded automatically."""
c = city.City(name="Freiburg")
p1 = city.Citizen(name="Peter")
p2 = city.Citizen(name="Anna")
p3 = city.Citizen(name="Julia")
c.add(p1, p2, p3, rel=city.hasInhabitant)
p1.add(p3, rel=city.hasChild)
p2.add(p3, rel=city.hasChild)
with SqliteSession(DB) as session:
wrapper = city.CityWrapper(session=session)
wrapper.add(c)
session.commit()
with TransportSessionClient(SqliteSession, URI, path=DB) as session:
wrapper = city.CityWrapper(session=session)
self.assertEqual(set(session._registry.keys()),
{c.uid, wrapper.uid})
cw = wrapper.get(c.uid)
p1w = cw.get(p1.uid)
p2w = cw.get(p2.uid)
p3w = p1w.get(p3.uid)
self.assertEqual(
set(session._registry.keys()),
{c.uid, wrapper.uid, p1.uid, p2.uid, p3.uid},
)
self.assertEqual(p1w.name, "Peter")
self.assertEqual(p2w.name, "Anna")
self.assertEqual(p3w.name, "Julia")
self.assertEqual(
p3w._neighbors[city.isChildOf],
{
p1.uid: p1.oclasses,
p2.uid: p2.oclasses
},
)
self.assertEqual(p2w._neighbors[city.hasChild],
{p3.uid: p3.oclasses})
self.assertEqual(
p2w._neighbors[city.INVERSE_OF_hasInhabitant],
{c.uid: c.oclasses},
)
def setUp(self):
"""Start the timer."""
if not RUN_PERFORMANCE_TEST:
return
self.iterations = 100000
self.c = city.City(name="A big city")
for i in range(10):
j = i * 9
self.c.add(city.Citizen(uid=j + 0), rel=city.hasInhabitant)
self.c.add(city.Citizen(uid=j + 1), rel=city.encloses)
self.c.add(city.Citizen(uid=j + 2), rel=city.hasPart)
self.c.add(city.Neighborhood(name="", uid=j + 3),
rel=city.hasInhabitant)
self.c.add(city.Neighborhood(name="", uid=j + 4),
rel=city.encloses)
self.c.add(city.Neighborhood(name="", uid=j + 5), rel=city.hasPart)
self.c.add(city.Street(name="", uid=j + 6), rel=city.hasInhabitant)
self.c.add(city.Street(name="", uid=j + 7), rel=city.encloses)
self.c.add(city.Street(name="", uid=j + 8), rel=city.hasPart)
self.start = time.time()
def _benchmark_set_up(self):
self.city = city.City(name="Freiburg")
self.iris = tuple(
rdflib.URIRef(f"http://example.org/city#Citizen_{i}")
for i in range(self.size)
)
self.citizens = tuple(
city.Citizen(name=f"citizen {i}", uid=self.iris[i])
for i in range(self.size)
)
for citizen in self.citizens:
self.city.add(citizen, rel=city.hasInhabitant)
