def test_get_neighbor_diff(self): """Test get_neighbor_diff method.""" c1 = city.City(name="Paris") c2 = city.City(name="Berlin") c3 = city.City(name="London") n1 = city.Neighborhood(name="Zähringen") n2 = city.Neighborhood(name="Herdern") s1 = city.Street(name="Waldkircher Straße") s2 = city.Street(name="Habsburger Straße") s3 = city.Street(name="Lange Straße") n1.add(c1, c2, rel=city.isPartOf) n2.add(c2, c3, rel=city.isPartOf) n1.add(s1, s2) n2.add(s2, s3) self.assertEqual(set(get_neighbor_diff(n1, n2)), {(c1.uid, city.isPartOf), (s1.uid, city.hasPart)}) self.assertEqual(set(get_neighbor_diff(n2, n1)), {(c3.uid, city.isPartOf), (s3.uid, city.hasPart)}) self.assertEqual( set(get_neighbor_diff(n1, None)), {(c1.uid, city.isPartOf), (s1.uid, city.hasPart), (c2.uid, city.isPartOf), (s2.uid, city.hasPart)}) self.assertEqual(set(get_neighbor_diff(None, n2)), set())
def test_get_not_reachable(self): """Test the pruning method.""" cities = list() for i in range(3): c = city.City(name="city %s" % i) cities.append(c) for j in range(2): n = city.Neighborhood(name="neighborhood %s %s" % (i, j)) c.add(n) for k in range(2): s = city.Street(name="street %s %s %s" % (i, j, k)) n.add(s) registry = cities[0].session._registry result = registry._get_not_reachable(cities[2].uid) self.assertEqual( set([k.name for k in result]), set([ "city 0", "city 1", "neighborhood 0 0", "neighborhood 0 1", "neighborhood 1 0", "neighborhood 1 1", "street 0 0 0", "street 0 0 1", "street 0 1 0", "street 0 1 1", "street 1 0 0", "street 1 0 1", "street 1 1 0", "street 1 1 1" ])) roots = [ n for n in cities[0].get() if n.name.startswith("neighborhood 0") ] registry.prune(*roots, rel=cuba.passiveRelationship) self.assertEqual( set([k.name for k in registry.values()]), set(["neighborhood 0 0", "neighborhood 0 1", "city 0"]))
def test_prune(self): """Test the pruning method.""" cities = list() for i in range(3): c = city.City(name="city %s" % i) cities.append(c) for j in range(2): n = city.Neighborhood(name="neighborhood %s %s" % (i, j)) c.add(n) for k in range(2): s = city.Street(name="street %s %s %s" % (i, j, k)) n.add(s) registry = cities[0].session._registry registry.prune(*[c.uid for c in cities[0:2]]) self.assertEqual( set([k.name for k in registry.values()]), set([ "city 0", "city 1", "neighborhood 0 0", "neighborhood 0 1", "neighborhood 1 0", "neighborhood 1 1", "street 0 0 0", "street 0 0 1", "street 0 1 0", "street 0 1 1", "street 1 0 0", "street 1 0 1", "street 1 1 0", "street 1 1 1" ])) root, = [n for n in cities[0].get() if n.name == "neighborhood 0 0"] registry.prune(root, rel=cuba.activeRelationship) self.assertEqual( set([k.name for k in registry.values()]), set(["neighborhood 0 0", "street 0 0 0", "street 0 0 1"]))
def test_serialize(self): """Test the serialize function.""" c = branch( city.City(name="Freiburg", uid=1), branch(city.Neighborhood(name="Littenweiler", uid=2), city.Street(name="Schwarzwaldstraße", uid=3))) self.maxDiff = None assertJsonLdEqual(self, json.loads(serialize(c)), CUDS_LIST) assertJsonLdEqual(self, serialize(c, json_dumps=False), CUDS_LIST)
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 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 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 _benchmark_set_up(self): self.city = city.City(name="Freiburg") citizen = city.Citizen(name="Citizen") streets = tuple( city.Street(name=f"street {i}") for i in range(self.size - 1) ) position = random.randint(0, (self.size - 1) - 1) things = list(streets) things.insert(position, citizen) things = tuple(things) rel = {position: city.hasInhabitant} for i, thing in enumerate(things): self.city.add(thing, rel=rel.get(i, city.hasPart))
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_get_subtree(self): """Tests the get_subtree method.""" c = city.City(name="a city") p = city.Citizen() n = city.Neighborhood(name="a neighborhood") s = city.Street(name="The street") c.add(p, rel=city.hasInhabitant) c.add(n) n.add(s) registry = c.session._registry self.assertEqual(registry.get_subtree(c.uid), set([c, p, n, s])) self.assertEqual( registry.get_subtree(c.uid, rel=cuba.activeRelationship), set([c, p, n, s])) self.assertEqual(registry.get_subtree(n.uid), set([c, p, n, s])) self.assertEqual( registry.get_subtree(n.uid, rel=cuba.activeRelationship), set([n, s]))
def test_update(self): """Tests the standard, normal behavior of the update() method.""" c = city.City(name="a city") n = city.Neighborhood(name="a neighborhood") new_n = create_from_cuds_object(n, CoreSession()) new_s = city.Street(name="a new street") new_n.add(new_s) c.add(n) old_neighborhood = c.get(n.uid) old_streets = old_neighborhood.get(oclass=city.Street) self.assertEqual(old_streets, []) c.update(new_n) new_neighborhood = c.get(n.uid) self.assertIs(new_neighborhood, n) new_streets = new_neighborhood.get(oclass=city.Street) self.assertEqual(new_streets, [new_s]) self.assertRaises(ValueError, c.update, n)
def test_notify_delete_call(self): """Tests if notify_delete is called, when we call prune.""" deleted = set() session = TestSession(notify_delete=lambda x: deleted.add(x)) w = city.CityWrapper(session=session) cities = list() for i in range(3): c = city.City(name="city %s" % i) cw = w.add(c) cities.append(cw) for j in range(2): n = city.Neighborhood(name="neighborhood %s %s" % (i, j)) cw.add(n) nw = cw.get(n.uid) for k in range(2): s = city.Street(name="street %s %s %s" % (i, j, k)) nw.add(s) w.remove(cities[1].uid, cities[2].uid) expected_deletion = { x.uid for x in session._registry.values() if (hasattr(x, "name") and x.name in { "city 2", "neighborhood 2 0", "neighborhood 2 1", "street 2 0 0", "street 2 0 1", "street 2 1 0", "street 2 1 1", "city 1", "neighborhood 1 0", "neighborhood 1 1", "street 1 0 0", "street 1 0 1", "street 1 1 0", "street 1 1 1" }) } session.prune(rel=None) self.assertEqual( set([ "wrapper" if k.is_a(cuba.Wrapper) else k.name for k in session._registry.values() ]), set([ "city 0", "neighborhood 0 0", "neighborhood 0 1", "street 0 0 0", "street 0 0 1", "street 0 1 0", "street 0 1 1", "wrapper" ])) self.assertEqual(set([d.uid for d in deleted]), expected_deletion)
def test_get_subtree(self): """Tests the get_subtree method.""" c = city.City(name="a city") p = city.Citizen() n = city.Neighborhood(name="a neighborhood") s = city.Street(name="The street") c.add(p, rel=city.hasInhabitant) c.add(n) n.add(s) registry = c.session._registry self.assertEqual(registry.get_subtree(c.uid), {c, p, n, s}) self.assertEqual( registry.get_subtree(c.uid, rel=cuba.activeRelationship), {c, p, n, s}, ) self.assertEqual(registry.get_subtree(n.uid), {c, p, n, s}) self.assertEqual( registry.get_subtree(n.uid, rel=cuba.activeRelationship), {n, s}) c_o = city.City(name="other city") n.add(c_o, rel=city.isPartOf) self.assertEqual(registry.get_subtree(c.uid), {c, p, n, s, c_o}) self.assertEqual( registry.get_subtree(c.uid, rel=cuba.activeRelationship), {c, p, n, s}, ) self.assertEqual(registry.get_subtree(n.uid), {c, p, n, s, c_o}) self.assertEqual( registry.get_subtree(n.uid, rel=cuba.activeRelationship), {n, s}) # Test whether cycles are a problem c_o.add(c, rel=cuba.relationship) self.assertEqual(registry.get_subtree(c_o.uid), {c, p, n, s, c_o}) # Disconnected items c_f = city.City(name="far city") self.assertEqual(registry.get_subtree(c.uid), {c, p, n, s, c_o}) self.assertEqual(registry.get_subtree(c_f.uid), {c_f})
def test_application_json_doc_city(self): """Test importing the `application/ld+json` mime type from doc dict. This test uses a city ontology instead. """ # Importing test_data_path = str( Path(__file__).parent / "test_importexport_city_import.json") with open(test_data_path, "r") as file: json_doc = json.loads(file.read()) with CoreSession(): cuds = import_cuds(json_doc, format="application/ld+json") self.assertTrue(cuds.is_a(city.Citizen)) self.assertEqual(cuds.name, "Peter") self.assertEqual(cuds.age, 23) export_file = io.StringIO() export_cuds(cuds, file=export_file, format="application/ld+json") export_file.seek(0) assertJsonLdEqual(self, json_doc, json.loads(export_file.read())) # Exporting test_data_path = str( Path(__file__).parent / "test_importexport_city_export.json") with open(test_data_path, "r") as file: json_doc = json.loads(file.read()) with CoreSession(): c = branch( city.City(name="Freiburg", uid=1), branch( city.Neighborhood(name="Littenweiler", uid=2), city.Street(name="Schwarzwaldstraße", uid=3), ), ) export_file = io.StringIO() export_cuds(c, file=export_file, format="application/ld+json") export_file.seek(0) assertJsonLdEqual(self, json.loads(export_file.read()), json_doc)
"server"] try: p = subprocess.Popen(args) except FileNotFoundError: args[0] = "python" p = subprocess.Popen(args) time.sleep(5) try: # Construct the Datastructure. c = city.City(name="Freiburg") p1 = city.Citizen(name="Peter") p2 = city.Citizen(name="Hans") p3 = city.Citizen(name="Michel") n = city.Neighborhood(name="Zähringen") s = city.Street(name="Le street") b = city.Building(name="Theater") a = city.Address(postalCode=79123, name='Le street', number=12) c.add(p1, p2, p3, rel=city.hasInhabitant) c.add(n).add(s).add(b).add(a) print("Connect to DB via transport session") with TransportSessionClient( SqliteSession, "ws://localhost:8688", path="test.db" ) as session: wrapper = city.CityWrapper(session=session) wrapper.add(c) wrapper.session.commit() print("Reconnect and check if data is still there") with TransportSessionClient(
emmo_town.add(city.Citizen(name='Emanuele Ghedini'), rel=city.hasInhabitant) emmo_town.add(city.Citizen(name='Adham Hashibon'), rel=city.hasInhabitant) emmo_town.add(city.Citizen(name='Jesper Friis'), city.Citizen(name='Gerhard Goldbeck'), city.Citizen(name='Georg Schmitz'), city.Citizen(name='Anne de Baas'), rel=city.hasInhabitant) emmo_town.add(city.Neighborhood(name="Ontology")) emmo_town.add(city.Neighborhood(name="User cases")) ontology_uid = None for neighborhood in emmo_town.get(oclass=city.Neighborhood): if neighborhood.name == "Ontology": ontology_uid = neighborhood.uid neighborhood.add(city.Street(name="Relationships"), rel=city.hasPart) neighborhood.add(city.Street(name="Entities"), rel=city.hasPart) onto = emmo_town.get(ontology_uid) # We can go through inverse relationships print(onto.get(rel=city.isPartOf)[0].name + ' is my city!') # Working with a DB-wrapper: Store in the DB. with SqlAlchemyWrapperSession(postgres_url) as session: wrapper = city.CityWrapper(session=session) wrapper.add(emmo_town) session.commit() # Load from the DB. with SqlAlchemyWrapperSession(postgres_url) as db_session: