def _do_test_lifecycle(self):
# Lifecycle tests
att = IonObject("InstrumentDevice", name='mine', description='desc')
rid,rev = self.resource_registry_service.create(att)
att1 = self.resource_registry_service.read(rid)
self.assertEquals(att1.name, att.name)
self.assertEquals(att1.lcstate, LCS.DRAFT)
self.assertEquals(att1.availability, AS.PRIVATE)
new_state = self.resource_registry_service.execute_lifecycle_transition(rid, LCE.PLAN)
self.assertEquals(new_state, lcstate(LCS.PLANNED, AS.PRIVATE))
att2 = self.resource_registry_service.read(rid)
self.assertEquals(att2.lcstate, LCS.PLANNED)
self.assertEquals(att2.availability, AS.PRIVATE)
with self.assertRaises(BadRequest) as cm:
self.resource_registry_service.execute_lifecycle_transition(rid, LCE.UNANNOUNCE)
self.assertTrue("type=InstrumentDevice, lcstate=PLANNED_PRIVATE has no transition for event unannounce" in cm.exception.message)
new_state = self.resource_registry_service.execute_lifecycle_transition(rid, LCE.DEVELOP)
self.assertEquals(new_state, lcstate(LCS.DEVELOPED, AS.PRIVATE))
with self.assertRaises(BadRequest):
self.resource_registry_service.execute_lifecycle_transition(
resource_id=rid, transition_event='NONE##')
self.resource_registry_service.set_lifecycle_state(rid, lcstate(LCS.INTEGRATED, AS.PRIVATE))
att1 = self.resource_registry_service.read(rid)
self.assertEquals(att1.lcstate, LCS.INTEGRATED)
self.assertEquals(att1.availability, AS.PRIVATE)
def _do_test_lifecycle(self):
# Lifecycle tests
att = IonObject("InstrumentDevice", name='mine', description='desc')
rid,rev = self.resource_registry_service.create(att)
att1 = self.resource_registry_service.read(rid)
self.assertEquals(att1.name, att.name)
self.assertEquals(att1.lcstate, LCS.DRAFT)
self.assertEquals(att1.availability, AS.PRIVATE)
new_state = self.resource_registry_service.execute_lifecycle_transition(rid, LCE.PLAN)
self.assertEquals(new_state, lcstate(LCS.PLANNED, AS.PRIVATE))
att2 = self.resource_registry_service.read(rid)
self.assertEquals(att2.lcstate, LCS.PLANNED)
self.assertEquals(att2.availability, AS.PRIVATE)
with self.assertRaises(BadRequest) as cm:
self.resource_registry_service.execute_lifecycle_transition(rid, LCE.UNANNOUNCE)
self.assertTrue("type=InstrumentDevice, lcstate=PLANNED_PRIVATE has no transition for event unannounce" in cm.exception.message)
new_state = self.resource_registry_service.execute_lifecycle_transition(rid, LCE.DEVELOP)
self.assertEquals(new_state, lcstate(LCS.DEVELOPED, AS.PRIVATE))
with self.assertRaises(BadRequest):
self.resource_registry_service.execute_lifecycle_transition(
resource_id=rid, transition_event='NONE##')
self.resource_registry_service.set_lifecycle_state(rid, lcstate(LCS.INTEGRATED, AS.PRIVATE))
att1 = self.resource_registry_service.read(rid)
self.assertEquals(att1.lcstate, LCS.INTEGRATED)
self.assertEquals(att1.availability, AS.PRIVATE)
def set_lifecycle_state(self, resource_id='', target_lcstate=''):
"""Sets the lifecycle state (if possible) to the target state. Supports compound states"""
if not target_lcstate:
raise BadRequest("Bad life-cycle state %s" % target_lcstate)
if target_lcstate.startswith('RETIRED'):
return self.retire(resource_id)
res_obj = self.read(resource_id)
old_target = target_lcstate
old_state = res_obj.lcstate
old_availability = res_obj.availability
old_lcs = lcstate(old_state, old_availability)
restype = res_obj._get_type()
restype_workflow = get_restype_lcsm(restype)
if not restype_workflow:
raise BadRequest("Resource id=%s type=%s has no lifecycle" % (resource_id, restype))
if '_' in target_lcstate: # Support compound
target_lcmat, target_lcav = lcsplit(target_lcstate)
if target_lcmat not in LCS:
raise BadRequest("Unknown life-cycle state %s" % target_lcmat)
if target_lcav and target_lcav not in AS:
raise BadRequest("Unknown life-cycle availability %s" % target_lcav)
elif target_lcstate in LCS:
target_lcmat, target_lcav = target_lcstate, res_obj.availability
target_lcstate = lcstate(target_lcmat, target_lcav)
elif target_lcstate in AS:
target_lcmat, target_lcav = res_obj.lcstate, target_lcstate
target_lcstate = lcstate(target_lcmat, target_lcav)
else:
raise BadRequest("Unknown life-cycle state %s" % target_lcstate)
# Check that target state is allowed
if not target_lcstate in restype_workflow.get_successors(old_lcs).values():
raise BadRequest("Target state %s not reachable for resource in state %s" % (target_lcstate, old_lcs))
res_obj.lcstate = target_lcmat
res_obj.availability = target_lcav
res_obj.ts_updated = get_ion_ts()
updres = self.rr_store.update(res_obj)
log.debug("set_lifecycle_state(res_id=%s, target=%s). Change %s_%s to %s_%s", resource_id, old_target,
old_state, old_availability, res_obj.lcstate, res_obj.availability)
if self.container.has_capability(self.container.CCAP.EVENT_PUBLISHER):
self.event_pub.publish_event(event_type="ResourceLifecycleEvent",
origin=res_obj._id, origin_type=res_obj.type_,
sub_type="%s.%s" % (res_obj.lcstate, res_obj.availability),
lcstate=res_obj.lcstate, availability=res_obj.availability,
lcstate_before=old_state, availability_before=old_availability)
def execute_lifecycle_transition(self, resource_id='', transition_event=''):
if transition_event == LCE.RETIRE:
return self.retire(resource_id)
res_obj = self.read(resource_id)
old_state = res_obj.lcstate
old_availability = res_obj.availability
old_lcs = lcstate(old_state, old_availability)
restype = res_obj._get_type()
restype_workflow = get_restype_lcsm(restype)
if not restype_workflow:
raise BadRequest("Resource id=%s type=%s has no lifecycle" % (resource_id, restype))
new_state = restype_workflow.get_successor(old_lcs, transition_event)
if not new_state:
raise BadRequest("Resource id=%s, type=%s, lcstate=%s has no transition for event %s" % (
resource_id, restype, old_lcs, transition_event))
lcmat, lcav = lcsplit(new_state)
res_obj.lcstate = lcmat
res_obj.availability = lcav
res_obj.ts_updated = get_ion_ts()
self.rr_store.update(res_obj)
log.debug("execute_lifecycle_transition(res_id=%s, event=%s). Change %s_%s to %s_%s", resource_id, transition_event,
old_state, old_availability, res_obj.lcstate, res_obj.availability)
if self.container.has_capability(self.container.CCAP.EVENT_PUBLISHER):
self.event_pub.publish_event(event_type="ResourceLifecycleEvent",
origin=res_obj._id, origin_type=res_obj.type_,
sub_type="%s.%s" % (res_obj.lcstate, res_obj.availability),
lcstate=res_obj.lcstate, availability=res_obj.availability,
lcstate_before=old_state, availability_before=old_availability,
transition_event=transition_event)
return lcstate(res_obj.lcstate, res_obj.availability)
def test_lifecycle(self):
svc_obj = IonObject("ServiceDefinition", name='abc')
sdid, _ = self.rr.create(svc_obj)
svc_obj1 = self.rr.read(sdid)
self.assertEquals(svc_obj1.lcstate, LCS.DEPLOYED)
self.assertEquals(svc_obj1.availability, AS.AVAILABLE)
inst_obj = IonObject("InstrumentDevice", name='instrument')
iid, _ = self.rr.create(inst_obj)
inst_obj1 = self.rr.read(iid)
self.assertEquals(inst_obj1.lcstate, LCS.DRAFT)
self.assertEquals(inst_obj1.availability, AS.PRIVATE)
lcres = self.rr.execute_lifecycle_transition(iid, LCE.PLAN)
inst_obj1 = self.rr.read(iid)
self.assertEquals(inst_obj1.lcstate, LCS.PLANNED)
self.assertEquals(inst_obj1.availability, AS.PRIVATE)
self.assertEquals(lcres, lcstate(LCS.PLANNED,AS.PRIVATE))
self.rr.execute_lifecycle_transition(iid, LCE.DEVELOP)
inst_obj1 = self.rr.read(iid)
self.assertEquals(inst_obj1.lcstate, LCS.DEVELOPED)
self.assertEquals(inst_obj1.availability, AS.PRIVATE)
with self.assertRaises(BadRequest):
self.rr.execute_lifecycle_transition(iid, "!!NONE")
with self.assertRaises(BadRequest):
self.rr.execute_lifecycle_transition(iid, LCE.PLAN)
with self.assertRaises(BadRequest):
self.rr.execute_lifecycle_transition(iid, LCE.DEVELOP)
with self.assertRaises(BadRequest):
self.rr.execute_lifecycle_transition(iid, LCE.UNANNOUNCE)
with self.assertRaises(BadRequest):
self.rr.execute_lifecycle_transition(iid, LCE.DISABLE)
self.rr.execute_lifecycle_transition(iid, LCE.ANNOUNCE)
inst_obj1 = self.rr.read(iid)
self.assertEquals(inst_obj1.lcstate, LCS.DEVELOPED)
self.assertEquals(inst_obj1.availability, AS.DISCOVERABLE)
with self.assertRaises(BadRequest):
self.rr.execute_lifecycle_transition(iid, LCE.ANNOUNCE)
self.rr.execute_lifecycle_transition(iid, LCE.INTEGRATE)
inst_obj1 = self.rr.read(iid)
self.assertEquals(inst_obj1.lcstate, LCS.INTEGRATED)
self.assertEquals(inst_obj1.availability, AS.DISCOVERABLE)
self.rr.execute_lifecycle_transition(iid, LCE.DEPLOY)
inst_obj1 = self.rr.read(iid)
self.assertEquals(inst_obj1.lcstate, LCS.DEPLOYED)
self.assertEquals(inst_obj1.availability, AS.DISCOVERABLE)
self.rr.execute_lifecycle_transition(iid, LCE.INTEGRATE)
inst_obj1 = self.rr.read(iid)
self.assertEquals(inst_obj1.lcstate, LCS.INTEGRATED)
self.assertEquals(inst_obj1.availability, AS.DISCOVERABLE)
self.rr.execute_lifecycle_transition(iid, LCE.DEVELOP)
inst_obj1 = self.rr.read(iid)
self.assertEquals(inst_obj1.lcstate, LCS.DEVELOPED)
self.assertEquals(inst_obj1.availability, AS.DISCOVERABLE)
aids,_ = self.rr.find_objects(iid, PRED.hasModel, RT.InstrumentModel, id_only=True)
self.assertEquals(len(aids), 0)
model_obj = IonObject("InstrumentModel", name='model1')
mid, _ = self.rr.create(model_obj)
aid1 = self.rr.create_association(iid, PRED.hasModel, mid)
aids,_ = self.rr.find_objects(iid, PRED.hasModel, RT.InstrumentModel, id_only=True)
self.assertEquals(len(aids), 1)
res_objs,_ = self.rr.find_resources("InstrumentDevice")
self.assertEquals(len(res_objs), 1)
res_objs,_ = self.rr.find_resources(name="instrument")
self.assertEquals(len(res_objs), 1)
massocs = self.rr.find_associations(anyside=mid)
self.assertEquals(len(massocs), 1)
self.rr.execute_lifecycle_transition(iid, LCE.RETIRE)
inst_obj1 = self.rr.read(iid)
self.assertEquals(inst_obj1.lcstate, LCS.RETIRED)
self.assertEquals(inst_obj1.availability, AS.PRIVATE)
massocs = self.rr.find_associations(anyside=mid)
self.assertEquals(len(massocs), 0)
res_objs,_ = self.rr.find_resources("InstrumentDevice")
self.assertEquals(len(res_objs), 0)
res_objs,_ = self.rr.find_resources(name="instrument")
self.assertEquals(len(res_objs), 0)
aids,_ = self.rr.find_objects(iid, PRED.hasModel, RT.InstrumentModel, id_only=True)
self.assertEquals(len(aids), 0)
with self.assertRaises(BadRequest):
self.rr.execute_lifecycle_transition(iid, LCE.RETIRE)
with self.assertRaises(BadRequest):
self.rr.execute_lifecycle_transition(iid, LCE.ANNOUNCE)
inst_obj = IonObject("InstrumentDevice", name='instrument')
iid, _ = self.rr.create(inst_obj)
inst_obj1 = self.rr.read(iid)
self.assertEquals(inst_obj1.lcstate, LCS.DRAFT)
self.assertEquals(inst_obj1.availability, AS.PRIVATE)
self.rr.set_lifecycle_state(iid, LCS.PLANNED)
inst_obj1 = self.rr.read(iid)
self.assertEquals(inst_obj1.lcstate, LCS.PLANNED)
self.assertEquals(inst_obj1.availability, AS.PRIVATE)
self.rr.set_lifecycle_state(iid, AS.DISCOVERABLE)
inst_obj1 = self.rr.read(iid)
self.assertEquals(inst_obj1.lcstate, LCS.PLANNED)
self.assertEquals(inst_obj1.availability, AS.DISCOVERABLE)
with self.assertRaises(BadRequest):
self.rr.set_lifecycle_state(iid, lcstate(LCS.DEPLOYED,AS.AVAILABLE))
self.rr.set_lifecycle_state(iid, lcstate(LCS.DEPLOYED,AS.DISCOVERABLE))
inst_obj1 = self.rr.read(iid)
self.assertEquals(inst_obj1.lcstate, LCS.DEPLOYED)
self.assertEquals(inst_obj1.availability, AS.DISCOVERABLE)
self.rr.set_lifecycle_state(iid, lcstate(LCS.DEPLOYED,AS.AVAILABLE))
inst_obj1 = self.rr.read(iid)
self.assertEquals(inst_obj1.lcstate, LCS.DEPLOYED)
self.assertEquals(inst_obj1.availability, AS.AVAILABLE)
def test_datastore_views(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()
res = data_store.list_objects()
numcoredocs = len(res)
# self.assertTrue(numcoredocs > 1) # This assumes design docs, which are not there for Postgres
data_store.refresh_views()
# HACK: Both Predicates so that this test works
from pyon.ion.resource import Predicates
Predicates[OWNER_OF] = dict(domain=[RT.ActorIdentity], range=[RT.ExchangeBroker, RT.ExchangePoint])
Predicates[HAS_A] = dict(domain=[RT.Resource], range=[RT.Resource])
Predicates[BASED_ON] = dict(domain=[RT.Commitment], range=[RT.Commitment])
admin_user_id = self._create_resource(RT.ActorIdentity, 'John Doe', description='Marine Operator',
lcstate=LCS.DEPLOYED, availability=AS.AVAILABLE,
details=IonObject("UserIdentityDetails",
contact=IonObject('ContactInformation', **{"individual_names_given": "John",
"email": "*****@*****.**"})))
admin_profile_id = self._create_resource(RT.AgentInstance, 'J.D. Profile', description='Some User')
other_user_id = self._create_resource(RT.ActorIdentity, 'Paul Smithy', description='Other user')
plat1_obj_id = self._create_resource(RT.ExchangeBroker, 'Buoy1', description='My Platform')
inst1_obj_id = self._create_resource(RT.ExchangePoint, 'CTD1', description='My Instrument')
inst2_obj_id = self._create_resource(RT.ExchangePoint, 'CTD2', description='Other Instrument')
ds1_obj_id = self._create_resource(RT.Commitment, 'DS_CTD_L0', description='My Dataset CTD L0', lcstate=LCS.DEPLOYED, availability=AS.AVAILABLE)
ds2_obj_id = self._create_resource(RT.Commitment, 'DS_CTD_L1', description='My Dataset CTD L1')
aid1, _ = self._create_association(admin_user_id, OWNER_OF, inst1_obj_id)
self._create_association(admin_user_id, HAS_A, admin_profile_id)
self._create_association(admin_user_id, OWNER_OF, ds1_obj_id)
self._create_association(other_user_id, OWNER_OF, inst2_obj_id)
self._create_association(plat1_obj_id, HAS_A, inst1_obj_id)
self._create_association(inst1_obj_id, HAS_A, ds1_obj_id)
self._create_association(ds1_obj_id, BASED_ON, ds1_obj_id)
# Subject -> Object direction
obj_ids1, obj_assocs1 = data_store.find_objects(admin_user_id, id_only=True)
self.assertEquals(len(obj_ids1), 3)
self.assertEquals(len(obj_assocs1), 3)
self.assertEquals(set(obj_ids1), set([inst1_obj_id, ds1_obj_id, admin_profile_id]))
obj_ids1n, obj_assocs1n = data_store.find_objects("Non_Existent", id_only=True)
self.assertEquals(len(obj_ids1n), 0)
self.assertEquals(len(obj_assocs1n), 0)
obj_ids1a, obj_assocs1a = data_store.find_objects(admin_user_id, id_only=False)
self.assertEquals(len(obj_ids1a), 3)
self.assertEquals(len(obj_assocs1a), 3)
self.assertEquals(set([o._id for o in obj_ids1a]), set([inst1_obj_id, ds1_obj_id, admin_profile_id]))
self.assertEquals(set([type(o).__name__ for o in obj_ids1a]), set([RT.AgentInstance, RT.Commitment, RT.ExchangePoint]))
obj_ids1an, obj_assocs1an = data_store.find_objects("Non_Existent", id_only=False)
self.assertEquals(len(obj_ids1an), 0)
self.assertEquals(len(obj_assocs1an), 0)
obj_ids2, obj_assocs2 = data_store.find_objects(admin_user_id, OWNER_OF, id_only=True)
self.assertEquals(len(obj_ids2), 2)
self.assertEquals(len(obj_assocs2), 2)
self.assertEquals(set(obj_ids2), set([inst1_obj_id, ds1_obj_id]))
obj_ids3, _ = data_store.find_objects(admin_user_id, OWNER_OF, RT.ExchangePoint, id_only=True)
self.assertEquals(len(obj_ids3), 1)
self.assertEquals(obj_ids3[0], inst1_obj_id)
# Object -> Subject direction
sub_ids1, sub_assoc1 = data_store.find_subjects(None, None, inst1_obj_id, id_only=True)
self.assertEquals(len(sub_ids1), 2)
self.assertEquals(len(sub_assoc1), 2)
self.assertEquals(set(sub_ids1), set([admin_user_id, plat1_obj_id]))
sub_ids1a, sub_assoc1a = data_store.find_subjects(None, None, inst1_obj_id, id_only=False)
self.assertEquals(len(sub_ids1a), 2)
self.assertEquals(len(sub_assoc1a), 2)
self.assertEquals(set([o._id for o in sub_ids1a]), set([admin_user_id, plat1_obj_id]))
sub_ids1an, sub_assoc1an = data_store.find_subjects(None, None, "Non_Existent", id_only=False)
self.assertEquals(len(sub_ids1an), 0)
self.assertEquals(len(sub_assoc1an), 0)
sub_ids2, sub_assoc2 = data_store.find_subjects(None, OWNER_OF, inst1_obj_id, id_only=True)
self.assertEquals(len(sub_ids2), 1)
self.assertEquals(len(sub_assoc2), 1)
self.assertEquals(set(sub_ids2), set([admin_user_id]))
sub_ids3, _ = data_store.find_subjects(RT.ActorIdentity, OWNER_OF, inst1_obj_id, id_only=True)
self.assertEquals(len(sub_ids3), 1)
self.assertEquals(set(sub_ids3), set([admin_user_id]))
data_store.refresh_views()
# Find all resources
res_ids1, res_assoc1 = data_store.find_res_by_type(None, None, id_only=True)
self.assertEquals(len(res_ids1), 8)
self.assertEquals(len(res_assoc1), 8)
# Find resources by type
res_ids1, res_assoc1 = data_store.find_res_by_type(RT.ActorIdentity, id_only=True)
self.assertEquals(len(res_ids1), 2)
self.assertEquals(len(res_assoc1), 2)
self.assertEquals(set(res_ids1), set([admin_user_id, other_user_id]))
res_ids1a, res_assoc1a = data_store.find_res_by_type(RT.ActorIdentity, id_only=False)
self.assertEquals(len(res_ids1a), 2)
self.assertEquals(len(res_assoc1a), 2)
self.assertEquals(set([o._id for o in res_ids1a]), set([admin_user_id, other_user_id]))
res_ids2n, res_assoc2n = data_store.find_res_by_type("NONE##", id_only=True)
self.assertEquals(len(res_ids2n), 0)
self.assertEquals(len(res_assoc2n), 0)
# Find resources by lcstate
res_ids1, res_assoc1 = data_store.find_res_by_lcstate(LCS.DEPLOYED, id_only=True)
self.assertEquals(len(res_ids1), 2)
self.assertEquals(len(res_assoc1), 2)
self.assertEquals(set(res_ids1), set([admin_user_id, ds1_obj_id]))
res_ids1a, res_assoc1a = data_store.find_res_by_lcstate(lcstate(LCS.DEPLOYED, AS.AVAILABLE), id_only=False)
self.assertEquals(len(res_ids1a), 2)
self.assertEquals(len(res_assoc1a), 2)
self.assertEquals(set([o._id for o in res_ids1a]), set([admin_user_id, ds1_obj_id]))
self.assertEquals(set([type(o).__name__ for o in res_ids1a]), set([RT.ActorIdentity, RT.Commitment]))
res_ids2, res_assoc2 = data_store.find_res_by_lcstate( AS.AVAILABLE, RT.ActorIdentity, id_only=True)
self.assertEquals(len(res_ids2), 1)
self.assertEquals(len(res_assoc2), 1)
self.assertEquals(set(res_ids2), set([admin_user_id]))
# Find resources by name
res_ids1, res_assoc1 = data_store.find_res_by_name('CTD1', id_only=True)
self.assertEquals(len(res_ids1), 1)
self.assertEquals(len(res_assoc1), 1)
self.assertEquals(set(res_ids1), set([inst1_obj_id]))
res_ids1a, res_assoc1a = data_store.find_res_by_name('CTD2', id_only=False)
self.assertEquals(len(res_ids1a), 1)
self.assertEquals(len(res_assoc1a), 1)
self.assertEquals(set([o._id for o in res_ids1a]), set([inst2_obj_id]))
self.assertEquals(set([type(o).__name__ for o in res_ids1a]), set([RT.ExchangePoint]))
res_ids2, res_assoc2 = data_store.find_res_by_name( 'John Doe', RT.ActorIdentity, id_only=True)
self.assertEquals(len(res_ids2), 1)
self.assertEquals(len(res_assoc2), 1)
self.assertEquals(set(res_ids2), set([admin_user_id]))
res_ids2n, res_assoc2n = data_store.find_res_by_name("NONE##", "XXXXX", id_only=True)
self.assertEquals(len(res_ids2n), 0)
self.assertEquals(len(res_assoc2n), 0)
# Find associations by triple
assocs = data_store.find_associations(admin_user_id, OWNER_OF, inst1_obj_id, id_only=True)
self.assertEquals(len(assocs), 1)
self.assertEquals(assocs[0], aid1)
assocs = data_store.find_associations(admin_user_id, OWNER_OF, inst1_obj_id, id_only=False)
self.assertEquals(len(assocs), 1)
self.assertEquals(type(assocs[0]).__name__, "Association")
assocs = data_store.find_associations(admin_user_id, None, inst1_obj_id, id_only=True)
self.assertEquals(len(assocs), 1)
self.assertEquals(assocs[0], aid1)
assocs = data_store.find_associations(subject=inst1_obj_id, id_only=True)
self.assertEquals(len(assocs), 1)
assocs = data_store.find_associations(obj=inst1_obj_id, id_only=True)
self.assertEquals(len(assocs), 2)
assocs = data_store.find_associations(None, OWNER_OF, None, id_only=True)
self.assertEquals(len(assocs), 3)
assocs = data_store.find_associations(anyside=inst1_obj_id, id_only=True)
self.assertEquals(len(assocs), 3)
assocs = data_store.find_associations(anyside=inst1_obj_id, predicate=HAS_A, id_only=True)
self.assertEquals(len(assocs), 2)
assocs = data_store.find_associations(anyside=[inst1_obj_id,other_user_id], id_only=True)
self.assertEquals(len(assocs), 4)
assocs = data_store.find_associations(anyside=[[inst1_obj_id, HAS_A], [other_user_id, OWNER_OF]], id_only=True)
self.assertEquals(len(assocs), 3)
assocs = data_store.find_associations(anyside=[(inst1_obj_id, HAS_A), (other_user_id, OWNER_OF)], id_only=True)
self.assertEquals(len(assocs), 3)
# Test regression bug: Inherited resources in associations
idev1_obj_id = self._create_resource(RT.Org, 'id1', description='')
iag1_obj_id = self._create_resource(RT.ExchangeSpace, 'ia1', description='')
self._create_association(idev1_obj_id, PRED.hasExchangeSpace, iag1_obj_id)
att1 = self._create_resource(RT.Attachment, 'att1', keywords=[])
att2 = self._create_resource(RT.Attachment, 'att2', keywords=['FOO'])
att3 = self._create_resource(RT.Attachment, 'att3', keywords=['BAR','FOO'])
res_list,key_list = data_store.find_resources_ext(restype="NONE", keyword="FOO")
self.assertEqual(len(res_list), 0)
res_list,key_list = data_store.find_resources_ext(keyword="FOO")
self.assertEqual(len(res_list), 2)
res_list,key_list = data_store.find_resources_ext(restype=RT.Attachment, keyword="FOO")
self.assertEqual(len(res_list), 2)
res_list,key_list = data_store.find_resources_ext(restype=RT.Attachment, keyword="FOO", limit=1)
self.assertEqual(len(res_list), 1)
res_list,key_list = data_store.find_resources_ext(restype=RT.Attachment, keyword="FOO", limit=1, skip=1)
self.assertEqual(len(res_list), 1)
res_list,key_list = data_store.find_resources_ext(restype="NONE", nested_type="UserIdentityDetails")
self.assertEqual(len(res_list), 0)
res_list,key_list = data_store.find_resources_ext(nested_type="UserIdentityDetails")
self.assertEqual(len(res_list), 1)
res_list,key_list = data_store.find_resources_ext(restype=RT.ActorIdentity, nested_type="UserIdentityDetails", id_only=False)
self.assertEqual(len(res_list), 1)
self.assertEqual(res_list[0]._get_type(), RT.ActorIdentity)
# Find by attribute
admin_user2_id = self._create_resource(RT.ActorIdentity, 'Other User',
details=IonObject("UserIdentityDetails",
contact=IonObject('ContactInformation', **{"individual_names_given": "Frank",
"email": "*****@*****.**"})),
alt_ids=["ALT_ID1"])
admin_user3_id = self._create_resource(RT.ActorIdentity, 'Different User',
details=IonObject("UserIdentityDetails",
contact=IonObject('ContactInformation', **{"individual_names_given": "Frank",
"email": "*****@*****.**"})),
alt_ids=["NS1:ALT_ID2", "ALT_ID2"])
res_list,key_list = data_store.find_resources(restype="ActorIdentity")
self.assertEqual(len(res_list), 4)
res_list,key_list = data_store.find_resources_ext(restype="ActorIdentity", attr_name="contact.email")
self.assertEqual(len(res_list), 3)
res_list,key_list = data_store.find_resources_ext(restype="ActorIdentity", attr_name="contact.email", attr_value="*****@*****.**")
self.assertEqual(len(res_list), 1)
res_list,key_list = data_store.find_resources_ext(restype="ActorIdentity", attr_name="contact.email", attr_value="DOES NOT EXIST")
self.assertEqual(len(res_list), 0)
# Find by alternate id
res_list,key_list = data_store.find_resources_ext(alt_id="ALT_ID1")
self.assertEqual(len(res_list), 1)
res_list,key_list = data_store.find_resources_ext(alt_id="ALT_ID2")
self.assertEqual(len(res_list), 2)
# NOTE: Couchdb returns one row for each alt_id x resource combination, not one per resource
#self.assertEqual(len(res_list), 1)
res_list,key_list = data_store.find_resources_ext(alt_id="ALT_ID2", alt_id_ns="NS1")
self.assertEqual(len(res_list), 1)
res_list,key_list = data_store.find_resources_ext(alt_id="ALT_ID2", alt_id_ns="_")
self.assertEqual(len(res_list), 1)
res_list,key_list = data_store.find_resources_ext(alt_id="ALT_ID2", alt_id_ns="BULL")
self.assertEqual(len(res_list), 0)
res_list,key_list = data_store.find_resources_ext(alt_id=None, alt_id_ns="NS1")
self.assertEqual(len(res_list), 1)
res_list,key_list = data_store.find_resources_ext(alt_id=None, alt_id_ns="_", id_only=True)
self.assertEqual(len(res_list), 2)
res_list,key_list = data_store.find_resources_ext(alt_id=None, alt_id_ns="_", id_only=False)
self.assertEqual(len(res_list), 2)
def test_resource_lcworkflow(self):
default_workflow = lcs_workflows['InstrumentDevice']
self.assertEquals(len(CommonResourceLifeCycleSM.BASE_STATES), 18)
self.assertEquals(len(default_workflow.BASE_STATES), 18)
self.assert_(lcstate(LCS.DRAFT, AS.PRIVATE) in CommonResourceLifeCycleSM.BASE_STATES)
self.assert_(CommonResourceLifeCycleSM.is_in_state(lcstate(LCS.DRAFT, AS.PRIVATE), lcstate(LCS.DRAFT, AS.PRIVATE)))
events = set(ev for (s0,ev) in CommonResourceLifeCycleSM.BASE_TRANSITIONS)
self.assertFalse(set(CommonResourceLifeCycleSM.BASE_STATES) & events)
self.assertEquals(len(default_workflow.transitions), 84)
self.assertEquals(default_workflow.get_successor(lcstate(LCS.DRAFT,AS.PRIVATE), LCE.PLAN), lcstate(LCS.PLANNED,AS.PRIVATE))
self.assertEquals(default_workflow.get_successor(lcstate(LCS.DRAFT,AS.PRIVATE), LCE.ANNOUNCE), lcstate(LCS.DRAFT,AS.DISCOVERABLE))
self.assertEquals(default_workflow.get_successor(lcstate(LCS.DRAFT,AS.DISCOVERABLE), LCE.UNANNOUNCE), lcstate(LCS.DRAFT,AS.PRIVATE))
self.assertEquals(default_workflow.get_successor(lcstate(LCS.DRAFT,AS.PRIVATE), LCE.ENABLE), lcstate(LCS.DRAFT,AS.AVAILABLE))
self.assertEquals(default_workflow.get_successor(lcstate(LCS.DRAFT,AS.AVAILABLE), LCE.DISABLE), lcstate(LCS.DRAFT,AS.DISCOVERABLE))
self.assertEquals(default_workflow.get_successor(lcstate(LCS.DRAFT,AS.AVAILABLE), LCE.UNANNOUNCE), lcstate(LCS.DRAFT,AS.PRIVATE))
self.assertEquals(default_workflow.get_successor(lcstate(LCS.PLANNED,AS.PRIVATE), LCE.PLAN), None)
self.assertEquals(default_workflow.get_successor(lcstate(LCS.PLANNED,AS.PRIVATE), LCE.DEVELOP), lcstate(LCS.DEVELOPED,AS.PRIVATE))
self.assertEquals(default_workflow.get_successor(lcstate(LCS.DEVELOPED,AS.PRIVATE), LCE.RETIRE), lcstate(LCS.RETIRED,AS.PRIVATE))
self.assertEquals(default_workflow.get_successors(lcstate(LCS.PLANNED,AS.PRIVATE)), {LCE.DEVELOP: lcstate(LCS.DEVELOPED,AS.PRIVATE),
LCE.INTEGRATE: lcstate(LCS.INTEGRATED,AS.PRIVATE),
LCE.DEPLOY: lcstate(LCS.DEPLOYED,AS.PRIVATE),
LCE.ANNOUNCE: lcstate(LCS.PLANNED,AS.DISCOVERABLE),
LCE.ENABLE: lcstate(LCS.PLANNED,AS.AVAILABLE),
LCE.RETIRE: lcstate(LCS.RETIRED,AS.PRIVATE)})
# self.assertEquals(default_workflow.get_predecessors(LCS.DEVELOPED_PRIVATE), {LCS.PLANNED: LCE.DEVELOP})
restrictions = dict(
initial_state=LCS.DRAFT,
initial_availability=AS.PRIVATE,
illegal_states=[LCS.DEVELOPED, LCS.INTEGRATED],
illegal_transitions=[],
)
restricted_wf = default_workflow._clone_with_restrictions(restrictions)
for (a_state, a_transition), a_newstate in restricted_wf.transitions.iteritems():
if LCS.DEVELOPED in a_state or LCS.DEVELOPED in a_newstate:
self.fail("Workflow contains illegal state")
def test_lifecycle(self):
svc_obj = IonObject("ServiceDefinition", name='abc')
sdid, _ = self.rr.create(svc_obj)
svc_obj1 = self.rr.read(sdid)
self.assertEquals(svc_obj1.lcstate, LCS.DEPLOYED)
self.assertEquals(svc_obj1.availability, AS.AVAILABLE)
inst_obj = IonObject("TestInstrument", name='instrument')
iid, _ = self.rr.create(inst_obj)
inst_obj1 = self.rr.read(iid)
self.assertEquals(inst_obj1.lcstate, LCS.DRAFT)
self.assertEquals(inst_obj1.availability, AS.PRIVATE)
lcres = self.rr.execute_lifecycle_transition(iid, LCE.PLAN)
inst_obj1 = self.rr.read(iid)
self.assertEquals(inst_obj1.lcstate, LCS.PLANNED)
self.assertEquals(inst_obj1.availability, AS.PRIVATE)
self.assertEquals(lcres, lcstate(LCS.PLANNED,AS.PRIVATE))
self.rr.execute_lifecycle_transition(iid, LCE.DEVELOP)
inst_obj1 = self.rr.read(iid)
self.assertEquals(inst_obj1.lcstate, LCS.DEVELOPED)
self.assertEquals(inst_obj1.availability, AS.PRIVATE)
with self.assertRaises(BadRequest):
self.rr.execute_lifecycle_transition(iid, "!!NONE")
with self.assertRaises(BadRequest):
self.rr.execute_lifecycle_transition(iid, LCE.PLAN)
with self.assertRaises(BadRequest):
self.rr.execute_lifecycle_transition(iid, LCE.DEVELOP)
with self.assertRaises(BadRequest):
self.rr.execute_lifecycle_transition(iid, LCE.UNANNOUNCE)
with self.assertRaises(BadRequest):
self.rr.execute_lifecycle_transition(iid, LCE.DISABLE)
self.rr.execute_lifecycle_transition(iid, LCE.ANNOUNCE)
inst_obj1 = self.rr.read(iid)
self.assertEquals(inst_obj1.lcstate, LCS.DEVELOPED)
self.assertEquals(inst_obj1.availability, AS.DISCOVERABLE)
with self.assertRaises(BadRequest):
self.rr.execute_lifecycle_transition(iid, LCE.ANNOUNCE)
self.rr.execute_lifecycle_transition(iid, LCE.INTEGRATE)
inst_obj1 = self.rr.read(iid)
self.assertEquals(inst_obj1.lcstate, LCS.INTEGRATED)
self.assertEquals(inst_obj1.availability, AS.DISCOVERABLE)
self.rr.execute_lifecycle_transition(iid, LCE.DEPLOY)
inst_obj1 = self.rr.read(iid)
self.assertEquals(inst_obj1.lcstate, LCS.DEPLOYED)
self.assertEquals(inst_obj1.availability, AS.DISCOVERABLE)
self.rr.execute_lifecycle_transition(iid, LCE.INTEGRATE)
inst_obj1 = self.rr.read(iid)
self.assertEquals(inst_obj1.lcstate, LCS.INTEGRATED)
self.assertEquals(inst_obj1.availability, AS.DISCOVERABLE)
self.rr.execute_lifecycle_transition(iid, LCE.DEVELOP)
inst_obj1 = self.rr.read(iid)
self.assertEquals(inst_obj1.lcstate, LCS.DEVELOPED)
self.assertEquals(inst_obj1.availability, AS.DISCOVERABLE)
aids,_ = self.rr.find_objects(iid, PRED.hasTestModel, RT.TestDeviceModel, id_only=True)
self.assertEquals(len(aids), 0)
model_obj = IonObject("TestDeviceModel", name='model1')
mid, _ = self.rr.create(model_obj)
aid1 = self.rr.create_association(iid, PRED.hasTestModel, mid)
aids,_ = self.rr.find_objects(iid, PRED.hasTestModel, RT.TestDeviceModel, id_only=True)
self.assertEquals(len(aids), 1)
res_objs,_ = self.rr.find_resources("TestInstrument")
self.assertEquals(len(res_objs), 1)
res_objs,_ = self.rr.find_resources(name="instrument")
self.assertEquals(len(res_objs), 1)
massocs = self.rr.find_associations(anyside=mid)
self.assertEquals(len(massocs), 1)
self.rr.execute_lifecycle_transition(iid, LCE.RETIRE)
inst_obj1 = self.rr.read(iid)
self.assertEquals(inst_obj1.lcstate, LCS.RETIRED)
self.assertEquals(inst_obj1.availability, AS.DISCOVERABLE)
with self.assertRaises(BadRequest):
self.rr.execute_lifecycle_transition(iid, LCE.RETIRE)
with self.assertRaises(BadRequest):
self.rr.execute_lifecycle_transition(iid, LCE.ANNOUNCE)
self.rr.execute_lifecycle_transition(iid, LCE.DELETE)
inst_obj1 = self.rr.read(iid)
self.assertEquals(inst_obj1.lcstate, LCS.DELETED)
self.assertEquals(inst_obj1.availability, AS.DISCOVERABLE)
massocs = self.rr.find_associations(anyside=mid)
self.assertEquals(len(massocs), 0)
res_objs,_ = self.rr.find_resources("TestInstrument")
self.assertEquals(len(res_objs), 0)
res_objs,_ = self.rr.find_resources(name="instrument")
self.assertEquals(len(res_objs), 0)
aids,_ = self.rr.find_objects(iid, PRED.hasTestModel, RT.TestDeviceModel, id_only=True)
self.assertEquals(len(aids), 0)
inst_obj = IonObject("TestInstrument", name='instrument')
iid, _ = self.rr.create(inst_obj)
inst_obj1 = self.rr.read(iid)
self.assertEquals(inst_obj1.lcstate, LCS.DRAFT)
self.assertEquals(inst_obj1.availability, AS.PRIVATE)
self.rr.set_lifecycle_state(iid, LCS.PLANNED)
inst_obj1 = self.rr.read(iid)
self.assertEquals(inst_obj1.lcstate, LCS.PLANNED)
self.assertEquals(inst_obj1.availability, AS.PRIVATE)
self.rr.set_lifecycle_state(iid, AS.DISCOVERABLE)
inst_obj1 = self.rr.read(iid)
self.assertEquals(inst_obj1.lcstate, LCS.PLANNED)
self.assertEquals(inst_obj1.availability, AS.DISCOVERABLE)
self.rr.set_lifecycle_state(iid, lcstate(LCS.DEPLOYED, AS.DISCOVERABLE))
inst_obj1 = self.rr.read(iid)
self.assertEquals(inst_obj1.lcstate, LCS.DEPLOYED)
self.assertEquals(inst_obj1.availability, AS.DISCOVERABLE)
self.rr.set_lifecycle_state(iid, lcstate(LCS.DEPLOYED, AS.AVAILABLE))
inst_obj1 = self.rr.read(iid)
self.assertEquals(inst_obj1.lcstate, LCS.DEPLOYED)
self.assertEquals(inst_obj1.availability, AS.AVAILABLE)
self.rr.set_lifecycle_state(iid, lcstate(LCS.INTEGRATED, AS.DISCOVERABLE))
inst_obj1 = self.rr.read(iid)
self.assertEquals(inst_obj1.lcstate, LCS.INTEGRATED)
self.assertEquals(inst_obj1.availability, AS.DISCOVERABLE)
