def test_merge(self):
proxy = EntityProxy.from_dict(model, ENTITY)
proxy.merge(proxy)
other = {"schema": "LegalEntity", "properties": {"country": ["gb"]}}
other = EntityProxy.from_dict(model, other)
proxy.merge(other)
assert "Ralph Tester" in proxy.names, proxy.names
assert "gb" in proxy.countries, proxy.countries
def test_merge(self):
proxy = EntityProxy.from_dict(model, ENTITY)
proxy.merge(proxy)
other = {'schema': 'LegalEntity', 'properties': {'country': 'gb'}}
other = EntityProxy.from_dict(model, other)
proxy.merge(other)
assert 'Ralph Tester' in proxy.names, proxy.names
assert 'gb' in proxy.countries, proxy.countries
def test_base_functions(self):
data = dict(ENTITY)
data["properties"]["banana"] = ["foo"]
proxy = EntityProxy.from_dict(model, data)
assert "test" in repr(proxy), repr(proxy)
assert hash(proxy) == hash(proxy.id)
assert proxy.get("name") == ["Ralph Tester"]
assert proxy.first("name") == "Ralph Tester"
prop = model.get_qname("Thing:name")
assert proxy.get(prop) == ["Ralph Tester"]
assert proxy.caption == "Ralph Tester"
assert str(proxy) == "Ralph Tester"
name = "Ralph the Great"
proxy.add("name", name)
assert len(proxy.get("name")) == 2
proxy.add("name", None)
assert len(proxy.get("name")) == 2
proxy.add("name", "")
assert len(proxy.get("name")) == 2
proxy.add("name", [""])
assert len(proxy.get("name")) == 2
proxy.add("name", {"name": "banana"})
assert len(proxy.get("name")) == 3, proxy.get("name")
assert name in proxy.get("name")
assert name in proxy.names, proxy.names
with raises(InvalidData):
proxy.add("banana", "yellow")
proxy.add("banana", "yellow", quiet=True)
mem = model.make_entity("Membership")
mem.id = "foo"
with raises(InvalidData):
proxy.add("directorshipDirector", mem)
with raises(InvalidData):
proxy.add("sameAs", proxy)
with raises(InvalidData):
proxy.get("banana")
assert [] == proxy.get("banana", quiet=True)
with raises(InvalidData):
proxy.first("banana")
assert proxy.first("banana", quiet=True) is None
assert len(proxy.get("nationality")) == 0
double = model.get_proxy(proxy)
assert double == proxy
proxy.add("banana", name, quiet=True)
with raises(InvalidData):
proxy.add("banana", name)
with raises(InvalidData):
EntityProxy.from_dict(model, {})
def test_base_functions(self):
proxy = EntityProxy.from_dict(model, ENTITY)
assert 'test' in repr(proxy), repr(proxy)
assert hash(proxy) == hash(proxy.id)
assert proxy.get('name') == ['Ralph Tester']
assert proxy.first('name') == 'Ralph Tester'
prop = model.get_qname('Thing:name')
assert proxy.get(prop) == ['Ralph Tester']
assert proxy.caption == 'Ralph Tester'
assert str(proxy) == 'Ralph Tester'
name = 'Ralph the Great'
proxy.add('name', name)
assert len(proxy.get('name')) == 2
proxy.add('name', None)
assert len(proxy.get('name')) == 2
proxy.add('name', '')
assert len(proxy.get('name')) == 2
proxy.add('name', [''])
assert len(proxy.get('name')) == 2
proxy.add('name', {'name': 'banana'}, cleaned=True)
assert len(proxy.get('name')) == 2
assert name in proxy.get('name')
assert name in proxy.names, proxy.names
with assert_raises(InvalidData):
proxy.add('banana', 'yellow')
proxy.add('banana', 'yellow', quiet=True)
mem = model.make_entity('Membership')
mem.id = 'foo'
with assert_raises(InvalidData):
proxy.add('directorshipDirector', mem)
with assert_raises(InvalidData):
proxy.add('sameAs', proxy)
with assert_raises(InvalidData):
proxy.get('banana')
assert [] == proxy.get('banana', quiet=True)
with assert_raises(InvalidData):
proxy.first('banana')
assert proxy.first('banana', quiet=True) is None
assert len(proxy.get('nationality')) == 0
double = EntityProxy.from_dict(model, proxy)
assert double == proxy
proxy.add('banana', name, quiet=True)
with assert_raises(InvalidData):
proxy.add('banana', name)
with assert_raises(InvalidData):
EntityProxy.from_dict(model, {})
def setUp(self):
super(MappingAPITest, self).setUp()
self.col = self.create_collection(foreign_id="map1")
aggregator = get_aggregator(self.col)
aggregator.delete()
_, self.headers = self.login(is_admin=True)
self.rolex = self.create_user(foreign_id="user_3")
_, self.headers_x = self.login(foreign_id="user_3")
self.fixture = self.get_fixture_path("experts.csv")
self.content_hash = archive.archive_file(self.fixture)
data = {
"id": "foo",
"schema": "Table",
"properties": {
"csvHash": self.content_hash,
"contentHash": self.content_hash,
"mimeType": "text/csv",
"fileName": "experts.csv",
"name": "experts.csv",
},
}
self.ent = EntityProxy.from_dict(model, data, cleaned=False)
self.ent.id = self.col.ns.sign(self.ent.id)
index_proxy(self.col, self.ent)
data = {
"id": "foo2",
"schema": "Table",
"properties": {
"csvHash": self.content_hash,
"contentHash": self.content_hash,
"mimeType": "text/csv",
"fileName": "experts.csv",
"name": "experts.csv",
},
}
self.ent2 = EntityProxy.from_dict(model, data, cleaned=False)
self.ent2.id = self.col.ns.sign(self.ent2.id)
index_proxy(self.col, self.ent2)
data = {
"id": "bar",
"schema": "LegalEntity",
"properties": {
"name": "John Doe"
},
}
ent = EntityProxy.from_dict(model, data, cleaned=False)
ent.id = self.col.ns.sign(ent.id)
index_proxy(self.col, ent)
def test_clone(self):
proxy = EntityProxy.from_dict(model, ENTITY)
other = proxy.clone()
assert other == proxy
other.id = 'banana'
assert proxy.id == 'test'
assert other != proxy
def test_rdf(self):
proxy = EntityProxy.from_dict(model, ENTITY)
triples = list(proxy.triples())
assert 10 == len(triples), len(triples)
proxy = model.make_entity("Person")
assert 0 == len(list(proxy.triples()))
def get_proxy(self,
data: Dict[str, Any],
cleaned: bool = True) -> EntityProxy:
"""Create an entity proxy to reflect the entity data in the given
dictionary. If ``cleaned`` is disabled, all property values are
fully re-validated and normalised. Use this if handling input data
from an untrusted source."""
return EntityProxy.from_dict(self, data, cleaned=cleaned)
def test_clone(self):
proxy = EntityProxy.from_dict(model, ENTITY)
other = proxy.clone()
assert other == proxy
other.id = "banana"
assert proxy.id == "test"
assert other != proxy
assert other != "banana"
def setUp(self):
super(MappingAPITest, self).setUp()
self.col = self.create_collection(data={'foreign_id': 'map1'})
_, self.headers = self.login(is_admin=True)
self.rolex = self.create_user(foreign_id='user_3')
_, self.headers_x = self.login(foreign_id='user_3')
self.fixture = self.get_fixture_path('experts.csv')
self.content_hash = archive.archive_file(self.fixture)
data = {
'id': 'foo',
'schema': 'Table',
'properties': {
'csvHash': self.content_hash,
'contentHash': self.content_hash,
'mimeType': 'text/csv',
'fileName': 'experts.csv',
'name': 'experts.csv'
}
}
self.ent = EntityProxy.from_dict(model, data)
self.ent.id = self.col.ns.sign(self.ent.id)
index_proxy(self.col, self.ent)
data = {
'id': 'foo2',
'schema': 'Table',
'properties': {
'csvHash': self.content_hash,
'contentHash': self.content_hash,
'mimeType': 'text/csv',
'fileName': 'experts.csv',
'name': 'experts.csv'
}
}
self.ent2 = EntityProxy.from_dict(model, data)
self.ent2.id = self.col.ns.sign(self.ent2.id)
index_proxy(self.col, self.ent2)
data = {
'id': 'bar',
'schema': 'LegalEntity',
'properties': {
'name': 'John Doe'
}
}
ent = EntityProxy.from_dict(model, data)
ent.id = self.col.ns.sign(ent.id)
index_proxy(self.col, ent)
def test_dict_passthrough(self):
proxy = EntityProxy.from_dict(model, ENTITY)
data = proxy.to_dict()
assert data["id"] == ENTITY["id"]
assert data["schema"] == ENTITY["schema"]
assert "idNumber" in data["properties"]
data = proxy.to_full_dict()
assert "Ralph Tester" in data["names"]
def test_dict_passthrough(self):
proxy = EntityProxy.from_dict(model, ENTITY)
data = proxy.to_dict()
assert data['id'] == ENTITY['id']
assert data['schema'] == ENTITY['schema']
assert 'idNumber' in data['properties']
data = proxy.to_full_dict()
assert ENTITY['schema'] in data['schemata']
assert 'Ralph Tester' in data['names']
def test_rdf(self):
proxy = EntityProxy.from_dict(model, ENTITY)
statements = list(proxy.statements)
assert 8 == len(statements), len(statements)
triples = list(proxy.triples)
count = len(statements) + 2
assert count == len(triples), len(triples)
proxy = model.make_entity('Person')
assert 0 == len(list(proxy.triples))
def import_vis(infile: Path, outfile: Path) -> None:
with path_writer(outfile) as outfh:
with open(infile, "r") as infh:
data = json.load(infh)
if "entities" in data:
entities = data.get("entities", data)
if "layout" in data:
entities = data.get("layout", {}).get("entities", data)
for entity_data in ensure_list(entities):
entity = EntityProxy.from_dict(model, entity_data)
write_entity(outfh, entity)
def test_inverted_props(self):
proxy = EntityProxy.from_dict(model, ENTITY)
data = proxy.get_type_inverted()
assert "names" in data
assert "1972-05-01" in data["dates"]
assert "countries" not in data
proxy.add("nationality", ["vg"])
assert "vg" in proxy.countries
data = proxy.get_type_inverted()
assert "countries" in data
assert "vg" in proxy.country_hints, proxy.country_hints
assert "us" in proxy.country_hints, proxy.country_hints
def test_pop(self):
proxy = EntityProxy.from_dict(model, ENTITY)
get_ids = proxy.get('idNumber')
assert get_ids, get_ids
ids = proxy.pop('idNumber')
assert get_ids == ids, ids
assert not proxy.get('idNumber')
assert not proxy.pop('idNumber')
with assert_raises(InvalidData):
proxy.pop('banana')
assert not proxy.pop('banana', quiet=True)
def test_inverted_props(self):
proxy = EntityProxy.from_dict(model, ENTITY)
data = proxy.get_type_inverted()
assert 'names' in data
assert '1972-05-01' in data['dates']
assert 'countries' not in data
proxy.add('nationality', ['vg'])
assert 'vg' in proxy.countries
data = proxy.get_type_inverted()
assert 'countries' in data
assert 'vg' in proxy.country_hints, proxy.country_hints
assert 'us' in proxy.country_hints, proxy.country_hints
def test_pop(self):
proxy = EntityProxy.from_dict(model, ENTITY)
get_ids = proxy.get("idNumber")
assert get_ids, get_ids
ids = proxy.pop("idNumber")
assert get_ids == ids, ids
assert not proxy.get("idNumber")
assert not proxy.pop("idNumber")
# new in 1.6.1: pop is quiet by default
assert not proxy.pop("banana")
with raises(InvalidData):
proxy.pop("banana", quiet=False)
def test_remove(self):
proxy = EntityProxy.from_dict(model, ENTITY)
assert "9177171" in proxy.get("idNumber")
proxy.remove("idNumber", "9177171")
assert "9177171" not in proxy.get("idNumber")
assert proxy.has("idNumber")
proxy.remove("idNumber", "banana")
assert proxy.has("idNumber")
proxy.remove("idNumber", "banana", quiet=False)
proxy.remove("fruit", "banana")
with raises(InvalidData):
proxy.remove("fruit", "banana", quiet=False)
def test_remove(self):
proxy = EntityProxy.from_dict(model, ENTITY)
assert '9177171' in proxy.get('idNumber')
proxy.remove('idNumber', '9177171')
assert '9177171' not in proxy.get('idNumber')
assert proxy.has('idNumber')
proxy.remove('idNumber', 'banana')
assert proxy.has('idNumber')
proxy.remove('idNumber', 'banana', quiet=False)
proxy.remove('fruit', 'banana')
with assert_raises(InvalidData):
proxy.remove('fruit', 'banana', quiet=False)
def test_base_functions(self):
proxy = EntityProxy.from_dict(model, ENTITY)
assert 'test' in repr(proxy), repr(proxy)
assert hash(proxy) == hash(proxy.id)
assert proxy.get('name') == ['Ralph Tester']
prop = model.get_qname('Thing:name')
assert proxy.get(prop) == ['Ralph Tester']
assert proxy.caption == 'Ralph Tester'
assert str(proxy) == 'Ralph Tester'
name = 'Ralph the Great'
proxy.add('name', name)
assert len(proxy.get('name')) == 2
proxy.add('name', None)
assert len(proxy.get('name')) == 2
proxy.add('name', '')
assert len(proxy.get('name')) == 2
proxy.add('name', [''])
assert len(proxy.get('name')) == 2
assert name in proxy.get('name')
assert name in proxy.names, proxy.names
with assert_raises(InvalidData):
proxy.get('banana')
assert [] == proxy.get('banana', quiet=True)
assert len(proxy.get('nationality')) == 0
double = EntityProxy.from_dict(model, proxy)
assert double == proxy
proxy.add('banana', name, quiet=True)
with assert_raises(InvalidData):
proxy.add('banana', name)
with assert_raises(InvalidData):
EntityProxy.from_dict(model, {})
def test_max_size(self):
t = registry.name
proxy = EntityProxy.from_dict(model, ENTITY)
prev_size = t.max_size
t.max_size = len(proxy) + 10
assert len(proxy.get("name")) == 1
proxy.add("name", "Louis George Maurice Adolphe Roche Albert Abel")
assert len(proxy.get("name")) == 1
proxy.set("name", "Louis")
assert len(proxy.get("name")) == 1, proxy.get("name")
proxy.add("name", "A")
assert len(proxy.get("name")) == 2, proxy.get("name")
proxy.add("name", "George")
assert len(proxy.get("name")) == 2, proxy.get("name")
t.max_size = prev_size
def test_max_size(self):
t = registry.name
proxy = EntityProxy.from_dict(model, ENTITY)
prev_size = t.max_size
t.max_size = len(proxy) + 10
assert len(proxy.get('name')) == 1
proxy.add('name', 'Louis George Maurice Adolphe Roche Albert Abel')
assert len(proxy.get('name')) == 1
proxy.set('name', 'Louis')
assert len(proxy.get('name')) == 1, proxy.get('name')
proxy.add('name', 'A')
assert len(proxy.get('name')) == 2, proxy.get('name')
proxy.add('name', 'George')
assert len(proxy.get('name')) == 2, proxy.get('name')
t.max_size = prev_size
def test_has(self):
proxy = EntityProxy.from_dict(model, ENTITY)
assert not proxy.has('birthPlace')
proxy.add('birthPlace', 'Inferno')
assert proxy.has('birthPlace')
assert 1 == len(proxy.get('birthPlace'))
proxy.add('birthPlace', 'Hell')
assert 2 == len(proxy.get('birthPlace'))
proxy.set('birthPlace', 'Inferno')
assert 1 == len(proxy.get('birthPlace'))
with assert_raises(InvalidData):
proxy.set('banana', 'fruit')
assert not proxy.set('banana', 'fruit', quiet=True)
with assert_raises(InvalidData):
proxy.has('banana')
assert not proxy.has('banana', quiet=True)
def test_has(self):
proxy = EntityProxy.from_dict(model, ENTITY)
assert not proxy.has("birthPlace")
proxy.add("birthPlace", "Inferno")
assert proxy.has("birthPlace")
assert 1 == len(proxy.get("birthPlace"))
proxy.add("birthPlace", "Hell")
assert 2 == len(proxy.get("birthPlace"))
proxy.set("birthPlace", "Inferno")
assert 1 == len(proxy.get("birthPlace"))
with raises(InvalidData):
proxy.set("banana", "fruit")
assert not proxy.set("banana", "fruit", quiet=True)
with raises(InvalidData):
proxy.has("banana")
assert not proxy.has("banana", quiet=True)
def get_proxy(self, data):
return EntityProxy.from_dict(self, data)
def test_context(self):
data = {'fruit': 'banana', 'schema': 'Person'}
proxy = EntityProxy.from_dict(model, data)
res = proxy.clone().to_dict()
assert res['fruit'] == data['fruit'], res
def get_proxy(self, data, cleaned=True):
return EntityProxy.from_dict(self, data, cleaned=cleaned)
def test_context(self):
data = {"fruit": "banana", "schema": "Person"}
proxy = EntityProxy.from_dict(model, data)
res = proxy.clone().to_dict()
assert res["fruit"] == data["fruit"], res
def test_len(self):
proxy = EntityProxy.from_dict(model, ENTITY)
proxy_len = len(proxy)
assert proxy_len > 0, proxy_len
proxy.add("name", "Some text")
assert len(proxy) > proxy_len, (len(proxy), proxy_len)