def setUp(self): self.clients = self._create_service_mock('data_product_management') self.data_product_management_service = DataProductManagementService() self.data_product_management_service.clients = self.clients # must call this manually self.data_product_management_service.on_init() self.data_source = Mock() self.data_source.name = 'data_source_name' self.data_source.description = 'data source desc'
def setUp(self): # Start container #print 'instantiating container' self._start_container() self.container.start_rel_from_url('res/deploy/r2deploy.yml') print 'started services' # Now create client to DataProductManagementService self.client = DataProductManagementServiceClient(node=self.container.node) self.rrclient = ResourceRegistryServiceClient(node=self.container.node) self.damsclient = DataAcquisitionManagementServiceClient(node=self.container.node) self.pubsubclient = PubsubManagementServiceClient(node=self.container.node) self.ingestclient = IngestionManagementServiceClient(node=self.container.node) self.dpmsclient = DataProductManagementService(node=self.container.node) self.imsclient = InstrumentManagementServiceClient(node=self.container.node) self.process_dispatcher = ProcessDispatcherServiceClient()
class TestDataProductManagementServiceUnit(PyonTestCase): def setUp(self): self.clients = self._create_service_mock('data_product_management') self.data_product_management_service = DataProductManagementService() self.data_product_management_service.clients = self.clients # must call this manually self.data_product_management_service.on_init() self.data_source = Mock() self.data_source.name = 'data_source_name' self.data_source.description = 'data source desc' #@unittest.skip('not working') def test_createDataProduct_and_DataProducer_success(self): # setup self.resource_registry.find_resources.return_value = ([], 'do not care') self.resource_registry.create.return_value = ('SOME_RR_ID1', 'Version_1') self.data_acquisition_management.assign_data_product.return_value = None # Data Product dpt_obj = IonObject(RT.DataProduct, name='DPT_Y', description='some new data product') # test call dp_id = self.data_product_management_service.create_data_product(dpt_obj, 'stream_def_id') # check results self.assertEqual(dp_id, 'SOME_RR_ID1') self.resource_registry.find_resources.assert_called_once_with(RT.DataProduct, None, dpt_obj.name, True) self.pubsub_management.create_stream.assert_called_once_with('', True, 'stream_def_id', 'DPT_Y', 'some new data product', '') self.resource_registry.create.assert_called_once_with(dpt_obj) @unittest.skip('not working') def test_createDataProduct_and_DataProducer_with_id_NotFound(self): # setup self.resource_registry.find_resources.return_value = ([], 'do not care') self.resource_registry.create.return_value = ('SOME_RR_ID1', 'Version_1') self.pubsub_management.create_stream.return_value = 'stream1' # Data Product dpt_obj = IonObject(RT.DataProduct, name='DPT_X', description='some new data product') # test call with self.assertRaises(NotFound) as cm: dp_id = self.data_product_management_service.create_data_product(dpt_obj, 'stream_def_id') # check results self.resource_registry.find_resources.assert_called_once_with(RT.DataProduct, None, dpt_obj.name, True) self.resource_registry.create.assert_called_once_with(dpt_obj) #todo: what are errors to check in create stream? def test_findDataProduct_success(self): # setup # Data Product dp_obj = IonObject(RT.DataProduct, name='DP_X', description='some existing dp') self.resource_registry.find_resources.return_value = ([dp_obj], []) # test call result = self.data_product_management_service.find_data_products() # check results self.assertEqual(result, [dp_obj]) self.resource_registry.find_resources.assert_called_once_with(RT.DataProduct, None, None, False)
def setUp(self): self.clients = self._create_service_mock('data_product_management') self.data_product_management_service = DataProductManagementService() self.data_product_management_service.clients = self.clients
class Test_DataProductManagementService_Unit(PyonTestCase): def setUp(self): self.clients = self._create_service_mock('data_product_management') self.data_product_management_service = DataProductManagementService() self.data_product_management_service.clients = self.clients def test_createDataProduct_success(self): # setup self.resource_registry.find_resources.return_value = ([], 'do not care') self.resource_registry.create.return_value = ('SOME_RR_ID', 'Version_1') # Data Product dp_obj = IonObject(RT.DataProduct, name='DP_X', description='some new dp') # test call dp_id = self.data_product_management_service.create_data_product(dp_obj) # check results self.assertEqual(dp_id, 'SOME_RR_ID') self.resource_registry.find_resources.assert_called_once_with(RT.DataProduct, None, dp_obj.name, True) self.resource_registry.create.assert_called_once_with(dp_obj) def test_createDataProduct_and_DataProducer_success(self): # setup self.resource_registry.find_resources.return_value = ([], 'do not care') self.resource_registry.create.return_value = ('SOME_RR_ID1', 'Version_1') self.data_acquisition_management.create_data_producer.return_value = ('SOME_RR_ID2') self.resource_registry.create_association.return_value = ('SOME_RR_ID3', 'Version_1') # Data Product dpt_obj = IonObject(RT.DataProduct, name='DPT_X', description='some new data product') # Data Producer dpr_obj = IonObject(RT.DataProducer, name='DP_X', description='some new data producer') # test call dp_id = self.data_product_management_service.create_data_product(dpt_obj, dpr_obj) # check results self.assertEqual(dp_id, 'SOME_RR_ID1') self.resource_registry.find_resources.assert_called_once_with(RT.DataProduct, None, dpt_obj.name, True) self.resource_registry.create.assert_called_once_with(dpt_obj) self.data_acquisition_management.create_data_producer.assert_called_once_with(dpr_obj) self.resource_registry.create_association.assert_called_once_with('SOME_RR_ID1', AT.hasDataProducer, 'SOME_RR_ID2', None) def test_createDataProduct_and_DataProducer_stream_NotFound(self): # setup self.resource_registry.find_resources.return_value = ([], 'do not care') self.resource_registry.create.return_value = ('SOME_RR_ID1', 'Version_1') self.data_acquisition_management.create_data_producer.side_effect = NotFound("Stream SOME_RR_ID2 does not exist") # Data Product dpt_obj = IonObject(RT.DataProduct, name='DPT_X', description='some new data product') # Data Producer dpr_obj = IonObject(RT.DataProducer, name='DP_X', description='some new data producer') # test call with self.assertRaises(NotFound) as cm: dp_id = self.data_product_management_service.create_data_product(dpt_obj, dpr_obj) # check results self.resource_registry.find_resources.assert_called_once_with(RT.DataProduct, None, dpt_obj.name, True) self.resource_registry.create.assert_called_once_with(dpt_obj) self.data_acquisition_management.create_data_producer.assert_called_once_with(dpr_obj) ex = cm.exception self.assertEqual(ex.message, "Stream SOME_RR_ID2 does not exist") def test_createDataProduct_and_DataProducer_with_id_BadRequest(self): # setup self.resource_registry.find_resources.return_value = ([], 'do not care') self.resource_registry.create.return_value = ('SOME_RR_ID1', 'Version_1') self.data_acquisition_management.create_data_producer.side_effect = BadRequest("Create cannot create document with ID: ") # Data Product dpt_obj = IonObject(RT.DataProduct, name='DPT_X', description='some new data product') # Data Producer dpr_obj = IonObject(RT.DataProducer, name='DP_X', description='some new data producer') dpr_obj._id = "SOME_OTHER_RR_ID" # test call with self.assertRaises(BadRequest) as cm: dp_id = self.data_product_management_service.create_data_product(dpt_obj, dpr_obj) # check results self.resource_registry.find_resources.assert_called_once_with(RT.DataProduct, None, dpt_obj.name, True) self.resource_registry.create.assert_called_once_with(dpt_obj) self.data_acquisition_management.create_data_producer.assert_called_once_with(dpr_obj) ex = cm.exception self.assertEqual(ex.message, "Create cannot create document with ID: ") def test_createDataProduct_and_DataProducer_with_rev_BadRequest(self): # setup self.resource_registry.find_resources.return_value = ([], 'do not care') self.resource_registry.create.return_value = ('SOME_RR_ID1', 'Version_1') self.data_acquisition_management.create_data_producer.side_effect = BadRequest("Create cannot create document with Rev: ") # Data Product dpt_obj = IonObject(RT.DataProduct, name='DPT_X', description='some new data product') # Data Producer dpr_obj = IonObject(RT.DataProducer, name='DP_X', description='some new data producer') dpr_obj._rev = "SOME_REV" # test call with self.assertRaises(BadRequest) as cm: dp_id = self.data_product_management_service.create_data_product(dpt_obj, dpr_obj) # check results self.resource_registry.find_resources.assert_called_once_with(RT.DataProduct, None, dpt_obj.name, True) self.resource_registry.create.assert_called_once_with(dpt_obj) self.data_acquisition_management.create_data_producer.assert_called_once_with(dpr_obj) ex = cm.exception self.assertEqual(ex.message, "Create cannot create document with Rev: ") def test_createDataProduct_already_exists_BadRequest(self): # setup self.resource_registry.find_resources.return_value = (['SOME_RR_ID'], 'Version_X') # Data Product dp_obj = IonObject(RT.DataProduct, name='DP_X', description='some new dp') # test call with self.assertRaises(BadRequest) as cm: dp_id = self.data_product_management_service.create_data_product(dp_obj) # check results self.resource_registry.find_resources.assert_called_once_with(RT.DataProduct, None, dp_obj.name, True) ex = cm.exception self.assertEqual(ex.message, "A data product named 'DP_X' already exists") def test_createDataProduct_with_id_BadRequest(self): # setup self.resource_registry.find_resources.return_value = ([], 'do not care') self.resource_registry.create.side_effect = BadRequest("Create cannot create document with ID: ") # Data Product dp_obj = IonObject(RT.DataProduct, name='DP_X', description='some other new dp') dp_obj._id = "SOME_OTHER_RR_ID" # test call with self.assertRaises(BadRequest) as cm: dp_id = self.data_product_management_service.create_data_product(dp_obj) # check results self.resource_registry.find_resources.assert_called_once_with(RT.DataProduct, None, dp_obj.name, True) self.resource_registry.create.assert_called_once_with(dp_obj) ex = cm.exception self.assertEqual(ex.message, "Create cannot create document with ID: ") def test_createDataProduct_with_rev_BadRequest(self): # setup self.resource_registry.find_resources.return_value = ([], 'do not care') self.resource_registry.create.side_effect = BadRequest("Create cannot create document with Rev: ") # Data Product dp_obj = IonObject(RT.DataProduct, name='DP_X', description='some other new dp') dp_obj._rev = "SOME_REV" # test call with self.assertRaises(BadRequest) as cm: dp_id = self.data_product_management_service.create_data_product(dp_obj) # check results self.resource_registry.find_resources.assert_called_once_with(RT.DataProduct, None, dp_obj.name, True) self.resource_registry.create.assert_called_once_with(dp_obj) ex = cm.exception self.assertEqual(ex.message, "Create cannot create document with Rev: ") def test_readDataProduct_success(self): # setup # Data Product dp_obj = IonObject(RT.DataProduct, name='DP_X', description='some new dp') self.resource_registry.read.return_value = (dp_obj) # test call returned_dp_obj = self.data_product_management_service.read_data_product('SOME_RR_ID1') # check results self.assertEqual(returned_dp_obj, dp_obj) self.resource_registry.read.assert_called_once_with('SOME_RR_ID1', '') def test_readDataProduct_NotFound(self): # setup self.resource_registry.read.side_effect = NotFound("Object with id SOME_RR_ID1 does not exist.") # test call with self.assertRaises(NotFound) as cm: returned_dp_obj = self.data_product_management_service.read_data_product('SOME_RR_ID1') # check results self.resource_registry.read.assert_called_once_with('SOME_RR_ID1', '') ex = cm.exception self.assertEqual(ex.message, "Object with id SOME_RR_ID1 does not exist.") def test_updateDataProduct_success(self): # setup # Data Product dp_obj = IonObject(RT.DataProduct, name='DP_X', description='some existing dp') self.resource_registry.update.return_value = ('SOME_RR_ID1', 'Version_1') # test call result = self.data_product_management_service.update_data_product(dp_obj) # check results self.assertEqual(result, True) self.resource_registry.update.assert_called_once_with(dp_obj) def test_updateDataProduct_without_id_BadRequest(self): # setup self.resource_registry.update.side_effect = BadRequest("Update failed: Document has no ID: ") # Data Product dp_obj = IonObject(RT.DataProduct, name='DP_X', description='some existing dp') result = None # test call with self.assertRaises(BadRequest) as cm: result = self.data_product_management_service.update_data_product(dp_obj) # check results self.resource_registry.update.assert_called_once_with(dp_obj) ex = cm.exception self.assertEqual(ex.message, "Update failed: Document has no ID: ") self.assertEqual(result, None) def test_updateDataProduct_without_rev_BadRequest(self): # setup self.resource_registry.update.side_effect = BadRequest("Update failed: Document has no Rev: ") # Data Product dp_obj = IonObject(RT.DataProduct, name='DP_X', description='some existing dp') result = None # test call with self.assertRaises(BadRequest) as cm: result = self.data_product_management_service.update_data_product(dp_obj) # check results self.resource_registry.update.assert_called_once_with(dp_obj) ex = cm.exception self.assertEqual(ex.message, "Update failed: Document has no Rev: ") self.assertEqual(result, None) def test_updateDataProduct_not_current_version_BadRequest(self): # setup self.resource_registry.update.side_effect = BadRequest("Object not based on most current version") # Data Product dp_obj = IonObject(RT.DataProduct, name='DP_X', description='some existing dp') result = None # test call with self.assertRaises(BadRequest) as cm: result = self.data_product_management_service.update_data_product(dp_obj) # check results self.resource_registry.update.assert_called_once_with(dp_obj) ex = cm.exception self.assertEqual(ex.message, "Object not based on most current version") self.assertEqual(result, None) def test_updateDataProduct_setting_lcs_BadRequest(self): # setup self.resource_registry.update.side_effect = BadRequest("Cannot modify life cycle state in update!") # Data Product dp_obj = IonObject(RT.DataProduct, name='DP_X', description='some existing dp') result = None # test call with self.assertRaises(BadRequest) as cm: result = self.data_product_management_service.update_data_product(dp_obj) # check results self.resource_registry.update.assert_called_once_with(dp_obj) ex = cm.exception self.assertEqual(ex.message, "Cannot modify life cycle state in update!") self.assertEqual(result, None) def test_deleteDataProduct_success(self): # setup # Data Product dp_obj = IonObject(RT.DataProduct, name='DP_X', description='some existing dp') self.resource_registry.delete.return_value = (dp_obj) # test call result = self.data_product_management_service.delete_data_product(dp_obj) # check results self.assertEqual(result, True) self.resource_registry.delete.assert_called_once_with(dp_obj) def test_deleteDataProduct_NotFound(self): # setup self.resource_registry.delete.side_effect = BadRequest("Object with id SOME_RR_ID1 does not exist.") # Data Product dp_obj = IonObject(RT.DataProduct, name='DP_X', description='some existing dp') result = None # test call with self.assertRaises(BadRequest) as cm: result = self.data_product_management_service.delete_data_product(dp_obj) # check results self.resource_registry.delete.assert_called_once_with(dp_obj) ex = cm.exception self.assertEqual(ex.message, "Object with id SOME_RR_ID1 does not exist.") self.assertEqual(result, None) def test_findDataProduct_success(self): # setup # Data Product dp_obj = IonObject(RT.DataProduct, name='DP_X', description='some existing dp') self.resource_registry.find_resources.return_value = ([dp_obj], []) # test call result = self.data_product_management_service.find_data_products() # check results self.assertEqual(result, [dp_obj]) self.resource_registry.find_resources.assert_called_once_with(RT.DataProduct, None, None, False)
class TestDataProductManagementServiceUnit(PyonTestCase): def setUp(self): self.clients = self._create_service_mock("data_product_management") self.data_product_management_service = DataProductManagementService() self.data_product_management_service.clients = self.clients # must call this manually self.data_product_management_service.on_init() self.data_source = Mock() self.data_source.name = "data_source_name" self.data_source.description = "data source desc" def test_createDataProduct_and_DataProducer_success(self): # setup self.resource_registry.find_resources.return_value = ([], "do not care") self.resource_registry.create.return_value = ("SOME_RR_ID1", "Version_1") self.data_acquisition_management.assign_data_product.return_value = None # Data Product dpt_obj = IonObject(RT.DataProduct, name="DPT_Y", description="some new data product") # test call dp_id = self.data_product_management_service.create_data_product(dpt_obj, "source_resource_id") # check results self.assertEqual(dp_id, "SOME_RR_ID1") self.resource_registry.find_resources.assert_called_once_with(RT.DataProduct, None, dpt_obj.name, True) self.resource_registry.create.assert_called_once_with(dpt_obj) # self.data_acquisition_management.assign_data_product.assert_called_once_with('source_resource_id', 'SOME_RR_ID1', True) def test_createDataProduct_and_DataProducer_with_id_NotFound(self): # setup self.resource_registry.find_resources.return_value = ([], "do not care") self.resource_registry.create.return_value = ("SOME_RR_ID1", "Version_1") self.data_acquisition_management.assign_data_product.return_value = None self.data_acquisition_management.assign_data_product.side_effect = NotFound( "Object with id SOME_RR_ID1 does not exist." ) # Data Product dpt_obj = IonObject(RT.DataProduct, name="DPT_X", description="some new data product") # test call with self.assertRaises(NotFound) as cm: dp_id = self.data_product_management_service.create_data_product(dpt_obj, "source_resource_id") # check results self.resource_registry.find_resources.assert_called_once_with(RT.DataProduct, None, dpt_obj.name, True) self.resource_registry.create.assert_called_once_with(dpt_obj) # self.data_acquisition_management.assign_data_product.assert_called_once_with('source_resource_id', 'SOME_RR_ID1', True) ex = cm.exception self.assertEqual(ex.message, "Object with id SOME_RR_ID1 does not exist.") def test_findDataProduct_success(self): # setup # Data Product dp_obj = IonObject(RT.DataProduct, name="DP_X", description="some existing dp") self.resource_registry.find_resources.return_value = ([dp_obj], []) # test call result = self.data_product_management_service.find_data_products() # check results self.assertEqual(result, [dp_obj]) self.resource_registry.find_resources.assert_called_once_with(RT.DataProduct, None, None, False)
class TestDataProductProvenance(IonIntegrationTestCase): def setUp(self): # Start container #print 'instantiating container' self._start_container() self.container.start_rel_from_url('res/deploy/r2deploy.yml') print 'started services' # Now create client to DataProductManagementService self.client = DataProductManagementServiceClient(node=self.container.node) self.rrclient = ResourceRegistryServiceClient(node=self.container.node) self.damsclient = DataAcquisitionManagementServiceClient(node=self.container.node) self.pubsubclient = PubsubManagementServiceClient(node=self.container.node) self.ingestclient = IngestionManagementServiceClient(node=self.container.node) self.dpmsclient = DataProductManagementService(node=self.container.node) self.imsclient = InstrumentManagementServiceClient(node=self.container.node) self.process_dispatcher = ProcessDispatcherServiceClient() @unittest.skip('not ready') def test_get_provenance(self): # Create InstrumentModel instModel_obj = IonObject(RT.InstrumentModel, name='SBE37IMModel', description="SBE37IMModel", model="SBE37IMModel" ) try: instModel_id = self.imsclient.create_instrument_model(instModel_obj) except BadRequest as ex: self.fail("failed to create new InstrumentModel: %s" %ex) log.debug( 'new InstrumentModel id = %s ', instModel_id) # Create InstrumentAgent instAgent_obj = IonObject(RT.InstrumentAgent, name='agent007', description="SBE37IMAgent", driver_module="ion.agents.instrument.instrument_agent", driver_class="InstrumentAgent" ) try: instAgent_id = self.imsclient.create_instrument_agent(instAgent_obj) except BadRequest as ex: self.fail("failed to create new InstrumentAgent: %s" %ex) log.debug( 'new InstrumentAgent id = %s', instAgent_id) self.imsclient.assign_instrument_model_to_instrument_agent(instModel_id, instAgent_id) # Create InstrumentDevice log.debug('test_activateInstrumentSample: Create instrument resource to represent the SBE37 (SA Req: L4-CI-SA-RQ-241) ') instDevice_obj = IonObject(RT.InstrumentDevice, name='SBE37IMDevice', description="SBE37IMDevice", serial_number="12345" ) try: instDevice_id = self.imsclient.create_instrument_device(instrument_device=instDevice_obj) self.imsclient.assign_instrument_model_to_instrument_device(instModel_id, instDevice_id) except BadRequest as ex: self.fail("failed to create new InstrumentDevice: %s" %ex) log.debug("test_activateInstrumentSample: new InstrumentDevice id = %s (SA Req: L4-CI-SA-RQ-241) ", instDevice_id) instAgentInstance_obj = IonObject(RT.InstrumentAgentInstance, name='SBE37IMAgentInstance', description="SBE37IMAgentInstance", driver_module='mi.instrument.seabird.sbe37smb.ooicore.driver', driver_class='SBE37Driver', comms_device_address='sbe37-simulator.oceanobservatories.org', comms_device_port=4001, port_agent_work_dir='/tmp/', port_agent_delimeter=['<<','>>'] ) instAgentInstance_id = self.imsclient.create_instrument_agent_instance(instAgentInstance_obj, instAgent_id, instDevice_id) # create a stream definition for the data from the ctd simulator ctd_stream_def = SBE37_CDM_stream_definition() ctd_stream_def_id = self.pubsubclient.create_stream_definition(container=ctd_stream_def) log.debug( 'new Stream Definition id = %s', instDevice_id) log.debug( 'Creating new CDM data product with a stream definition') craft = CoverageCraft sdom, tdom = craft.create_domains() sdom = sdom.dump() tdom = tdom.dump() parameter_dictionary = craft.create_parameters() parameter_dictionary = parameter_dictionary.dump() dp_obj = IonObject(RT.DataProduct, name='the parsed data', description='ctd stream test', temporal_domain = tdom, spatial_domain = sdom) ctd_parsed_data_product = self.dpmsclient.create_data_product(dp_obj, ctd_stream_def_id, parameter_dictionary) log.debug( 'new dp_id = %s', ctd_parsed_data_product) self.damsclient.assign_data_product(input_resource_id=instDevice_id, data_product_id=ctd_parsed_data_product) self.dpmsclient.activate_data_product_persistence(data_product_id=ctd_parsed_data_product) # Retrieve the id of the OUTPUT stream from the out Data Product stream_ids, _ = self.rrclient.find_objects(ctd_parsed_data_product, PRED.hasStream, None, True) log.debug( 'Data product streams1 = %s', stream_ids) pid = self.create_logger('ctd_parsed', stream_ids[0] ) self.loggerpids.append(pid) print 'TestDataProductProvenance: Data product streams1 = ', stream_ids #------------------------------- # L0 Conductivity - Temperature - Pressure: Data Process Definition #------------------------------- log.debug("TestDataProductProvenance: create data process definition ctd_L0_all") dpd_obj = IonObject(RT.DataProcessDefinition, name='ctd_L0_all', description='transform ctd package into three separate L0 streams', module='ion.processes.data.transforms.ctd.ctd_L0_all', class_name='ctd_L0_all', process_source='some_source_reference') try: ctd_L0_all_dprocdef_id = self.dataprocessclient.create_data_process_definition(dpd_obj) except BadRequest as ex: self.fail("failed to create new ctd_L0_all data process definition: %s" %ex) #------------------------------- # L1 Conductivity: Data Process Definition #------------------------------- log.debug("TestDataProductProvenance: create data process definition CTDL1ConductivityTransform") dpd_obj = IonObject(RT.DataProcessDefinition, name='ctd_L1_conductivity', description='create the L1 conductivity data product', module='ion.processes.data.transforms.ctd.ctd_L1_conductivity', class_name='CTDL1ConductivityTransform', process_source='CTDL1ConductivityTransform source code here...') try: ctd_L1_conductivity_dprocdef_id = self.dataprocessclient.create_data_process_definition(dpd_obj) except BadRequest as ex: self.fail("failed to create new CTDL1ConductivityTransform data process definition: %s" %ex) #------------------------------- # L1 Pressure: Data Process Definition #------------------------------- log.debug("TestDataProductProvenance: create data process definition CTDL1PressureTransform") dpd_obj = IonObject(RT.DataProcessDefinition, name='ctd_L1_pressure', description='create the L1 pressure data product', module='ion.processes.data.transforms.ctd.ctd_L1_pressure', class_name='CTDL1PressureTransform', process_source='CTDL1PressureTransform source code here...') try: ctd_L1_pressure_dprocdef_id = self.dataprocessclient.create_data_process_definition(dpd_obj) except BadRequest as ex: self.fail("failed to create new CTDL1PressureTransform data process definition: %s" %ex) #------------------------------- # L1 Temperature: Data Process Definition #------------------------------- log.debug("TestDataProductProvenance: create data process definition CTDL1TemperatureTransform") dpd_obj = IonObject(RT.DataProcessDefinition, name='ctd_L1_temperature', description='create the L1 temperature data product', module='ion.processes.data.transforms.ctd.ctd_L1_temperature', class_name='CTDL1TemperatureTransform', process_source='CTDL1TemperatureTransform source code here...') try: ctd_L1_temperature_dprocdef_id = self.dataprocessclient.create_data_process_definition(dpd_obj) except BadRequest as ex: self.fail("failed to create new CTDL1TemperatureTransform data process definition: %s" %ex) #------------------------------- # L2 Salinity: Data Process Definition #------------------------------- log.debug("TestDataProductProvenance: create data process definition SalinityTransform") dpd_obj = IonObject(RT.DataProcessDefinition, name='ctd_L2_salinity', description='create the L1 temperature data product', module='ion.processes.data.transforms.ctd.ctd_L2_salinity', class_name='SalinityTransform', process_source='SalinityTransform source code here...') try: ctd_L2_salinity_dprocdef_id = self.dataprocessclient.create_data_process_definition(dpd_obj) except BadRequest as ex: self.fail("failed to create new SalinityTransform data process definition: %s" %ex) #------------------------------- # L2 Density: Data Process Definition #------------------------------- log.debug("TestDataProductProvenance: create data process definition DensityTransform") dpd_obj = IonObject(RT.DataProcessDefinition, name='ctd_L2_density', description='create the L1 temperature data product', module='ion.processes.data.transforms.ctd.ctd_L2_density', class_name='DensityTransform', process_source='DensityTransform source code here...') try: ctd_L2_density_dprocdef_id = self.dataprocessclient.create_data_process_definition(dpd_obj) except BadRequest as ex: self.fail("failed to create new DensityTransform data process definition: %s" %ex) #------------------------------- # L0 Conductivity - Temperature - Pressure: Output Data Products #------------------------------- outgoing_stream_l0_conductivity = L0_conductivity_stream_definition() outgoing_stream_l0_conductivity_id = self.pubsubclient.create_stream_definition(container=outgoing_stream_l0_conductivity, name='L0_Conductivity') self.dataprocessclient.assign_stream_definition_to_data_process_definition(outgoing_stream_l0_conductivity_id, ctd_L0_all_dprocdef_id ) outgoing_stream_l0_pressure = L0_pressure_stream_definition() outgoing_stream_l0_pressure_id = self.pubsubclient.create_stream_definition(container=outgoing_stream_l0_pressure, name='L0_Pressure') self.dataprocessclient.assign_stream_definition_to_data_process_definition(outgoing_stream_l0_pressure_id, ctd_L0_all_dprocdef_id ) outgoing_stream_l0_temperature = L0_temperature_stream_definition() outgoing_stream_l0_temperature_id = self.pubsubclient.create_stream_definition(container=outgoing_stream_l0_temperature, name='L0_Temperature') self.dataprocessclient.assign_stream_definition_to_data_process_definition(outgoing_stream_l0_temperature_id, ctd_L0_all_dprocdef_id ) self.output_products={} log.debug("TestDataProductProvenance: create output data product L0 conductivity") ctd_l0_conductivity_output_dp_obj = IonObject( RT.DataProduct, name='L0_Conductivity', description='transform output conductivity', temporal_domain = tdom, spatial_domain = sdom) ctd_l0_conductivity_output_dp_id = self.dpmsclient.create_data_product(ctd_l0_conductivity_output_dp_obj, outgoing_stream_l0_conductivity_id, parameter_dictionary) self.output_products['conductivity'] = ctd_l0_conductivity_output_dp_id self.dpmsclient.activate_data_product_persistence(data_product_id=ctd_l0_conductivity_output_dp_id) log.debug("TestDataProductProvenance: create output data product L0 pressure") ctd_l0_pressure_output_dp_obj = IonObject( RT.DataProduct, name='L0_Pressure', description='transform output pressure', temporal_domain = tdom, spatial_domain = sdom) ctd_l0_pressure_output_dp_id = self.dpmsclient.create_data_product(ctd_l0_pressure_output_dp_obj, outgoing_stream_l0_pressure_id, parameter_dictionary) self.output_products['pressure'] = ctd_l0_pressure_output_dp_id self.dpmsclient.activate_data_product_persistence(data_product_id=ctd_l0_pressure_output_dp_id) log.debug("TestDataProductProvenance: create output data product L0 temperature") ctd_l0_temperature_output_dp_obj = IonObject( RT.DataProduct, name='L0_Temperature', description='transform output temperature', temporal_domain = tdom, spatial_domain = sdom) ctd_l0_temperature_output_dp_id = self.dpmsclient.create_data_product(ctd_l0_temperature_output_dp_obj, outgoing_stream_l0_temperature_id, parameter_dictionary) self.output_products['temperature'] = ctd_l0_temperature_output_dp_id self.dpmsclient.activate_data_product_persistence(data_product_id=ctd_l0_temperature_output_dp_id) #------------------------------- # L1 Conductivity - Temperature - Pressure: Output Data Products #------------------------------- outgoing_stream_l1_conductivity = L1_conductivity_stream_definition() outgoing_stream_l1_conductivity_id = self.pubsubclient.create_stream_definition(container=outgoing_stream_l1_conductivity, name='L1_conductivity') self.dataprocessclient.assign_stream_definition_to_data_process_definition(outgoing_stream_l1_conductivity_id, ctd_L1_conductivity_dprocdef_id ) outgoing_stream_l1_pressure = L1_pressure_stream_definition() outgoing_stream_l1_pressure_id = self.pubsubclient.create_stream_definition(container=outgoing_stream_l1_pressure, name='L1_Pressure') self.dataprocessclient.assign_stream_definition_to_data_process_definition(outgoing_stream_l1_pressure_id, ctd_L1_pressure_dprocdef_id ) outgoing_stream_l1_temperature = L1_temperature_stream_definition() outgoing_stream_l1_temperature_id = self.pubsubclient.create_stream_definition(container=outgoing_stream_l1_temperature, name='L1_Temperature') self.dataprocessclient.assign_stream_definition_to_data_process_definition(outgoing_stream_l1_temperature_id, ctd_L1_temperature_dprocdef_id ) log.debug("TestDataProductProvenance: create output data product L1 conductivity") ctd_l1_conductivity_output_dp_obj = IonObject(RT.DataProduct, name='L1_Conductivity', description='transform output L1 conductivity', temporal_domain = tdom, spatial_domain = sdom) ctd_l1_conductivity_output_dp_id = self.dpmsclient.create_data_product(ctd_l1_conductivity_output_dp_obj, outgoing_stream_l1_conductivity_id, parameter_dictionary) self.dpmsclient.activate_data_product_persistence(data_product_id=ctd_l1_conductivity_output_dp_id) # Retrieve the id of the OUTPUT stream from the out Data Product and add to granule logger stream_ids, _ = self.rrclient.find_objects(ctd_l1_conductivity_output_dp_id, PRED.hasStream, None, True) pid = self.create_logger('ctd_l1_conductivity', stream_ids[0] ) self.loggerpids.append(pid) log.debug("TestDataProductProvenance: create output data product L1 pressure") ctd_l1_pressure_output_dp_obj = IonObject( RT.DataProduct, name='L1_Pressure', description='transform output L1 pressure', temporal_domain = tdom, spatial_domain = sdom) ctd_l1_pressure_output_dp_id = self.dpmsclient.create_data_product(ctd_l1_pressure_output_dp_obj, outgoing_stream_l1_pressure_id, parameter_dictionary) self.dpmsclient.activate_data_product_persistence(data_product_id=ctd_l1_pressure_output_dp_id) # Retrieve the id of the OUTPUT stream from the out Data Product and add to granule logger stream_ids, _ = self.rrclient.find_objects(ctd_l1_pressure_output_dp_id, PRED.hasStream, None, True) pid = self.create_logger('ctd_l1_pressure', stream_ids[0] ) self.loggerpids.append(pid) log.debug("TestDataProductProvenance: create output data product L1 temperature") ctd_l1_temperature_output_dp_obj = IonObject( RT.DataProduct, name='L1_Temperature', description='transform output L1 temperature', temporal_domain = tdom, spatial_domain = sdom) ctd_l1_temperature_output_dp_id = self.dpmsclient.create_data_product(ctd_l1_temperature_output_dp_obj, outgoing_stream_l1_temperature_id, parameter_dictionary) self.dpmsclient.activate_data_product_persistence(data_product_id=ctd_l1_temperature_output_dp_id) # Retrieve the id of the OUTPUT stream from the out Data Product and add to granule logger stream_ids, _ = self.rrclient.find_objects(ctd_l1_temperature_output_dp_id, PRED.hasStream, None, True) pid = self.create_logger('ctd_l1_temperature', stream_ids[0] ) self.loggerpids.append(pid) #------------------------------- # L2 Salinity - Density: Output Data Products #------------------------------- outgoing_stream_l2_salinity = L2_practical_salinity_stream_definition() outgoing_stream_l2_salinity_id = self.pubsubclient.create_stream_definition(container=outgoing_stream_l2_salinity, name='L2_salinity') self.dataprocessclient.assign_stream_definition_to_data_process_definition(outgoing_stream_l2_salinity_id, ctd_L2_salinity_dprocdef_id ) outgoing_stream_l2_density = L2_density_stream_definition() outgoing_stream_l2_density_id = self.pubsubclient.create_stream_definition(container=outgoing_stream_l2_density, name='L2_Density') self.dataprocessclient.assign_stream_definition_to_data_process_definition(outgoing_stream_l2_density_id, ctd_L2_density_dprocdef_id ) log.debug("TestDataProductProvenance: create output data product L2 Salinity") ctd_l2_salinity_output_dp_obj = IonObject( RT.DataProduct, name='L2_Salinity', description='transform output L2 salinity', temporal_domain = tdom, spatial_domain = sdom) ctd_l2_salinity_output_dp_id = self.dpmsclient.create_data_product(ctd_l2_salinity_output_dp_obj, outgoing_stream_l2_salinity_id, parameter_dictionary) self.dpmsclient.activate_data_product_persistence(data_product_id=ctd_l2_salinity_output_dp_id) # Retrieve the id of the OUTPUT stream from the out Data Product and add to granule logger stream_ids, _ = self.rrclient.find_objects(ctd_l2_salinity_output_dp_id, PRED.hasStream, None, True) pid = self.create_logger('ctd_l2_salinity', stream_ids[0] ) self.loggerpids.append(pid) log.debug("TestDataProductProvenance: create output data product L2 Density") ctd_l2_density_output_dp_obj = IonObject( RT.DataProduct, name='L2_Density', description='transform output pressure', temporal_domain = tdom, spatial_domain = sdom) ctd_l2_density_output_dp_id = self.dpmsclient.create_data_product(ctd_l2_density_output_dp_obj, outgoing_stream_l2_density_id, parameter_dictionary) self.dpmsclient.activate_data_product_persistence(data_product_id=ctd_l2_density_output_dp_id) # Retrieve the id of the OUTPUT stream from the out Data Product and add to granule logger stream_ids, _ = self.rrclient.find_objects(ctd_l2_density_output_dp_id, PRED.hasStream, None, True) pid = self.create_logger('ctd_l2_density', stream_ids[0] ) self.loggerpids.append(pid) #------------------------------- # L0 Conductivity - Temperature - Pressure: Create the data process #------------------------------- log.debug("TestDataProductProvenance: create L0 all data_process start") try: ctd_l0_all_data_process_id = self.dataprocessclient.create_data_process(ctd_L0_all_dprocdef_id, [ctd_parsed_data_product], self.output_products) self.dataprocessclient.activate_data_process(ctd_l0_all_data_process_id) except BadRequest as ex: self.fail("failed to create new data process: %s" %ex) log.debug("TestDataProductProvenance: create L0 all data_process return") #------------------------------- # L1 Conductivity: Create the data process #------------------------------- log.debug("TestDataProductProvenance: create L1 Conductivity data_process start") try: l1_conductivity_data_process_id = self.dataprocessclient.create_data_process(ctd_L1_conductivity_dprocdef_id, [ctd_l0_conductivity_output_dp_id], {'output':ctd_l1_conductivity_output_dp_id}) self.dataprocessclient.activate_data_process(l1_conductivity_data_process_id) except BadRequest as ex: self.fail("failed to create new data process: %s" %ex) log.debug("TestDataProductProvenance: create L1 Conductivity data_process return") #------------------------------- # L1 Pressure: Create the data process #------------------------------- log.debug("TestDataProductProvenance: create L1_Pressure data_process start") try: l1_pressure_data_process_id = self.dataprocessclient.create_data_process(ctd_L1_pressure_dprocdef_id, [ctd_l0_pressure_output_dp_id], {'output':ctd_l1_pressure_output_dp_id}) self.dataprocessclient.activate_data_process(l1_pressure_data_process_id) except BadRequest as ex: self.fail("failed to create new data process: %s" %ex) log.debug("TestDataProductProvenance: create L1_Pressure data_process return") #------------------------------- # L1 Temperature: Create the data process #------------------------------- log.debug("TestDataProductProvenance: create L1_Pressure data_process start") try: l1_temperature_all_data_process_id = self.dataprocessclient.create_data_process(ctd_L1_temperature_dprocdef_id, [ctd_l0_temperature_output_dp_id], {'output':ctd_l1_temperature_output_dp_id}) self.dataprocessclient.activate_data_process(l1_temperature_all_data_process_id) except BadRequest as ex: self.fail("failed to create new data process: %s" %ex) log.debug("TestDataProductProvenance: create L1_Pressure data_process return") #------------------------------- # L2 Salinity: Create the data process #------------------------------- log.debug("TestDataProductProvenance: create L2_salinity data_process start") try: l2_salinity_all_data_process_id = self.dataprocessclient.create_data_process(ctd_L2_salinity_dprocdef_id, [ctd_parsed_data_product], {'output':ctd_l2_salinity_output_dp_id}) self.dataprocessclient.activate_data_process(l2_salinity_all_data_process_id) except BadRequest as ex: self.fail("failed to create new data process: %s" %ex) log.debug("TestDataProductProvenance: create L2_salinity data_process return") #------------------------------- # L2 Density: Create the data process #------------------------------- log.debug("TestDataProductProvenance: create L2_Density data_process start") try: l2_density_all_data_process_id = self.dataprocessclient.create_data_process(ctd_L2_density_dprocdef_id, [ctd_parsed_data_product], {'output':ctd_l2_density_output_dp_id}) self.dataprocessclient.activate_data_process(l2_density_all_data_process_id) except BadRequest as ex: self.fail("failed to create new data process: %s" %ex) log.debug("TestDataProductProvenance: create L2_Density data_process return") provenance_dict = self.dpmsclient.get_data_product_provenance(ctd_l2_density_output_dp_id)
class TestDataProductManagementServiceUnit(PyonTestCase): def setUp(self): self.clients = self._create_service_mock('data_product_management') self.data_product_management_service = DataProductManagementService() self.data_product_management_service.clients = self.clients # must call this manually self.data_product_management_service.on_init() self.data_source = Mock() self.data_source.name = 'data_source_name' self.data_source.description = 'data source desc' def test_createDataProduct_and_DataProducer_success(self): # setup self.clients.resource_registry.find_resources.return_value = ( [], 'do not care') self.clients.resource_registry.find_associations.return_value = [] self.clients.resource_registry.create.return_value = ('SOME_RR_ID1', 'Version_1') self.clients.data_acquisition_management.assign_data_product.return_value = None self.clients.pubsub_management.create_stream.return_value = "stream_id", "route_id" # Construct temporal and spatial Coordinate Reference System objects tcrs = CRS([AxisTypeEnum.TIME]) scrs = CRS([AxisTypeEnum.LON, AxisTypeEnum.LAT]) # Construct temporal and spatial Domain objects tdom = GridDomain(GridShape('temporal', [0]), tcrs, MutabilityEnum.EXTENSIBLE) # 1d (timeline) sdom = GridDomain(GridShape('spatial', [0]), scrs, MutabilityEnum.IMMUTABLE ) # 1d spatial topology (station/trajectory) sdom = sdom.dump() tdom = tdom.dump() dp_obj = IonObject(RT.DataProduct, name='DP1', description='some new dp', temporal_domain=tdom, spatial_domain=sdom) # test call dp_id = self.data_product_management_service.create_data_product( data_product=dp_obj, stream_definition_id='a stream def id') @unittest.skip('not working') def test_createDataProduct_and_DataProducer_with_id_NotFound(self): # setup self.clients.resource_registry.find_resources.return_value = ( [], 'do not care') self.clients.resource_registry.create.return_value = ('SOME_RR_ID1', 'Version_1') self.clients.pubsub_management.create_stream.return_value = 'stream1' # Data Product dpt_obj = IonObject(RT.DataProduct, name='DPT_X', description='some new data product') # test call with self.assertRaises(NotFound) as cm: dp_id = self.data_product_management_service.create_data_product( dpt_obj, 'stream_def_id') # check results self.clients.resource_registry.find_resources.assert_called_once_with( RT.DataProduct, None, dpt_obj.name, True) self.clients.resource_registry.create.assert_called_once_with(dpt_obj) #todo: what are errors to check in create stream? def test_findDataProduct_success(self): # setup # Data Product dp_obj = IonObject(RT.DataProduct, name='DP_X', description='some existing dp') self.clients.resource_registry.find_resources.return_value = ([dp_obj], []) # test call result = self.data_product_management_service.find_data_products() # check results self.assertEqual(result, [dp_obj]) self.clients.resource_registry.find_resources.assert_called_once_with( RT.DataProduct, None, None, False)
class TestDataProductManagementServiceUnit(PyonTestCase): def setUp(self): self.clients = self._create_service_mock('data_product_management') self.data_product_management_service = DataProductManagementService() self.data_product_management_service.clients = self.clients # must call this manually self.data_product_management_service.on_init() self.data_source = Mock() self.data_source.name = 'data_source_name' self.data_source.description = 'data source desc' @unittest.skip('not working') def test_createDataProduct_and_DataProducer_success(self): # setup self.clients.resource_registry.find_resources.return_value = ([], 'do not care') self.clients.resource_registry.find_associations.return_value = [] self.clients.resource_registry.create.return_value = ('SOME_RR_ID1', 'Version_1') self.clients.data_acquisition_management.assign_data_product.return_value = None self.clients.pubsub_management.create_stream.return_value = "stream_id" craft = CoverageCraft sdom, tdom = craft.create_domains() sdom = sdom.dump() tdom = tdom.dump() parameter_dictionary = craft.create_parameters() parameter_dictionary = parameter_dictionary.dump() dp_obj = IonObject(RT.DataProduct, name='DP1', description='some new dp', temporal_domain = tdom, spatial_domain = sdom) # test call dp_id = self.data_product_management_service.create_data_product(data_product=dp_obj, stream_definition_id='a stream def id', parameter_dictionary=parameter_dictionary) @unittest.skip('not working') def test_createDataProduct_and_DataProducer_with_id_NotFound(self): # setup self.clients.resource_registry.find_resources.return_value = ([], 'do not care') self.clients.resource_registry.create.return_value = ('SOME_RR_ID1', 'Version_1') self.clients.pubsub_management.create_stream.return_value = 'stream1' # Data Product dpt_obj = IonObject(RT.DataProduct, name='DPT_X', description='some new data product') # test call with self.assertRaises(NotFound) as cm: dp_id = self.data_product_management_service.create_data_product(dpt_obj, 'stream_def_id') # check results self.clients.resource_registry.find_resources.assert_called_once_with(RT.DataProduct, None, dpt_obj.name, True) self.clients.resource_registry.create.assert_called_once_with(dpt_obj) #todo: what are errors to check in create stream? def test_findDataProduct_success(self): # setup # Data Product dp_obj = IonObject(RT.DataProduct, name='DP_X', description='some existing dp') self.clients.resource_registry.find_resources.return_value = ([dp_obj], []) # test call result = self.data_product_management_service.find_data_products() # check results self.assertEqual(result, [dp_obj]) self.clients.resource_registry.find_resources.assert_called_once_with(RT.DataProduct, None, None, False)
class TestDataProductManagementServiceUnit(PyonTestCase): def setUp(self): self.clients = self._create_service_mock('data_product_management') self.data_product_management_service = DataProductManagementService() self.data_product_management_service.clients = self.clients # must call this manually self.data_product_management_service.on_init() self.data_source = Mock() self.data_source.name = 'data_source_name' self.data_source.description = 'data source desc' @unittest.skip('not working') def test_createDataProduct_and_DataProducer_success(self): # setup self.clients.resource_registry.find_resources.return_value = ([], 'do not care') self.clients.resource_registry.find_associations.return_value = [] self.clients.resource_registry.create.return_value = ('SOME_RR_ID1', 'Version_1') self.clients.data_acquisition_management.assign_data_product.return_value = None self.clients.pubsub_management.create_stream.return_value = "stream_id" # Construct temporal and spatial Coordinate Reference System objects tcrs = CRS([AxisTypeEnum.TIME]) scrs = CRS([AxisTypeEnum.LON, AxisTypeEnum.LAT]) # Construct temporal and spatial Domain objects tdom = GridDomain(GridShape('temporal', [0]), tcrs, MutabilityEnum.EXTENSIBLE) # 1d (timeline) sdom = GridDomain(GridShape('spatial', [0]), scrs, MutabilityEnum.IMMUTABLE) # 1d spatial topology (station/trajectory) sdom = sdom.dump() tdom = tdom.dump() #@TODO: DO NOT DO THIS, WHEN THIS TEST IS REWRITTEN GET RID OF THIS, IT WILL FAIL, thanks -Luke parameter_dictionary = get_param_dict('ctd_parsed_param_dict') parameter_dictionary = parameter_dictionary.dump() dp_obj = IonObject(RT.DataProduct, name='DP1', description='some new dp', temporal_domain = tdom, spatial_domain = sdom) # test call dp_id = self.data_product_management_service.create_data_product(data_product=dp_obj, stream_definition_id='a stream def id') @unittest.skip('not working') def test_createDataProduct_and_DataProducer_with_id_NotFound(self): # setup self.clients.resource_registry.find_resources.return_value = ([], 'do not care') self.clients.resource_registry.create.return_value = ('SOME_RR_ID1', 'Version_1') self.clients.pubsub_management.create_stream.return_value = 'stream1' # Data Product dpt_obj = IonObject(RT.DataProduct, name='DPT_X', description='some new data product') # test call with self.assertRaises(NotFound) as cm: dp_id = self.data_product_management_service.create_data_product(dpt_obj, 'stream_def_id') # check results self.clients.resource_registry.find_resources.assert_called_once_with(RT.DataProduct, None, dpt_obj.name, True) self.clients.resource_registry.create.assert_called_once_with(dpt_obj) #todo: what are errors to check in create stream? def test_findDataProduct_success(self): # setup # Data Product dp_obj = IonObject(RT.DataProduct, name='DP_X', description='some existing dp') self.clients.resource_registry.find_resources.return_value = ([dp_obj], []) # test call result = self.data_product_management_service.find_data_products() # check results self.assertEqual(result, [dp_obj]) self.clients.resource_registry.find_resources.assert_called_once_with(RT.DataProduct, None, None, False)