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)