def test_get_relation(self):
from_record_args = base_connector_record_parameter_example()
to_record_args = base_connector_record_parameter_example()
relation_args = base_connector_relation_parameter_example()
from_identifier = relation_args["from_node"]
to_identifier = relation_args["to_node"]
from_record_args["metadata"][METADATA_KEY_IDENTIFIER] = from_identifier
to_record_args["metadata"][METADATA_KEY_IDENTIFIER] = to_identifier
doc_id = self.instance.save_document()
from_record_id = self.instance.save_record(doc_id, from_record_args["attributes"],
from_record_args["metadata"]) #
to_record_id = self.instance.save_record(doc_id, to_record_args["attributes"], to_record_args["metadata"]) #
relation_id = self.instance.save_relation(doc_id, from_identifier, doc_id, to_identifier,
relation_args["attributes"], relation_args["metadata"])
relation_raw = self.instance.get_relation(relation_id)
self.assertIsNotNone(relation_raw)
self.assertIsNotNone(relation_raw.attributes)
self.assertIsNotNone(relation_raw.metadata)
self.assertIsInstance(relation_raw.metadata, dict)
self.assertIsInstance(relation_raw.attributes, dict)
attributes_primitive = encode_dict_values_to_primitive(relation_args["attributes"])
metadata_primitive = encode_dict_values_to_primitive(relation_args["metadata"])
self.assertEqual(relation_raw.attributes, attributes_primitive)
self.assertEqual(relation_raw.metadata, metadata_primitive)
def test_save_record(self):
args = base_connector_record_parameter_example()
doc_id = self.instance.save_document()
record_id = self.instance.save_record(doc_id, args["attributes"], args["metadata"])
self.assertIsNotNone(record_id)
self.assertIs(type(record_id), str, "id should be a string ")
def test_get_document(self):
args = base_connector_record_parameter_example()
doc_id = self.instance.save_document()
record_id = self.instance.save_record(doc_id, args["attributes"], args["metadata"])
raw_doc = self.instance.get_document(doc_id)
# Return structure...
# raw_doc = {
# document: {identifier: "undefined if document", records: [{attributes:{},metadata: {}}]}
# bundles: [{identifier: "name bundle", records: [{attributes:{},metadata: {}}]}]
# }
self.assertIsNotNone(raw_doc)
self.assertIsNotNone(raw_doc.document)
self.assertIsInstance(raw_doc.document.records, list)
self.assertEqual(len(raw_doc.document.records), 1)
self.assertIsInstance(raw_doc.document.records[0].attributes, dict)
self.assertIsInstance(raw_doc.document.records[0].metadata, dict)
attr_dict = encode_dict_values_to_primitive(args["attributes"])
meta_dict = encode_dict_values_to_primitive(args["metadata"])
self.assertEqual(raw_doc.document.records[0].attributes, attr_dict)
self.assertEqual(raw_doc.document.records[0].metadata, meta_dict)
# check bundle
self.assertIsInstance(raw_doc.bundles, list)
self.assertEqual(len(raw_doc.bundles), 0)
def insert_document_with_bundles(instance):
args_record = base_connector_record_parameter_example()
args_bundle = base_connector_bundle_parameter_example()
doc = ProvDocument()
doc.add_namespace("ex", "http://example.com")
# document with 1 record
doc_id = instance.save_document()
doc_record_id = instance.save_record(doc_id, args_record["attributes"], args_record["metadata"])
# bundle with 1 record
bundle_id = instance.save_bundle(doc_id, args_bundle["attributes"], args_bundle["metadata"])
bundle_record_id = instance.save_record(bundle_id, args_record["attributes"], args_record["metadata"])
# add relation
from_record_args = base_connector_record_parameter_example()
to_record_args = base_connector_record_parameter_example()
relation_args = base_connector_relation_parameter_example()
from_label = doc.valid_qualified_name("ex:FROM NODE")
to_label = doc.valid_qualified_name("ex:TO NODE")
from_record_args["metadata"][METADATA_KEY_IDENTIFIER] = from_label
to_record_args["metadata"][METADATA_KEY_IDENTIFIER] = to_label
from_record_id = instance.save_record(doc_id, from_record_args["attributes"], from_record_args["metadata"])
to_record_id = instance.save_record(doc_id, to_record_args["attributes"], to_record_args["metadata"])
relation_id = instance.save_relation(doc_id, from_label, doc_id, to_label, relation_args["attributes"],
relation_args["metadata"])
return {
"relation_id": relation_id,
"from_record_id": from_record_id,
"to_record_id": to_record_id,
"bundle_id": bundle_id,
"bundle_record_id": bundle_record_id,
"doc_id": doc_id,
"doc_record_id": doc_record_id
}
def test_save_relation(self):
args_relation = base_connector_relation_parameter_example()
args_records = base_connector_record_parameter_example()
doc_id = self.instance.save_document()
from_meta = args_records["metadata"].copy()
from_meta.update({METADATA_KEY_IDENTIFIER: args_relation["from_node"]})
from_node_id = self.instance.save_record(doc_id, args_records["attributes"], from_meta)
to_meta = args_records["metadata"].copy()
to_meta.update({METADATA_KEY_IDENTIFIER: args_relation["to_node"]})
to_node_id = self.instance.save_record(doc_id, args_records["attributes"], to_meta)
relation_id = self.instance.save_relation(doc_id, args_relation["from_node"], doc_id, args_relation["to_node"],
args_relation["attributes"], args_relation["metadata"])
self.assertIsNotNone(relation_id)
self.assertIs(type(relation_id), str, "id should be a string ")
def test_get_record(self):
args = base_connector_record_parameter_example()
doc_id = self.instance.save_document()
record_id = self.instance.save_record(doc_id, args["attributes"], args["metadata"]) #
record_raw = self.instance.get_record(record_id)
self.assertIsNotNone(record_raw)
self.assertIsNotNone(record_raw.attributes)
self.assertIsNotNone(record_raw.metadata)
self.assertIsInstance(record_raw.metadata, dict)
self.assertIsInstance(record_raw.attributes, dict)
attributes_primitive = encode_dict_values_to_primitive(args["attributes"])
metadata_primitive = encode_dict_values_to_primitive(args["metadata"])
self.assertEqual(record_raw.attributes, attributes_primitive)
self.assertEqual(record_raw.metadata, metadata_primitive)
self.assertIs(type(record_id), str, "id should be a string ")
def test_get_bundle(self):
args = base_connector_record_parameter_example()
args_bundle = base_connector_bundle_parameter_example()
doc_id = self.instance.save_document()
bundle_id = self.instance.save_bundle(doc_id, args_bundle["attributes"], args_bundle["metadata"])
record_id = self.instance.save_record(bundle_id, args["attributes"], args["metadata"])
raw_bundle = self.instance.get_bundle(bundle_id)
# Return structure...
# raw_doc = {
# records: []
# identifier: ""
# }
# check bundle
self.assertIsNotNone(raw_bundle)
self.assertIsNotNone(raw_bundle.bundle_record)
self.assertIsNotNone(raw_bundle.bundle_record.metadata)
self.assertIsNotNone(raw_bundle.bundle_record.attributes)
self.assertIsInstance(raw_bundle.records, list)
self.assertIsInstance(raw_bundle.bundle_record.attributes, dict)
self.assertIsInstance(raw_bundle.bundle_record.metadata, dict)
self.assertEqual(len(raw_bundle.records), 1)
args_simple = encode_dict_values_to_primitive(args_bundle["metadata"])
self.assertEqual(raw_bundle.bundle_record.metadata, args_simple)
# check if the metadata of the record equals
attr_dict = encode_dict_values_to_primitive(args["attributes"])
meta_dict = encode_dict_values_to_primitive(args["metadata"])
self.assertEqual(raw_bundle.records[0].attributes, attr_dict)
self.assertEqual(raw_bundle.records[0].metadata, meta_dict)