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):
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)