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)