def _do_test(self, data_store): self.data_store = data_store self.resources = {} # Just in case previous run failed without cleaning up, # delete data store deleteFailed = False try: data_store.delete_datastore() except NotFound: deleteFailed = True self.assertFalse(deleteFailed) # Create should succeed and not throw error data_store.create_datastore() # Create should throw exception the second time createFailed = False try: data_store.create_datastore() except BadRequest: createFailed = True self.assertTrue(createFailed) # Call ops with wrong object type and make sure exception is thrown createFailed = False try: data_store.create({"foo": "bar"}) except BadRequest: createFailed = True self.assertTrue(createFailed) createMultFailed = False try: data_store.create_mult([{"foo": "bar"}]) except BadRequest: createMultFailed = True self.assertTrue(createMultFailed) readFailed = False try: data_store.read({"foo": "bar"}) except BadRequest: readFailed = True self.assertTrue(readFailed) readMultFailed = False try: data_store.read_mult([{"foo": "bar"}]) except BadRequest: readMultFailed = True self.assertTrue(readMultFailed) updateFailed = False try: data_store.update({"foo": "bar"}) except BadRequest: updateFailed = True self.assertTrue(updateFailed) deleteFailed = False try: data_store.delete({"foo": "bar"}) except BadRequest: deleteFailed = True self.assertTrue(deleteFailed) # Should see new data self.assertIn('my_ds', data_store.list_datastores()) # Something should be returned self.assertTrue(data_store.info_datastore() is not None) res = data_store.list_objects() numcoredocs = len(res) # Construct user role objects admin_role = { "name":"Admin", "description":"Super user" } admin_role_obj = IonObject('UserRole', admin_role) admin_role_tuple = data_store.create(admin_role_obj) self.assertTrue(len(admin_role_tuple) == 2) admin_role_ooi_id = admin_role_tuple[0] data_provider_role = { "name":"Data Provider", "description":"User allowed to ingest data sets" } data_provider_role_obj = IonObject('UserRole', data_provider_role) data_provider_role_tuple = data_store.create(data_provider_role_obj) self.assertTrue(len(data_provider_role_tuple) == 2) data_provider_role_ooi_id = data_provider_role_tuple[0] marine_operator_role = { "name":"Marine Operator", "description":"User allowed to administer instruments" } marine_operator_role_obj = IonObject('UserRole', marine_operator_role) marine_operator_role_tuple = data_store.create(marine_operator_role_obj) self.assertTrue(len(marine_operator_role_tuple) == 2) marine_operator_role_ooi_id = marine_operator_role_tuple[0] role_objs = data_store.read_mult([admin_role_ooi_id, data_provider_role_ooi_id, marine_operator_role_ooi_id]) self.assertTrue(len(role_objs) == 3) self.assertTrue(role_objs[0]._id == admin_role_ooi_id) self.assertTrue(role_objs[1]._id == data_provider_role_ooi_id) self.assertTrue(role_objs[2]._id == marine_operator_role_ooi_id) # Construct three user info objects and assign them roles hvl_contact_info = { "name": "Heitor Villa-Lobos", "email": "*****@*****.**", "variables": [ {"name": "Claim To Fame", "value": "Legendary Brazilian composer"} ] } hvl_contact_info_obj = IonObject('ContactInformation', hvl_contact_info) hvl_user_info = { "name": "Heitor Villa-Lobos", "contact": hvl_contact_info_obj } hvl_user_info_obj = IonObject('UserInfo', hvl_user_info) hvl_user_info_tuple = data_store.create(hvl_user_info_obj) self.assertTrue(len(hvl_user_info_tuple) == 2) heitor_villa_lobos_ooi_id = hvl_user_info_tuple[0] ats_contact_info = { "name": "Andres Torres Segovia", "email": "*****@*****.**", "variables": [ {"name": "Claim To Fame", "value": "Legendary Concert Guitarist"} ] } ats_contact_info_obj = IonObject('ContactInformation', ats_contact_info) ats_user_info = { "name": "Andres Torres Segovia", "contact": ats_contact_info_obj } ats_user_info_obj = IonObject('UserInfo', ats_user_info) ats_user_info_tuple = data_store.create(ats_user_info_obj) self.assertTrue(len(ats_user_info_tuple) == 2) pok_contact_info = { "name": "Per-Olov Kindgren", "email": "*****@*****.**", "variables": [ {"name": "Claim To Fame", "value": "Composer and YouTube star"} ] } pok_contact_info_obj = IonObject('ContactInformation', pok_contact_info) pok_user_info = { "name": "Per-Olov Kindgren", "contact": pok_contact_info_obj } pok_user_info_obj = IonObject('UserInfo', pok_user_info) pok_user_info_tuple = data_store.create(pok_user_info_obj) self.assertTrue(len(pok_user_info_tuple) == 2) # List all objects in data store and confirm there are six docs res = data_store.list_objects() # There are indices. Therefore can't could all docs self.assertTrue(len(res) == 6 + numcoredocs) # Find all the UserInfo records res = data_store.find([["type_", "==", "UserInfo"]]) self.assertTrue(len(res) == 3) # Find only the UserInfo record for user Heitor Villa-Lobos res = data_store.find([["type_", DataStore.EQUAL, "UserInfo"], DataStore.AND, ["name", DataStore.EQUAL, "Heitor Villa-Lobos"]]) self.assertTrue(len(res) == 1) user_info_obj = res[0] self.assertTrue(user_info_obj.contact.name == "Heitor Villa-Lobos") # Create an Ion object with default values set (if any) data_set = IonObject('DataSet') self.assertTrue(isinstance(data_set, interface.objects.DataSet)) # Assign values to object fields data_set.description = "Real-time water data for Choptank River near Greensboro, MD" data_set.min_datetime = "2011-08-04T13:15:00Z" data_set.max_datetime = "2011-08-09T19:15:00Z" data_set.variables = [ {"name":"water_height", "value":"ft"} ] data_set.contact.name = "Heitor Villa-Lobos" data_set.last_modified = "Heitor Villa-Lobos" # Write DataSet object" write_tuple_1 = data_store.create(data_set) self.assertTrue(len(write_tuple_1) == 2) # Save off the object UUID data_set_uuid = write_tuple_1[0] # Read back the HEAD version of the object and validate fields data_set_read_obj = data_store.read(data_set_uuid) self.assertTrue(data_set_read_obj._id == data_set_uuid) self.assertTrue(isinstance(data_set_read_obj, interface.objects.DataSet)) self.assertTrue(data_set_read_obj.description == "Real-time water data for Choptank River near Greensboro, MD") self.assertTrue(not 'type_' in data_set_read_obj) # Update DataSet's Description field and write data_set_read_obj.description = "Updated Description" write_tuple_2 = data_store.update(data_set_read_obj) self.assertTrue(len(write_tuple_2) == 2) # Retrieve the updated DataSet data_set_read_obj_2 = data_store.read(data_set_uuid) self.assertTrue(data_set_read_obj_2._id == data_set_uuid) self.assertTrue(data_set_read_obj_2.description == "Updated Description") # List all the revisions of DataSet in data store, should be two res = data_store.list_object_revisions(data_set_uuid) self.assertTrue(len(res) == 2) # Do another update to the object data_set_read_obj_2.description = "USGS instantaneous value data for station 01491000" write_tuple_3 = data_store.update(data_set_read_obj_2) # List revisions of DataSet in data store, should now be three res = data_store.list_object_revisions(data_set_uuid) self.assertTrue(len(res) == 3) # Retrieve original version of DataSet obj1 = data_store.read(data_set_uuid, rev_id=write_tuple_1[1]) self.assertTrue(obj1._id == data_set_uuid) self.assertTrue(obj1.description == "Real-time water data for Choptank River near Greensboro, MD") # Retrieve second version of DataSet obj2 = data_store.read(data_set_uuid, rev_id=write_tuple_2[1]) self.assertTrue(obj2._id == data_set_uuid) self.assertTrue(obj2.description == "Updated Description") # Retrieve third version of DataSet obj3 = data_store.read(data_set_uuid, rev_id=write_tuple_3[1]) self.assertTrue(obj3._id == data_set_uuid) self.assertTrue(obj3.description == "USGS instantaneous value data for station 01491000") # Retrieve HEAD version of DataSet head = data_store.read(data_set_uuid) self.assertTrue(head._id == data_set_uuid) self.assertTrue(head.description == "USGS instantaneous value data for station 01491000") # Delete DataSet by object id data_store.delete(head) # Try to re-delete DataSet by object id. Should throw exception. delete_failed = False try: data_store.delete(head._id) except NotFound: delete_failed = True self.assertTrue(delete_failed == True) # List all objects in data store, should be back to six res = data_store.list_objects() self.assertTrue(len(res) == 6 + numcoredocs) # List revisions of now deleted DataSet, should be empty list res = data_store.list_object_revisions(data_set_uuid) self.assertTrue(len(res) == 0) o1 = IonObject("DataSet", name="One more") o2 = IonObject("DataSet", name="Another one") res = data_store.create_mult((o1, o2)) self.assertTrue(all([success for success, oid, rev in res])) res = data_store.list_objects() self.assertTrue(len(res) == 8 + numcoredocs) # Delete data store to clean up data_store.delete_datastore() # Assert data store is now gone self.assertNotIn('my_ds', data_store.list_datastores())