def test_expected_exceptions(self):
""" test uses that are expected to throw exceptions (and probably need code fixes) """
obj1 = IonObject(RT.InstrumentDevice, name='SBE37IMDevice', description="SBE37IMDevice", serial_number="12345")
# invalid name for repository
try:
self.repo.insert('bad name', obj1)
self.fail('should fail')
except:
pass
# invalid argument types
try:
self.repo.insert('sample', None)
self.fail('should fail')
except:
pass
try:
self.repo.insert('sample', "not ion obj")
self.fail('should fail')
except:
pass
# cannot reinsert with same id
_,id,__ = self.repo.insert('sample', obj1)
_,__,obj2 = self.repo.read('sample', id)
try:
success,_,__ = self.repo.insert('sample', obj2)
self.fail('should not succeed')
except:
pass
# cannot insert with _rev
obj1._rev = obj2._rev
try:
success,_,__ = self.repo.insert('sample', obj1)
self.fail('should not succeed')
except:
pass
def test_datastore_basic(self):
data_store = self.ds_class(datastore_name='ion_test_ds', profile=DataStore.DS_PROFILE.RESOURCES, scope=get_sys_name())
self.data_store = data_store
self.resources = {}
# Just in case previous run failed without cleaning up,
# delete data store
try:
data_store.delete_datastore()
except NotFound:
pass
# Create should succeed and not throw exception
data_store.create_datastore()
# Create should throw exception the second time
with self.assertRaises(BadRequest):
data_store.create_datastore()
# Call ops with wrong object type and make sure exception is thrown
with self.assertRaises(BadRequest):
data_store.create({"foo": "bar"})
with self.assertRaises(BadRequest):
data_store.create_mult([{"foo": "bar"}])
with self.assertRaises(BadRequest):
data_store.read({"foo": "bar"})
with self.assertRaises(BadRequest):
data_store.read_mult([{"foo": "bar"}])
with self.assertRaises(BadRequest):
data_store.update({"foo": "bar"})
with self.assertRaises(BadRequest):
data_store.delete({"foo": "bar"})
# Should see new data
self.assertTrue([1 for dsn in data_store.list_datastores() if dsn in ('ion_test_ds', '%s_%s' % (get_sys_name(), 'ion_test_ds'))])
# 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]
# Check that a create fails with an existing ID
admin_role_obj2 = IonObject('UserRole', admin_role)
with self.assertRaises(BadRequest):
data_store.create(admin_role_obj2, object_id=admin_role_ooi_id)
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)
with self.assertRaises(NotFound):
data_store.read_mult([admin_role_ooi_id, data_provider_role_ooi_id, "NONEXISTENT"])
role_objs1 = data_store.read_mult([admin_role_ooi_id, "NONEXISTENT", data_provider_role_ooi_id], strict=False)
self.assertTrue(len(role_objs1) == 3)
self.assertTrue(role_objs1[0]._id == admin_role_ooi_id)
self.assertTrue(role_objs1[1] is None)
self.assertTrue(role_objs1[2]._id == data_provider_role_ooi_id)
# Construct three user info objects and assign them roles
hvl_contact_info = {
"individual_names_given": "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('ActorIdentity', 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 = {
"individual_names_given": "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('ActorIdentity', 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 = {
"individual_names_given": "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('ActorIdentity', 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)
# Create an Ion object with default values set (if any)
data_set = IonObject('Commitment')
self.assertTrue(isinstance(data_set, interface.objects.Commitment))
# Assign values to object fields
data_set.description = "Real-time water data for Choptank River near Greensboro, MD"
# 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.Commitment))
self.assertTrue(data_set_read_obj.description == "Real-time water data for Choptank River near Greensboro, MD")
self.assertTrue('type_' in data_set_read_obj)
data_set_read_obj2 = data_store.read(data_set_uuid)
# 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")
# Check that a second update fails
self.assertNotEqual(data_set_read_obj_2._rev, data_set_read_obj2._rev)
with self.assertRaises(Conflict):
data_store.update(data_set_read_obj2)
# Test update with non-existing object
spurious_obj = IonObject('Commitment')
with self.assertRaises(BadRequest):
data_store.update(spurious_obj)
spurious_obj._rev = data_set_read_obj._rev
with self.assertRaises(BadRequest):
data_store.update(spurious_obj)
#spurious_obj._id = "NON EXISTING ID"
#with self.assertRaises(NotFound):
# data_store.update(spurious_obj)
# 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)
# 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)
xobj = dict(some="content")
xoid, _ = data_store.create_doc(xobj)
xobj2 = data_store.read_doc(xoid)
xobj2["_deleted"] = True
data_store.update_doc(xobj2)
with self.assertRaises(NotFound):
data_store.read_doc(xoid)
xobj = dict(some="content1")
xoid, _ = data_store.create_doc(xobj)
xobj2 = data_store.read_doc(xoid)
xobj2["_deleted"] = True
data_store.update_doc_mult([xobj2])
with self.assertRaises(NotFound):
data_store.read_doc(xoid)
# Try to re-delete Dataset by object id. Should throw exception.
with self.assertRaises(NotFound):
data_store.delete(head._id)
# 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("Commitment", name="One more")
o2 = IonObject("Commitment", name="Another one")
res = data_store.create_mult((o1, o2))
self.assertTrue(all([success for success, oid, rev in res]))
oids = [oid for success, oid, rev in res]
res = data_store.list_objects()
self.assertTrue(len(res) == 8 + numcoredocs)
o1 = dict(type_="Resource", name="name1xxx", visibility=1, lcstate=LCS.DRAFT, availability=AS.AVAILABLE)
o2 = dict(type_="DirEntry", key="key1", parent="/Parent", org="ION")
o3 = dict(type_="Association", s=oids[0], o=oids[1], st="Dataset", ot="Dataset", p="some", retired=False)
res = data_store.create_doc_mult([o1, o2, o3])
start_key = ["ION", "/Parent", 0]
end_key = ["ION", "/Parent"]
res1 = data_store.find_docs_by_view("directory", "by_parent", start_key=start_key, end_key=end_key, id_only=True)
self.assertEquals(len(res1), 1)
res1 = data_store.find_associations(predicate="some", id_only=True)
self.assertEquals(len(res1), 1)
res1,_ = data_store.find_resources(name="name1xxx", id_only=True)
self.assertEquals(len(res1), 1)
res = data_store.list_objects()
self.assertTrue(len(res) == 11 + numcoredocs)
# Delete data store to clean up
data_store.delete_datastore()
# Assert data store is now gone
self.assertFalse([1 for dsn in data_store.list_datastores() if dsn in ('ion_test_ds', '%s_%s' % (get_sys_name(), 'ion_test_ds'))])
