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())
