def test_related_records_pagination(dataset):
patient = dataset.create_model(
"patient",
description="patient",
schema=[
ModelProperty("name",
data_type=ModelPropertyType(data_type=str),
title=True)
],
)
visit = dataset.create_model(
"visit",
description="visit",
schema=[
ModelProperty("field",
data_type=ModelPropertyType(data_type=str),
title=True)
],
)
attends = dataset.create_relationship_type("attends", "an attendance")
fred = patient.create_record({"name": "Fred"})
visits = visit.create_records([{"field": str(i)} for i in range(200)])
fred.relate_to(visits, attends)
# Get all records
gotten = fred.get_related()
assert len(gotten) == 200
assert [int(r.get("field")) for r in gotten] == list(range(200))
def test_complex_model_properties(dataset):
model_with_complex_props = dataset.create_model('Complex_Props', description='a new description', schema=[
ModelProperty('name', data_type=ModelPropertyType(data_type=str), title=True),
ModelProperty('age', data_type=ModelPropertyType(data_type=int)),
ModelProperty('email', data_type=ModelPropertyType(data_type=str, format='email'))
])
assert dataset.get_model(model_with_complex_props.id) == model_with_complex_props
# Add a property
model_with_complex_props.add_property('weight', ModelPropertyType(data_type=float, unit='kg'), display_name='Weight')
updated_model = dataset.get_model(model_with_complex_props.id)
weight_property = updated_model.get_property('weight')
assert (weight_property.display_name == 'Weight')
assert (weight_property.type == float)
assert (weight_property._type.data_type == float)
assert (weight_property._type.format == None)
assert (weight_property.unit == 'kg')
email_property = model_with_complex_props.get_property('email')
assert (email_property.type == unicode)
assert (email_property._type.data_type == unicode)
assert (email_property._type.format.lower() == 'email')
assert (email_property.unit == None)
good_values = {'name': 'Bob', 'age': 1, 'email': '*****@*****.**', 'weight': 10}
good_record = updated_model.create_record(good_values)
bad_values = {'name': 'Bob', 'age': 1, 'email': '123455', 'weight': 10}
with pytest.raises(Exception):
bad_record = updated_model.create_record(bad_values)
def test_enum_model_properties(dataset):
model = dataset.create_model('Enum_Props', description='a new description', schema=[
ModelProperty('name', data_type=str, title=True),
ModelProperty('int_enum', data_type=ModelPropertyEnumType(
data_type=float, enum=[1.0, 2.0, 3.0], unit="cm", multi_select=False)),
ModelProperty('str_enum', data_type=ModelPropertyEnumType(
data_type=str, enum=['foo', 'bar', 'baz'], multi_select=True)),
])
assert model == dataset.get_model(model.id)
int_enum = model.get_property('int_enum')
str_enum = model.get_property('str_enum')
assert (int_enum.type == float)
assert (int_enum.multi_select == False)
assert (int_enum.enum == [1.0, 2.0, 3.0])
assert (int_enum.unit == 'cm')
assert (str_enum.type == unicode)
assert (str_enum.multi_select == True)
assert (str_enum.enum == ['foo', 'bar', 'baz'])
record = model.create_record({'name': 'A', 'int_enum': 1.0, 'str_enum': ['foo', 'bar']})
gotten = model.get_all()[0]
assert gotten.values['int_enum'] == 1.0
assert set(gotten.values['str_enum']) == set(['foo', 'bar'])
with pytest.raises(Exception, match=r"Value '5' is not a member*"):
model.create_record({'name': 'A', 'int_enum': 5, 'str_enum': ['foo', 'bar']})
with pytest.raises(Exception, match=r"Value 'blah' is not a member*"):
model.create_record({'name': 'A', 'int_enum': 1.0, 'str_enum': ['blah']})
def test_get_connected(dataset):
model_1 = dataset.create_model('Model_A', description="model a", schema=[
ModelProperty("prop1", data_type=ModelPropertyType(data_type=str),
title=True)])
related_models = model_1.get_connected()
# For a single, unconnected model, it should return nothing
assert len(related_models) == 0
model_2 = dataset.create_model('Model_B', description="model b", schema=[
ModelProperty("prop1", data_type=ModelPropertyType(data_type=str),
title=True)])
relationship = dataset.create_relationship_type(
'New_Relationship_{}'.format(current_ts()), 'a new relationship')
model_instance_1 = model_1.create_record({"prop1": "val1"})
model_instance_2 = model_2.create_record({"prop1": "val1"})
model_instance_1.relate_to(model_instance_2, relationship)
related_models = model_1.get_connected()
assert len(related_models) == 2
# For a connected model, return all connections + the model itself
related_models = model_2.get_connected()
assert len(related_models) == 2
# Check that get_connected_models from the dataset object also works
related_models = dataset.get_connected_models(model_1.id)
assert len(related_models) == 2
related_models = dataset.get_connected_models(model_2.id)
assert len(related_models) == 2
def test_enum_model_properties(dataset):
model = dataset.create_model(
"Enum_Props",
description="a new description",
schema=[
ModelProperty("name", data_type=str, title=True),
ModelProperty(
"int_enum",
data_type=ModelPropertyEnumType(data_type=float,
enum=[1.0, 2.0, 3.0],
unit="cm",
multi_select=False),
),
ModelProperty(
"str_enum",
data_type=ModelPropertyEnumType(data_type=str,
enum=["foo", "bar", "baz"],
multi_select=True),
),
],
)
assert model == dataset.get_model(model.id)
int_enum = model.get_property("int_enum")
str_enum = model.get_property("str_enum")
assert int_enum.type == float
assert int_enum.multi_select == False
assert int_enum.enum == [1.0, 2.0, 3.0]
assert int_enum.unit == "cm"
assert str_enum.type == unicode
assert str_enum.multi_select == True
assert str_enum.enum == ["foo", "bar", "baz"]
record = model.create_record({
"name": "A",
"int_enum": 1.0,
"str_enum": ["foo", "bar"]
})
gotten = model.get_all()[0]
assert gotten.values["int_enum"] == 1.0
assert set(gotten.values["str_enum"]) == set(["foo", "bar"])
with pytest.raises(Exception, match=r"Value '5' is not a member*"):
model.create_record({
"name": "A",
"int_enum": 5,
"str_enum": ["foo", "bar"]
})
with pytest.raises(Exception, match=r"Value 'blah' is not a member*"):
model.create_record({
"name": "A",
"int_enum": 1.0,
"str_enum": ["blah"]
})
def test_retrieve_linked_properties(dataset):
# make a model and add a linked property
source = dataset.create_model('source_model_{}'.format(uuid4()),
schema=[ModelProperty('name', title=True)])
target = dataset.create_model('target_model_{}'.format(uuid4()),
schema=[ModelProperty('name', title=True)])
source.add_linked_property('link', target, 'my linked property')
new_source = dataset.get_model(source.type)
assert 'link' in new_source.linked
def test_retrieve_linked_properties(dataset):
# make a model and add a linked property
source = dataset.create_model("source_model_{}".format(make_id()),
schema=[ModelProperty("name", title=True)])
target = dataset.create_model("target_model_{}".format(make_id()),
schema=[ModelProperty("name", title=True)])
source.add_linked_property("link", target, "my linked property")
new_source = dataset.get_model(source.type)
assert "link" in new_source.linked
def test_delete_linked_property(dataset):
# make a model and add a linked property
source = dataset.create_model("source_model_{}".format(make_id()),
schema=[ModelProperty("name", title=True)])
target = dataset.create_model("target_model_{}".format(make_id()),
schema=[ModelProperty("name", title=True)])
source.add_linked_property("link", target, "my linked property")
# delete the link
source.remove_linked_property("link")
# Make sure changes were saved
assert "link" not in source.linked
def test_delete_linked_property(dataset):
# make a model and add a linked property
source = dataset.create_model('source_model_{}'.format(uuid4()),
schema=[ModelProperty('name', title=True)])
target = dataset.create_model('target_model_{}'.format(uuid4()),
schema=[ModelProperty('name', title=True)])
source.add_linked_property('link', target, 'my linked property')
# delete the link
source.remove_linked_property('link')
# Make sure changes were saved
assert 'link' not in source.linked
def test_complex_model_properties(dataset):
model_with_complex_props = dataset.create_model(
"Complex_Props",
description="a new description",
schema=[
ModelProperty("name",
data_type=ModelPropertyType(data_type=str),
title=True),
ModelProperty("age", data_type=ModelPropertyType(data_type=int)),
ModelProperty("email",
data_type=ModelPropertyType(data_type=str,
format="email")),
],
)
assert dataset.get_model(
model_with_complex_props.id) == model_with_complex_props
# Add a property
model_with_complex_props.add_property("weight",
ModelPropertyType(data_type=float,
unit="kg"),
display_name="Weight")
updated_model = dataset.get_model(model_with_complex_props.id)
weight_property = updated_model.get_property("weight")
assert weight_property.display_name == "Weight"
assert weight_property.type == float
assert weight_property._type.data_type == float
assert weight_property._type.format == None
assert weight_property.unit == "kg"
email_property = model_with_complex_props.get_property("email")
assert email_property.type == unicode
assert email_property._type.data_type == unicode
assert email_property._type.format.lower() == "email"
assert email_property.unit == None
good_values = {
"name": "Bob",
"age": 1,
"email": "*****@*****.**",
"weight": 10
}
good_record = updated_model.create_record(good_values)
bad_values = {"name": "Bob", "age": 1, "email": "123455", "weight": 10}
with pytest.raises(Exception):
bad_record = updated_model.create_record(bad_values)
def test_make_linked_property(dataset):
# make a new model
model = dataset.create_model('my_model_{}'.format(uuid4()),
schema=[ModelProperty('name', title=True)])
# create a linked property linking to that model,
# and make sure the link initialized correctly
link1 = LinkedModelProperty('link1', model, '1st linked property')
dct1 = link1.as_dict()
assert dct1['name'] == 'link1'
assert dct1['displayName'] == '1st linked property'
assert dct1['to'] == model.id
# make a linked property from a dict,
# and make sure it initialized correctly
link2 = LinkedModelProperty.from_dict({
'link': {
'name': 'link2',
'displayName': '2nd linked property',
'to': model.id,
'id': 'XXX-XXX-XXX',
'position': 0
}
})
assert link2.id == 'XXX-XXX-XXX'
assert link2.position == 0
dct2 = link2.as_dict()
assert dct2['name'] == 'link2'
assert dct2['displayName'] == '2nd linked property'
assert dct2['to'] == model.id
def update_properties(self, dataset, concept):
assert isinstance(concept, Model), "concept must be type Model"
assert concept.schema, "concept schema cannot be empty"
data = concept.as_dict()['schema']
dataset_id = self._get_id(dataset)
resp = self._put(self._uri('/{dataset_id}/concepts/{id}/properties', dataset_id=dataset_id, id=concept.id), json=data)
return [ModelProperty.from_dict(r) for r in resp]
def test_make_linked_property(dataset):
# make a new model
model = dataset.create_model("my_model_{}".format(make_id()),
schema=[ModelProperty("name", title=True)])
# create a linked property linking to that model,
# and make sure the link initialized correctly
link1 = LinkedModelProperty("link1", model, "1st linked property")
dct1 = link1.as_dict()
assert dct1["name"] == "link1"
assert dct1["displayName"] == "1st linked property"
assert dct1["to"] == model.id
# make a linked property from a dict,
# and make sure it initialized correctly
link2 = LinkedModelProperty.from_dict({
"link": {
"name": "link2",
"displayName": "2nd linked property",
"to": model.id,
"id": "XXX-XXX-XXX",
"position": 0,
}
})
assert link2.id == "XXX-XXX-XXX"
assert link2.position == 0
dct2 = link2.as_dict()
assert dct2["name"] == "link2"
assert dct2["displayName"] == "2nd linked property"
assert dct2["to"] == model.id
def test_package_proxy_import(bf, dataset, organization, assert_in_neo4j):
"""
Needs to be run in non-prod, on an organization that has not been fully migrated.
Test that multiple proxy relationships can be imported for the same proxy
concept, and that we can import edges both too and from proxy concepts.
"""
person = dataset.create_model(
"Person",
schema=[
ModelProperty("name", data_type=str, title=True, required=True)
],
)
alice = person.create_record({"name": "Alice"})
bob = person.create_record({"name": "Bob"})
pkg = DataPackage("Some MRI", package_type="MRI")
dataset.add(pkg)
pkg.relate_to(alice, bob)
alice_files = alice.get_files()
bob_files = bob.get_files()
migrate_dataset(organization_id=organization.int_id,
dataset_ids=[dataset.int_id])
assert_in_neo4j()
assert alice.get_files() == alice_files
assert bob.get_files() == bob_files
def apply(self, dataset, template):
org_id = self._get_int_id(self.session._context)
dataset_id = self._get_int_id(dataset)
template_id = self._get_id(template)
resp = self._post(self._uri('/organizations/{orgId}/templates/{templateId}/datasets/{datasetId}',
orgId=org_id, templateId=template_id, datasetId=dataset_id))
return [ModelProperty.from_dict(t) for t in resp]
def simple_graph(client):
"""
Creates a small test graph in an independent dataset to de-couple
from other tests
"""
test_dataset = create_test_dataset(client)
model_1 = test_dataset.create_model(
"Model_A",
description="model a",
schema=[
ModelProperty("prop1",
data_type=ModelPropertyType(data_type=str),
title=True)
],
)
model_2 = test_dataset.create_model(
"Model_B",
description="model b",
schema=[
ModelProperty("prop1",
data_type=ModelPropertyType(data_type=str),
title=True)
],
)
relationship = test_dataset.create_relationship_type(
"New_Relationship_{}".format(current_ts()), "a new relationship")
model_instance_1 = model_1.create_record({"prop1": "val1"})
model_instance_2 = model_2.create_record({"prop1": "val1"})
model_instance_1.relate_to(model_instance_2, relationship)
graph = Graph(
test_dataset,
models=[model_1, model_2],
model_records=[model_instance_1, model_instance_2],
relationships=[relationship],
relationship_records=None,
)
yield graph
ds_id = test_dataset.id
client._api.datasets.delete(test_dataset)
all_dataset_ids = [x.id for x in client.datasets()]
assert ds_id not in all_dataset_ids
assert not test_dataset.exists
def test_migrate_dataset(bf, dataset, organization, assert_in_neo4j):
"""
Needs to be run in non-prod, on an organization that has not been fully migrated.
"""
person = dataset.create_model(
"Person",
schema=[
ModelProperty("name", data_type=str, title=True, required=True),
ModelProperty("age", data_type=int),
ModelProperty("dob", data_type=datetime),
],
)
likes = dataset.create_relationship_type("likes",
"",
source=person.id,
destination=person.id)
alice = person.create_record({
"name": "Alice",
"age": 25,
"dob": datetime(1994, 11, 19)
})
bob = person.create_record({
"name": "Bob",
"age": 24,
"dob": datetime(1995, 11, 19)
})
likes.relate(alice, bob)
migrate_dataset(
organization_id=organization.int_id,
# organization_node_id=organization.id,
dataset_ids=[dataset.int_id]
# dataset_node_id=dataset.id,
)
assert_in_neo4j()
assert len(dataset.models()) == 1
person = dataset.get_model("Person")
assert person.get_all() == [alice, bob]
assert len(dataset.relationships()) == 1
assert alice.get_related(person.type) == [bob]
def test_get_link(dataset):
# make a model and add a linked property
source = dataset.create_model('source_model_{}'.format(uuid4()),
schema=[ModelProperty('name', title=True)])
target = dataset.create_model('target_model_{}'.format(uuid4()),
schema=[ModelProperty('name', title=True)])
prop = source.add_linked_property('link', target, 'my linked property')
# make records and link them
source_rec = source.create_record({'name': 'source_record'})
target_rec = target.create_record({'name': 'target_record'})
link = source_rec.add_linked_value(target_rec, prop)
link2 = source_rec.get_linked_value('link')
link3 = source_rec.get_linked_value(link.id)
assert link.id == link2.id == link3.id
assert link.source_model.id == source.id
assert link.target_model.id == target.id
def test_edit_linked_property(dataset):
# make a model and add a linked property
source = dataset.create_model('source_model_{}'.format(uuid4()),
schema=[ModelProperty('name', title=True)])
target = dataset.create_model('target_model_{}'.format(uuid4()),
schema=[ModelProperty('name', title=True)])
link = source.add_linked_property('link', target, 'my linked property')
# edit the linked property and update model
link.display_name = 'updated linked property'
link.position = 99
source.update()
# Make sure changes were saved
new_link = source.get_linked_property('link')
assert new_link.position == 99
assert new_link.display_name == 'updated linked property'
def test_remove_link(dataset):
# make a model and add a linked property
source = dataset.create_model('source_model_{}'.format(uuid4()),
schema=[ModelProperty('name', title=True)])
target = dataset.create_model('target_model_{}'.format(uuid4()),
schema=[ModelProperty('name', title=True)])
prop = source.add_linked_property('link', target, 'my linked property')
# make records and link them
source_rec = source.create_record({'name': 'source_record'})
target_rec = target.create_record({'name': 'target_record'})
link = source_rec.add_linked_value(target_rec, prop)
# delete the link
source_rec.delete_linked_value(link.id)
assert not any(link.target == target_rec.id
for link in source_rec.get_linked_values())
def test_edit_linked_property(dataset):
# make a model and add a linked property
source = dataset.create_model("source_model_{}".format(make_id()),
schema=[ModelProperty("name", title=True)])
target = dataset.create_model("target_model_{}".format(make_id()),
schema=[ModelProperty("name", title=True)])
link = source.add_linked_property("link", target, "my linked property")
# edit the linked property and update model
link.display_name = "updated linked property"
link.position = 99
source.update()
# Make sure changes were saved
new_link = source.get_linked_property("link")
assert new_link.position == 99
assert new_link.display_name == "updated linked property"
def test_remove_link(dataset):
# make a model and add a linked property
source = dataset.create_model("source_model_{}".format(make_id()),
schema=[ModelProperty("name", title=True)])
target = dataset.create_model("target_model_{}".format(make_id()),
schema=[ModelProperty("name", title=True)])
prop = source.add_linked_property("link", target, "my linked property")
# make records and link them
source_rec = source.create_record({"name": "source_record"})
target_rec = target.create_record({"name": "target_record"})
link = source_rec.add_linked_value(target_rec, prop)
# delete the link
source_rec.delete_linked_value(link.id)
assert not any(link.target == target_rec.id
for link in source_rec.get_linked_values())
def test_get_link(dataset):
# make a model and add a linked property
source = dataset.create_model("source_model_{}".format(make_id()),
schema=[ModelProperty("name", title=True)])
target = dataset.create_model("target_model_{}".format(make_id()),
schema=[ModelProperty("name", title=True)])
prop = source.add_linked_property("link", target, "my linked property")
# make records and link them
source_rec = source.create_record({"name": "source_record"})
target_rec = target.create_record({"name": "target_record"})
link = source_rec.add_linked_value(target_rec, prop)
link2 = source_rec.get_linked_value("link")
link3 = source_rec.get_linked_value(link.id)
assert link.id == link2.id == link3.id
assert link.source_model.id == source.id
assert link.target_model.id == target.id
def test_add_linked_property_bulk(dataset):
# Link one model to three others
source = dataset.create_model("source_model_{}".format(make_id()),
schema=[ModelProperty("name", title=True)])
target = dataset.create_model("target_model_{}".format(make_id()),
schema=[ModelProperty("name", title=True)])
link1 = LinkedModelProperty("link1", target, "bulk-added")
link2 = LinkedModelProperty("link2", target, "bulk-added")
link3 = LinkedModelProperty("link3", target, "bulk-added")
source.add_linked_properties([link1, link2, link3])
# Make sure newly created links are accessible through the API
bulk = [
x for x in dataset.get_topology()["linked_properties"]
if x.display_name == "bulk-added"
]
assert len(bulk) == 3
assert len(source.linked) == 3
def test_add_linked_property_bulk(dataset):
# Link one model to three others
source = dataset.create_model('source_model_{}'.format(uuid4()),
schema=[ModelProperty('name', title=True)])
target = dataset.create_model('target_model_{}'.format(uuid4()),
schema=[ModelProperty('name', title=True)])
link1 = LinkedModelProperty('link1', target, 'bulk-added')
link2 = LinkedModelProperty('link2', target, 'bulk-added')
link3 = LinkedModelProperty('link3', target, 'bulk-added')
source.add_linked_properties([link1, link2, link3])
# Make sure newly created links are accessible through the API
bulk = [
x for x in dataset.get_topology()['linked_properties']
if x.display_name == 'bulk-added'
]
assert len(bulk) == 3
assert len(source.linked) == 3
def test_add_linked_property(dataset):
# Create two models and link one to the other
source = dataset.create_model('source_model_{}'.format(uuid4()),
schema=[ModelProperty('name', title=True)])
target = dataset.create_model('target_model_{}'.format(uuid4()),
schema=[ModelProperty('name', title=True)])
source.add_linked_property('link', target, 'my linked property')
# Make sure newly created link is accessible through the API
assert any(l.name == 'link' and l.target == target.id
for l in dataset.get_topology()['linked_properties'])
assert 'link' in source.linked
# Prevent user from adding duplicate linked properties
with pytest.raises(Exception):
source.add_linked_property('link', source, 'duplicate linked property')
assert not any(l.display_name == 'duplicate linked property'
for l in dataset.get_topology()['linked_properties'])
def test_add_linked_property(dataset):
# Create two models and link one to the other
source = dataset.create_model("source_model_{}".format(make_id()),
schema=[ModelProperty("name", title=True)])
target = dataset.create_model("target_model_{}".format(make_id()),
schema=[ModelProperty("name", title=True)])
source.add_linked_property("link", target, "my linked property")
# Make sure newly created link is accessible through the API
assert any(l.name == "link" and l.target == target.id
for l in dataset.get_topology()["linked_properties"])
assert "link" in source.linked
# Prevent user from adding duplicate linked properties
with pytest.raises(Exception):
source.add_linked_property("link", source, "duplicate linked property")
assert not any(l.display_name == "duplicate linked property"
for l in dataset.get_topology()["linked_properties"])
def get_properties(self, dataset, concept):
dataset_id = self._get_id(dataset)
concept_id = self._get_id(concept)
resp = self._get(
self._uri(
"/{dataset_id}/concepts/{id}/properties",
dataset_id=dataset_id,
id=concept_id,
))
return [ModelProperty.from_dict(r) for r in resp]
def test_merge_duplicate_linked_property_instances(bf, dataset, organization,
assert_in_neo4j):
"""
Needs to be run in non-prod, on an organization that has not been fully migrated.
Test that the migration dedupulicates linked property instances.
"""
person = dataset.create_model(
"Person",
schema=[
ModelProperty("name", data_type=str, title=True, required=True)
],
)
likes = person.add_linked_property("likes", person)
alice = person.create_record({"name": "Alice"})
bob = person.create_record({"name": "Bob"})
# Add one instance: (alice)-[likes]->(alice)
alice.add_linked_value(alice, likes)
# Add another: (alice)-[likes]->(bob)
# The Python client deletes existing linked properties before adding new ones -
# this manual request allows us to duplicate the linked property instance.
# (This is the same requeust `add_linked_value` makes under the hood.)
bf._api.concepts.instances._post(
bf._api.concepts.instances._uri(
"/{dataset_id}/concepts/{concept_id}/instances/{instance_id}/linked",
dataset_id=dataset.id,
concept_id=person.id,
instance_id=alice.id,
),
json={
"schemaLinkedPropertyId": likes.id,
"to": bob.id,
"name": "likes",
"displayName": "likes",
},
)
# This should not be possible - there should only be one "likes" property
assert [lp.type.name
for lp in alice.get_linked_values()] == ["likes", "likes"]
migrate_dataset(organization_id=organization.int_id,
dataset_ids=[dataset.int_id])
assert_in_neo4j()
# Import should merge linked values
linked_values = alice.get_linked_values()
assert len(linked_values) == 1
assert linked_values[0].type.name == "likes"
assert linked_values[0].target_record_id == bob.id
def test_add_link(dataset):
# make a model and add a linked property
source = dataset.create_model("source_model_{}".format(make_id()),
schema=[ModelProperty("name", title=True)])
target = dataset.create_model("target_model_{}".format(make_id()),
schema=[ModelProperty("name", title=True)])
prop = source.add_linked_property("link", target, "my linked property")
# make records and link them
source_rec = source.create_record({"name": "source_record"})
target_rec = target.create_record({"name": "target_record"})
link = source_rec.add_linked_value(target_rec, prop)
assert link.id == source_rec.get_linked_value("link").id
# prevent duplicate links from being created
target_rec2 = target.create_record({"name": "second_target"})
link2 = source_rec.add_linked_value(target_rec2, prop)
links = source_rec.get_linked_values()
assert len(links) == 1
assert links[0].target_record_id == target_rec2.id
