def test_get_extended_user_identity(self):
actor_identity_obj = IonObject("ActorIdentity", {"name": self.subject})
user_id = self.identity_management_service.create_actor_identity(actor_identity_obj)
user_credentials_obj = IonObject("UserCredentials", {"name": self.subject})
self.identity_management_service.register_user_credentials(user_id, user_credentials_obj)
user_info_obj = IonObject("UserInfo", {"name": "Foo"})
user_info = self.identity_management_service.create_user_info(user_id, user_info_obj)
org_client = OrgManagementServiceClient(node=self.container.node)
ion_org = org_client.find_org()
extended_user = self.identity_management_service.get_actor_identity_extension(user_id, ion_org._id)
self.assertEqual(actor_identity_obj.type_,extended_user.resource.type_)
self.assertEqual(len(extended_user.roles),1)
extended_user = self.identity_management_service.get_actor_identity_extension(user_id)
self.assertEqual(actor_identity_obj.type_,extended_user.resource.type_)
self.assertEqual(len(extended_user.roles),0)
self.identity_management_service.delete_user_info(user_info)
self.identity_management_service.unregister_user_credentials(user_id, self.subject)
self.identity_management_service.delete_actor_identity(user_id)
def setUp(self):
# Start container
#print 'instantiating container'
self._start_container()
#container = Container()
#print 'starting container'
#container.start()
#print 'started container'
self.container.start_rel_from_url('res/deploy/r2deploy.yml')
self.RR = ResourceRegistryServiceClient(node=self.container.node)
self.RR2 = EnhancedResourceRegistryClient(self.RR)
self.OMS = ObservatoryManagementServiceClient(node=self.container.node)
self.org_management_service = OrgManagementServiceClient(
node=self.container.node)
self.IMS = InstrumentManagementServiceClient(node=self.container.node)
self.dpclient = DataProductManagementServiceClient(
node=self.container.node)
self.pubsubcli = PubsubManagementServiceClient(
node=self.container.node)
self.damsclient = DataAcquisitionManagementServiceClient(
node=self.container.node)
self.dataset_management = DatasetManagementServiceClient()
#print 'TestObservatoryManagementServiceIntegration: started services'
self.event_publisher = EventPublisher()
def setUp(self):
# Start container
self._start_container()
self.container.start_rel_from_url('res/deploy/r2coi.yml')
self.org_management_service = OrgManagementServiceClient(
node=self.container.node)
def setUp(self):
self.subject = "/DC=org/DC=cilogon/C=US/O=ProtectNetwork/CN=Roger Unwin A254"
# Start container
self._start_container()
self.container.start_rel_from_url('res/deploy/r2coi.yml')
self.identity_management_service = IdentityManagementServiceClient(node=self.container.node)
self.org_client = OrgManagementServiceClient(node=self.container.node)
def setUp(self):
# Start container
self._start_container()
self.container.start_rel_from_url('res/deploy/r2coi.yml')
self.org_management_service = OrgManagementServiceClient(node=self.container.node)
def setUp(self):
# Start container
self._start_container()
self.container.start_rel_from_url("res/deploy/r2coi.yml")
self.resource_registry = ResourceRegistryServiceClient(node=self.container.node)
self.org_management_service = OrgManagementServiceClient(node=self.container.node)
def setUp(self):
self.subject = "/DC=org/DC=cilogon/C=US/O=ProtectNetwork/CN=Roger Unwin A254"
# Start container
self._start_container()
self.container.start_rel_from_url('res/deploy/r2coi.yml')
self.identity_management_service = IdentityManagementServiceClient(node=self.container.node)
self.org_client = OrgManagementServiceClient(node=self.container.node)
def setUp(self):
# Start container
self._start_container()
# Establish endpoint with container
container_client = ContainerAgentClient(node=self.container.node, name=self.container.name)
container_client.start_rel_from_url('res/deploy/r2coi.yml')
self.org_management_service = OrgManagementServiceClient(node=self.container.node)
def setUp(self):
# Start container
#print 'instantiating container'
self._start_container()
#container = Container()
#print 'starting container'
#container.start()
#print 'started container'
self.container.start_rel_from_url('res/deploy/r2deploy.yml')
self.RR = ResourceRegistryServiceClient(node=self.container.node)
self.OMS = ObservatoryManagementServiceClient(node=self.container.node)
self.org_management_service = OrgManagementServiceClient(node=self.container.node)
self.instrument_management_service = InstrumentManagementServiceClient(node=self.container.node)
def setUp(self):
self._start_container()
self.container.start_rel_from_url('res/deploy/r2deploy.yml')
self.RR = ResourceRegistryServiceClient()
self.RR2 = EnhancedResourceRegistryClient(self.RR)
self.OMS = ObservatoryManagementServiceClient()
self.org_management_service = OrgManagementServiceClient()
self.IMS = InstrumentManagementServiceClient()
self.dpclient = DataProductManagementServiceClient()
self.pubsubcli = PubsubManagementServiceClient()
self.damsclient = DataAcquisitionManagementServiceClient()
self.dataset_management = DatasetManagementServiceClient()
self.data_retriever = DataRetrieverServiceClient()
self.data_product_management = DataProductManagementServiceClient()
self._load_stage = 0
self._resources = {}
def setUp(self):
# Start container
#print 'instantiating container'
self._start_container()
#container = Container()
#print 'starting container'
#container.start()
#print 'started container'
self.container.start_rel_from_url('res/deploy/r2deploy.yml')
self.RR = ResourceRegistryServiceClient(node=self.container.node)
self.OMS = ObservatoryManagementServiceClient(node=self.container.node)
self.org_management_service = OrgManagementServiceClient(node=self.container.node)
self.IMS = InstrumentManagementServiceClient(node=self.container.node)
self.dpclient = DataProductManagementServiceClient(node=self.container.node)
self.pubsubcli = PubsubManagementServiceClient(node=self.container.node)
self.damsclient = DataAcquisitionManagementServiceClient(node=self.container.node)
self.dataset_management = DatasetManagementServiceClient()
#print 'TestObservatoryManagementServiceIntegration: started services'
self.event_publisher = EventPublisher()
class TestOrgManagementServiceInt(IonIntegrationTestCase):
def setUp(self):
# Start container
self._start_container()
self.container.start_rel_from_url('res/deploy/r2coi.yml')
self.org_management_service = OrgManagementServiceClient(
node=self.container.node)
def test_org_crud(self):
with self.assertRaises(BadRequest) as br:
self.org_management_service.create_org(
IonObject("Org", {"name": "Test Facility"}))
self.assertTrue(
"can only contain alphanumeric and underscore characters" in
br.exception.message)
org_obj = IonObject("Org", {"name": "TestFacility"})
org_id = self.org_management_service.create_org(org_obj)
self.assertNotEqual(org_id, None)
org = None
org = self.org_management_service.read_org(org_id)
self.assertNotEqual(org, None)
#Check that the roles got associated to them
role_list = self.org_management_service.find_org_roles(org_id)
self.assertEqual(len(role_list), 2)
org.name = 'Updated_TestFacility'
self.org_management_service.update_org(org)
org = None
org = self.org_management_service.read_org(org_id)
self.assertNotEqual(org, None)
self.assertEqual(org.name, 'Updated_TestFacility')
self.org_management_service.delete_org(org_id)
with self.assertRaises(NotFound) as cm:
self.org_management_service.read_org(org_id)
self.assertIn("does not exist", cm.exception.message)
with self.assertRaises(NotFound) as cm:
self.org_management_service.delete_org(org_id)
self.assertIn("does not exist", cm.exception.message)
def test_org_affiliation(self):
root_org = None
root_org = self.org_management_service.find_org()
self.assertNotEqual(root_org, None)
org_obj = IonObject("Org", {"name": "TestFacility"})
org_id = self.org_management_service.create_org(org_obj)
self.assertNotEqual(org_id, None)
ret = self.org_management_service.affiliate_org(root_org._id, org_id)
self.assertTrue(ret)
ret = self.org_management_service.unaffiliate_org(root_org._id, org_id)
self.assertTrue(ret)
def test_user_role_cache(self):
# Create a user
id_client = IdentityManagementServiceClient()
actor_id, valid_until, registered = id_client.signon(USER1_CERTIFICATE, True)
# Make a request with this new user to get it into the cache
response = self.test_app.get(
"/ion-service/resource_registry/find_resources?name=TestDataProduct&id_only=True&requester=" + actor_id
)
self.check_response_headers(response)
self.assertIn(GATEWAY_RESPONSE, response.json["data"])
# Check the contents of the user role cache for this user
service_gateway_user_role_cache = self.container.proc_manager.procs_by_name["service_gateway"].user_role_cache
self.assertEqual(service_gateway_user_role_cache.has_key(actor_id), True)
role_header = service_gateway_user_role_cache.get(actor_id)
self.assertIn("ION", role_header)
self.assertEqual(len(role_header["ION"]), 1)
self.assertIn("ORG_MEMBER", role_header["ION"])
org_client = OrgManagementServiceClient()
ion_org = org_client.find_org()
manager_role = org_client.find_org_role_by_name(org_id=ion_org._id, role_name="ORG_MANAGER")
org_client.grant_role(org_id=ion_org._id, actor_id=actor_id, role_name="ORG_MANAGER")
# Just allow some time for event processing on slower platforms
gevent.sleep(2)
# The user should be evicted from the cache due to a change in roles
self.assertEqual(service_gateway_user_role_cache.has_key(actor_id), False)
# Do it again to check for new roles
response = self.test_app.get(
"/ion-service/resource_registry/find_resources?name=TestDataProduct&id_only=True&requester=" + actor_id
)
self.check_response_headers(response)
self.assertIn(GATEWAY_RESPONSE, response.json["data"])
# Check the contents of the user role cache for this user
self.assertEqual(service_gateway_user_role_cache.has_key(actor_id), True)
role_header = service_gateway_user_role_cache.get(actor_id)
self.assertIn("ION", role_header)
self.assertEqual(len(role_header["ION"]), 2)
self.assertIn("ORG_MEMBER", role_header["ION"])
self.assertIn("ORG_MANAGER", role_header["ION"])
# Now flush the user_role_cache and make sure it was flushed
event_publisher = EventPublisher()
event_publisher.publish_event(event_type=OT.UserRoleCacheResetEvent)
# Just allow some time for event processing on slower platforms
gevent.sleep(2)
self.assertEqual(service_gateway_user_role_cache.has_key(actor_id), False)
self.assertEqual(service_gateway_user_role_cache.size(), 0)
# Change the role once again and see if it is there again
org_client.revoke_role(org_id=ion_org._id, actor_id=actor_id, role_name="ORG_MANAGER")
# Just allow some time for event processing on slower platforms
gevent.sleep(2)
# The user should still not be there
self.assertEqual(service_gateway_user_role_cache.has_key(actor_id), False)
# Do it again to check for new roles
response = self.test_app.get(
"/ion-service/resource_registry/find_resources?name=TestDataProduct&id_only=True&requester=" + actor_id
)
self.check_response_headers(response)
self.assertIn(GATEWAY_RESPONSE, response.json["data"])
# Check the contents of the user role cache for this user
self.assertEqual(service_gateway_user_role_cache.has_key(actor_id), True)
role_header = service_gateway_user_role_cache.get(actor_id)
self.assertIn("ION", role_header)
self.assertEqual(len(role_header["ION"]), 1)
self.assertIn("ORG_MEMBER", role_header["ION"])
id_client.delete_actor_identity(actor_id)
class TestObservatoryManagementServiceIntegration(IonIntegrationTestCase):
def setUp(self):
# Start container
#print 'instantiating container'
self._start_container()
#container = Container()
#print 'starting container'
#container.start()
#print 'started container'
self.container.start_rel_from_url('res/deploy/r2deploy.yml')
self.RR = ResourceRegistryServiceClient(node=self.container.node)
self.RR2 = EnhancedResourceRegistryClient(self.RR)
self.OMS = ObservatoryManagementServiceClient(node=self.container.node)
self.org_management_service = OrgManagementServiceClient(node=self.container.node)
self.IMS = InstrumentManagementServiceClient(node=self.container.node)
self.dpclient = DataProductManagementServiceClient(node=self.container.node)
self.pubsubcli = PubsubManagementServiceClient(node=self.container.node)
self.damsclient = DataAcquisitionManagementServiceClient(node=self.container.node)
self.dataset_management = DatasetManagementServiceClient()
#print 'TestObservatoryManagementServiceIntegration: started services'
self.event_publisher = EventPublisher()
# @unittest.skip('this exists only for debugging the launch process')
# def test_just_the_setup(self):
# return
def destroy(self, resource_ids):
self.OMS.force_delete_observatory(resource_ids.observatory_id)
self.OMS.force_delete_subsite(resource_ids.subsite_id)
self.OMS.force_delete_subsite(resource_ids.subsite2_id)
self.OMS.force_delete_subsite(resource_ids.subsiteb_id)
self.OMS.force_delete_subsite(resource_ids.subsitez_id)
self.OMS.force_delete_platform_site(resource_ids.platform_site_id)
self.OMS.force_delete_platform_site(resource_ids.platform_siteb_id)
self.OMS.force_delete_platform_site(resource_ids.platform_siteb2_id)
self.OMS.force_delete_platform_site(resource_ids.platform_site3_id)
self.OMS.force_delete_instrument_site(resource_ids.instrument_site_id)
self.OMS.force_delete_instrument_site(resource_ids.instrument_site2_id)
self.OMS.force_delete_instrument_site(resource_ids.instrument_siteb3_id)
self.OMS.force_delete_instrument_site(resource_ids.instrument_site4_id)
#@unittest.skip('targeting')
def test_observatory_management(self):
resources = self._make_associations()
self._do_test_find_related_sites(resources)
self._do_test_get_sites_devices_status(resources)
self._do_test_find_site_data_products(resources)
self._do_test_find_related_frames_of_reference(resources)
self._do_test_create_geospatial_point_center(resources)
self._do_test_find_observatory_org(resources)
self.destroy(resources)
def _do_test_find_related_sites(self, resources):
site_resources, site_children = self.OMS.find_related_sites(resources.org_id)
#import sys, pprint
#print >> sys.stderr, pprint.pformat(site_resources)
#print >> sys.stderr, pprint.pformat(site_children)
#self.assertIn(resources.org_id, site_resources)
self.assertIn(resources.observatory_id, site_resources)
self.assertIn(resources.subsite_id, site_resources)
self.assertIn(resources.subsite_id, site_resources)
self.assertIn(resources.subsite2_id, site_resources)
self.assertIn(resources.platform_site_id, site_resources)
self.assertIn(resources.instrument_site_id, site_resources)
self.assertEquals(len(site_resources), 13)
self.assertEquals(site_resources[resources.observatory_id].type_, RT.Observatory)
self.assertIn(resources.org_id, site_children)
self.assertIn(resources.observatory_id, site_children)
self.assertIn(resources.subsite_id, site_children)
self.assertIn(resources.subsite_id, site_children)
self.assertIn(resources.subsite2_id, site_children)
self.assertIn(resources.platform_site_id, site_children)
self.assertNotIn(resources.instrument_site_id, site_children)
self.assertEquals(len(site_children), 9)
self.assertIsInstance(site_children[resources.subsite_id], list)
self.assertEquals(len(site_children[resources.subsite_id]), 2)
def _do_test_get_sites_devices_status(self, resources):
result_dict = self.OMS.get_sites_devices_status(resources.org_id)
site_resources = result_dict.get("site_resources", None)
site_children = result_dict.get("site_children", None)
self.assertEquals(len(site_resources), 14)
self.assertEquals(len(site_children), 9)
result_dict = self.OMS.get_sites_devices_status(resources.org_id, include_devices=True, include_status=True)
log.debug("RESULT DICT: %s", result_dict.keys())
site_resources = result_dict.get("site_resources", None)
site_children = result_dict.get("site_children", None)
site_status = result_dict.get("site_status", None)
self.assertEquals(len(site_resources), 14)
self.assertEquals(len(site_children), 9)
result_dict = self.OMS.get_sites_devices_status(resources.observatory_id, include_devices=True, include_status=True)
site_resources = result_dict.get("site_resources")
site_children = result_dict.get("site_children")
site_status = result_dict.get("site_status")
self.assertEquals(len(site_resources), 13)
self.assertEquals(len(site_children), 8)
def _do_test_find_site_data_products(self, resources):
res_dict = self.OMS.find_site_data_products(resources.org_id)
#import sys, pprint
#print >> sys.stderr, pprint.pformat(res_dict)
self.assertIsNone(res_dict['data_product_resources'])
self.assertIn(resources.platform_device_id, res_dict['device_data_products'])
self.assertIn(resources.instrument_device_id, res_dict['device_data_products'])
#@unittest.skip('targeting')
def _do_test_find_related_frames_of_reference(self, stuff):
# finding subordinates gives a dict of obj lists, convert objs to ids
def idify(adict):
ids = {}
for k, v in adict.iteritems():
ids[k] = []
for obj in v:
ids[k].append(obj._id)
return ids
# a short version of the function we're testing, with id-ify
def short(resource_id, output_types):
ret = self.OMS.find_related_frames_of_reference(resource_id,
output_types)
return idify(ret)
#set up associations first
stuff = self._make_associations()
#basic traversal of tree from instrument to platform
ids = short(stuff.instrument_site_id, [RT.PlatformSite])
self.assertIn(RT.PlatformSite, ids)
self.assertIn(stuff.platform_site_id, ids[RT.PlatformSite])
self.assertIn(stuff.platform_siteb_id, ids[RT.PlatformSite])
self.assertNotIn(stuff.platform_siteb2_id, ids[RT.PlatformSite])
#since this is the first search, just make sure the input inst_id got stripped
if RT.InstrumentSite in ids:
self.assertNotIn(stuff.instrument_site_id, ids[RT.InstrumentSite])
#basic traversal of tree from platform to instrument
ids = short(stuff.platform_siteb_id, [RT.InstrumentSite])
self.assertIn(RT.InstrumentSite, ids)
self.assertIn(stuff.instrument_site_id, ids[RT.InstrumentSite])
self.assertNotIn(stuff.instrument_site2_id, ids[RT.InstrumentSite])
#full traversal of tree from observatory down to instrument
ids = short(stuff.observatory_id, [RT.InstrumentSite])
self.assertIn(RT.InstrumentSite, ids)
self.assertIn(stuff.instrument_site_id, ids[RT.InstrumentSite])
#full traversal of tree from instrument to observatory
ids = short(stuff.instrument_site_id, [RT.Observatory])
self.assertIn(RT.Observatory, ids)
self.assertIn(stuff.observatory_id, ids[RT.Observatory])
#partial traversal, only down to platform
ids = short(stuff.observatory_id, [RT.Subsite, RT.PlatformSite])
self.assertIn(RT.PlatformSite, ids)
self.assertIn(RT.Subsite, ids)
self.assertIn(stuff.platform_site_id, ids[RT.PlatformSite])
self.assertIn(stuff.platform_siteb_id, ids[RT.PlatformSite])
self.assertIn(stuff.platform_siteb2_id, ids[RT.PlatformSite])
self.assertIn(stuff.platform_site3_id, ids[RT.PlatformSite])
self.assertIn(stuff.subsite_id, ids[RT.Subsite])
self.assertIn(stuff.subsite2_id, ids[RT.Subsite])
self.assertIn(stuff.subsitez_id, ids[RT.Subsite])
self.assertIn(stuff.subsiteb_id, ids[RT.Subsite])
self.assertNotIn(RT.InstrumentSite, ids)
#partial traversal, only down to platform
ids = short(stuff.instrument_site_id, [RT.Subsite, RT.PlatformSite])
self.assertIn(RT.PlatformSite, ids)
self.assertIn(RT.Subsite, ids)
self.assertIn(stuff.platform_siteb_id, ids[RT.PlatformSite])
self.assertIn(stuff.platform_site_id, ids[RT.PlatformSite])
self.assertIn(stuff.subsite_id, ids[RT.Subsite])
self.assertIn(stuff.subsiteb_id, ids[RT.Subsite])
self.assertNotIn(stuff.subsite2_id, ids[RT.Subsite])
self.assertNotIn(stuff.subsitez_id, ids[RT.Subsite])
self.assertNotIn(stuff.platform_siteb2_id, ids[RT.PlatformSite])
self.assertNotIn(RT.Observatory, ids)
self.destroy(stuff)
def _make_associations(self):
"""
create one of each resource and association used by OMS
to guard against problems in ion-definitions
"""
#raise unittest.SkipTest("https://jira.oceanobservatories.org/tasks/browse/CISWCORE-41")
"""
the tree we're creating (observatory, sites, platforms, instruments)
rows are lettered, colums numbered.
- first row is implied a
- first column is implied 1
- site Z, just because
O--Sz
|
S--S2--P3--I4
|
Sb-Pb2-Ib3
|
P--I2 <- PlatformDevice, InstrumentDevice2
|
Pb <- PlatformDevice b
|
I <- InstrumentDevice
"""
org_id = self.OMS.create_marine_facility(any_old(RT.Org))
def create_under_org(resource_type, extra_fields=None):
obj = any_old(resource_type, extra_fields)
if RT.InstrumentDevice == resource_type:
resource_id = self.IMS.create_instrument_device(obj)
else:
resource_id, _ = self.RR.create(obj)
self.OMS.assign_resource_to_observatory_org(resource_id=resource_id, org_id=org_id)
return resource_id
#stuff we control
observatory_id = create_under_org(RT.Observatory)
subsite_id = create_under_org(RT.Subsite)
subsite2_id = create_under_org(RT.Subsite)
subsiteb_id = create_under_org(RT.Subsite)
subsitez_id = create_under_org(RT.Subsite)
platform_site_id = create_under_org(RT.PlatformSite)
platform_siteb_id = create_under_org(RT.PlatformSite)
platform_siteb2_id = create_under_org(RT.PlatformSite)
platform_site3_id = create_under_org(RT.PlatformSite)
instrument_site_id = create_under_org(RT.InstrumentSite)
instrument_site2_id = create_under_org(RT.InstrumentSite)
instrument_siteb3_id = create_under_org(RT.InstrumentSite)
instrument_site4_id = create_under_org(RT.InstrumentSite)
#stuff we associate to
instrument_device_id = create_under_org(RT.InstrumentDevice)
instrument_device2_id = create_under_org(RT.InstrumentDevice)
platform_device_id = create_under_org(RT.PlatformDevice)
platform_deviceb_id = create_under_org(RT.PlatformDevice)
instrument_model_id, _ = self.RR.create(any_old(RT.InstrumentModel))
platform_model_id, _ = self.RR.create(any_old(RT.PlatformModel))
deployment_id, _ = self.RR.create(any_old(RT.Deployment))
#observatory
self.RR.create_association(observatory_id, PRED.hasSite, subsite_id)
self.RR.create_association(observatory_id, PRED.hasSite, subsitez_id)
#site
self.RR.create_association(subsite_id, PRED.hasSite, subsite2_id)
self.RR.create_association(subsite_id, PRED.hasSite, subsiteb_id)
self.RR.create_association(subsite2_id, PRED.hasSite, platform_site3_id)
self.RR.create_association(subsiteb_id, PRED.hasSite, platform_siteb2_id)
self.RR.create_association(subsiteb_id, PRED.hasSite, platform_site_id)
#platform_site(s)
self.RR.create_association(platform_site3_id, PRED.hasSite, instrument_site4_id)
self.RR.create_association(platform_siteb2_id, PRED.hasSite, instrument_siteb3_id)
self.RR.create_association(platform_site_id, PRED.hasSite, instrument_site2_id)
self.RR.create_association(platform_site_id, PRED.hasSite, platform_siteb_id)
self.RR.create_association(platform_siteb_id, PRED.hasSite, instrument_site_id)
self.RR.create_association(platform_siteb_id, PRED.hasDevice, platform_deviceb_id)
#test network parent link
self.OMS.assign_device_to_network_parent(platform_device_id, platform_deviceb_id)
self.RR.create_association(platform_site_id, PRED.hasModel, platform_model_id)
self.RR.create_association(platform_site_id, PRED.hasDevice, platform_device_id)
self.RR.create_association(platform_site_id, PRED.hasDeployment, deployment_id)
#instrument_site(s)
self.RR.create_association(instrument_site_id, PRED.hasModel, instrument_model_id)
self.RR.create_association(instrument_site_id, PRED.hasDevice, instrument_device_id)
self.RR.create_association(instrument_site_id, PRED.hasDeployment, deployment_id)
self.RR.create_association(instrument_site2_id, PRED.hasDevice, instrument_device2_id)
#platform_device
self.RR.create_association(platform_device_id, PRED.hasModel, platform_model_id)
#instrument_device
self.RR.create_association(instrument_device_id, PRED.hasModel, instrument_model_id)
self.RR.create_association(instrument_device2_id, PRED.hasModel, instrument_model_id)
ret = DotDict()
ret.org_id = org_id
ret.observatory_id = observatory_id
ret.subsite_id = subsite_id
ret.subsite2_id = subsite2_id
ret.subsiteb_id = subsiteb_id
ret.subsitez_id = subsitez_id
ret.platform_site_id = platform_site_id
ret.platform_siteb_id = platform_siteb_id
ret.platform_siteb2_id = platform_siteb2_id
ret.platform_site3_id = platform_site3_id
ret.instrument_site_id = instrument_site_id
ret.instrument_site2_id = instrument_site2_id
ret.instrument_siteb3_id = instrument_siteb3_id
ret.instrument_site4_id = instrument_site4_id
ret.instrument_device_id = instrument_device_id
ret.instrument_device2_id = instrument_device2_id
ret.platform_device_id = platform_device_id
ret.platform_deviceb_id = platform_deviceb_id
ret.instrument_model_id = instrument_model_id
ret.platform_model_id = platform_model_id
ret.deployment_id = deployment_id
return ret
#@unittest.skip("targeting")
def test_create_observatory(self):
observatory_obj = IonObject(RT.Observatory,
name='TestFacility',
description='some new mf')
observatory_id = self.OMS.create_observatory(observatory_obj)
self.OMS.force_delete_observatory(observatory_id)
#@unittest.skip("targeting")
def _do_test_create_geospatial_point_center(self, resources):
platformsite_obj = IonObject(RT.PlatformSite,
name='TestPlatformSite',
description='some new TestPlatformSite')
geo_index_obj = IonObject(OT.GeospatialBounds)
geo_index_obj.geospatial_latitude_limit_north = 20.0
geo_index_obj.geospatial_latitude_limit_south = 10.0
geo_index_obj.geospatial_longitude_limit_east = 15.0
geo_index_obj.geospatial_longitude_limit_west = 20.0
platformsite_obj.constraint_list = [geo_index_obj]
platformsite_id = self.OMS.create_platform_site(platformsite_obj)
# now get the dp back to see if it was updated
platformsite_obj = self.OMS.read_platform_site(platformsite_id)
self.assertEquals('some new TestPlatformSite', platformsite_obj.description)
self.assertAlmostEqual(15.0, platformsite_obj.geospatial_point_center.lat, places=1)
#now adjust a few params
platformsite_obj.description = 'some old TestPlatformSite'
geo_index_obj = IonObject(OT.GeospatialBounds)
geo_index_obj.geospatial_latitude_limit_north = 30.0
geo_index_obj.geospatial_latitude_limit_south = 20.0
platformsite_obj.constraint_list = [geo_index_obj]
update_result = self.OMS.update_platform_site(platformsite_obj)
# now get the dp back to see if it was updated
platformsite_obj = self.OMS.read_platform_site(platformsite_id)
self.assertEquals('some old TestPlatformSite', platformsite_obj.description)
self.assertAlmostEqual(25.0, platformsite_obj.geospatial_point_center.lat, places=1)
self.OMS.force_delete_platform_site(platformsite_id)
#@unittest.skip("targeting")
def _do_test_find_observatory_org(self, resources):
log.debug("Make TestOrg")
org_obj = IonObject(RT.Org,
name='TestOrg',
description='some new mf org')
org_id = self.OMS.create_marine_facility(org_obj)
log.debug("Make Observatory")
observatory_obj = IonObject(RT.Observatory,
name='TestObservatory',
description='some new obs')
observatory_id = self.OMS.create_observatory(observatory_obj)
log.debug("assign observatory to org")
self.OMS.assign_resource_to_observatory_org(observatory_id, org_id)
log.debug("verify assigment")
org_objs = self.OMS.find_org_by_observatory(observatory_id)
self.assertEqual(1, len(org_objs))
self.assertEqual(org_id, org_objs[0]._id)
log.debug("org_id=<" + org_id + ">")
log.debug("create a subsite with parent Observatory")
subsite_obj = IonObject(RT.Subsite,
name= 'TestSubsite',
description = 'sample subsite')
subsite_id = self.OMS.create_subsite(subsite_obj, observatory_id)
self.assertIsNotNone(subsite_id, "Subsite not created.")
log.debug("verify that Subsite is linked to Observatory")
mf_subsite_assoc = self.RR.get_association(observatory_id, PRED.hasSite, subsite_id)
self.assertIsNotNone(mf_subsite_assoc, "Subsite not connected to Observatory.")
log.debug("add the Subsite as a resource of this Observatory")
self.OMS.assign_resource_to_observatory_org(resource_id=subsite_id, org_id=org_id)
log.debug("verify that Subsite is linked to Org")
org_subsite_assoc = self.RR.get_association(org_id, PRED.hasResource, subsite_id)
self.assertIsNotNone(org_subsite_assoc, "Subsite not connected as resource to Org.")
log.debug("create a logical platform with parent Subsite")
platform_site_obj = IonObject(RT.PlatformSite,
name= 'TestPlatformSite',
description = 'sample logical platform')
platform_site_id = self.OMS.create_platform_site(platform_site_obj, subsite_id)
self.assertIsNotNone(platform_site_id, "PlatformSite not created.")
log.debug("verify that PlatformSite is linked to Site")
site_lp_assoc = self.RR.get_association(subsite_id, PRED.hasSite, platform_site_id)
self.assertIsNotNone(site_lp_assoc, "PlatformSite not connected to Site.")
log.debug("add the PlatformSite as a resource of this Observatory")
self.OMS.assign_resource_to_observatory_org(resource_id=platform_site_id, org_id=org_id)
log.debug("verify that PlatformSite is linked to Org")
org_lp_assoc = self.RR.get_association(org_id, PRED.hasResource, platform_site_id)
self.assertIsNotNone(org_lp_assoc, "PlatformSite not connected as resource to Org.")
log.debug("create a logical instrument with parent logical platform")
instrument_site_obj = IonObject(RT.InstrumentSite,
name= 'TestInstrumentSite',
description = 'sample logical instrument')
instrument_site_id = self.OMS.create_instrument_site(instrument_site_obj, platform_site_id)
self.assertIsNotNone(instrument_site_id, "InstrumentSite not created.")
log.debug("verify that InstrumentSite is linked to PlatformSite")
li_lp_assoc = self.RR.get_association(platform_site_id, PRED.hasSite, instrument_site_id)
self.assertIsNotNone(li_lp_assoc, "InstrumentSite not connected to PlatformSite.")
log.debug("add the InstrumentSite as a resource of this Observatory")
self.OMS.assign_resource_to_observatory_org(resource_id=instrument_site_id, org_id=org_id)
log.debug("verify that InstrumentSite is linked to Org")
org_li_assoc = self.RR.get_association(org_id, PRED.hasResource, instrument_site_id)
self.assertIsNotNone(org_li_assoc, "InstrumentSite not connected as resource to Org.")
log.debug("remove the InstrumentSite as a resource of this Observatory")
self.OMS.unassign_resource_from_observatory_org(instrument_site_id, org_id)
log.debug("verify that InstrumentSite is linked to Org")
assocs,_ = self.RR.find_objects(org_id, PRED.hasResource, RT.InstrumentSite, id_only=True )
self.assertEqual(0, len(assocs))
log.debug("remove the InstrumentSite, association should drop automatically")
self.OMS.delete_instrument_site(instrument_site_id)
assocs, _ = self.RR.find_objects(platform_site_id, PRED.hasSite, RT.InstrumentSite, id_only=True )
self.assertEqual(0, len(assocs))
log.debug("remove the PlatformSite as a resource of this Observatory")
self.OMS.unassign_resource_from_observatory_org(platform_site_id, org_id)
log.debug("verify that PlatformSite is linked to Org")
assocs,_ = self.RR.find_objects(org_id, PRED.hasResource, RT.PlatformSite, id_only=True )
self.assertEqual(0, len(assocs))
log.debug("remove the Site as a resource of this Observatory")
self.OMS.unassign_resource_from_observatory_org(subsite_id, org_id)
log.debug("verify that Site is linked to Org")
assocs,_ = self.RR.find_objects(org_id, PRED.hasResource, RT.Subsite, id_only=True )
self.assertEqual(0, len(assocs))
self.RR.delete(org_id)
self.OMS.force_delete_observatory(observatory_id)
self.OMS.force_delete_subsite(subsite_id)
self.OMS.force_delete_platform_site(platform_site_id)
self.OMS.force_delete_instrument_site(instrument_site_id)
@attr('EXT')
def test_observatory_extensions(self):
obs_id = self.RR2.create(any_old(RT.Observatory))
pss_id = self.RR2.create(any_old(RT.PlatformSite, dict(alt_resource_type="StationSite")))
pas_id = self.RR2.create(any_old(RT.PlatformSite, dict(alt_resource_type="PlatformAssemblySite")))
pcs_id = self.RR2.create(any_old(RT.PlatformSite, dict(alt_resource_type="PlatformComponentSite")))
ins_id = self.RR2.create(any_old(RT.InstrumentSite))
obs_obj = self.RR2.read(obs_id)
pss_obj = self.RR2.read(pss_id)
pas_obj = self.RR2.read(pas_id)
pcs_obj = self.RR2.read(pcs_id)
ins_obj = self.RR2.read(ins_id)
self.RR2.create_association(obs_id, PRED.hasSite, pss_id)
self.RR2.create_association(pss_id, PRED.hasSite, pas_id)
self.RR2.create_association(pas_id, PRED.hasSite, pcs_id)
self.RR2.create_association(pcs_id, PRED.hasSite, ins_id)
extended_obs = self.OMS.get_observatory_site_extension(obs_id, user_id=12345)
self.assertEqual([pss_obj], extended_obs.computed.platform_station_sites.value)
self.assertEqual(ComputedValueAvailability.PROVIDED, extended_obs.computed.platform_station_sites.status)
self.assertEqual([pas_obj], extended_obs.computed.platform_assembly_sites.value)
self.assertEqual(ComputedValueAvailability.PROVIDED, extended_obs.computed.platform_assembly_sites.status)
self.assertEqual([pcs_obj], extended_obs.computed.platform_component_sites.value)
self.assertEqual(ComputedValueAvailability.PROVIDED, extended_obs.computed.platform_component_sites.status)
self.assertEqual([ins_obj], extended_obs.computed.instrument_sites.value)
extended_pss = self.OMS.get_observatory_site_extension(obs_id, user_id=12345)
self.assertEqual([pas_obj], extended_pss.computed.platform_assembly_sites.value)
self.assertEqual([pcs_obj], extended_pss.computed.platform_component_sites.value)
self.assertEqual([ins_obj], extended_pss.computed.instrument_sites.value)
extended_pas = self.OMS.get_observatory_site_extension(pas_id, user_id=12345)
self.assertEqual([pcs_obj], extended_pas.computed.platform_component_sites.value)
self.assertEqual([ins_obj], extended_pas.computed.instrument_sites.value)
extended_pcs = self.OMS.get_platform_component_site_extension(pcs_id, user_id=12345)
self.assertEqual([ins_obj], extended_pcs.computed.instrument_sites.value)
#@unittest.skip("in development...")
@attr('EXT')
@attr('EXT1')
def test_observatory_org_extended(self):
stuff = self._make_associations()
parsed_pdict_id = self.dataset_management.read_parameter_dictionary_by_name('ctd_parsed_param_dict',
id_only=True)
parsed_stream_def_id = self.pubsubcli.create_stream_definition(name='parsed',
parameter_dictionary_id=parsed_pdict_id)
tdom, sdom = time_series_domain()
sdom = sdom.dump()
tdom = tdom.dump()
dp_obj = IonObject(RT.DataProduct,
name='the parsed data',
description='ctd stream test',
temporal_domain = tdom,
spatial_domain = sdom)
data_product_id1 = self.dpclient.create_data_product(data_product=dp_obj,
stream_definition_id=parsed_stream_def_id)
self.damsclient.assign_data_product(input_resource_id=stuff.instrument_device_id,
data_product_id=data_product_id1)
#Create a user to be used as regular member
member_actor_obj = IonObject(RT.ActorIdentity, name='org member actor')
member_actor_id,_ = self.RR.create(member_actor_obj)
assert(member_actor_id)
member_actor_header = get_actor_header(member_actor_id)
member_user_obj = IonObject(RT.UserInfo, name='org member user')
member_user_id,_ = self.RR.create(member_user_obj)
assert(member_user_id)
self.RR.create_association(subject=member_actor_id, predicate=PRED.hasInfo, object=member_user_id)
#Build the Service Agreement Proposal to enroll a user actor
sap = IonObject(OT.EnrollmentProposal,consumer=member_actor_id, provider=stuff.org_id )
sap_response = self.org_management_service.negotiate(sap, headers=member_actor_header )
#enroll the member without using negotiation
self.org_management_service.enroll_member(org_id=stuff.org_id, actor_id=member_actor_id)
#--------------------------------------------------------------------------------
# Get the extended Site (platformSite)
#--------------------------------------------------------------------------------
try:
extended_site = self.OMS.get_site_extension(stuff.platform_site_id)
except:
log.error('failed to get extended site', exc_info=True)
raise
log.debug("extended_site: %r ", extended_site)
self.assertEqual(1, len(extended_site.platform_devices))
self.assertEqual(1, len(extended_site.platform_models))
self.assertEqual(stuff.platform_device_id, extended_site.platform_devices[0]._id)
self.assertEqual(stuff.platform_model_id, extended_site.platform_models[0]._id)
log.debug("verify that PlatformDeviceb is linked to PlatformDevice with hasNetworkParent link")
associations = self.RR.find_associations(subject=stuff.platform_deviceb_id, predicate=PRED.hasNetworkParent, object=stuff.platform_device_id, id_only=True)
self.assertIsNotNone(associations, "PlatformDevice child not connected to PlatformDevice parent.")
#--------------------------------------------------------------------------------
# Get the extended Org
#--------------------------------------------------------------------------------
#test the extended resource
extended_org = self.OMS.get_marine_facility_extension(stuff.org_id)
log.debug("test_observatory_org_extended: extended_org: %s ", str(extended_org))
#self.assertEqual(2, len(extended_org.instruments_deployed) )
#self.assertEqual(1, len(extended_org.platforms_not_deployed) )
self.assertEqual(2, extended_org.number_of_platforms)
self.assertEqual(2, len(extended_org.platform_models) )
self.assertEqual(2, extended_org.number_of_instruments)
self.assertEqual(2, len(extended_org.instrument_models) )
self.assertEqual(1, len(extended_org.members))
self.assertNotEqual(extended_org.members[0]._id, member_actor_id)
self.assertEqual(extended_org.members[0]._id, member_user_id)
self.assertEqual(1, len(extended_org.open_requests))
self.assertTrue(len(extended_site.deployments)>0)
self.assertEqual(len(extended_site.deployments), len(extended_site.deployment_info))
#test the extended resource of the ION org
ion_org_id = self.org_management_service.find_org()
extended_org = self.OMS.get_marine_facility_extension(ion_org_id._id, user_id=12345)
log.debug("test_observatory_org_extended: extended_ION_org: %s ", str(extended_org))
self.assertEqual(1, len(extended_org.members))
self.assertEqual(0, extended_org.number_of_platforms)
#self.assertEqual(1, len(extended_org.sites))
#--------------------------------------------------------------------------------
# Get the extended Site
#--------------------------------------------------------------------------------
#create device state events to use for op /non-op filtering in extended
t = get_ion_ts()
self.event_publisher.publish_event( ts_created= t, event_type = 'ResourceAgentStateEvent',
origin = stuff.instrument_device_id, state=ResourceAgentState.STREAMING )
self.event_publisher.publish_event( ts_created= t, event_type = 'ResourceAgentStateEvent',
origin = stuff.instrument_device2_id, state=ResourceAgentState.INACTIVE )
extended_site = self.OMS.get_site_extension(stuff.instrument_site2_id)
log.debug("test_observatory_org_extended: extended_site: %s ", str(extended_site))
self.dpclient.delete_data_product(data_product_id1)
class TestOrgManagementServiceInt(IonIntegrationTestCase):
def setUp(self):
# Start container
self._start_container()
self.container.start_rel_from_url('res/deploy/r2coi.yml')
self.resource_registry = ResourceRegistryServiceClient(
node=self.container.node)
self.org_management_service = OrgManagementServiceClient(
node=self.container.node)
def test_org_crud(self):
with self.assertRaises(BadRequest) as br:
self.org_management_service.create_org(
IonObject("Org", {"name": "Test Facility"}))
self.assertTrue(
"can only contain alphanumeric and underscore characters" in
br.exception.message)
with self.assertRaises(BadRequest):
self.org_management_service.create_org()
org_obj = IonObject("Org", {"name": "TestFacility"})
org_id = self.org_management_service.create_org(org_obj)
self.assertNotEqual(org_id, None)
org = None
org = self.org_management_service.read_org(org_id)
self.assertNotEqual(org, None)
#Check that the roles got associated to them
role_list = self.org_management_service.find_org_roles(org_id)
self.assertEqual(len(role_list), 2)
with self.assertRaises(BadRequest):
self.org_management_service.update_org()
org.name = 'Updated_TestFacility'
self.org_management_service.update_org(org)
org = None
org = self.org_management_service.read_org(org_id)
self.assertNotEqual(org, None)
self.assertEqual(org.name, 'Updated_TestFacility')
user_role = self.org_management_service.find_org_role_by_name(
org_id, ORG_MANAGER_ROLE)
self.assertNotEqual(user_role, None)
#find_org = self.org_management_service.remove_user_role(org_id, ORG_MANAGER_ROLE)
#self.assertEqual(find_org, True)
with self.assertRaises(BadRequest):
self.org_management_service.delete_org()
self.org_management_service.delete_org(org_id)
with self.assertRaises(NotFound) as cm:
self.org_management_service.read_org(org_id)
self.assertIn("does not exist", cm.exception.message)
with self.assertRaises(NotFound) as cm:
self.org_management_service.delete_org(org_id)
self.assertIn("does not exist", cm.exception.message)
def test_org_affiliation(self):
root_org = None
root_org = self.org_management_service.find_org()
self.assertNotEqual(root_org, None)
org_obj = IonObject("Org", {"name": "TestFacility"})
org_id = self.org_management_service.create_org(org_obj)
self.assertNotEqual(org_id, None)
ret = self.org_management_service.affiliate_org(root_org._id, org_id)
self.assertTrue(ret)
ret = self.org_management_service.unaffiliate_org(root_org._id, org_id)
self.assertTrue(ret)
def test_find_org_containers(self):
root_org = None
root_org = self.org_management_service.find_org()
self.assertNotEqual(root_org, None)
containers = self.org_management_service.find_org_containers(
root_org._id)
all_containers, _ = self.resource_registry.find_resources(
restype=RT.CapabilityContainer, id_only=True)
self.assertEqual(len(containers), len(all_containers))
class TestObservatoryManagementServiceIntegration(IonIntegrationTestCase):
def setUp(self):
# Start container
#print 'instantiating container'
self._start_container()
#container = Container()
#print 'starting container'
#container.start()
#print 'started container'
self.container.start_rel_from_url('res/deploy/r2deploy.yml')
self.RR = ResourceRegistryServiceClient(node=self.container.node)
self.OMS = ObservatoryManagementServiceClient(node=self.container.node)
self.org_management_service = OrgManagementServiceClient(node=self.container.node)
self.IMS = InstrumentManagementServiceClient(node=self.container.node)
self.dpclient = DataProductManagementServiceClient(node=self.container.node)
self.pubsubcli = PubsubManagementServiceClient(node=self.container.node)
self.damsclient = DataAcquisitionManagementServiceClient(node=self.container.node)
self.dataset_management = DatasetManagementServiceClient()
#print 'TestObservatoryManagementServiceIntegration: started services'
self.event_publisher = EventPublisher()
# @unittest.skip('this exists only for debugging the launch process')
# def test_just_the_setup(self):
# return
def destroy(self, resource_ids):
self.OMS.force_delete_observatory(resource_ids.observatory_id)
self.OMS.force_delete_subsite(resource_ids.subsite_id)
self.OMS.force_delete_subsite(resource_ids.subsite2_id)
self.OMS.force_delete_subsite(resource_ids.subsiteb_id)
self.OMS.force_delete_subsite(resource_ids.subsitez_id)
self.OMS.force_delete_platform_site(resource_ids.platform_site_id)
self.OMS.force_delete_platform_site(resource_ids.platform_siteb_id)
self.OMS.force_delete_platform_site(resource_ids.platform_siteb2_id)
self.OMS.force_delete_platform_site(resource_ids.platform_site3_id)
self.OMS.force_delete_instrument_site(resource_ids.instrument_site_id)
self.OMS.force_delete_instrument_site(resource_ids.instrument_site2_id)
self.OMS.force_delete_instrument_site(resource_ids.instrument_siteb3_id)
self.OMS.force_delete_instrument_site(resource_ids.instrument_site4_id)
#@unittest.skip('targeting')
def test_resources_associations(self):
resources = self._make_associations()
self.destroy(resources)
#@unittest.skip('targeting')
def test_find_related_frames_of_reference(self):
# finding subordinates gives a dict of obj lists, convert objs to ids
def idify(adict):
ids = {}
for k, v in adict.iteritems():
ids[k] = []
for obj in v:
ids[k].append(obj._id)
return ids
# a short version of the function we're testing, with id-ify
def short(resource_id, output_types):
ret = self.OMS.find_related_frames_of_reference(resource_id,
output_types)
return idify(ret)
#set up associations first
stuff = self._make_associations()
#basic traversal of tree from instrument to platform
ids = short(stuff.instrument_site_id, [RT.PlatformSite])
self.assertIn(RT.PlatformSite, ids)
self.assertIn(stuff.platform_site_id, ids[RT.PlatformSite])
self.assertIn(stuff.platform_siteb_id, ids[RT.PlatformSite])
self.assertNotIn(stuff.platform_siteb2_id, ids[RT.PlatformSite])
#since this is the first search, just make sure the input inst_id got stripped
if RT.InstrumentSite in ids:
self.assertNotIn(stuff.instrument_site_id, ids[RT.InstrumentSite])
#basic traversal of tree from platform to instrument
ids = short(stuff.platform_siteb_id, [RT.InstrumentSite])
self.assertIn(RT.InstrumentSite, ids)
self.assertIn(stuff.instrument_site_id, ids[RT.InstrumentSite])
self.assertNotIn(stuff.instrument_site2_id, ids[RT.InstrumentSite])
#full traversal of tree from observatory down to instrument
ids = short(stuff.observatory_id, [RT.InstrumentSite])
self.assertIn(RT.InstrumentSite, ids)
self.assertIn(stuff.instrument_site_id, ids[RT.InstrumentSite])
#full traversal of tree from instrument to observatory
ids = short(stuff.instrument_site_id, [RT.Observatory])
self.assertIn(RT.Observatory, ids)
self.assertIn(stuff.observatory_id, ids[RT.Observatory])
#partial traversal, only down to platform
ids = short(stuff.observatory_id, [RT.Subsite, RT.PlatformSite])
self.assertIn(RT.PlatformSite, ids)
self.assertIn(RT.Subsite, ids)
self.assertIn(stuff.platform_site_id, ids[RT.PlatformSite])
self.assertIn(stuff.platform_siteb_id, ids[RT.PlatformSite])
self.assertIn(stuff.platform_siteb2_id, ids[RT.PlatformSite])
self.assertIn(stuff.platform_site3_id, ids[RT.PlatformSite])
self.assertIn(stuff.subsite_id, ids[RT.Subsite])
self.assertIn(stuff.subsite2_id, ids[RT.Subsite])
self.assertIn(stuff.subsitez_id, ids[RT.Subsite])
self.assertIn(stuff.subsiteb_id, ids[RT.Subsite])
self.assertNotIn(RT.InstrumentSite, ids)
#partial traversal, only down to platform
ids = short(stuff.instrument_site_id, [RT.Subsite, RT.PlatformSite])
self.assertIn(RT.PlatformSite, ids)
self.assertIn(RT.Subsite, ids)
self.assertIn(stuff.platform_siteb_id, ids[RT.PlatformSite])
self.assertIn(stuff.platform_site_id, ids[RT.PlatformSite])
self.assertIn(stuff.subsite_id, ids[RT.Subsite])
self.assertIn(stuff.subsiteb_id, ids[RT.Subsite])
self.assertNotIn(stuff.subsite2_id, ids[RT.Subsite])
self.assertNotIn(stuff.subsitez_id, ids[RT.Subsite])
self.assertNotIn(stuff.platform_siteb2_id, ids[RT.PlatformSite])
self.assertNotIn(RT.Observatory, ids)
self.destroy(stuff)
def _make_associations(self):
"""
create one of each resource and association used by OMS
to guard against problems in ion-definitions
"""
#raise unittest.SkipTest("https://jira.oceanobservatories.org/tasks/browse/CISWCORE-41")
"""
the tree we're creating (observatory, sites, platforms, instruments)
rows are lettered, colums numbered.
- first row is implied a
- first column is implied 1
- site Z, just because
O--Sz
|
S--S2--P3--I4
|
Sb-Pb2-Ib3
|
P--I2 <- PlatformDevice, InstrumentDevice2
|
Pb <- PlatformDevice b
|
I <- InstrumentDevice
"""
org_id = self.OMS.create_marine_facility(any_old(RT.Org))
def create_under_org(resource_type):
obj = any_old(resource_type)
if RT.InstrumentDevice == resource_type:
resource_id = self.IMS.create_instrument_device(obj)
else:
resource_id, _ = self.RR.create(obj)
self.OMS.assign_resource_to_observatory_org(resource_id=resource_id, org_id=org_id)
return resource_id
#stuff we control
observatory_id = create_under_org(RT.Observatory)
subsite_id = create_under_org(RT.Subsite)
subsite2_id = create_under_org(RT.Subsite)
subsiteb_id = create_under_org(RT.Subsite)
subsitez_id = create_under_org(RT.Subsite)
platform_site_id = create_under_org(RT.PlatformSite)
platform_siteb_id = create_under_org(RT.PlatformSite)
platform_siteb2_id = create_under_org(RT.PlatformSite)
platform_site3_id = create_under_org(RT.PlatformSite)
instrument_site_id = create_under_org(RT.InstrumentSite)
instrument_site2_id = create_under_org(RT.InstrumentSite)
instrument_siteb3_id = create_under_org(RT.InstrumentSite)
instrument_site4_id = create_under_org(RT.InstrumentSite)
#stuff we associate to
instrument_device_id = create_under_org(RT.InstrumentDevice)
instrument_device2_id = create_under_org(RT.InstrumentDevice)
platform_device_id = create_under_org(RT.PlatformDevice)
platform_deviceb_id = create_under_org(RT.PlatformDevice)
instrument_model_id, _ = self.RR.create(any_old(RT.InstrumentModel))
platform_model_id, _ = self.RR.create(any_old(RT.PlatformModel))
deployment_id, _ = self.RR.create(any_old(RT.Deployment))
#observatory
self.RR.create_association(observatory_id, PRED.hasSite, subsite_id)
self.RR.create_association(observatory_id, PRED.hasSite, subsitez_id)
#site
self.RR.create_association(subsite_id, PRED.hasSite, subsite2_id)
self.RR.create_association(subsite_id, PRED.hasSite, subsiteb_id)
self.RR.create_association(subsite2_id, PRED.hasSite, platform_site3_id)
self.RR.create_association(subsiteb_id, PRED.hasSite, platform_siteb2_id)
self.RR.create_association(subsiteb_id, PRED.hasSite, platform_site_id)
#platform_site(s)
self.RR.create_association(platform_site3_id, PRED.hasSite, instrument_site4_id)
self.RR.create_association(platform_siteb2_id, PRED.hasSite, instrument_siteb3_id)
self.RR.create_association(platform_site_id, PRED.hasSite, instrument_site2_id)
self.RR.create_association(platform_site_id, PRED.hasSite, platform_siteb_id)
self.RR.create_association(platform_siteb_id, PRED.hasSite, instrument_site_id)
self.RR.create_association(platform_siteb_id, PRED.hasDevice, platform_deviceb_id)
self.RR.create_association(platform_site_id, PRED.hasModel, platform_model_id)
self.RR.create_association(platform_site_id, PRED.hasDevice, platform_device_id)
self.RR.create_association(platform_site_id, PRED.hasDeployment, deployment_id)
#instrument_site(s)
self.RR.create_association(instrument_site_id, PRED.hasModel, instrument_model_id)
self.RR.create_association(instrument_site_id, PRED.hasDevice, instrument_device_id)
self.RR.create_association(instrument_site_id, PRED.hasDeployment, deployment_id)
self.RR.create_association(instrument_site2_id, PRED.hasDevice, instrument_device2_id)
#platform_device
self.RR.create_association(platform_device_id, PRED.hasModel, platform_model_id)
#instrument_device
self.RR.create_association(instrument_device_id, PRED.hasModel, instrument_model_id)
self.RR.create_association(instrument_device2_id, PRED.hasModel, instrument_model_id)
ret = DotDict()
ret.org_id = org_id
ret.observatory_id = observatory_id
ret.subsite_id = subsite_id
ret.subsite2_id = subsite2_id
ret.subsiteb_id = subsiteb_id
ret.subsitez_id = subsitez_id
ret.platform_site_id = platform_site_id
ret.platform_siteb_id = platform_siteb_id
ret.platform_siteb2_id = platform_siteb2_id
ret.platform_site3_id = platform_site3_id
ret.instrument_site_id = instrument_site_id
ret.instrument_site2_id = instrument_site2_id
ret.instrument_siteb3_id = instrument_siteb3_id
ret.instrument_site4_id = instrument_site4_id
ret.instrument_device_id = instrument_device_id
ret.instrument_device2_id = instrument_device2_id
ret.platform_device_id = platform_device_id
ret.platform_deviceb_id = platform_deviceb_id
ret.instrument_model_id = instrument_model_id
ret.platform_model_id = platform_model_id
ret.deployment_id = deployment_id
return ret
#@unittest.skip("targeting")
def test_create_observatory(self):
observatory_obj = IonObject(RT.Observatory,
name='TestFacility',
description='some new mf')
observatory_id = self.OMS.create_observatory(observatory_obj)
self.OMS.force_delete_observatory(observatory_id)
#@unittest.skip("targeting")
def test_find_observatory_org(self):
org_obj = IonObject(RT.Org,
name='TestOrg',
description='some new mf org')
org_id = self.OMS.create_marine_facility(org_obj)
observatory_obj = IonObject(RT.Observatory,
name='TestObservatory',
description='some new obs')
observatory_id = self.OMS.create_observatory(observatory_obj)
#make association
self.OMS.assign_resource_to_observatory_org(observatory_id, org_id)
#find association
org_objs = self.OMS.find_org_by_observatory(observatory_id)
self.assertEqual(1, len(org_objs))
self.assertEqual(org_id, org_objs[0]._id)
print("org_id=<" + org_id + ">")
#create a subsite with parent Observatory
subsite_obj = IonObject(RT.Subsite,
name= 'TestSubsite',
description = 'sample subsite')
subsite_id = self.OMS.create_subsite(subsite_obj, observatory_id)
self.assertIsNotNone(subsite_id, "Subsite not created.")
# verify that Subsite is linked to Observatory
mf_subsite_assoc = self.RR.get_association(observatory_id, PRED.hasSite, subsite_id)
self.assertIsNotNone(mf_subsite_assoc, "Subsite not connected to Observatory.")
# add the Subsite as a resource of this Observatory
self.OMS.assign_resource_to_observatory_org(resource_id=subsite_id, org_id=org_id)
# verify that Subsite is linked to Org
org_subsite_assoc = self.RR.get_association(org_id, PRED.hasResource, subsite_id)
self.assertIsNotNone(org_subsite_assoc, "Subsite not connected as resource to Org.")
#create a logical platform with parent Subsite
platform_site_obj = IonObject(RT.PlatformSite,
name= 'TestPlatformSite',
description = 'sample logical platform')
platform_site_id = self.OMS.create_platform_site(platform_site_obj, subsite_id)
self.assertIsNotNone(platform_site_id, "PlatformSite not created.")
# verify that PlatformSite is linked to Site
site_lp_assoc = self.RR.get_association(subsite_id, PRED.hasSite, platform_site_id)
self.assertIsNotNone(site_lp_assoc, "PlatformSite not connected to Site.")
# add the PlatformSite as a resource of this Observatory
self.OMS.assign_resource_to_observatory_org(resource_id=platform_site_id, org_id=org_id)
# verify that PlatformSite is linked to Org
org_lp_assoc = self.RR.get_association(org_id, PRED.hasResource, platform_site_id)
self.assertIsNotNone(org_lp_assoc, "PlatformSite not connected as resource to Org.")
#create a logical instrument with parent logical platform
instrument_site_obj = IonObject(RT.InstrumentSite,
name= 'TestInstrumentSite',
description = 'sample logical instrument')
instrument_site_id = self.OMS.create_instrument_site(instrument_site_obj, platform_site_id)
self.assertIsNotNone(instrument_site_id, "InstrumentSite not created.")
# verify that InstrumentSite is linked to PlatformSite
li_lp_assoc = self.RR.get_association(platform_site_id, PRED.hasSite, instrument_site_id)
self.assertIsNotNone(li_lp_assoc, "InstrumentSite not connected to PlatformSite.")
# add the InstrumentSite as a resource of this Observatory
self.OMS.assign_resource_to_observatory_org(resource_id=instrument_site_id, org_id=org_id)
# verify that InstrumentSite is linked to Org
org_li_assoc = self.RR.get_association(org_id, PRED.hasResource, instrument_site_id)
self.assertIsNotNone(org_li_assoc, "InstrumentSite not connected as resource to Org.")
# remove the InstrumentSite as a resource of this Observatory
self.OMS.unassign_resource_from_observatory_org(instrument_site_id, org_id)
# verify that InstrumentSite is linked to Org
assocs,_ = self.RR.find_objects(org_id, PRED.hasResource, RT.InstrumentSite, id_only=True )
self.assertEqual(len(assocs), 0)
# remove the InstrumentSite
self.OMS.delete_instrument_site(instrument_site_id)
assocs, _ = self.RR.find_objects(platform_site_id, PRED.hasSite, RT.InstrumentSite, id_only=True )
self.assertEqual(len(assocs), 1)
#todo: remove the dangling association
# remove the PlatformSite as a resource of this Observatory
self.OMS.unassign_resource_from_observatory_org(platform_site_id, org_id)
# verify that PlatformSite is linked to Org
assocs,_ = self.RR.find_objects(org_id, PRED.hasResource, RT.PlatformSite, id_only=True )
self.assertEqual(len(assocs), 0)
# remove the Site as a resource of this Observatory
self.OMS.unassign_resource_from_observatory_org(subsite_id, org_id)
# verify that Site is linked to Org
assocs,_ = self.RR.find_objects(org_id, PRED.hasResource, RT.Subsite, id_only=True )
self.assertEqual(len(assocs), 0)
self.RR.delete(org_id)
self.OMS.force_delete_observatory(observatory_id)
self.OMS.force_delete_subsite(subsite_id)
self.OMS.force_delete_platform_site(platform_site_id)
self.OMS.force_delete_instrument_site(instrument_site_id)
#@unittest.skip("in development...")
@attr('EXT')
def test_observatory_org_extended(self):
stuff = self._make_associations()
parsed_pdict_id = self.dataset_management.read_parameter_dictionary_by_name('ctd_parsed_param_dict',
id_only=True)
parsed_stream_def_id = self.pubsubcli.create_stream_definition(name='parsed',
parameter_dictionary_id=parsed_pdict_id)
tdom, sdom = time_series_domain()
sdom = sdom.dump()
tdom = tdom.dump()
dp_obj = IonObject(RT.DataProduct,
name='the parsed data',
description='ctd stream test',
temporal_domain = tdom,
spatial_domain = sdom)
data_product_id1 = self.dpclient.create_data_product(data_product=dp_obj,
stream_definition_id=parsed_stream_def_id)
self.damsclient.assign_data_product(input_resource_id=stuff.instrument_device_id,
data_product_id=data_product_id1)
#--------------------------------------------------------------------------------
# Get the extended Site (platformSite)
#--------------------------------------------------------------------------------
extended_site = self.OMS.get_site_extension(stuff.platform_site_id)
log.debug("extended_site: %s ", str(extended_site))
self.assertEqual(1, len(extended_site.platform_devices))
self.assertEqual(1, len(extended_site.platform_models))
self.assertEqual(stuff.platform_device_id, extended_site.platform_devices[0]._id)
self.assertEqual(stuff.platform_model_id, extended_site.platform_models[0]._id)
#--------------------------------------------------------------------------------
# Get the extended Org
#--------------------------------------------------------------------------------
#test the extended resource
extended_org = self.org_management_service.get_marine_facility_extension(stuff.org_id)
log.debug("test_observatory_org_extended: extended_org: %s ", str(extended_org))
#self.assertEqual(2, len(extended_org.instruments_deployed) )
#self.assertEqual(1, len(extended_org.platforms_not_deployed) )
self.assertEqual(2, extended_org.number_of_platforms)
self.assertEqual(2, len(extended_org.platform_models) )
self.assertEqual(2, extended_org.number_of_instruments)
self.assertEqual(2, len(extended_org.instrument_models) )
#test the extended resource of the ION org
ion_org_id = self.org_management_service.find_org()
extended_org = self.org_management_service.get_marine_facility_extension(ion_org_id._id, user_id=12345)
log.debug("test_observatory_org_extended: extended_ION_org: %s ", str(extended_org))
self.assertEqual(0, len(extended_org.members))
self.assertEqual(0, extended_org.number_of_platforms)
#self.assertEqual(1, len(extended_org.sites))
#--------------------------------------------------------------------------------
# Get the extended Site
#--------------------------------------------------------------------------------
#create device state events to use for op /non-op filtering in extended
t = get_ion_ts()
self.event_publisher.publish_event( ts_created= t, event_type = 'ResourceAgentStateEvent',
origin = stuff.instrument_device_id, state=ResourceAgentState.STREAMING )
self.event_publisher.publish_event( ts_created= t, event_type = 'ResourceAgentStateEvent',
origin = stuff.instrument_device2_id, state=ResourceAgentState.INACTIVE )
extended_site = self.OMS.get_site_extension(stuff.instrument_site2_id)
log.debug("test_observatory_org_extended: extended_site: %s ", str(extended_site))
self.dpclient.delete_data_product(data_product_id1)
class TestIdentityManagementServiceInt(IonIntegrationTestCase):
def setUp(self):
self.subject = "/DC=org/DC=cilogon/C=US/O=ProtectNetwork/CN=Roger Unwin A254"
# Start container
self._start_container()
self.container.start_rel_from_url('res/deploy/r2deploy.yml')
self.resource_registry = ResourceRegistryServiceClient(node=self.container.node)
self.identity_management_service = IdentityManagementServiceClient(node=self.container.node)
self.org_client = OrgManagementServiceClient(node=self.container.node)
def test_actor_identity(self):
actor_identity_obj = IonObject("ActorIdentity", {"name": self.subject})
user_id = self.identity_management_service.create_actor_identity(actor_identity_obj)
actor_identity = self.identity_management_service.read_actor_identity(user_id)
actor_identity.name = 'Updated subject'
self.identity_management_service.update_actor_identity(actor_identity)
ai = self.identity_management_service.find_actor_identity_by_name(actor_identity.name)
self._baseAssertEqual(ai.name, actor_identity.name)
with self.assertRaises(NotFound):
ai = self.identity_management_service.find_actor_identity_by_name("Yeah, well, you know, that's just, like, your opinion, man.")
self._baseAssertEqual(ai.name, actor_identity.name)
self.identity_management_service.delete_actor_identity(user_id)
with self.assertRaises(NotFound) as cm:
self.identity_management_service.read_actor_identity(user_id)
self.assertTrue("does not exist" in cm.exception.message)
with self.assertRaises(NotFound) as cm:
self.identity_management_service.delete_actor_identity(user_id)
self.assertTrue("does not exist" in cm.exception.message)
def test_user_credentials(self):
actor_identity_obj = IonObject("ActorIdentity", {"name": self.subject})
user_id = self.identity_management_service.create_actor_identity(actor_identity_obj)
user_credentials_obj = IonObject("UserCredentials", {"name": self.subject})
self.identity_management_service.register_user_credentials(user_id, user_credentials_obj)
with self.assertRaises(NotFound) as cm:
self.identity_management_service.unregister_user_credentials("bad", self.subject)
self.assertTrue("does not exist" in cm.exception.message)
with self.assertRaises(NotFound) as cm:
self.identity_management_service.unregister_user_credentials(user_id, "bad")
self.assertTrue("does not exist" in cm.exception.message)
with self.assertRaises(NotFound) as cm:
self.identity_management_service.unregister_user_credentials('bad', 'bad')
self.assertTrue("does not exist" in cm.exception.message)
self.identity_management_service.unregister_user_credentials(user_id, self.subject)
self.identity_management_service.delete_actor_identity(user_id)
def test_user_info(self):
actor_identity_obj = IonObject("ActorIdentity", {"name": self.subject})
user_id = self.identity_management_service.create_actor_identity(actor_identity_obj)
user_credentials_obj = IonObject("UserCredentials", {"name": self.subject})
self.identity_management_service.register_user_credentials(user_id, user_credentials_obj)
user_info_obj = IonObject("UserInfo", {"name": "Foo"})
user_info = self.identity_management_service.create_user_info(user_id, user_info_obj)
with self.assertRaises(Conflict) as cm:
self.identity_management_service.create_user_info(user_id, user_info_obj)
self.assertTrue("UserInfo already exists for user id" in cm.exception.message)
user_info_obj = self.identity_management_service.find_user_info_by_id(user_id)
user_info_obj = self.identity_management_service.find_user_info_by_name("Foo")
user_info_obj = self.identity_management_service.find_user_info_by_subject(self.subject)
user_info_obj = self.identity_management_service.read_user_info(user_info)
user_info_obj.name = 'Jane Doe'
self.identity_management_service.update_user_info(user_info_obj)
self.identity_management_service.delete_user_info(user_info)
with self.assertRaises(NotFound) as cm:
self.identity_management_service.read_user_info(user_info)
self.assertTrue('does not exist' in cm.exception.message)
with self.assertRaises(NotFound) as cm:
self.identity_management_service.delete_user_info(user_info)
self.assertTrue('does not exist' in cm.exception.message)
with self.assertRaises(NotFound) as cm:
self.identity_management_service.find_user_info_by_name("John Doe")
self.assertEqual(cm.exception.message, 'UserInfo with name John Doe does not exist')
with self.assertRaises(NotFound) as cm:
self.identity_management_service.find_user_info_by_subject("Bogus subject")
self.assertEqual(cm.exception.message, "UserCredentials with subject Bogus subject does not exist")
self.identity_management_service.unregister_user_credentials(user_id, self.subject)
self.identity_management_service.delete_actor_identity(user_id)
def test_signon(self):
certificate = """-----BEGIN CERTIFICATE-----
MIIEMzCCAxugAwIBAgICBQAwDQYJKoZIhvcNAQEFBQAwajETMBEGCgmSJomT8ixkARkWA29yZzEX
MBUGCgmSJomT8ixkARkWB2NpbG9nb24xCzAJBgNVBAYTAlVTMRAwDgYDVQQKEwdDSUxvZ29uMRsw
GQYDVQQDExJDSUxvZ29uIEJhc2ljIENBIDEwHhcNMTAxMTE4MjIyNTA2WhcNMTAxMTE5MTAzMDA2
WjBvMRMwEQYKCZImiZPyLGQBGRMDb3JnMRcwFQYKCZImiZPyLGQBGRMHY2lsb2dvbjELMAkGA1UE
BhMCVVMxFzAVBgNVBAoTDlByb3RlY3ROZXR3b3JrMRkwFwYDVQQDExBSb2dlciBVbndpbiBBMjU0
MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA6QhsWxhUXbIxg+1ZyEc7d+hIGvchVmtb
g0kKLmivgoVsA4U7swNDRH6svW242THta0oTf6crkRx7kOKg6jma2lcAC1sjOSddqX7/92ChoUPq
7LWt2T6GVVA10ex5WAeB/o7br/Z4U8/75uCBis+ru7xEDl09PToK20mrkcz9M4HqIv1eSoPkrs3b
2lUtQc6cjuHRDU4NknXaVMXTBHKPM40UxEDHJueFyCiZJFg3lvQuSsAl4JL5Z8pC02T8/bODBuf4
dszsqn2SC8YDw1xrujvW2Bd7Q7BwMQ/gO+dZKM1mLJFpfEsR9WrjMeg6vkD2TMWLMr0/WIkGC8u+
6M6SMQIDAQABo4HdMIHaMAwGA1UdEwEB/wQCMAAwDgYDVR0PAQH/BAQDAgSwMBMGA1UdJQQMMAoG
CCsGAQUFBwMCMBgGA1UdIAQRMA8wDQYLKwYBBAGCkTYBAgEwagYDVR0fBGMwYTAuoCygKoYoaHR0
cDovL2NybC5jaWxvZ29uLm9yZy9jaWxvZ29uLWJhc2ljLmNybDAvoC2gK4YpaHR0cDovL2NybC5k
b2Vncmlkcy5vcmcvY2lsb2dvbi1iYXNpYy5jcmwwHwYDVR0RBBgwFoEUaXRzYWdyZWVuMUB5YWhv
by5jb20wDQYJKoZIhvcNAQEFBQADggEBAEYHQPMY9Grs19MHxUzMwXp1GzCKhGpgyVKJKW86PJlr
HGruoWvx+DLNX75Oj5FC4t8bOUQVQusZGeGSEGegzzfIeOI/jWP1UtIjzvTFDq3tQMNvsgROSCx5
CkpK4nS0kbwLux+zI7BWON97UpMIzEeE05pd7SmNAETuWRsHMP+x6i7hoUp/uad4DwbzNUGIotdK
f8b270icOVgkOKRdLP/Q4r/x8skKSCRz1ZsRdR+7+B/EgksAJj7Ut3yiWoUekEMxCaTdAHPTMD/g
Mh9xL90hfMJyoGemjJswG5g3fAdTP/Lv0I6/nWeH/cLjwwpQgIEjEAVXl7KHuzX5vPD/wqQ=
-----END CERTIFICATE-----"""
id, valid_until, registered = self.identity_management_service.signon(certificate, True)
self.assertFalse(registered)
id2, valid_until2, registered2 = self.identity_management_service.signon(certificate, True)
self.assertFalse(registered2)
self.assertTrue(id == id2)
self.assertTrue(valid_until == valid_until2)
user_info_obj = IonObject("UserInfo", {"name": "Foo"})
self.identity_management_service.create_user_info(id, user_info_obj)
id3, valid_until3, registered3 = self.identity_management_service.signon(certificate, True)
self.assertTrue(registered3)
self.assertTrue(id == id3)
self.assertTrue(valid_until == valid_until3)
@attr('EXT')
def test_get_extended_user_identity(self):
actor_identity_obj = IonObject("ActorIdentity", {"name": self.subject})
actor_id = self.identity_management_service.create_actor_identity(actor_identity_obj)
user_credentials_obj = IonObject("UserCredentials", {"name": self.subject})
self.identity_management_service.register_user_credentials(actor_id, user_credentials_obj)
user_info_obj = IonObject("UserInfo", {"name": "Foo"})
user_info_id = self.identity_management_service.create_user_info(actor_id, user_info_obj)
ion_org = self.org_client.find_org()
#Build the Service Agreement Proposal to to request a role but never close it
sap = IonObject(OT.RequestRoleProposal,consumer=actor_id, provider=ion_org._id, role_name=ORG_MANAGER_ROLE )
sap_response = self.org_client.negotiate(sap)
#Just grant the role anyway
#self.org_client.grant_role(ion_org._id, actor_id, ORG_MANAGER_ROLE)
with self.assertRaises(NotFound):
self.identity_management_service.get_user_info_extension('That rug really tied the room together.')
with self.assertRaises(BadRequest):
self.identity_management_service.get_user_info_extension()
#Check the user without the negotiation role request
extended_user = self.identity_management_service.get_user_info_extension(user_info_id, org_id=ion_org._id)
self.assertEqual(user_info_obj.type_,extended_user.resource.type_)
self.assertEqual(len(extended_user.roles),1)
self.assertEqual(len(extended_user.open_requests),1)
self.assertEqual(extended_user.open_requests[0].org_id, ion_org._id)
self.assertEqual(extended_user.open_requests[0].user_id, user_info_id)
self.assertEqual(extended_user.open_requests[0].request_type, OT.RequestRoleProposal)
self.assertEqual(len(extended_user.closed_requests),0)
self.assertEqual(extended_user.open_requests[0]._id, extended_user.open_requests[0].negotiation_id)
neg = self.resource_registry.read(object_id=extended_user.open_requests[0].negotiation_id)
sap_response = Negotiation.create_counter_proposal(neg, ProposalStatusEnum.ACCEPTED, ProposalOriginatorEnum.PROVIDER)
sap_response2 = self.org_client.negotiate(sap_response)
#Now check the user after the negotiation has been accepted and the role granted
extended_user = self.identity_management_service.get_user_info_extension(user_info_id, org_id=ion_org._id)
self.assertEqual(user_info_obj.type_,extended_user.resource.type_)
self.assertEqual(len(extended_user.roles),2)
self.assertEqual(len(extended_user.open_requests),0)
self.assertEqual(len(extended_user.closed_requests),1)
self.assertEqual(extended_user.closed_requests[0].org_id, ion_org._id)
self.assertEqual(extended_user.closed_requests[0].user_id, user_info_id)
self.assertEqual(extended_user.closed_requests[0].request_type, OT.RequestRoleProposal)
self.identity_management_service.delete_user_info(user_info_id)
self.org_client.revoke_role(org_id=ion_org._id, actor_id=actor_id, role_name=ORG_MANAGER_ROLE)
self.identity_management_service.unregister_user_credentials(actor_id, self.subject)
self.identity_management_service.delete_actor_identity(actor_id)
def test_account_merge(self):
certificate = """-----BEGIN CERTIFICATE-----
MIIEMzCCAxugAwIBAgICBQAwDQYJKoZIhvcNAQEFBQAwajETMBEGCgmSJomT8ixkARkWA29yZzEX
MBUGCgmSJomT8ixkARkWB2NpbG9nb24xCzAJBgNVBAYTAlVTMRAwDgYDVQQKEwdDSUxvZ29uMRsw
GQYDVQQDExJDSUxvZ29uIEJhc2ljIENBIDEwHhcNMTAxMTE4MjIyNTA2WhcNMTAxMTE5MTAzMDA2
WjBvMRMwEQYKCZImiZPyLGQBGRMDb3JnMRcwFQYKCZImiZPyLGQBGRMHY2lsb2dvbjELMAkGA1UE
BhMCVVMxFzAVBgNVBAoTDlByb3RlY3ROZXR3b3JrMRkwFwYDVQQDExBSb2dlciBVbndpbiBBMjU0
MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA6QhsWxhUXbIxg+1ZyEc7d+hIGvchVmtb
g0kKLmivgoVsA4U7swNDRH6svW242THta0oTf6crkRx7kOKg6jma2lcAC1sjOSddqX7/92ChoUPq
7LWt2T6GVVA10ex5WAeB/o7br/Z4U8/75uCBis+ru7xEDl09PToK20mrkcz9M4HqIv1eSoPkrs3b
2lUtQc6cjuHRDU4NknXaVMXTBHKPM40UxEDHJueFyCiZJFg3lvQuSsAl4JL5Z8pC02T8/bODBuf4
dszsqn2SC8YDw1xrujvW2Bd7Q7BwMQ/gO+dZKM1mLJFpfEsR9WrjMeg6vkD2TMWLMr0/WIkGC8u+
6M6SMQIDAQABo4HdMIHaMAwGA1UdEwEB/wQCMAAwDgYDVR0PAQH/BAQDAgSwMBMGA1UdJQQMMAoG
CCsGAQUFBwMCMBgGA1UdIAQRMA8wDQYLKwYBBAGCkTYBAgEwagYDVR0fBGMwYTAuoCygKoYoaHR0
cDovL2NybC5jaWxvZ29uLm9yZy9jaWxvZ29uLWJhc2ljLmNybDAvoC2gK4YpaHR0cDovL2NybC5k
b2Vncmlkcy5vcmcvY2lsb2dvbi1iYXNpYy5jcmwwHwYDVR0RBBgwFoEUaXRzYWdyZWVuMUB5YWhv
by5jb20wDQYJKoZIhvcNAQEFBQADggEBAEYHQPMY9Grs19MHxUzMwXp1GzCKhGpgyVKJKW86PJlr
HGruoWvx+DLNX75Oj5FC4t8bOUQVQusZGeGSEGegzzfIeOI/jWP1UtIjzvTFDq3tQMNvsgROSCx5
CkpK4nS0kbwLux+zI7BWON97UpMIzEeE05pd7SmNAETuWRsHMP+x6i7hoUp/uad4DwbzNUGIotdK
f8b270icOVgkOKRdLP/Q4r/x8skKSCRz1ZsRdR+7+B/EgksAJj7Ut3yiWoUekEMxCaTdAHPTMD/g
Mh9xL90hfMJyoGemjJswG5g3fAdTP/Lv0I6/nWeH/cLjwwpQgIEjEAVXl7KHuzX5vPD/wqQ=
-----END CERTIFICATE-----"""
subject = "/DC=org/DC=cilogon/C=US/O=ProtectNetwork/CN=Roger Unwin A254"
certificate_2 = """-----BEGIN CERTIFICATE-----
MIIEMzCCAxugAwIBAgIDAJ/lMA0GCSqGSIb3DQEBCwUAMGsxEzARBgoJkiaJk/IsZAEZFgNvcmcx
FzAVBgoJkiaJk/IsZAEZFgdjaWxvZ29uMQswCQYDVQQGEwJVUzEQMA4GA1UEChMHQ0lMb2dvbjEc
MBoGA1UEAxMTQ0lMb2dvbiBPcGVuSUQgQ0EgMTAeFw0xMjEwMTcwMDE2NDlaFw0xMjEwMTcxMjIx
NDlaMGkxEzARBgoJkiaJk/IsZAEZEwNvcmcxFzAVBgoJkiaJk/IsZAEZEwdjaWxvZ29uMQswCQYD
VQQGEwJVUzEPMA0GA1UEChMGR29vZ2xlMRswGQYDVQQDExJPd2VuIE93bmVycmVwIEE4OTMwggEi
MA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDYLdpgg88sntivH+af4oamlp7blsUQcCQ5Yc/b
VDP/dwEKfxTcW36tMV3asLO7GcL7z4FESG761LAe86siT9rcwg2ttLkRjI9KeA3sFjC28N8XjKZ1
estCqG3odqw2pjo3VEFaU57219vIYMJhjmHKEgSnlMQeChMYun/sYIO5uNFba9BfiB6/PRS+bgee
cXRsIAm1vkB89AHdEjqdvH0uSN+jGjF6aAPXsESh70DUAHzs14lbFAomig7AZafT+weh0G5pnayC
lutVnhb9SyS3s1+A6kx8z9mkDUwY/NKXisuDeXa+WbRVq51D+Lc7ffOI+Ph+ynyfFGMcCBzbMADX
AgMBAAGjgeEwgd4wDAYDVR0TAQH/BAIwADAOBgNVHQ8BAf8EBAMCBLAwEwYDVR0lBAwwCgYIKwYB
BQUHAwIwGAYDVR0gBBEwDzANBgsrBgEEAYKRNgEDAzBsBgNVHR8EZTBjMC+gLaArhilodHRwOi8v
Y3JsLmNpbG9nb24ub3JnL2NpbG9nb24tb3BlbmlkLmNybDAwoC6gLIYqaHR0cDovL2NybC5kb2Vn
cmlkcy5vcmcvY2lsb2dvbi1vcGVuaWQuY3JsMCEGA1UdEQQaMBiBFm93ZW5vd25lcnJlcEBnbWFp
bC5jb20wDQYJKoZIhvcNAQELBQADggEBAHWd6ZOjSmJyOUyyLgZAPJpkSuk7DT5mFRhszJhfTGnu
gANHRIJZMs5e/LCMypE+ftxb8mnhAE+kURA2DmeucazHUDP5oYofU+8KMYqcNKnPpLnuiw+bCJPa
3BDxrYoi+vVislHb0U+QDjVYtUtQ2b1/Xhv8ShH89O9i65bbOq+sqez6z2AD9RWOEwRwpQLc9D65
9lkrsKGmJtuG8q3NTpZ1DSuaLOtn0QqttdmCg3pu5edRtgdpGadaSGR4s222JasV439bSTL8Z0Ug
HtjSclGqi8IBmvRkTZI61zTVbGdOKMP90LV1p8noJVLRkZpWRjLxI5xy9El8daAWMdjfrSc=
-----END CERTIFICATE-----"""
subject_2 = "/DC=org/DC=cilogon/C=US/O=Google/CN=Owen Ownerrep A893"
# Try to merge with nonexistent email account
with self.assertRaises(NotFound):
self.identity_management_service.initiate_account_merge("*****@*****.**")
with self.assertRaises(BadRequest):
self.identity_management_service.initiate_account_merge()
# Create two users
id, valid_until, registered = self.identity_management_service.signon(certificate, True)
self.assertFalse(registered)
id_2, valid_until_2, registered_2 = self.identity_management_service.signon(certificate_2, True)
self.assertFalse(registered_2)
# Validate the two accounts are different
self.assertNotEqual(id, id_2, "The two accounts should have two different user id")
# Create UserInfo
contact_info_obj = IonObject("ContactInformation",{"email": "*****@*****.**"})
user_info_obj = IonObject("UserInfo", {"name": "Dude", "contact": contact_info_obj})
user_info_id = self.identity_management_service.create_user_info(id, user_info_obj)
contact_info_obj_2 = IonObject("ContactInformation",{"email": "*****@*****.**"})
user_info_obj_2 = IonObject("UserInfo", {"name": "theDude", "contact": contact_info_obj_2})
user_info_id_2 = self.identity_management_service.create_user_info(id_2, user_info_obj_2)
# Make sure the two users are registered
id, valid_until, registered = self.identity_management_service.signon(certificate, True)
self.assertTrue(registered)
id_2, valid_until_2, registered_2 = self.identity_management_service.signon(certificate_2, True)
self.assertTrue(registered_2)
token = self.identity_management_service.initiate_account_merge("*****@*****.**", headers={'ion-actor-id':id})
# Try merging accounts with invalid token string
with self.assertRaises(NotFound):
self.identity_management_service.complete_account_merge(token_string="0xBeeF", headers={'ion-actor-id':id})
with self.assertRaises(BadRequest):
self.identity_management_service.complete_account_merge()
# Try merging accounts with a different user
# Since this user hasn't initiated account merge, the token doesn't exist in his/her UserInfo
with self.assertRaises(NotFound):
self.identity_management_service.complete_account_merge(token, headers={'ion-actor-id':id_2})
self.identity_management_service.complete_account_merge(token, headers={'ion-actor-id':id})
# Try merging the account again
with self.assertRaises(BadRequest):
self.identity_management_service.complete_account_merge(token, headers={'ion-actor-id':id})
# Signon again and verify the two accounts have been merged
id, valid_until, registered = self.identity_management_service.signon(certificate, True)
self.assertTrue(registered)
id_2, valid_until_2, registered_2 = self.identity_management_service.signon(certificate_2, True)
self.assertTrue(registered_2)
# Validate the two accounts are the same
self.assertEqual(id, id_2, "The two accounts should have the same id")
# Try to merge to your own account
with self.assertRaises(BadRequest):
token = self.identity_management_service.initiate_account_merge("*****@*****.**", headers={'ion-actor-id':id})
# Done testing. Delete user
self.identity_management_service.delete_user_info(user_info_id)
self.identity_management_service.unregister_user_credentials(id, subject)
self.identity_management_service.delete_actor_identity(id)
class TestObservatoryManagementServiceIntegration(IonIntegrationTestCase):
def setUp(self):
# Start container
#print 'instantiating container'
self._start_container()
#container = Container()
#print 'starting container'
#container.start()
#print 'started container'
self.container.start_rel_from_url('res/deploy/r2deploy.yml')
self.RR = ResourceRegistryServiceClient(node=self.container.node)
self.RR2 = EnhancedResourceRegistryClient(self.RR)
self.OMS = ObservatoryManagementServiceClient(node=self.container.node)
self.org_management_service = OrgManagementServiceClient(
node=self.container.node)
self.IMS = InstrumentManagementServiceClient(node=self.container.node)
self.dpclient = DataProductManagementServiceClient(
node=self.container.node)
self.pubsubcli = PubsubManagementServiceClient(
node=self.container.node)
self.damsclient = DataAcquisitionManagementServiceClient(
node=self.container.node)
self.dataset_management = DatasetManagementServiceClient()
#print 'TestObservatoryManagementServiceIntegration: started services'
self.event_publisher = EventPublisher()
# @unittest.skip('this exists only for debugging the launch process')
# def test_just_the_setup(self):
# return
def destroy(self, resource_ids):
self.OMS.force_delete_observatory(resource_ids.observatory_id)
self.OMS.force_delete_subsite(resource_ids.subsite_id)
self.OMS.force_delete_subsite(resource_ids.subsite2_id)
self.OMS.force_delete_subsite(resource_ids.subsiteb_id)
self.OMS.force_delete_subsite(resource_ids.subsitez_id)
self.OMS.force_delete_platform_site(resource_ids.platform_site_id)
self.OMS.force_delete_platform_site(resource_ids.platform_siteb_id)
self.OMS.force_delete_platform_site(resource_ids.platform_siteb2_id)
self.OMS.force_delete_platform_site(resource_ids.platform_site3_id)
self.OMS.force_delete_instrument_site(resource_ids.instrument_site_id)
self.OMS.force_delete_instrument_site(resource_ids.instrument_site2_id)
self.OMS.force_delete_instrument_site(
resource_ids.instrument_siteb3_id)
self.OMS.force_delete_instrument_site(resource_ids.instrument_site4_id)
#@unittest.skip('targeting')
def test_observatory_management(self):
resources = self._make_associations()
self._do_test_find_related_sites(resources)
self._do_test_get_sites_devices_status(resources)
self._do_test_find_site_data_products(resources)
self._do_test_find_related_frames_of_reference(resources)
self._do_test_create_geospatial_point_center(resources)
self._do_test_find_observatory_org(resources)
self.destroy(resources)
def _do_test_find_related_sites(self, resources):
site_resources, site_children, _, _ = self.OMS.find_related_sites(
resources.org_id)
#import sys, pprint
#print >> sys.stderr, pprint.pformat(site_resources)
#print >> sys.stderr, pprint.pformat(site_children)
#self.assertIn(resources.org_id, site_resources)
self.assertIn(resources.observatory_id, site_resources)
self.assertIn(resources.subsite_id, site_resources)
self.assertIn(resources.subsite_id, site_resources)
self.assertIn(resources.subsite2_id, site_resources)
self.assertIn(resources.platform_site_id, site_resources)
self.assertIn(resources.instrument_site_id, site_resources)
self.assertEquals(len(site_resources), 13)
self.assertEquals(site_resources[resources.observatory_id].type_,
RT.Observatory)
self.assertIn(resources.org_id, site_children)
self.assertIn(resources.observatory_id, site_children)
self.assertIn(resources.subsite_id, site_children)
self.assertIn(resources.subsite_id, site_children)
self.assertIn(resources.subsite2_id, site_children)
self.assertIn(resources.platform_site_id, site_children)
self.assertNotIn(resources.instrument_site_id, site_children)
self.assertEquals(len(site_children), 9)
self.assertIsInstance(site_children[resources.subsite_id], list)
self.assertEquals(len(site_children[resources.subsite_id]), 2)
def _do_test_get_sites_devices_status(self, resources):
#bin/nosetests -s -v --nologcapture ion/services/sa/observatory/test/test_observatory_management_service_integration.py:TestObservatoryManagementServiceIntegration.test_observatory_management
full_result_dict = self.OMS.get_sites_devices_status(
parent_resource_ids=[resources.org_id], include_sites=True)
result_dict = full_result_dict[resources.org_id]
site_resources = result_dict.get("site_resources", None)
site_children = result_dict.get("site_children", None)
self.assertEquals(len(site_resources), 14)
self.assertEquals(len(site_children), 9)
full_result_dict = self.OMS.get_sites_devices_status(
parent_resource_ids=[resources.org_id],
include_sites=True,
include_devices=True,
include_status=True)
result_dict = full_result_dict[resources.org_id]
log.debug("RESULT DICT: %s", result_dict.keys())
site_resources = result_dict.get("site_resources", None)
site_children = result_dict.get("site_children", None)
site_status = result_dict.get("site_status", None)
self.assertEquals(len(site_resources), 14)
self.assertEquals(len(site_children), 9)
full_result_dict = self.OMS.get_sites_devices_status(
parent_resource_ids=[resources.observatory_id],
include_sites=True,
include_devices=True,
include_status=True)
result_dict = full_result_dict[resources.observatory_id]
site_resources = result_dict.get("site_resources")
site_children = result_dict.get("site_children")
site_status = result_dict.get("site_status")
self.assertEquals(len(site_resources), 13)
self.assertEquals(len(site_children), 8)
def _do_test_find_site_data_products(self, resources):
res_dict = self.OMS.find_site_data_products(resources.org_id)
#import sys, pprint
#print >> sys.stderr, pprint.pformat(res_dict)
self.assertIsNone(res_dict['data_product_resources'])
self.assertIn(resources.platform_device_id,
res_dict['device_data_products'])
self.assertIn(resources.instrument_device_id,
res_dict['device_data_products'])
#@unittest.skip('targeting')
def _do_test_find_related_frames_of_reference(self, stuff):
# finding subordinates gives a dict of obj lists, convert objs to ids
def idify(adict):
ids = {}
for k, v in adict.iteritems():
ids[k] = []
for obj in v:
ids[k].append(obj._id)
return ids
# a short version of the function we're testing, with id-ify
def short(resource_id, output_types):
ret = self.OMS.find_related_frames_of_reference(
resource_id, output_types)
return idify(ret)
#set up associations first
stuff = self._make_associations()
#basic traversal of tree from instrument to platform
ids = short(stuff.instrument_site_id, [RT.PlatformSite])
self.assertIn(RT.PlatformSite, ids)
self.assertIn(stuff.platform_site_id, ids[RT.PlatformSite])
self.assertIn(stuff.platform_siteb_id, ids[RT.PlatformSite])
self.assertNotIn(stuff.platform_siteb2_id, ids[RT.PlatformSite])
#since this is the first search, just make sure the input inst_id got stripped
if RT.InstrumentSite in ids:
self.assertNotIn(stuff.instrument_site_id, ids[RT.InstrumentSite])
#basic traversal of tree from platform to instrument
ids = short(stuff.platform_siteb_id, [RT.InstrumentSite])
self.assertIn(RT.InstrumentSite, ids)
self.assertIn(stuff.instrument_site_id, ids[RT.InstrumentSite])
self.assertNotIn(stuff.instrument_site2_id, ids[RT.InstrumentSite])
#full traversal of tree from observatory down to instrument
ids = short(stuff.observatory_id, [RT.InstrumentSite])
self.assertIn(RT.InstrumentSite, ids)
self.assertIn(stuff.instrument_site_id, ids[RT.InstrumentSite])
#full traversal of tree from instrument to observatory
ids = short(stuff.instrument_site_id, [RT.Observatory])
self.assertIn(RT.Observatory, ids)
self.assertIn(stuff.observatory_id, ids[RT.Observatory])
#partial traversal, only down to platform
ids = short(stuff.observatory_id, [RT.Subsite, RT.PlatformSite])
self.assertIn(RT.PlatformSite, ids)
self.assertIn(RT.Subsite, ids)
self.assertIn(stuff.platform_site_id, ids[RT.PlatformSite])
self.assertIn(stuff.platform_siteb_id, ids[RT.PlatformSite])
self.assertIn(stuff.platform_siteb2_id, ids[RT.PlatformSite])
self.assertIn(stuff.platform_site3_id, ids[RT.PlatformSite])
self.assertIn(stuff.subsite_id, ids[RT.Subsite])
self.assertIn(stuff.subsite2_id, ids[RT.Subsite])
self.assertIn(stuff.subsitez_id, ids[RT.Subsite])
self.assertIn(stuff.subsiteb_id, ids[RT.Subsite])
self.assertNotIn(RT.InstrumentSite, ids)
#partial traversal, only down to platform
ids = short(stuff.instrument_site_id, [RT.Subsite, RT.PlatformSite])
self.assertIn(RT.PlatformSite, ids)
self.assertIn(RT.Subsite, ids)
self.assertIn(stuff.platform_siteb_id, ids[RT.PlatformSite])
self.assertIn(stuff.platform_site_id, ids[RT.PlatformSite])
self.assertIn(stuff.subsite_id, ids[RT.Subsite])
self.assertIn(stuff.subsiteb_id, ids[RT.Subsite])
self.assertNotIn(stuff.subsite2_id, ids[RT.Subsite])
self.assertNotIn(stuff.subsitez_id, ids[RT.Subsite])
self.assertNotIn(stuff.platform_siteb2_id, ids[RT.PlatformSite])
self.assertNotIn(RT.Observatory, ids)
self.destroy(stuff)
def _make_associations(self):
"""
create one of each resource and association used by OMS
to guard against problems in ion-definitions
"""
#raise unittest.SkipTest("https://jira.oceanobservatories.org/tasks/browse/CISWCORE-41")
"""
the tree we're creating (observatory, sites, platforms, instruments)
rows are lettered, colums numbered.
- first row is implied a
- first column is implied 1
- site Z, just because
O--Sz
|
S--S2--P3--I4
|
Sb-Pb2-Ib3
|
P--I2 <- PlatformDevice, InstrumentDevice2
|
Pb <- PlatformDevice b
|
I <- InstrumentDevice
"""
org_id = self.OMS.create_marine_facility(any_old(RT.Org))
def create_under_org(resource_type, extra_fields=None):
obj = any_old(resource_type, extra_fields)
if RT.InstrumentDevice == resource_type:
resource_id = self.IMS.create_instrument_device(obj)
else:
resource_id, _ = self.RR.create(obj)
self.OMS.assign_resource_to_observatory_org(
resource_id=resource_id, org_id=org_id)
return resource_id
#stuff we control
observatory_id = create_under_org(RT.Observatory)
subsite_id = create_under_org(RT.Subsite)
subsite2_id = create_under_org(RT.Subsite)
subsiteb_id = create_under_org(RT.Subsite)
subsitez_id = create_under_org(RT.Subsite)
platform_site_id = create_under_org(RT.PlatformSite)
platform_siteb_id = create_under_org(RT.PlatformSite)
platform_siteb2_id = create_under_org(RT.PlatformSite)
platform_site3_id = create_under_org(RT.PlatformSite)
instrument_site_id = create_under_org(RT.InstrumentSite)
instrument_site2_id = create_under_org(RT.InstrumentSite)
instrument_siteb3_id = create_under_org(RT.InstrumentSite)
instrument_site4_id = create_under_org(RT.InstrumentSite)
#stuff we associate to
instrument_device_id = create_under_org(RT.InstrumentDevice)
instrument_device2_id = create_under_org(RT.InstrumentDevice)
platform_device_id = create_under_org(RT.PlatformDevice)
platform_deviceb_id = create_under_org(RT.PlatformDevice)
instrument_model_id, _ = self.RR.create(any_old(RT.InstrumentModel))
platform_model_id, _ = self.RR.create(any_old(RT.PlatformModel))
deployment_id, _ = self.RR.create(any_old(RT.Deployment))
# marine tracking resources
asset_id = create_under_org(RT.Asset)
asset_type_id = create_under_org(RT.AssetType)
event_duration_id = create_under_org(RT.EventDuration)
event_duration_type_id = create_under_org(RT.EventDurationType)
#observatory
self.RR.create_association(observatory_id, PRED.hasSite, subsite_id)
self.RR.create_association(observatory_id, PRED.hasSite, subsitez_id)
#site
self.RR.create_association(subsite_id, PRED.hasSite, subsite2_id)
self.RR.create_association(subsite_id, PRED.hasSite, subsiteb_id)
self.RR.create_association(subsite2_id, PRED.hasSite,
platform_site3_id)
self.RR.create_association(subsiteb_id, PRED.hasSite,
platform_siteb2_id)
self.RR.create_association(subsiteb_id, PRED.hasSite, platform_site_id)
#platform_site(s)
self.RR.create_association(platform_site3_id, PRED.hasSite,
instrument_site4_id)
self.RR.create_association(platform_siteb2_id, PRED.hasSite,
instrument_siteb3_id)
self.RR.create_association(platform_site_id, PRED.hasSite,
instrument_site2_id)
self.RR.create_association(platform_site_id, PRED.hasSite,
platform_siteb_id)
self.RR.create_association(platform_siteb_id, PRED.hasSite,
instrument_site_id)
self.RR.create_association(platform_siteb_id, PRED.hasDevice,
platform_deviceb_id)
#test network parent link
self.OMS.assign_device_to_network_parent(platform_device_id,
platform_deviceb_id)
self.RR.create_association(platform_site_id, PRED.hasModel,
platform_model_id)
self.RR.create_association(platform_site_id, PRED.hasDevice,
platform_device_id)
self.RR.create_association(platform_site_id, PRED.hasDeployment,
deployment_id)
#instrument_site(s)
self.RR.create_association(instrument_site_id, PRED.hasModel,
instrument_model_id)
self.RR.create_association(instrument_site_id, PRED.hasDevice,
instrument_device_id)
self.RR.create_association(instrument_site_id, PRED.hasDeployment,
deployment_id)
self.RR.create_association(instrument_site2_id, PRED.hasDevice,
instrument_device2_id)
#platform_device
self.RR.create_association(platform_device_id, PRED.hasModel,
platform_model_id)
#instrument_device
self.RR.create_association(instrument_device_id, PRED.hasModel,
instrument_model_id)
self.RR.create_association(instrument_device2_id, PRED.hasModel,
instrument_model_id)
ret = DotDict()
ret.org_id = org_id
ret.observatory_id = observatory_id
ret.subsite_id = subsite_id
ret.subsite2_id = subsite2_id
ret.subsiteb_id = subsiteb_id
ret.subsitez_id = subsitez_id
ret.platform_site_id = platform_site_id
ret.platform_siteb_id = platform_siteb_id
ret.platform_siteb2_id = platform_siteb2_id
ret.platform_site3_id = platform_site3_id
ret.instrument_site_id = instrument_site_id
ret.instrument_site2_id = instrument_site2_id
ret.instrument_siteb3_id = instrument_siteb3_id
ret.instrument_site4_id = instrument_site4_id
ret.instrument_device_id = instrument_device_id
ret.instrument_device2_id = instrument_device2_id
ret.platform_device_id = platform_device_id
ret.platform_deviceb_id = platform_deviceb_id
ret.instrument_model_id = instrument_model_id
ret.platform_model_id = platform_model_id
ret.deployment_id = deployment_id
ret.asset_id = asset_id
ret.asset_type_id = asset_type_id
ret.event_duration_id = event_duration_id
ret.event_duration_type_id = event_duration_type_id
return ret
#@unittest.skip("targeting")
def test_create_observatory(self):
observatory_obj = IonObject(RT.Observatory,
name='TestFacility',
description='some new mf')
observatory_id = self.OMS.create_observatory(observatory_obj)
self.OMS.force_delete_observatory(observatory_id)
#@unittest.skip("targeting")
def _do_test_create_geospatial_point_center(self, resources):
platformsite_obj = IonObject(RT.PlatformSite,
name='TestPlatformSite',
description='some new TestPlatformSite')
geo_index_obj = IonObject(OT.GeospatialBounds)
geo_index_obj.geospatial_latitude_limit_north = 20.0
geo_index_obj.geospatial_latitude_limit_south = 10.0
geo_index_obj.geospatial_longitude_limit_east = 15.0
geo_index_obj.geospatial_longitude_limit_west = 20.0
platformsite_obj.constraint_list = [geo_index_obj]
platformsite_id = self.OMS.create_platform_site(platformsite_obj)
# now get the dp back to see if it was updated
platformsite_obj = self.OMS.read_platform_site(platformsite_id)
self.assertEquals('some new TestPlatformSite',
platformsite_obj.description)
self.assertAlmostEqual(15.0,
platformsite_obj.geospatial_point_center.lat,
places=1)
#now adjust a few params
platformsite_obj.description = 'some old TestPlatformSite'
geo_index_obj = IonObject(OT.GeospatialBounds)
geo_index_obj.geospatial_latitude_limit_north = 30.0
geo_index_obj.geospatial_latitude_limit_south = 20.0
platformsite_obj.constraint_list = [geo_index_obj]
update_result = self.OMS.update_platform_site(platformsite_obj)
# now get the dp back to see if it was updated
platformsite_obj = self.OMS.read_platform_site(platformsite_id)
self.assertEquals('some old TestPlatformSite',
platformsite_obj.description)
self.assertAlmostEqual(25.0,
platformsite_obj.geospatial_point_center.lat,
places=1)
self.OMS.force_delete_platform_site(platformsite_id)
#@unittest.skip("targeting")
def _do_test_find_observatory_org(self, resources):
log.debug("Make TestOrg")
org_obj = IonObject(RT.Org,
name='TestOrg',
description='some new mf org')
org_id = self.OMS.create_marine_facility(org_obj)
log.debug("Make Observatory")
observatory_obj = IonObject(RT.Observatory,
name='TestObservatory',
description='some new obs')
observatory_id = self.OMS.create_observatory(observatory_obj)
log.debug("assign observatory to org")
self.OMS.assign_resource_to_observatory_org(observatory_id, org_id)
log.debug("verify assigment")
org_objs = self.OMS.find_org_by_observatory(observatory_id)
self.assertEqual(1, len(org_objs))
self.assertEqual(org_id, org_objs[0]._id)
log.debug("org_id=<" + org_id + ">")
log.debug("create a subsite with parent Observatory")
subsite_obj = IonObject(RT.Subsite,
name='TestSubsite',
description='sample subsite')
subsite_id = self.OMS.create_subsite(subsite_obj, observatory_id)
self.assertIsNotNone(subsite_id, "Subsite not created.")
log.debug("verify that Subsite is linked to Observatory")
mf_subsite_assoc = self.RR.get_association(observatory_id,
PRED.hasSite, subsite_id)
self.assertIsNotNone(mf_subsite_assoc,
"Subsite not connected to Observatory.")
log.debug("add the Subsite as a resource of this Observatory")
self.OMS.assign_resource_to_observatory_org(resource_id=subsite_id,
org_id=org_id)
log.debug("verify that Subsite is linked to Org")
org_subsite_assoc = self.RR.get_association(org_id, PRED.hasResource,
subsite_id)
self.assertIsNotNone(org_subsite_assoc,
"Subsite not connected as resource to Org.")
log.debug("create a logical platform with parent Subsite")
platform_site_obj = IonObject(RT.PlatformSite,
name='TestPlatformSite',
description='sample logical platform')
platform_site_id = self.OMS.create_platform_site(
platform_site_obj, subsite_id)
self.assertIsNotNone(platform_site_id, "PlatformSite not created.")
log.debug("verify that PlatformSite is linked to Site")
site_lp_assoc = self.RR.get_association(subsite_id, PRED.hasSite,
platform_site_id)
self.assertIsNotNone(site_lp_assoc,
"PlatformSite not connected to Site.")
log.debug("add the PlatformSite as a resource of this Observatory")
self.OMS.assign_resource_to_observatory_org(
resource_id=platform_site_id, org_id=org_id)
log.debug("verify that PlatformSite is linked to Org")
org_lp_assoc = self.RR.get_association(org_id, PRED.hasResource,
platform_site_id)
self.assertIsNotNone(org_lp_assoc,
"PlatformSite not connected as resource to Org.")
log.debug("create a logical instrument with parent logical platform")
instrument_site_obj = IonObject(
RT.InstrumentSite,
name='TestInstrumentSite',
description='sample logical instrument')
instrument_site_id = self.OMS.create_instrument_site(
instrument_site_obj, platform_site_id)
self.assertIsNotNone(instrument_site_id, "InstrumentSite not created.")
log.debug("verify that InstrumentSite is linked to PlatformSite")
li_lp_assoc = self.RR.get_association(platform_site_id, PRED.hasSite,
instrument_site_id)
self.assertIsNotNone(li_lp_assoc,
"InstrumentSite not connected to PlatformSite.")
log.debug("add the InstrumentSite as a resource of this Observatory")
self.OMS.assign_resource_to_observatory_org(
resource_id=instrument_site_id, org_id=org_id)
log.debug("verify that InstrumentSite is linked to Org")
org_li_assoc = self.RR.get_association(org_id, PRED.hasResource,
instrument_site_id)
self.assertIsNotNone(
org_li_assoc, "InstrumentSite not connected as resource to Org.")
log.debug(
"remove the InstrumentSite as a resource of this Observatory")
self.OMS.unassign_resource_from_observatory_org(
instrument_site_id, org_id)
log.debug("verify that InstrumentSite is linked to Org")
assocs, _ = self.RR.find_objects(org_id,
PRED.hasResource,
RT.InstrumentSite,
id_only=True)
self.assertEqual(0, len(assocs))
log.debug(
"remove the InstrumentSite, association should drop automatically")
self.OMS.delete_instrument_site(instrument_site_id)
assocs, _ = self.RR.find_objects(platform_site_id,
PRED.hasSite,
RT.InstrumentSite,
id_only=True)
self.assertEqual(0, len(assocs))
log.debug("remove the PlatformSite as a resource of this Observatory")
self.OMS.unassign_resource_from_observatory_org(
platform_site_id, org_id)
log.debug("verify that PlatformSite is linked to Org")
assocs, _ = self.RR.find_objects(org_id,
PRED.hasResource,
RT.PlatformSite,
id_only=True)
self.assertEqual(0, len(assocs))
log.debug("remove the Site as a resource of this Observatory")
self.OMS.unassign_resource_from_observatory_org(subsite_id, org_id)
log.debug("verify that Site is linked to Org")
assocs, _ = self.RR.find_objects(org_id,
PRED.hasResource,
RT.Subsite,
id_only=True)
self.assertEqual(0, len(assocs))
self.RR.delete(org_id)
self.OMS.force_delete_observatory(observatory_id)
self.OMS.force_delete_subsite(subsite_id)
self.OMS.force_delete_platform_site(platform_site_id)
self.OMS.force_delete_instrument_site(instrument_site_id)
@attr('EXT')
@unittest.skipIf(os.getenv(
'CEI_LAUNCH_TEST', False
), 'Skip test while in CEI LAUNCH mode as it depends on modifying CFG on service side'
)
def test_observatory_extensions(self):
self.patch_cfg(CFG["container"],
{"extended_resources": {
"strip_results": False
}})
obs_id = self.RR2.create(any_old(RT.Observatory))
pss_id = self.RR2.create(
any_old(RT.PlatformSite, dict(alt_resource_type="StationSite")))
pas_id = self.RR2.create(
any_old(RT.PlatformSite,
dict(alt_resource_type="PlatformAssemblySite")))
pcs_id = self.RR2.create(
any_old(RT.PlatformSite,
dict(alt_resource_type="PlatformComponentSite")))
ins_id = self.RR2.create(any_old(RT.InstrumentSite))
obs_obj = self.RR2.read(obs_id)
pss_obj = self.RR2.read(pss_id)
pas_obj = self.RR2.read(pas_id)
pcs_obj = self.RR2.read(pcs_id)
ins_obj = self.RR2.read(ins_id)
self.RR2.create_association(obs_id, PRED.hasSite, pss_id)
self.RR2.create_association(pss_id, PRED.hasSite, pas_id)
self.RR2.create_association(pas_id, PRED.hasSite, pcs_id)
self.RR2.create_association(pcs_id, PRED.hasSite, ins_id)
extended_obs = self.OMS.get_observatory_site_extension(obs_id,
user_id=12345)
self.assertEqual([pss_obj], extended_obs.platform_station_sites)
self.assertEqual([pas_obj], extended_obs.platform_assembly_sites)
self.assertEqual([pcs_obj], extended_obs.platform_component_sites)
self.assertEqual([ins_obj], extended_obs.instrument_sites)
extended_pss = self.OMS.get_observatory_site_extension(obs_id,
user_id=12345)
self.assertEqual([pas_obj], extended_pss.platform_assembly_sites)
self.assertEqual([pcs_obj], extended_pss.platform_component_sites)
self.assertEqual([ins_obj], extended_pss.instrument_sites)
extended_pas = self.OMS.get_observatory_site_extension(pas_id,
user_id=12345)
self.assertEqual([pcs_obj], extended_pas.platform_component_sites)
self.assertEqual([ins_obj], extended_pas.instrument_sites)
extended_pcs = self.OMS.get_platform_component_site_extension(
pcs_id, user_id=12345)
self.assertEqual([ins_obj], extended_pcs.instrument_sites)
#@unittest.skip("in development...")
@attr('EXT')
@attr('EXT1')
@unittest.skipIf(os.getenv(
'CEI_LAUNCH_TEST', False
), 'Skip test while in CEI LAUNCH mode as it depends on modifying CFG on service side'
)
def test_observatory_org_extended(self):
self.patch_cfg(CFG["container"],
{"extended_resources": {
"strip_results": False
}})
stuff = self._make_associations()
parsed_pdict_id = self.dataset_management.read_parameter_dictionary_by_name(
'ctd_parsed_param_dict', id_only=True)
parsed_stream_def_id = self.pubsubcli.create_stream_definition(
name='parsed', parameter_dictionary_id=parsed_pdict_id)
dp_obj = IonObject(RT.DataProduct,
name='the parsed data',
description='ctd stream test')
data_product_id1 = self.dpclient.create_data_product(
data_product=dp_obj, stream_definition_id=parsed_stream_def_id)
self.damsclient.assign_data_product(
input_resource_id=stuff.instrument_device_id,
data_product_id=data_product_id1)
#Create a user to be used as regular member
member_actor_obj = IonObject(RT.ActorIdentity, name='org member actor')
member_actor_id, _ = self.RR.create(member_actor_obj)
assert (member_actor_id)
member_actor_header = get_actor_header(member_actor_id)
member_user_obj = IonObject(RT.UserInfo, name='org member user')
member_user_id, _ = self.RR.create(member_user_obj)
assert (member_user_id)
self.RR.create_association(subject=member_actor_id,
predicate=PRED.hasInfo,
object=member_user_id)
#Build the Service Agreement Proposal to enroll a user actor
sap = IonObject(OT.EnrollmentProposal,
consumer=member_actor_id,
provider=stuff.org_id)
sap_response = self.org_management_service.negotiate(
sap, headers=member_actor_header)
#enroll the member without using negotiation
self.org_management_service.enroll_member(org_id=stuff.org_id,
actor_id=member_actor_id)
#--------------------------------------------------------------------------------
# Get the extended Site (platformSite)
#--------------------------------------------------------------------------------
try:
extended_site = self.OMS.get_site_extension(stuff.platform_site_id)
except:
log.error('failed to get extended site', exc_info=True)
raise
log.debug("extended_site: %r ", extended_site)
self.assertEquals(stuff.subsiteb_id, extended_site.parent_site._id)
self.assertEqual(2, len(extended_site.sites))
self.assertEqual(2, len(extended_site.platform_devices))
self.assertEqual(2, len(extended_site.platform_models))
self.assertIn(stuff.platform_device_id,
[o._id for o in extended_site.platform_devices])
self.assertIn(
stuff.platform_model_id,
[o._id for o in extended_site.platform_models if o is not None])
log.debug(
"verify that PlatformDeviceb is linked to PlatformDevice with hasNetworkParent link"
)
associations = self.RR.find_associations(
subject=stuff.platform_deviceb_id,
predicate=PRED.hasNetworkParent,
object=stuff.platform_device_id,
id_only=True)
self.assertIsNotNone(
associations,
"PlatformDevice child not connected to PlatformDevice parent.")
#--------------------------------------------------------------------------------
# Get the extended Org
#--------------------------------------------------------------------------------
#test the extended resource
extended_org = self.OMS.get_marine_facility_extension(stuff.org_id)
log.debug("test_observatory_org_extended: extended_org: %s ",
str(extended_org))
#self.assertEqual(2, len(extended_org.instruments_deployed) )
#self.assertEqual(1, len(extended_org.platforms_not_deployed) )
self.assertEqual(2, extended_org.number_of_platforms)
self.assertEqual(2, len(extended_org.platform_models))
self.assertEqual(2, extended_org.number_of_instruments)
self.assertEqual(2, len(extended_org.instrument_models))
self.assertEqual(1, len(extended_org.members))
self.assertNotEqual(extended_org.members[0]._id, member_actor_id)
self.assertEqual(extended_org.members[0]._id, member_user_id)
self.assertEqual(1, len(extended_org.open_requests))
self.assertTrue(len(extended_site.deployments) > 0)
self.assertEqual(len(extended_site.deployments),
len(extended_site.deployment_info))
self.assertEqual(1, extended_org.number_of_assets)
self.assertEqual(1, extended_org.number_of_asset_types)
self.assertEqual(1, extended_org.number_of_event_durations)
self.assertEqual(1, extended_org.number_of_event_duration_types)
#test the extended resource of the ION org
ion_org_id = self.org_management_service.find_org()
extended_org = self.OMS.get_marine_facility_extension(ion_org_id._id,
user_id=12345)
log.debug("test_observatory_org_extended: extended_ION_org: %s ",
str(extended_org))
self.assertEqual(1, len(extended_org.members))
self.assertEqual(0, extended_org.number_of_platforms)
#self.assertEqual(1, len(extended_org.sites))
#--------------------------------------------------------------------------------
# Get the extended Site
#--------------------------------------------------------------------------------
#create device state events to use for op /non-op filtering in extended
t = get_ion_ts()
self.event_publisher.publish_event(
ts_created=t,
event_type='ResourceAgentStateEvent',
origin=stuff.instrument_device_id,
state=ResourceAgentState.STREAMING)
self.event_publisher.publish_event(
ts_created=t,
event_type='ResourceAgentStateEvent',
origin=stuff.instrument_device2_id,
state=ResourceAgentState.INACTIVE)
extended_site = self.OMS.get_site_extension(stuff.instrument_site2_id)
log.debug("test_observatory_org_extended: extended_site: %s ",
str(extended_site))
self.dpclient.delete_data_product(data_product_id1)
class TestIdentityManagementServiceInt(IonIntegrationTestCase):
def setUp(self):
self.subject = "/DC=org/DC=cilogon/C=US/O=ProtectNetwork/CN=Roger Unwin A254"
# Start container
self._start_container()
self.container.start_rel_from_url('res/deploy/r2deploy.yml')
self.resource_registry = ResourceRegistryServiceClient(
node=self.container.node)
self.identity_management_service = IdentityManagementServiceClient(
node=self.container.node)
self.org_client = OrgManagementServiceClient(node=self.container.node)
def test_actor_identity(self):
actor_identity_obj = IonObject("ActorIdentity", {"name": self.subject})
user_id = self.identity_management_service.create_actor_identity(
actor_identity_obj)
actor_identity = self.identity_management_service.read_actor_identity(
user_id)
actor_identity.name = 'Updated subject'
self.identity_management_service.update_actor_identity(actor_identity)
ai = self.identity_management_service.find_actor_identity_by_name(
actor_identity.name)
self._baseAssertEqual(ai.name, actor_identity.name)
with self.assertRaises(NotFound):
ai = self.identity_management_service.find_actor_identity_by_name(
"Yeah, well, you know, that's just, like, your opinion, man.")
self._baseAssertEqual(ai.name, actor_identity.name)
self.identity_management_service.delete_actor_identity(user_id)
with self.assertRaises(NotFound) as cm:
self.identity_management_service.read_actor_identity(user_id)
self.assertTrue("does not exist" in cm.exception.message)
with self.assertRaises(NotFound) as cm:
self.identity_management_service.delete_actor_identity(user_id)
self.assertTrue("does not exist" in cm.exception.message)
def test_user_credentials(self):
actor_identity_obj = IonObject("ActorIdentity", {"name": self.subject})
user_id = self.identity_management_service.create_actor_identity(
actor_identity_obj)
user_credentials_obj = IonObject("UserCredentials",
{"name": self.subject})
self.identity_management_service.register_user_credentials(
user_id, user_credentials_obj)
with self.assertRaises(NotFound) as cm:
self.identity_management_service.unregister_user_credentials(
"bad", self.subject)
self.assertTrue("does not exist" in cm.exception.message)
with self.assertRaises(NotFound) as cm:
self.identity_management_service.unregister_user_credentials(
user_id, "bad")
self.assertTrue("does not exist" in cm.exception.message)
with self.assertRaises(NotFound) as cm:
self.identity_management_service.unregister_user_credentials(
'bad', 'bad')
self.assertTrue("does not exist" in cm.exception.message)
self.identity_management_service.unregister_user_credentials(
user_id, self.subject)
self.identity_management_service.delete_actor_identity(user_id)
def test_user_info(self):
actor_identity_obj = IonObject("ActorIdentity", {"name": self.subject})
user_id = self.identity_management_service.create_actor_identity(
actor_identity_obj)
user_credentials_obj = IonObject("UserCredentials",
{"name": self.subject})
self.identity_management_service.register_user_credentials(
user_id, user_credentials_obj)
user_info_obj = IonObject("UserInfo", {"name": "Foo"})
user_info = self.identity_management_service.create_user_info(
user_id, user_info_obj)
with self.assertRaises(Conflict) as cm:
self.identity_management_service.create_user_info(
user_id, user_info_obj)
self.assertTrue(
"UserInfo already exists for user id" in cm.exception.message)
user_info_obj = self.identity_management_service.find_user_info_by_id(
user_id)
user_info_obj = self.identity_management_service.find_user_info_by_name(
"Foo")
user_info_obj = self.identity_management_service.find_user_info_by_subject(
self.subject)
user_info_obj = self.identity_management_service.read_user_info(
user_info)
user_info_obj.name = 'Jane Doe'
self.identity_management_service.update_user_info(user_info_obj)
self.identity_management_service.delete_user_info(user_info)
with self.assertRaises(NotFound) as cm:
self.identity_management_service.read_user_info(user_info)
self.assertTrue('does not exist' in cm.exception.message)
with self.assertRaises(NotFound) as cm:
self.identity_management_service.delete_user_info(user_info)
self.assertTrue('does not exist' in cm.exception.message)
with self.assertRaises(NotFound) as cm:
self.identity_management_service.find_user_info_by_name("John Doe")
self.assertEqual(cm.exception.message,
'UserInfo with name John Doe does not exist')
with self.assertRaises(NotFound) as cm:
self.identity_management_service.find_user_info_by_subject(
"Bogus subject")
self.assertEqual(
cm.exception.message,
"UserCredentials with subject Bogus subject does not exist")
self.identity_management_service.unregister_user_credentials(
user_id, self.subject)
self.identity_management_service.delete_actor_identity(user_id)
def test_signon(self):
certificate = """-----BEGIN CERTIFICATE-----
MIIEMzCCAxugAwIBAgICBQAwDQYJKoZIhvcNAQEFBQAwajETMBEGCgmSJomT8ixkARkWA29yZzEX
MBUGCgmSJomT8ixkARkWB2NpbG9nb24xCzAJBgNVBAYTAlVTMRAwDgYDVQQKEwdDSUxvZ29uMRsw
GQYDVQQDExJDSUxvZ29uIEJhc2ljIENBIDEwHhcNMTAxMTE4MjIyNTA2WhcNMTAxMTE5MTAzMDA2
WjBvMRMwEQYKCZImiZPyLGQBGRMDb3JnMRcwFQYKCZImiZPyLGQBGRMHY2lsb2dvbjELMAkGA1UE
BhMCVVMxFzAVBgNVBAoTDlByb3RlY3ROZXR3b3JrMRkwFwYDVQQDExBSb2dlciBVbndpbiBBMjU0
MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA6QhsWxhUXbIxg+1ZyEc7d+hIGvchVmtb
g0kKLmivgoVsA4U7swNDRH6svW242THta0oTf6crkRx7kOKg6jma2lcAC1sjOSddqX7/92ChoUPq
7LWt2T6GVVA10ex5WAeB/o7br/Z4U8/75uCBis+ru7xEDl09PToK20mrkcz9M4HqIv1eSoPkrs3b
2lUtQc6cjuHRDU4NknXaVMXTBHKPM40UxEDHJueFyCiZJFg3lvQuSsAl4JL5Z8pC02T8/bODBuf4
dszsqn2SC8YDw1xrujvW2Bd7Q7BwMQ/gO+dZKM1mLJFpfEsR9WrjMeg6vkD2TMWLMr0/WIkGC8u+
6M6SMQIDAQABo4HdMIHaMAwGA1UdEwEB/wQCMAAwDgYDVR0PAQH/BAQDAgSwMBMGA1UdJQQMMAoG
CCsGAQUFBwMCMBgGA1UdIAQRMA8wDQYLKwYBBAGCkTYBAgEwagYDVR0fBGMwYTAuoCygKoYoaHR0
cDovL2NybC5jaWxvZ29uLm9yZy9jaWxvZ29uLWJhc2ljLmNybDAvoC2gK4YpaHR0cDovL2NybC5k
b2Vncmlkcy5vcmcvY2lsb2dvbi1iYXNpYy5jcmwwHwYDVR0RBBgwFoEUaXRzYWdyZWVuMUB5YWhv
by5jb20wDQYJKoZIhvcNAQEFBQADggEBAEYHQPMY9Grs19MHxUzMwXp1GzCKhGpgyVKJKW86PJlr
HGruoWvx+DLNX75Oj5FC4t8bOUQVQusZGeGSEGegzzfIeOI/jWP1UtIjzvTFDq3tQMNvsgROSCx5
CkpK4nS0kbwLux+zI7BWON97UpMIzEeE05pd7SmNAETuWRsHMP+x6i7hoUp/uad4DwbzNUGIotdK
f8b270icOVgkOKRdLP/Q4r/x8skKSCRz1ZsRdR+7+B/EgksAJj7Ut3yiWoUekEMxCaTdAHPTMD/g
Mh9xL90hfMJyoGemjJswG5g3fAdTP/Lv0I6/nWeH/cLjwwpQgIEjEAVXl7KHuzX5vPD/wqQ=
-----END CERTIFICATE-----"""
id, valid_until, registered = self.identity_management_service.signon(
certificate, True)
self.assertFalse(registered)
id2, valid_until2, registered2 = self.identity_management_service.signon(
certificate, True)
self.assertFalse(registered2)
self.assertTrue(id == id2)
self.assertTrue(valid_until == valid_until2)
user_info_obj = IonObject("UserInfo", {"name": "Foo"})
self.identity_management_service.create_user_info(id, user_info_obj)
id3, valid_until3, registered3 = self.identity_management_service.signon(
certificate, True)
self.assertTrue(registered3)
self.assertTrue(id == id3)
self.assertTrue(valid_until == valid_until3)
@attr('EXT')
def test_get_extended_user_identity(self):
actor_identity_obj = IonObject("ActorIdentity", {"name": self.subject})
actor_id = self.identity_management_service.create_actor_identity(
actor_identity_obj)
user_credentials_obj = IonObject("UserCredentials",
{"name": self.subject})
self.identity_management_service.register_user_credentials(
actor_id, user_credentials_obj)
user_info_obj = IonObject("UserInfo", {"name": "Foo"})
user_info_id = self.identity_management_service.create_user_info(
actor_id, user_info_obj)
ion_org = self.org_client.find_org()
#Build the Service Agreement Proposal to to request a role but never close it
sap = IonObject(OT.RequestRoleProposal,
consumer=actor_id,
provider=ion_org._id,
role_name=ORG_MANAGER_ROLE)
sap_response = self.org_client.negotiate(sap)
#Just grant the role anyway
#self.org_client.grant_role(ion_org._id, actor_id, ORG_MANAGER_ROLE)
with self.assertRaises(NotFound):
self.identity_management_service.get_user_info_extension(
'That rug really tied the room together.')
with self.assertRaises(BadRequest):
self.identity_management_service.get_user_info_extension()
#Check the user without the negotiation role request
extended_user = self.identity_management_service.get_user_info_extension(
user_info_id, org_id=ion_org._id)
self.assertEqual(user_info_obj.type_, extended_user.resource.type_)
self.assertEqual(len(extended_user.roles), 1)
self.assertEqual(len(extended_user.open_requests), 1)
self.assertEqual(extended_user.open_requests[0].org_id, ion_org._id)
self.assertEqual(extended_user.open_requests[0].user_id, user_info_id)
self.assertEqual(extended_user.open_requests[0].request_type,
OT.RequestRoleProposal)
self.assertEqual(len(extended_user.closed_requests), 0)
self.assertEqual(extended_user.open_requests[0]._id,
extended_user.open_requests[0].negotiation_id)
neg = self.resource_registry.read(
object_id=extended_user.open_requests[0].negotiation_id)
sap_response = Negotiation.create_counter_proposal(
neg, ProposalStatusEnum.ACCEPTED, ProposalOriginatorEnum.PROVIDER)
sap_response2 = self.org_client.negotiate(sap_response)
#Now check the user after the negotiation has been accepted and the role granted
extended_user = self.identity_management_service.get_user_info_extension(
user_info_id, org_id=ion_org._id)
self.assertEqual(user_info_obj.type_, extended_user.resource.type_)
self.assertEqual(len(extended_user.roles), 2)
self.assertEqual(len(extended_user.open_requests), 0)
self.assertEqual(len(extended_user.closed_requests), 1)
self.assertEqual(extended_user.closed_requests[0].org_id, ion_org._id)
self.assertEqual(extended_user.closed_requests[0].user_id,
user_info_id)
self.assertEqual(extended_user.closed_requests[0].request_type,
OT.RequestRoleProposal)
self.identity_management_service.delete_user_info(user_info_id)
self.org_client.revoke_role(org_id=ion_org._id,
actor_id=actor_id,
role_name=ORG_MANAGER_ROLE)
self.identity_management_service.unregister_user_credentials(
actor_id, self.subject)
self.identity_management_service.delete_actor_identity(actor_id)
def test_account_merge(self):
certificate = """-----BEGIN CERTIFICATE-----
MIIEMzCCAxugAwIBAgICBQAwDQYJKoZIhvcNAQEFBQAwajETMBEGCgmSJomT8ixkARkWA29yZzEX
MBUGCgmSJomT8ixkARkWB2NpbG9nb24xCzAJBgNVBAYTAlVTMRAwDgYDVQQKEwdDSUxvZ29uMRsw
GQYDVQQDExJDSUxvZ29uIEJhc2ljIENBIDEwHhcNMTAxMTE4MjIyNTA2WhcNMTAxMTE5MTAzMDA2
WjBvMRMwEQYKCZImiZPyLGQBGRMDb3JnMRcwFQYKCZImiZPyLGQBGRMHY2lsb2dvbjELMAkGA1UE
BhMCVVMxFzAVBgNVBAoTDlByb3RlY3ROZXR3b3JrMRkwFwYDVQQDExBSb2dlciBVbndpbiBBMjU0
MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA6QhsWxhUXbIxg+1ZyEc7d+hIGvchVmtb
g0kKLmivgoVsA4U7swNDRH6svW242THta0oTf6crkRx7kOKg6jma2lcAC1sjOSddqX7/92ChoUPq
7LWt2T6GVVA10ex5WAeB/o7br/Z4U8/75uCBis+ru7xEDl09PToK20mrkcz9M4HqIv1eSoPkrs3b
2lUtQc6cjuHRDU4NknXaVMXTBHKPM40UxEDHJueFyCiZJFg3lvQuSsAl4JL5Z8pC02T8/bODBuf4
dszsqn2SC8YDw1xrujvW2Bd7Q7BwMQ/gO+dZKM1mLJFpfEsR9WrjMeg6vkD2TMWLMr0/WIkGC8u+
6M6SMQIDAQABo4HdMIHaMAwGA1UdEwEB/wQCMAAwDgYDVR0PAQH/BAQDAgSwMBMGA1UdJQQMMAoG
CCsGAQUFBwMCMBgGA1UdIAQRMA8wDQYLKwYBBAGCkTYBAgEwagYDVR0fBGMwYTAuoCygKoYoaHR0
cDovL2NybC5jaWxvZ29uLm9yZy9jaWxvZ29uLWJhc2ljLmNybDAvoC2gK4YpaHR0cDovL2NybC5k
b2Vncmlkcy5vcmcvY2lsb2dvbi1iYXNpYy5jcmwwHwYDVR0RBBgwFoEUaXRzYWdyZWVuMUB5YWhv
by5jb20wDQYJKoZIhvcNAQEFBQADggEBAEYHQPMY9Grs19MHxUzMwXp1GzCKhGpgyVKJKW86PJlr
HGruoWvx+DLNX75Oj5FC4t8bOUQVQusZGeGSEGegzzfIeOI/jWP1UtIjzvTFDq3tQMNvsgROSCx5
CkpK4nS0kbwLux+zI7BWON97UpMIzEeE05pd7SmNAETuWRsHMP+x6i7hoUp/uad4DwbzNUGIotdK
f8b270icOVgkOKRdLP/Q4r/x8skKSCRz1ZsRdR+7+B/EgksAJj7Ut3yiWoUekEMxCaTdAHPTMD/g
Mh9xL90hfMJyoGemjJswG5g3fAdTP/Lv0I6/nWeH/cLjwwpQgIEjEAVXl7KHuzX5vPD/wqQ=
-----END CERTIFICATE-----"""
subject = "/DC=org/DC=cilogon/C=US/O=ProtectNetwork/CN=Roger Unwin A254"
certificate_2 = """-----BEGIN CERTIFICATE-----
MIIEMzCCAxugAwIBAgIDAJ/lMA0GCSqGSIb3DQEBCwUAMGsxEzARBgoJkiaJk/IsZAEZFgNvcmcx
FzAVBgoJkiaJk/IsZAEZFgdjaWxvZ29uMQswCQYDVQQGEwJVUzEQMA4GA1UEChMHQ0lMb2dvbjEc
MBoGA1UEAxMTQ0lMb2dvbiBPcGVuSUQgQ0EgMTAeFw0xMjEwMTcwMDE2NDlaFw0xMjEwMTcxMjIx
NDlaMGkxEzARBgoJkiaJk/IsZAEZEwNvcmcxFzAVBgoJkiaJk/IsZAEZEwdjaWxvZ29uMQswCQYD
VQQGEwJVUzEPMA0GA1UEChMGR29vZ2xlMRswGQYDVQQDExJPd2VuIE93bmVycmVwIEE4OTMwggEi
MA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDYLdpgg88sntivH+af4oamlp7blsUQcCQ5Yc/b
VDP/dwEKfxTcW36tMV3asLO7GcL7z4FESG761LAe86siT9rcwg2ttLkRjI9KeA3sFjC28N8XjKZ1
estCqG3odqw2pjo3VEFaU57219vIYMJhjmHKEgSnlMQeChMYun/sYIO5uNFba9BfiB6/PRS+bgee
cXRsIAm1vkB89AHdEjqdvH0uSN+jGjF6aAPXsESh70DUAHzs14lbFAomig7AZafT+weh0G5pnayC
lutVnhb9SyS3s1+A6kx8z9mkDUwY/NKXisuDeXa+WbRVq51D+Lc7ffOI+Ph+ynyfFGMcCBzbMADX
AgMBAAGjgeEwgd4wDAYDVR0TAQH/BAIwADAOBgNVHQ8BAf8EBAMCBLAwEwYDVR0lBAwwCgYIKwYB
BQUHAwIwGAYDVR0gBBEwDzANBgsrBgEEAYKRNgEDAzBsBgNVHR8EZTBjMC+gLaArhilodHRwOi8v
Y3JsLmNpbG9nb24ub3JnL2NpbG9nb24tb3BlbmlkLmNybDAwoC6gLIYqaHR0cDovL2NybC5kb2Vn
cmlkcy5vcmcvY2lsb2dvbi1vcGVuaWQuY3JsMCEGA1UdEQQaMBiBFm93ZW5vd25lcnJlcEBnbWFp
bC5jb20wDQYJKoZIhvcNAQELBQADggEBAHWd6ZOjSmJyOUyyLgZAPJpkSuk7DT5mFRhszJhfTGnu
gANHRIJZMs5e/LCMypE+ftxb8mnhAE+kURA2DmeucazHUDP5oYofU+8KMYqcNKnPpLnuiw+bCJPa
3BDxrYoi+vVislHb0U+QDjVYtUtQ2b1/Xhv8ShH89O9i65bbOq+sqez6z2AD9RWOEwRwpQLc9D65
9lkrsKGmJtuG8q3NTpZ1DSuaLOtn0QqttdmCg3pu5edRtgdpGadaSGR4s222JasV439bSTL8Z0Ug
HtjSclGqi8IBmvRkTZI61zTVbGdOKMP90LV1p8noJVLRkZpWRjLxI5xy9El8daAWMdjfrSc=
-----END CERTIFICATE-----"""
subject_2 = "/DC=org/DC=cilogon/C=US/O=Google/CN=Owen Ownerrep A893"
# Try to merge with nonexistent email account
with self.assertRaises(NotFound):
self.identity_management_service.initiate_account_merge(
"*****@*****.**")
with self.assertRaises(BadRequest):
self.identity_management_service.initiate_account_merge()
# Create two users
id, valid_until, registered = self.identity_management_service.signon(
certificate, True)
self.assertFalse(registered)
id_2, valid_until_2, registered_2 = self.identity_management_service.signon(
certificate_2, True)
self.assertFalse(registered_2)
# Validate the two accounts are different
self.assertNotEqual(
id, id_2, "The two accounts should have two different user id")
# Create UserInfo
contact_info_obj = IonObject("ContactInformation",
{"email": "*****@*****.**"})
user_info_obj = IonObject("UserInfo", {
"name": "Dude",
"contact": contact_info_obj
})
user_info_id = self.identity_management_service.create_user_info(
id, user_info_obj)
contact_info_obj_2 = IonObject("ContactInformation",
{"email": "*****@*****.**"})
user_info_obj_2 = IonObject("UserInfo", {
"name": "theDude",
"contact": contact_info_obj_2
})
user_info_id_2 = self.identity_management_service.create_user_info(
id_2, user_info_obj_2)
# Make sure the two users are registered
id, valid_until, registered = self.identity_management_service.signon(
certificate, True)
self.assertTrue(registered)
id_2, valid_until_2, registered_2 = self.identity_management_service.signon(
certificate_2, True)
self.assertTrue(registered_2)
token = self.identity_management_service.initiate_account_merge(
"*****@*****.**", headers={'ion-actor-id': id})
# Try merging accounts with invalid token string
with self.assertRaises(NotFound):
self.identity_management_service.complete_account_merge(
token_string="0xBeeF", headers={'ion-actor-id': id})
with self.assertRaises(BadRequest):
self.identity_management_service.complete_account_merge()
# Try merging accounts with a different user
# Since this user hasn't initiated account merge, the token doesn't exist in his/her UserInfo
with self.assertRaises(NotFound):
self.identity_management_service.complete_account_merge(
token, headers={'ion-actor-id': id_2})
self.identity_management_service.complete_account_merge(
token, headers={'ion-actor-id': id})
# Try merging the account again
with self.assertRaises(BadRequest):
self.identity_management_service.complete_account_merge(
token, headers={'ion-actor-id': id})
# Signon again and verify the two accounts have been merged
id, valid_until, registered = self.identity_management_service.signon(
certificate, True)
self.assertTrue(registered)
id_2, valid_until_2, registered_2 = self.identity_management_service.signon(
certificate_2, True)
self.assertTrue(registered_2)
# Validate the two accounts are the same
self.assertEqual(id, id_2, "The two accounts should have the same id")
# Try to merge to your own account
with self.assertRaises(BadRequest):
token = self.identity_management_service.initiate_account_merge(
"*****@*****.**", headers={'ion-actor-id': id})
# Done testing. Delete user
self.identity_management_service.delete_user_info(user_info_id)
self.identity_management_service.unregister_user_credentials(
id, subject)
self.identity_management_service.delete_actor_identity(id)
def instrument_test_driver(container):
org_client = OrgManagementServiceClient(node=container.node)
id_client = IdentityManagementServiceClient(node=container.node)
system_actor = id_client.find_actor_identity_by_name(name=CFG.system.system_actor)
log.info("system actor:" + system_actor._id)
sa_header_roles = get_role_message_headers(org_client.find_all_roles_by_user(system_actor._id))
# Names of agent data streams to be configured.
parsed_stream_name = "ctd_parsed"
raw_stream_name = "ctd_raw"
# Driver configuration.
# Simulator
driver_config = {
"svr_addr": "localhost",
"cmd_port": 5556,
"evt_port": 5557,
"dvr_mod": "ion.services.mi.drivers.sbe37_driver",
"dvr_cls": "SBE37Driver",
"comms_config": {
SBE37Channel.CTD: {
"method": "ethernet",
"device_addr": CFG.device.sbe37.host,
"device_port": CFG.device.sbe37.port,
"server_addr": "localhost",
"server_port": 8888,
}
},
}
# Hardware
_container_client = ContainerAgentClient(node=container.node, name=container.name)
# Create a pubsub client to create streams.
_pubsub_client = PubsubManagementServiceClient(node=container.node)
# A callback for processing subscribed-to data.
def consume(message, headers):
log.info("Subscriber received message: %s", str(message))
# Create a stream subscriber registrar to create subscribers.
subscriber_registrar = StreamSubscriberRegistrar(process=container, node=container.node)
subs = []
# Create streams for each stream named in driver.
stream_config = {}
for (stream_name, val) in PACKET_CONFIG.iteritems():
stream_def = ctd_stream_definition(stream_id=None)
stream_def_id = _pubsub_client.create_stream_definition(container=stream_def)
stream_id = _pubsub_client.create_stream(
name=stream_name,
stream_definition_id=stream_def_id,
original=True,
encoding="ION R2",
headers={"ion-actor-id": system_actor._id, "ion-actor-roles": sa_header_roles},
)
stream_config[stream_name] = stream_id
# Create subscriptions for each stream.
exchange_name = "%s_queue" % stream_name
sub = subscriber_registrar.create_subscriber(exchange_name=exchange_name, callback=consume)
sub.start()
query = StreamQuery(stream_ids=[stream_id])
sub_id = _pubsub_client.create_subscription(query=query, exchange_name=exchange_name)
_pubsub_client.activate_subscription(sub_id)
subs.append(sub)
# Create agent config.
agent_resource_id = "123xyz"
agent_config = {
"driver_config": driver_config,
"stream_config": stream_config,
"agent": {"resource_id": agent_resource_id},
}
# Launch an instrument agent process.
_ia_name = "agent007"
_ia_mod = "ion.services.mi.instrument_agent"
_ia_class = "InstrumentAgent"
_ia_pid = _container_client.spawn_process(name=_ia_name, module=_ia_mod, cls=_ia_class, config=agent_config)
log.info("got pid=%s for resource_id=%s" % (str(_ia_pid), str(agent_resource_id)))
class TestOrgManagementServiceInt(IonIntegrationTestCase):
def setUp(self):
# Start container
self._start_container()
self.container.start_rel_from_url('res/deploy/r2coi.yml')
self.org_management_service = OrgManagementServiceClient(node=self.container.node)
def test_org_crud(self):
with self.assertRaises(BadRequest) as br:
self.org_management_service.create_org(IonObject("Org", {"name": "Test Facility"}))
self.assertTrue("can only contain alphanumeric and underscore characters" in br.exception.message)
org_obj = IonObject("Org", {"name": "TestFacility"})
org_id = self.org_management_service.create_org(org_obj)
self.assertNotEqual(org_id, None)
org = None
org = self.org_management_service.read_org(org_id)
self.assertNotEqual(org, None)
#Check that the roles got associated to them
role_list = self.org_management_service.find_org_roles(org_id)
self.assertEqual(len(role_list),2 )
org.name = 'Updated_TestFacility'
self.org_management_service.update_org(org)
org = None
org = self.org_management_service.read_org(org_id)
self.assertNotEqual(org, None)
self.assertEqual(org.name, 'Updated_TestFacility')
self.org_management_service.delete_org(org_id)
with self.assertRaises(NotFound) as cm:
self.org_management_service.read_org(org_id)
self.assertIn("does not exist", cm.exception.message)
with self.assertRaises(NotFound) as cm:
self.org_management_service.delete_org(org_id)
self.assertIn("does not exist", cm.exception.message)
def test_org_affiliation(self):
root_org = None
root_org = self.org_management_service.find_org()
self.assertNotEqual(root_org, None)
org_obj = IonObject("Org", {"name": "TestFacility"})
org_id = self.org_management_service.create_org(org_obj)
self.assertNotEqual(org_id, None)
ret = self.org_management_service.affiliate_org(root_org._id, org_id)
self.assertTrue(ret)
ret = self.org_management_service.unaffiliate_org(root_org._id, org_id)
self.assertTrue(ret)
class TestOrgManagementServiceInt(IonIntegrationTestCase):
def setUp(self):
# Start container
self._start_container()
# Establish endpoint with container
container_client = ContainerAgentClient(node=self.container.node, name=self.container.name)
container_client.start_rel_from_url('res/deploy/r2coi.yml')
self.org_management_service = OrgManagementServiceClient(node=self.container.node)
def test_org_crud(self):
org_obj = IonObject("Org", {"name": "Test Facility"})
org_id = self.org_management_service.create_org(org_obj)
self.assertNotEqual(org_id, None)
org = None
org = self.org_management_service.read_org(org_id)
self.assertNotEqual(org, None)
org.name = 'Updated Test Facility'
self.org_management_service.update_org(org)
org = None
org = self.org_management_service.read_org(org_id)
self.assertNotEqual(org, None)
self.assertEqual(org.name, 'Updated Test Facility')
self.org_management_service.delete_org(org_id)
with self.assertRaises(NotFound) as cm:
self.org_management_service.read_org(org_id)
self.assertIn("does not exist", cm.exception.message)
with self.assertRaises(NotFound) as cm:
self.org_management_service.delete_org(org_id)
self.assertIn("does not exist", cm.exception.message)
def test_org_affiliation(self):
root_org = None
root_org = self.org_management_service.find_org()
self.assertNotEqual(root_org, None)
org_obj = IonObject("Org", {"name": "Test Facility"})
org_id = self.org_management_service.create_org(org_obj)
self.assertNotEqual(org_id, None)
ret = self.org_management_service.affiliate_org(root_org._id, org_id)
self.assertTrue(ret)
ret = self.org_management_service.unaffiliate_org(root_org._id, org_id)
self.assertTrue(ret)
class TestObservatoryManagementServiceIntegration(IonIntegrationTestCase):
def setUp(self):
# Start container
#print 'instantiating container'
self._start_container()
#container = Container()
#print 'starting container'
#container.start()
#print 'started container'
self.container.start_rel_from_url('res/deploy/r2deploy.yml')
self.RR = ResourceRegistryServiceClient(node=self.container.node)
self.OMS = ObservatoryManagementServiceClient(node=self.container.node)
self.org_management_service = OrgManagementServiceClient(node=self.container.node)
self.instrument_management_service = InstrumentManagementServiceClient(node=self.container.node)
#print 'TestObservatoryManagementServiceIntegration: started services'
# @unittest.skip('this exists only for debugging the launch process')
# def test_just_the_setup(self):
# return
def destroy(self, resource_ids):
self.OMS.force_delete_observatory(resource_ids.observatory_id)
self.OMS.force_delete_subsite(resource_ids.subsite_id)
self.OMS.force_delete_subsite(resource_ids.subsite2_id)
self.OMS.force_delete_subsite(resource_ids.subsiteb_id)
self.OMS.force_delete_subsite(resource_ids.subsitez_id)
self.OMS.force_delete_platform_site(resource_ids.platform_site_id)
self.OMS.force_delete_platform_site(resource_ids.platform_siteb_id)
self.OMS.force_delete_platform_site(resource_ids.platform_siteb2_id)
self.OMS.force_delete_platform_site(resource_ids.platform_site3_id)
self.OMS.force_delete_instrument_site(resource_ids.instrument_site_id)
self.OMS.force_delete_instrument_site(resource_ids.instrument_site2_id)
self.OMS.force_delete_instrument_site(resource_ids.instrument_siteb3_id)
self.OMS.force_delete_instrument_site(resource_ids.instrument_site4_id)
#@unittest.skip('targeting')
def test_resources_associations(self):
resources = self._make_associations()
self.destroy(resources)
#@unittest.skip('targeting')
def test_find_related_frames_of_reference(self):
# finding subordinates gives a dict of obj lists, convert objs to ids
def idify(adict):
ids = {}
for k, v in adict.iteritems():
ids[k] = []
for obj in v:
ids[k].append(obj._id)
return ids
# a short version of the function we're testing, with id-ify
def short(resource_id, output_types):
ret = self.OMS.find_related_frames_of_reference(resource_id,
output_types)
return idify(ret)
#set up associations first
stuff = self._make_associations()
#basic traversal of tree from instrument to platform
ids = short(stuff.instrument_site_id, [RT.PlatformSite])
self.assertIn(RT.PlatformSite, ids)
self.assertIn(stuff.platform_site_id, ids[RT.PlatformSite])
self.assertIn(stuff.platform_siteb_id, ids[RT.PlatformSite])
self.assertNotIn(stuff.platform_siteb2_id, ids[RT.PlatformSite])
#since this is the first search, just make sure the input inst_id got stripped
if RT.InstrumentSite in ids:
self.assertNotIn(stuff.instrument_site_id, ids[RT.InstrumentSite])
#basic traversal of tree from platform to instrument
ids = short(stuff.platform_siteb_id, [RT.InstrumentSite])
self.assertIn(RT.InstrumentSite, ids)
self.assertIn(stuff.instrument_site_id, ids[RT.InstrumentSite])
self.assertNotIn(stuff.instrument_site2_id, ids[RT.InstrumentSite])
#full traversal of tree from observatory down to instrument
ids = short(stuff.observatory_id, [RT.InstrumentSite])
self.assertIn(RT.InstrumentSite, ids)
self.assertIn(stuff.instrument_site_id, ids[RT.InstrumentSite])
#full traversal of tree from instrument to observatory
ids = short(stuff.instrument_site_id, [RT.Observatory])
self.assertIn(RT.Observatory, ids)
self.assertIn(stuff.observatory_id, ids[RT.Observatory])
#partial traversal, only down to platform
ids = short(stuff.observatory_id, [RT.Subsite, RT.PlatformSite])
self.assertIn(RT.PlatformSite, ids)
self.assertIn(RT.Subsite, ids)
self.assertIn(stuff.platform_site_id, ids[RT.PlatformSite])
self.assertIn(stuff.platform_siteb_id, ids[RT.PlatformSite])
self.assertIn(stuff.platform_siteb2_id, ids[RT.PlatformSite])
self.assertIn(stuff.platform_site3_id, ids[RT.PlatformSite])
self.assertIn(stuff.subsite_id, ids[RT.Subsite])
self.assertIn(stuff.subsite2_id, ids[RT.Subsite])
self.assertIn(stuff.subsitez_id, ids[RT.Subsite])
self.assertIn(stuff.subsiteb_id, ids[RT.Subsite])
self.assertNotIn(RT.InstrumentSite, ids)
#partial traversal, only down to platform
ids = short(stuff.instrument_site_id, [RT.Subsite, RT.PlatformSite])
self.assertIn(RT.PlatformSite, ids)
self.assertIn(RT.Subsite, ids)
self.assertIn(stuff.platform_siteb_id, ids[RT.PlatformSite])
self.assertIn(stuff.platform_site_id, ids[RT.PlatformSite])
self.assertIn(stuff.subsite_id, ids[RT.Subsite])
self.assertIn(stuff.subsiteb_id, ids[RT.Subsite])
self.assertNotIn(stuff.subsite2_id, ids[RT.Subsite])
self.assertNotIn(stuff.subsitez_id, ids[RT.Subsite])
self.assertNotIn(stuff.platform_siteb2_id, ids[RT.PlatformSite])
self.assertNotIn(RT.Observatory, ids)
self.destroy(stuff)
def _make_associations(self):
"""
create one of each resource and association used by OMS
to guard against problems in ion-definitions
"""
#raise unittest.SkipTest("https://jira.oceanobservatories.org/tasks/browse/CISWCORE-41")
"""
the tree we're creating (observatory, sites, platforms, instruments)
rows are lettered, colums numbered.
- first row is implied a
- first column is implied 1
- site Z, just because
O--Sz
|
S--S2--P3--I4
|
Sb-Pb2-Ib3
|
P--I2
|
Pb
|
I
"""
#stuff we control
observatory_id, _ = self.RR.create(any_old(RT.Observatory))
subsite_id, _ = self.RR.create(any_old(RT.Subsite))
subsite2_id, _ = self.RR.create(any_old(RT.Subsite))
subsiteb_id, _ = self.RR.create(any_old(RT.Subsite))
subsitez_id, _ = self.RR.create(any_old(RT.Subsite))
platform_site_id, _ = self.RR.create(any_old(RT.PlatformSite))
platform_siteb_id, _ = self.RR.create(any_old(RT.PlatformSite))
platform_siteb2_id, _ = self.RR.create(any_old(RT.PlatformSite))
platform_site3_id, _ = self.RR.create(any_old(RT.PlatformSite))
instrument_site_id, _ = self.RR.create(any_old(RT.InstrumentSite))
instrument_site2_id, _ = self.RR.create(any_old(RT.InstrumentSite))
instrument_siteb3_id, _ = self.RR.create(any_old(RT.InstrumentSite))
instrument_site4_id, _ = self.RR.create(any_old(RT.InstrumentSite))
#stuff we associate to
instrument_model_id, _ = self.RR.create(any_old(RT.InstrumentModel))
instrument_device_id, _ = self.RR.create(any_old(RT.InstrumentDevice))
platform_model_id, _ = self.RR.create(any_old(RT.PlatformModel))
platform_device_id, _ = self.RR.create(any_old(RT.PlatformDevice))
deployment_id, _ = self.RR.create(any_old(RT.Deployment))
#observatory
self.RR.create_association(observatory_id, PRED.hasSite, subsite_id)
self.RR.create_association(observatory_id, PRED.hasSite, subsitez_id)
#site
self.RR.create_association(subsite_id, PRED.hasSite, subsite2_id)
self.RR.create_association(subsite_id, PRED.hasSite, subsiteb_id)
self.RR.create_association(subsite2_id, PRED.hasSite, platform_site3_id)
self.RR.create_association(subsiteb_id, PRED.hasSite, platform_siteb2_id)
self.RR.create_association(subsiteb_id, PRED.hasSite, platform_site_id)
#platform_site
self.RR.create_association(platform_site3_id, PRED.hasSite, instrument_site4_id)
self.RR.create_association(platform_siteb2_id, PRED.hasSite, instrument_siteb3_id)
self.RR.create_association(platform_site_id, PRED.hasSite, instrument_site2_id)
self.RR.create_association(platform_site_id, PRED.hasSite, platform_siteb_id)
self.RR.create_association(platform_siteb_id, PRED.hasSite, instrument_site_id)
self.RR.create_association(platform_site_id, PRED.hasModel, platform_model_id)
self.RR.create_association(platform_site_id, PRED.hasDevice, platform_device_id)
self.RR.create_association(platform_site_id, PRED.hasDeployment, deployment_id)
#instrument_site
self.RR.create_association(instrument_site_id, PRED.hasModel, instrument_model_id)
self.RR.create_association(instrument_site_id, PRED.hasDevice, instrument_device_id)
self.RR.create_association(instrument_site_id, PRED.hasDeployment, deployment_id)
ret = DotDict()
ret.observatory_id = observatory_id
ret.subsite_id = subsite_id
ret.subsite2_id = subsite2_id
ret.subsiteb_id = subsiteb_id
ret.subsitez_id = subsitez_id
ret.platform_site_id = platform_site_id
ret.platform_siteb_id = platform_siteb_id
ret.platform_siteb2_id = platform_siteb2_id
ret.platform_site3_id = platform_site3_id
ret.instrument_site_id = instrument_site_id
ret.instrument_site2_id = instrument_site2_id
ret.instrument_siteb3_id = instrument_siteb3_id
ret.instrument_site4_id = instrument_site4_id
return ret
#@unittest.skip("targeting")
def test_create_observatory(self):
observatory_obj = IonObject(RT.Observatory,
name='TestFacility',
description='some new mf')
observatory_id = self.OMS.create_observatory(observatory_obj)
self.OMS.force_delete_observatory(observatory_id)
#@unittest.skip("targeting")
def test_find_observatory_org(self):
org_obj = IonObject(RT.Org,
name='TestOrg',
description='some new mf org')
org_id = self.OMS.create_marine_facility(org_obj)
observatory_obj = IonObject(RT.Observatory,
name='TestObservatory',
description='some new obs')
observatory_id = self.OMS.create_observatory(observatory_obj)
#make association
self.OMS.assign_resource_to_observatory_org(observatory_id, org_id)
#find association
org_objs = self.OMS.find_org_by_observatory(observatory_id)
self.assertEqual(1, len(org_objs))
self.assertEqual(org_id, org_objs[0]._id)
print("org_id=<" + org_id + ">")
#create a subsite with parent Observatory
subsite_obj = IonObject(RT.Subsite,
name= 'TestSubsite',
description = 'sample subsite')
subsite_id = self.OMS.create_subsite(subsite_obj, observatory_id)
self.assertIsNotNone(subsite_id, "Subsite not created.")
# verify that Subsite is linked to Observatory
mf_subsite_assoc = self.RR.get_association(observatory_id, PRED.hasSite, subsite_id)
self.assertIsNotNone(mf_subsite_assoc, "Subsite not connected to Observatory.")
# add the Subsite as a resource of this Observatory
self.OMS.assign_resource_to_observatory_org(resource_id=subsite_id, org_id=org_id)
# verify that Subsite is linked to Org
org_subsite_assoc = self.RR.get_association(org_id, PRED.hasResource, subsite_id)
self.assertIsNotNone(org_subsite_assoc, "Subsite not connected as resource to Org.")
#create a logical platform with parent Subsite
platform_site_obj = IonObject(RT.PlatformSite,
name= 'TestPlatformSite',
description = 'sample logical platform')
platform_site_id = self.OMS.create_platform_site(platform_site_obj, subsite_id)
self.assertIsNotNone(platform_site_id, "PlatformSite not created.")
# verify that PlatformSite is linked to Site
site_lp_assoc = self.RR.get_association(subsite_id, PRED.hasSite, platform_site_id)
self.assertIsNotNone(site_lp_assoc, "PlatformSite not connected to Site.")
# add the PlatformSite as a resource of this Observatory
self.OMS.assign_resource_to_observatory_org(resource_id=platform_site_id, org_id=org_id)
# verify that PlatformSite is linked to Org
org_lp_assoc = self.RR.get_association(org_id, PRED.hasResource, platform_site_id)
self.assertIsNotNone(org_lp_assoc, "PlatformSite not connected as resource to Org.")
#create a logical instrument with parent logical platform
instrument_site_obj = IonObject(RT.InstrumentSite,
name= 'TestInstrumentSite',
description = 'sample logical instrument')
instrument_site_id = self.OMS.create_instrument_site(instrument_site_obj, platform_site_id)
self.assertIsNotNone(instrument_site_id, "InstrumentSite not created.")
# verify that InstrumentSite is linked to PlatformSite
li_lp_assoc = self.RR.get_association(platform_site_id, PRED.hasSite, instrument_site_id)
self.assertIsNotNone(li_lp_assoc, "InstrumentSite not connected to PlatformSite.")
# add the InstrumentSite as a resource of this Observatory
self.OMS.assign_resource_to_observatory_org(resource_id=instrument_site_id, org_id=org_id)
# verify that InstrumentSite is linked to Org
org_li_assoc = self.RR.get_association(org_id, PRED.hasResource, instrument_site_id)
self.assertIsNotNone(org_li_assoc, "InstrumentSite not connected as resource to Org.")
# remove the InstrumentSite as a resource of this Observatory
self.OMS.unassign_resource_from_observatory_org(instrument_site_id, org_id)
# verify that InstrumentSite is linked to Org
assocs,_ = self.RR.find_objects(org_id, PRED.hasResource, RT.InstrumentSite, id_only=True )
self.assertEqual(len(assocs), 0)
# remove the InstrumentSite
self.OMS.delete_instrument_site(instrument_site_id)
assocs, _ = self.RR.find_objects(platform_site_id, PRED.hasSite, RT.InstrumentSite, id_only=True )
self.assertEqual(len(assocs), 1)
#todo: remove the dangling association
# remove the PlatformSite as a resource of this Observatory
self.OMS.unassign_resource_from_observatory_org(platform_site_id, org_id)
# verify that PlatformSite is linked to Org
assocs,_ = self.RR.find_objects(org_id, PRED.hasResource, RT.PlatformSite, id_only=True )
self.assertEqual(len(assocs), 0)
# remove the Site as a resource of this Observatory
self.OMS.unassign_resource_from_observatory_org(subsite_id, org_id)
# verify that Site is linked to Org
assocs,_ = self.RR.find_objects(org_id, PRED.hasResource, RT.Subsite, id_only=True )
self.assertEqual(len(assocs), 0)
self.RR.delete(org_id)
self.OMS.force_delete_observatory(observatory_id)
self.OMS.force_delete_subsite(subsite_id)
self.OMS.force_delete_platform_site(platform_site_id)
self.OMS.force_delete_instrument_site(instrument_site_id)
#@unittest.skip("in development...")
def test_observatory_org_extended(self):
org_obj = IonObject(RT.Org,
name='TestOrg',
description='some new mf org')
org_id = self.OMS.create_marine_facility(org_obj)
observatory_obj = IonObject(RT.Observatory,
name='TestObservatory',
description='some new obs')
observatory_id = self.OMS.create_observatory(observatory_obj)
#make association
self.OMS.assign_resource_to_observatory_org(observatory_id, org_id)
log.debug("test_observatory_org_extended: org_id: %s ", str(org_id))
#create a PlatformSite with parent Observatory
subsite_obj = IonObject(RT.PlatformSite,
name= 'PlatformSite1',
description = 'sample PlatformSite')
pltfrm_site_id = self.OMS.create_platform_site(subsite_obj, observatory_id)
self.assertIsNotNone(pltfrm_site_id, "PlatformSite not created.")
self.OMS.assign_resource_to_observatory_org(resource_id=pltfrm_site_id, org_id=org_id)
#create a InstrumentSite with parent Observatory
subsite_obj = IonObject(RT.InstrumentSite,
name= 'InstrumentSite1',
description = 'sample InstrumentSite')
inst_site_id = self.OMS.create_instrument_site(subsite_obj, pltfrm_site_id)
self.assertIsNotNone(inst_site_id, "InstrumentSite not created.")
self.OMS.assign_resource_to_observatory_org(resource_id=inst_site_id, org_id=org_id)
# create two PLATFORM devices, one deployed and one not
platfrmDevice1_obj = IonObject(RT.PlatformDevice,
name='PlatformDevice1',
description="PlatformDevice1")
platfrmDevice1_id = self.instrument_management_service.create_platform_device(platfrmDevice1_obj)
self.OMS.assign_resource_to_observatory_org(resource_id=platfrmDevice1_id, org_id=org_id)
self.RR.create_association(subject=pltfrm_site_id, predicate=PRED.hasDevice, object=platfrmDevice1_id)
platfrmDevice2_obj = IonObject(RT.PlatformDevice,
name='PlatformDevice2',
description="PlatformDevice2")
platfrmDevice2_id = self.instrument_management_service.create_platform_device(platfrmDevice2_obj)
self.OMS.assign_resource_to_observatory_org(resource_id=platfrmDevice2_id, org_id=org_id)
# create two INSTRUMENT devices, one deployed and one not
instDevice1_obj = IonObject(RT.InstrumentDevice,
name='SBE37IMDevice1',
description="SBE37IMDevice1",
serial_number="1" )
instDevice1_id = self.instrument_management_service.create_instrument_device(instrument_device=instDevice1_obj)
self.OMS.assign_resource_to_observatory_org(resource_id=instDevice1_id, org_id=org_id)
self.RR.create_association(subject=inst_site_id, predicate=PRED.hasDevice, object=instDevice1_id)
instDevice2_obj = IonObject(RT.InstrumentDevice,
name='SBE37IMDevice2',
description="SBE37IMDevice2",
serial_number="2" )
instDevice2_id = self.instrument_management_service.create_instrument_device(instrument_device=instDevice2_obj)
self.OMS.assign_resource_to_observatory_org(resource_id=instDevice2_id, org_id=org_id)
#test the extended resource
extended_org = self.org_management_service.get_marine_facility_extension(org_id)
#log.debug("test_observatory_org_extended: extended_org: %s ", str(extended_org))
self.assertEqual(1, len(extended_org.instruments_deployed) )
self.assertEqual(1, len(extended_org.platforms_not_deployed) )
self.assertEqual(0, len(extended_org.platform_models) )
class TestOrgManagementServiceInt(IonIntegrationTestCase):
def setUp(self):
# Start container
self._start_container()
self.container.start_rel_from_url("res/deploy/r2coi.yml")
self.resource_registry = ResourceRegistryServiceClient(node=self.container.node)
self.org_management_service = OrgManagementServiceClient(node=self.container.node)
def test_org_crud(self):
with self.assertRaises(BadRequest) as br:
self.org_management_service.create_org(
IonObject("Org", {"name": "Test Facility", "org_governance_name": "Test Facility"})
)
self.assertTrue("can only contain alphanumeric and underscore characters" in br.exception.message)
with self.assertRaises(BadRequest):
self.org_management_service.create_org()
org_obj = IonObject("Org", {"name": "Test Facility"})
org_id = self.org_management_service.create_org(org_obj)
self.assertNotEqual(org_id, None)
org = None
org = self.org_management_service.read_org(org_id)
self.assertNotEqual(org, None)
self.assertEqual(org.org_governance_name, "Test_Facility")
# Check that the roles got associated to them
role_list = self.org_management_service.find_org_roles(org_id)
self.assertEqual(len(role_list), 2)
with self.assertRaises(BadRequest):
self.org_management_service.update_org()
org.name = "Updated Test Facility"
self.org_management_service.update_org(org)
org = None
org = self.org_management_service.read_org(org_id)
self.assertNotEqual(org, None)
self.assertEqual(org.name, "Updated Test Facility")
self.assertEqual(org.org_governance_name, "Test_Facility")
user_role = self.org_management_service.find_org_role_by_name(org_id, ORG_MANAGER_ROLE)
self.assertNotEqual(user_role, None)
self.org_management_service.remove_user_role(org_id, ORG_MANAGER_ROLE)
with self.assertRaises(BadRequest) as cm:
user_role = self.org_management_service.find_org_role_by_name(org_id, ORG_MANAGER_ROLE)
self.assertIn("The User Role 'ORG_MANAGER' does not exist for this Org", cm.exception.message)
with self.assertRaises(BadRequest):
self.org_management_service.delete_org()
self.org_management_service.delete_org(org_id)
with self.assertRaises(NotFound) as cm:
self.org_management_service.read_org(org_id)
self.assertIn("does not exist", cm.exception.message)
with self.assertRaises(NotFound) as cm:
self.org_management_service.delete_org(org_id)
self.assertIn("does not exist", cm.exception.message)
def test_org_affiliation(self):
root_org = None
root_org = self.org_management_service.find_org()
self.assertNotEqual(root_org, None)
org_obj = IonObject("Org", {"name": "TestFacility"})
org_id = self.org_management_service.create_org(org_obj)
self.assertNotEqual(org_id, None)
ret = self.org_management_service.affiliate_org(root_org._id, org_id)
self.assertTrue(ret)
ret = self.org_management_service.unaffiliate_org(root_org._id, org_id)
self.assertTrue(ret)
def test_find_org_containers(self):
root_org = None
root_org = self.org_management_service.find_org()
self.assertNotEqual(root_org, None)
containers = self.org_management_service.find_org_containers(root_org._id)
all_containers, _ = self.resource_registry.find_resources(restype=RT.CapabilityContainer, id_only=True)
self.assertEqual(len(containers), len(all_containers))
def test_user_role_cache(self):
#Create a user
id_client = IdentityManagementServiceClient(node=self.container.node)
actor_id, valid_until, registered = id_client.signon(
USER1_CERTIFICATE, True)
#Make a request with this new user to get it into the cache
response = self.test_app.get(
'/ion-service/resource_registry/find_resources?name=TestDataProduct&id_only=True&requester='
+ actor_id)
self.check_response_headers(response)
self.assertIn(GATEWAY_RESPONSE, response.json['data'])
#Check the contents of the user role cache for this user
service_gateway_user_cache = self.container.proc_manager.procs_by_name[
'service_gateway'].user_data_cache
self.assertEqual(service_gateway_user_cache.has_key(actor_id), True)
role_header = service_gateway_user_cache.get(actor_id)
self.assertIn('ION', role_header)
self.assertEqual(len(role_header['ION']), 1)
self.assertIn('ORG_MEMBER', role_header['ION'])
org_client = OrgManagementServiceClient(node=self.container.node)
ion_org = org_client.find_org()
manager_role = org_client.find_org_role_by_name(
org_id=ion_org._id, role_name='ORG_MANAGER')
org_client.grant_role(org_id=ion_org._id,
user_id=actor_id,
role_name='ORG_MANAGER')
#Just allow some time for event processing on slower platforms
gevent.sleep(2)
#The user should be evicted from the cache due to a change in roles
self.assertEqual(service_gateway_user_cache.has_key(actor_id), False)
#Do it again to check for new roles
response = self.test_app.get(
'/ion-service/resource_registry/find_resources?name=TestDataProduct&id_only=True&requester='
+ actor_id)
self.check_response_headers(response)
self.assertIn(GATEWAY_RESPONSE, response.json['data'])
#Check the contents of the user role cache for this user
self.assertEqual(service_gateway_user_cache.has_key(actor_id), True)
role_header = service_gateway_user_cache.get(actor_id)
self.assertIn('ION', role_header)
self.assertEqual(len(role_header['ION']), 2)
self.assertIn('ORG_MEMBER', role_header['ION'])
self.assertIn('ORG_MANAGER', role_header['ION'])
#Now flush the user_role_cache and make sure it was flushed
event_publisher = EventPublisher()
event_publisher.publish_event(event_type=OT.UserRoleCacheResetEvent)
#Just allow some time for event processing on slower platforms
gevent.sleep(2)
self.assertEqual(service_gateway_user_cache.has_key(actor_id), False)
self.assertEqual(service_gateway_user_cache.size(), 0)
#Change the role once again and see if it is there again
org_client.revoke_role(org_id=ion_org._id,
user_id=actor_id,
role_name='ORG_MANAGER')
#Just allow some time for event processing on slower platforms
gevent.sleep(2)
#The user should still not be there
self.assertEqual(service_gateway_user_cache.has_key(actor_id), False)
#Do it again to check for new roles
response = self.test_app.get(
'/ion-service/resource_registry/find_resources?name=TestDataProduct&id_only=True&requester='
+ actor_id)
self.check_response_headers(response)
self.assertIn(GATEWAY_RESPONSE, response.json['data'])
#Check the contents of the user role cache for this user
self.assertEqual(service_gateway_user_cache.has_key(actor_id), True)
role_header = service_gateway_user_cache.get(actor_id)
self.assertIn('ION', role_header)
self.assertEqual(len(role_header['ION']), 1)
self.assertIn('ORG_MEMBER', role_header['ION'])
id_client.delete_actor_identity(actor_id)
def instrument_test_driver(container):
org_client = OrgManagementServiceClient(node=container.node)
id_client = IdentityManagementServiceClient(node=container.node)
system_actor = id_client.find_actor_identity_by_name(name=CFG.system.system_actor)
log.info('system actor:' + system_actor._id)
sa_header_roles = get_role_message_headers(org_client.find_all_roles_by_user(system_actor._id))
# Names of agent data streams to be configured.
parsed_stream_name = 'ctd_parsed'
raw_stream_name = 'ctd_raw'
# Driver configuration.
#Simulator
driver_config = {
'svr_addr': 'localhost',
'cmd_port': 5556,
'evt_port': 5557,
'dvr_mod': 'ion.agents.instrument.drivers.sbe37.sbe37_driver',
'dvr_cls': 'SBE37Driver',
'comms_config': {
SBE37Channel.CTD: {
'method':'ethernet',
'device_addr': CFG.device.sbe37.host,
'device_port': CFG.device.sbe37.port,
'server_addr': 'localhost',
'server_port': 8888
}
}
}
#Hardware
_container_client = ContainerAgentClient(node=container.node,
name=container.name)
# Create a pubsub client to create streams.
_pubsub_client = PubsubManagementServiceClient(node=container.node)
# A callback for processing subscribed-to data.
def consume(message, headers):
log.info('Subscriber received message: %s', str(message))
# Create a stream subscriber registrar to create subscribers.
subscriber_registrar = StreamSubscriberRegistrar(process=container,
node=container.node)
subs = []
# Create streams for each stream named in driver.
stream_config = {}
for (stream_name, val) in PACKET_CONFIG.iteritems():
stream_def = ctd_stream_definition(stream_id=None)
stream_def_id = _pubsub_client.create_stream_definition(
container=stream_def)
stream_id = _pubsub_client.create_stream(
name=stream_name,
stream_definition_id=stream_def_id,
original=True,
encoding='ION R2', headers={'ion-actor-id': system_actor._id, 'ion-actor-roles': sa_header_roles })
stream_config[stream_name] = stream_id
# Create subscriptions for each stream.
exchange_name = '%s_queue' % stream_name
sub = subscriber_registrar.create_subscriber(exchange_name=exchange_name, callback=consume)
sub.start()
query = StreamQuery(stream_ids=[stream_id])
sub_id = _pubsub_client.create_subscription(\
query=query, exchange_name=exchange_name )
_pubsub_client.activate_subscription(sub_id)
subs.append(sub)
# Create agent config.
agent_resource_id = '123xyz'
agent_config = {
'driver_config' : driver_config,
'stream_config' : stream_config,
'agent' : {'resource_id': agent_resource_id}
}
# Launch an instrument agent process.
_ia_name = 'agent007'
_ia_mod = 'ion.agents.instrument.instrument_agent'
_ia_class = 'InstrumentAgent'
_ia_pid = _container_client.spawn_process(name=_ia_name,
module=_ia_mod, cls=_ia_class,
config=agent_config)
log.info('got pid=%s for resource_id=%s' % (str(_ia_pid), str(agent_resource_id)))
class TestObservatoryManagementServiceIntegration(IonIntegrationTestCase):
def setUp(self):
# Start container
#print 'instantiating container'
self._start_container()
#container = Container()
#print 'starting container'
#container.start()
#print 'started container'
self.container.start_rel_from_url('res/deploy/r2deploy.yml')
self.RR = ResourceRegistryServiceClient(node=self.container.node)
self.OMS = ObservatoryManagementServiceClient(node=self.container.node)
self.org_management_service = OrgManagementServiceClient(node=self.container.node)
self.IMS = InstrumentManagementServiceClient(node=self.container.node)
self.dpclient = DataProductManagementServiceClient(node=self.container.node)
self.pubsubcli = PubsubManagementServiceClient(node=self.container.node)
self.damsclient = DataAcquisitionManagementServiceClient(node=self.container.node)
self.dataset_management = DatasetManagementServiceClient()
#print 'TestObservatoryManagementServiceIntegration: started services'
self.event_publisher = EventPublisher()
# @unittest.skip('this exists only for debugging the launch process')
# def test_just_the_setup(self):
# return
def destroy(self, resource_ids):
self.OMS.force_delete_observatory(resource_ids.observatory_id)
self.OMS.force_delete_subsite(resource_ids.subsite_id)
self.OMS.force_delete_subsite(resource_ids.subsite2_id)
self.OMS.force_delete_subsite(resource_ids.subsiteb_id)
self.OMS.force_delete_subsite(resource_ids.subsitez_id)
self.OMS.force_delete_platform_site(resource_ids.platform_site_id)
self.OMS.force_delete_platform_site(resource_ids.platform_siteb_id)
self.OMS.force_delete_platform_site(resource_ids.platform_siteb2_id)
self.OMS.force_delete_platform_site(resource_ids.platform_site3_id)
self.OMS.force_delete_instrument_site(resource_ids.instrument_site_id)
self.OMS.force_delete_instrument_site(resource_ids.instrument_site2_id)
self.OMS.force_delete_instrument_site(resource_ids.instrument_siteb3_id)
self.OMS.force_delete_instrument_site(resource_ids.instrument_site4_id)
#@unittest.skip('targeting')
def test_resources_associations(self):
resources = self._make_associations()
self.destroy(resources)
#@unittest.skip('targeting')
def test_find_related_frames_of_reference(self):
# finding subordinates gives a dict of obj lists, convert objs to ids
def idify(adict):
ids = {}
for k, v in adict.iteritems():
ids[k] = []
for obj in v:
ids[k].append(obj._id)
return ids
# a short version of the function we're testing, with id-ify
def short(resource_id, output_types):
ret = self.OMS.find_related_frames_of_reference(resource_id,
output_types)
return idify(ret)
#set up associations first
stuff = self._make_associations()
#basic traversal of tree from instrument to platform
ids = short(stuff.instrument_site_id, [RT.PlatformSite])
self.assertIn(RT.PlatformSite, ids)
self.assertIn(stuff.platform_site_id, ids[RT.PlatformSite])
self.assertIn(stuff.platform_siteb_id, ids[RT.PlatformSite])
self.assertNotIn(stuff.platform_siteb2_id, ids[RT.PlatformSite])
#since this is the first search, just make sure the input inst_id got stripped
if RT.InstrumentSite in ids:
self.assertNotIn(stuff.instrument_site_id, ids[RT.InstrumentSite])
#basic traversal of tree from platform to instrument
ids = short(stuff.platform_siteb_id, [RT.InstrumentSite])
self.assertIn(RT.InstrumentSite, ids)
self.assertIn(stuff.instrument_site_id, ids[RT.InstrumentSite])
self.assertNotIn(stuff.instrument_site2_id, ids[RT.InstrumentSite])
#full traversal of tree from observatory down to instrument
ids = short(stuff.observatory_id, [RT.InstrumentSite])
self.assertIn(RT.InstrumentSite, ids)
self.assertIn(stuff.instrument_site_id, ids[RT.InstrumentSite])
#full traversal of tree from instrument to observatory
ids = short(stuff.instrument_site_id, [RT.Observatory])
self.assertIn(RT.Observatory, ids)
self.assertIn(stuff.observatory_id, ids[RT.Observatory])
#partial traversal, only down to platform
ids = short(stuff.observatory_id, [RT.Subsite, RT.PlatformSite])
self.assertIn(RT.PlatformSite, ids)
self.assertIn(RT.Subsite, ids)
self.assertIn(stuff.platform_site_id, ids[RT.PlatformSite])
self.assertIn(stuff.platform_siteb_id, ids[RT.PlatformSite])
self.assertIn(stuff.platform_siteb2_id, ids[RT.PlatformSite])
self.assertIn(stuff.platform_site3_id, ids[RT.PlatformSite])
self.assertIn(stuff.subsite_id, ids[RT.Subsite])
self.assertIn(stuff.subsite2_id, ids[RT.Subsite])
self.assertIn(stuff.subsitez_id, ids[RT.Subsite])
self.assertIn(stuff.subsiteb_id, ids[RT.Subsite])
self.assertNotIn(RT.InstrumentSite, ids)
#partial traversal, only down to platform
ids = short(stuff.instrument_site_id, [RT.Subsite, RT.PlatformSite])
self.assertIn(RT.PlatformSite, ids)
self.assertIn(RT.Subsite, ids)
self.assertIn(stuff.platform_siteb_id, ids[RT.PlatformSite])
self.assertIn(stuff.platform_site_id, ids[RT.PlatformSite])
self.assertIn(stuff.subsite_id, ids[RT.Subsite])
self.assertIn(stuff.subsiteb_id, ids[RT.Subsite])
self.assertNotIn(stuff.subsite2_id, ids[RT.Subsite])
self.assertNotIn(stuff.subsitez_id, ids[RT.Subsite])
self.assertNotIn(stuff.platform_siteb2_id, ids[RT.PlatformSite])
self.assertNotIn(RT.Observatory, ids)
self.destroy(stuff)
def _make_associations(self):
"""
create one of each resource and association used by OMS
to guard against problems in ion-definitions
"""
#raise unittest.SkipTest("https://jira.oceanobservatories.org/tasks/browse/CISWCORE-41")
"""
the tree we're creating (observatory, sites, platforms, instruments)
rows are lettered, colums numbered.
- first row is implied a
- first column is implied 1
- site Z, just because
O--Sz
|
S--S2--P3--I4
|
Sb-Pb2-Ib3
|
P--I2 <- PlatformDevice, InstrumentDevice2
|
Pb <- PlatformDevice b
|
I <- InstrumentDevice
"""
org_id = self.OMS.create_marine_facility(any_old(RT.Org))
def create_under_org(resource_type):
obj = any_old(resource_type)
if RT.InstrumentDevice == resource_type:
resource_id = self.IMS.create_instrument_device(obj)
else:
resource_id, _ = self.RR.create(obj)
self.OMS.assign_resource_to_observatory_org(resource_id=resource_id, org_id=org_id)
return resource_id
#stuff we control
observatory_id = create_under_org(RT.Observatory)
subsite_id = create_under_org(RT.Subsite)
subsite2_id = create_under_org(RT.Subsite)
subsiteb_id = create_under_org(RT.Subsite)
subsitez_id = create_under_org(RT.Subsite)
platform_site_id = create_under_org(RT.PlatformSite)
platform_siteb_id = create_under_org(RT.PlatformSite)
platform_siteb2_id = create_under_org(RT.PlatformSite)
platform_site3_id = create_under_org(RT.PlatformSite)
instrument_site_id = create_under_org(RT.InstrumentSite)
instrument_site2_id = create_under_org(RT.InstrumentSite)
instrument_siteb3_id = create_under_org(RT.InstrumentSite)
instrument_site4_id = create_under_org(RT.InstrumentSite)
#stuff we associate to
instrument_device_id = create_under_org(RT.InstrumentDevice)
instrument_device2_id = create_under_org(RT.InstrumentDevice)
platform_device_id = create_under_org(RT.PlatformDevice)
platform_deviceb_id = create_under_org(RT.PlatformDevice)
instrument_model_id, _ = self.RR.create(any_old(RT.InstrumentModel))
platform_model_id, _ = self.RR.create(any_old(RT.PlatformModel))
deployment_id, _ = self.RR.create(any_old(RT.Deployment))
#observatory
self.RR.create_association(observatory_id, PRED.hasSite, subsite_id)
self.RR.create_association(observatory_id, PRED.hasSite, subsitez_id)
#site
self.RR.create_association(subsite_id, PRED.hasSite, subsite2_id)
self.RR.create_association(subsite_id, PRED.hasSite, subsiteb_id)
self.RR.create_association(subsite2_id, PRED.hasSite, platform_site3_id)
self.RR.create_association(subsiteb_id, PRED.hasSite, platform_siteb2_id)
self.RR.create_association(subsiteb_id, PRED.hasSite, platform_site_id)
#platform_site(s)
self.RR.create_association(platform_site3_id, PRED.hasSite, instrument_site4_id)
self.RR.create_association(platform_siteb2_id, PRED.hasSite, instrument_siteb3_id)
self.RR.create_association(platform_site_id, PRED.hasSite, instrument_site2_id)
self.RR.create_association(platform_site_id, PRED.hasSite, platform_siteb_id)
self.RR.create_association(platform_siteb_id, PRED.hasSite, instrument_site_id)
self.RR.create_association(platform_siteb_id, PRED.hasDevice, platform_deviceb_id)
self.RR.create_association(platform_site_id, PRED.hasModel, platform_model_id)
self.RR.create_association(platform_site_id, PRED.hasDevice, platform_device_id)
self.RR.create_association(platform_site_id, PRED.hasDeployment, deployment_id)
#instrument_site(s)
self.RR.create_association(instrument_site_id, PRED.hasModel, instrument_model_id)
self.RR.create_association(instrument_site_id, PRED.hasDevice, instrument_device_id)
self.RR.create_association(instrument_site_id, PRED.hasDeployment, deployment_id)
self.RR.create_association(instrument_site2_id, PRED.hasDevice, instrument_device2_id)
#platform_device
self.RR.create_association(platform_device_id, PRED.hasModel, platform_model_id)
#instrument_device
self.RR.create_association(instrument_device_id, PRED.hasModel, instrument_model_id)
self.RR.create_association(instrument_device2_id, PRED.hasModel, instrument_model_id)
ret = DotDict()
ret.org_id = org_id
ret.observatory_id = observatory_id
ret.subsite_id = subsite_id
ret.subsite2_id = subsite2_id
ret.subsiteb_id = subsiteb_id
ret.subsitez_id = subsitez_id
ret.platform_site_id = platform_site_id
ret.platform_siteb_id = platform_siteb_id
ret.platform_siteb2_id = platform_siteb2_id
ret.platform_site3_id = platform_site3_id
ret.instrument_site_id = instrument_site_id
ret.instrument_site2_id = instrument_site2_id
ret.instrument_siteb3_id = instrument_siteb3_id
ret.instrument_site4_id = instrument_site4_id
ret.instrument_device_id = instrument_device_id
ret.instrument_device2_id = instrument_device2_id
ret.platform_device_id = platform_device_id
ret.platform_deviceb_id = platform_deviceb_id
ret.instrument_model_id = instrument_model_id
ret.platform_model_id = platform_model_id
ret.deployment_id = deployment_id
return ret
#@unittest.skip("targeting")
def test_create_observatory(self):
observatory_obj = IonObject(RT.Observatory,
name='TestFacility',
description='some new mf')
observatory_id = self.OMS.create_observatory(observatory_obj)
self.OMS.force_delete_observatory(observatory_id)
#@unittest.skip("targeting")
def test_find_observatory_org(self):
org_obj = IonObject(RT.Org,
name='TestOrg',
description='some new mf org')
org_id = self.OMS.create_marine_facility(org_obj)
observatory_obj = IonObject(RT.Observatory,
name='TestObservatory',
description='some new obs')
observatory_id = self.OMS.create_observatory(observatory_obj)
#make association
self.OMS.assign_resource_to_observatory_org(observatory_id, org_id)
#find association
org_objs = self.OMS.find_org_by_observatory(observatory_id)
self.assertEqual(1, len(org_objs))
self.assertEqual(org_id, org_objs[0]._id)
print("org_id=<" + org_id + ">")
#create a subsite with parent Observatory
subsite_obj = IonObject(RT.Subsite,
name= 'TestSubsite',
description = 'sample subsite')
subsite_id = self.OMS.create_subsite(subsite_obj, observatory_id)
self.assertIsNotNone(subsite_id, "Subsite not created.")
# verify that Subsite is linked to Observatory
mf_subsite_assoc = self.RR.get_association(observatory_id, PRED.hasSite, subsite_id)
self.assertIsNotNone(mf_subsite_assoc, "Subsite not connected to Observatory.")
# add the Subsite as a resource of this Observatory
self.OMS.assign_resource_to_observatory_org(resource_id=subsite_id, org_id=org_id)
# verify that Subsite is linked to Org
org_subsite_assoc = self.RR.get_association(org_id, PRED.hasResource, subsite_id)
self.assertIsNotNone(org_subsite_assoc, "Subsite not connected as resource to Org.")
#create a logical platform with parent Subsite
platform_site_obj = IonObject(RT.PlatformSite,
name= 'TestPlatformSite',
description = 'sample logical platform')
platform_site_id = self.OMS.create_platform_site(platform_site_obj, subsite_id)
self.assertIsNotNone(platform_site_id, "PlatformSite not created.")
# verify that PlatformSite is linked to Site
site_lp_assoc = self.RR.get_association(subsite_id, PRED.hasSite, platform_site_id)
self.assertIsNotNone(site_lp_assoc, "PlatformSite not connected to Site.")
# add the PlatformSite as a resource of this Observatory
self.OMS.assign_resource_to_observatory_org(resource_id=platform_site_id, org_id=org_id)
# verify that PlatformSite is linked to Org
org_lp_assoc = self.RR.get_association(org_id, PRED.hasResource, platform_site_id)
self.assertIsNotNone(org_lp_assoc, "PlatformSite not connected as resource to Org.")
#create a logical instrument with parent logical platform
instrument_site_obj = IonObject(RT.InstrumentSite,
name= 'TestInstrumentSite',
description = 'sample logical instrument')
instrument_site_id = self.OMS.create_instrument_site(instrument_site_obj, platform_site_id)
self.assertIsNotNone(instrument_site_id, "InstrumentSite not created.")
# verify that InstrumentSite is linked to PlatformSite
li_lp_assoc = self.RR.get_association(platform_site_id, PRED.hasSite, instrument_site_id)
self.assertIsNotNone(li_lp_assoc, "InstrumentSite not connected to PlatformSite.")
# add the InstrumentSite as a resource of this Observatory
self.OMS.assign_resource_to_observatory_org(resource_id=instrument_site_id, org_id=org_id)
# verify that InstrumentSite is linked to Org
org_li_assoc = self.RR.get_association(org_id, PRED.hasResource, instrument_site_id)
self.assertIsNotNone(org_li_assoc, "InstrumentSite not connected as resource to Org.")
# remove the InstrumentSite as a resource of this Observatory
self.OMS.unassign_resource_from_observatory_org(instrument_site_id, org_id)
# verify that InstrumentSite is linked to Org
assocs,_ = self.RR.find_objects(org_id, PRED.hasResource, RT.InstrumentSite, id_only=True )
self.assertEqual(len(assocs), 0)
# remove the InstrumentSite
self.OMS.delete_instrument_site(instrument_site_id)
assocs, _ = self.RR.find_objects(platform_site_id, PRED.hasSite, RT.InstrumentSite, id_only=True )
self.assertEqual(len(assocs), 1)
#todo: remove the dangling association
# remove the PlatformSite as a resource of this Observatory
self.OMS.unassign_resource_from_observatory_org(platform_site_id, org_id)
# verify that PlatformSite is linked to Org
assocs,_ = self.RR.find_objects(org_id, PRED.hasResource, RT.PlatformSite, id_only=True )
self.assertEqual(len(assocs), 0)
# remove the Site as a resource of this Observatory
self.OMS.unassign_resource_from_observatory_org(subsite_id, org_id)
# verify that Site is linked to Org
assocs,_ = self.RR.find_objects(org_id, PRED.hasResource, RT.Subsite, id_only=True )
self.assertEqual(len(assocs), 0)
self.RR.delete(org_id)
self.OMS.force_delete_observatory(observatory_id)
self.OMS.force_delete_subsite(subsite_id)
self.OMS.force_delete_platform_site(platform_site_id)
self.OMS.force_delete_instrument_site(instrument_site_id)
#@unittest.skip("in development...")
@attr('EXT')
def test_observatory_org_extended(self):
stuff = self._make_associations()
parsed_pdict_id = self.dataset_management.read_parameter_dictionary_by_name('ctd_parsed_param_dict',
id_only=True)
parsed_stream_def_id = self.pubsubcli.create_stream_definition(name='parsed',
parameter_dictionary_id=parsed_pdict_id)
tdom, sdom = time_series_domain()
sdom = sdom.dump()
tdom = tdom.dump()
dp_obj = IonObject(RT.DataProduct,
name='the parsed data',
description='ctd stream test',
temporal_domain = tdom,
spatial_domain = sdom)
data_product_id1 = self.dpclient.create_data_product(data_product=dp_obj,
stream_definition_id=parsed_stream_def_id)
self.damsclient.assign_data_product(input_resource_id=stuff.instrument_device_id,
data_product_id=data_product_id1)
#--------------------------------------------------------------------------------
# Get the extended Site (platformSite)
#--------------------------------------------------------------------------------
extended_site = self.OMS.get_site_extension(stuff.platform_site_id)
log.debug("extended_site: %s ", str(extended_site))
self.assertEqual(1, len(extended_site.platform_devices))
self.assertEqual(1, len(extended_site.platform_models))
self.assertEqual(stuff.platform_device_id, extended_site.platform_devices[0]._id)
self.assertEqual(stuff.platform_model_id, extended_site.platform_models[0]._id)
#--------------------------------------------------------------------------------
# Get the extended Org
#--------------------------------------------------------------------------------
#test the extended resource
extended_org = self.org_management_service.get_marine_facility_extension(stuff.org_id)
log.debug("test_observatory_org_extended: extended_org: %s ", str(extended_org))
#self.assertEqual(2, len(extended_org.instruments_deployed) )
#self.assertEqual(1, len(extended_org.platforms_not_deployed) )
self.assertEqual(2, extended_org.number_of_platforms)
self.assertEqual(2, len(extended_org.platform_models) )
self.assertEqual(2, extended_org.number_of_instruments)
self.assertEqual(2, len(extended_org.instrument_models) )
#test the extended resource of the ION org
ion_org_id = self.org_management_service.find_org()
extended_org = self.org_management_service.get_marine_facility_extension(ion_org_id._id)
log.debug("test_observatory_org_extended: extended_ION_org: %s ", str(extended_org))
self.assertEqual(0, len(extended_org.members))
self.assertEqual(0, extended_org.number_of_platforms)
#self.assertEqual(1, len(extended_org.sites))
#--------------------------------------------------------------------------------
# Get the extended Site
#--------------------------------------------------------------------------------
#create device state events to use for op /non-op filtering in extended
t = get_ion_ts()
self.event_publisher.publish_event( ts_created= t, event_type = 'ResourceAgentStateEvent',
origin = stuff.instrument_device_id, state=ResourceAgentState.STREAMING )
self.event_publisher.publish_event( ts_created= t, event_type = 'ResourceAgentStateEvent',
origin = stuff.instrument_device2_id, state=ResourceAgentState.INACTIVE )
extended_site = self.OMS.get_site_extension(stuff.instrument_site2_id)
log.debug("test_observatory_org_extended: extended_site: %s ", str(extended_site))
self.dpclient.delete_data_product(data_product_id1)
