class TestInstrumentAgent(IonTestCase): @defer.inlineCallbacks def setUp(self): yield self._start_container() # Start an instrument agent processes = [ {'name':'pubsub_registry','module':'ion.services.dm.distribution.pubsub_registry','class':'DataPubSubRegistryService'}, {'name':'pubsub_service','module':'ion.services.dm.distribution.pubsub_service','class':'DataPubsubService'}, {'name':'agent_registry', 'module':'ion.services.coi.agent_registry', 'class':'ResourceRegistryService'}, {'name':'testSBE49IA', 'module':'ion.agents.instrumentagents.SBE49_IA', 'class':'SBE49InstrumentAgent'}, ] self.sup = yield self._spawn_processes(processes) self.svc_id = yield self.sup.get_child_id('testSBE49IA') self.reg_id = yield self.sup.get_child_id('agent_registry') # Start a client (for the RPC) self.IAClient = IA.InstrumentAgentClient(proc=self.sup, target=self.svc_id) # Start an Agent Registry to test against self.reg_client = AgentRegistryClient(proc=self.sup) yield self.reg_client.clear_registry() @defer.inlineCallbacks def tearDown(self): yield self._stop_container() @defer.inlineCallbacks def test_get_SBE49_capabilities(self): """ Test the ability to gather capabilities from the SBE49 instrument capabilities """ result = yield self.IAClient.get_capabilities() #logging.info("getCapabilities result: "+ str(result)) self.assert_(set(IACIParameters).issubset(set(result[IA.ci_parameters]))) self.assert_(IA.driver_address in result[IA.ci_parameters]) self.assert_(list(IACICommands) == result[IA.ci_commands]) self.assert_(list(IAInstCommands) == result[IA.instrument_commands]) self.assert_(list(IAInstParameters) == result[IA.instrument_parameters]) @defer.inlineCallbacks def test_get_set_SBE49_params(self): """ Test the ability of the SBE49 driver to send and receive get, set, and other messages. Best called as RPC message pairs. """ self.simulator = Simulator("123", 9000) self.simulator.start() # Sleep for a while to allow simlator to get set up. yield pu.asleep(1) try: response = yield self.IAClient.get_from_instrument(['baudrate', 'outputformat']) self.assert_(response['status'] == 'OK') self.assertEqual(response['baudrate'], 9600) self.assertEqual(response['outputformat'], 0) response = yield self.IAClient.set_to_instrument({'baudrate': 19200, 'outputformat': 1}) self.assert_(response['status'] == 'OK') self.assertEqual(response['baudrate'], 19200) self.assertEqual(response['outputformat'], 1) response = yield self.IAClient.get_from_instrument(['baudrate', 'outputformat']) self.assert_(response['status'] == 'OK') self.assertEqual(response['baudrate'], 19200) self.assertEqual(response['outputformat'], 1) response = yield self.IAClient.set_to_instrument({'outputformat': 2}) self.assert_(response['status'] == 'OK') self.assertEqual(response['outputformat'], 2) # Try setting something bad response = yield self.IAClient.set_to_instrument({'baudrate': 19200, 'badvalue': 1}) self.assert_(response['status'] == 'ERROR') self.assert_('baudrate' not in response) finally: yield self.simulator.stop() @defer.inlineCallbacks def test_registration(self): """ Tests the ability of an instrument agent to successfully register ifself with the resource registry. """ reg_ref = yield self.IAClient.register_resource("123") result = yield self.IAClient.get_resource_instance() self.assertNotEqual(result, None) self.assert_(isinstance(result, InstrumentAgentResourceInstance)) self.assertNotEqual(result.driver_process_id, None) self.assertEqual(result.instrument_ref.RegistryIdentity, "123") self.assertEqual(reg_ref.RegistryCommit, '') self.assertNotEqual(result.RegistryCommit, reg_ref.RegistryCommit) self.assertEqual(reg_ref.RegistryIdentity, result.RegistryIdentity) # Verify the reference is the same result = yield self.IAClient.get_resource_ref() self.assertEqual(result, reg_ref) @defer.inlineCallbacks def test_lifecycle_states(self): """ Test the resource lifecycle management """ yield self.IAClient.register_resource("123") response = yield self.IAClient.set_lifecycle_state(LCS.inactive) self.assertEqual(response, LCS.inactive) response = yield self.IAClient.get_lifecycle_state() self.assertEqual(response, LCS.inactive) self.assertNotEqual(response, LCS.active) response = yield self.IAClient.set_lifecycle_state(LCS.active) self.assertEqual(response, LCS.active) response = yield self.IAClient.get_lifecycle_state() self.assertEqual(response, LCS.active) @defer.inlineCallbacks def test_execute(self): """ Test the ability of the SBE49 driver to execute commands through the InstrumentAgentClient class """ self.simulator = Simulator("123", 9000) self.simulator.start() try: response = yield self.IAClient.execute_instrument([['start','now', 1], ['stop']]) print "response ", response self.assert_(isinstance(response, dict)) self.assert_('status' in response.keys()) self.assertEqual(response['status'], 'OK') self.assert_('start' in response['value']) self.assert_('stop' in response['value']) self.assert_(response['status'] == 'OK') response = yield self.IAClient.execute_instrument([['badcommand', 'now','1']]) self.assert_(isinstance(response, dict)) self.assertEqual(response['status'], 'ERROR') response = yield self.IAClient.execute_instrument([]) self.assert_(isinstance(response, dict)) self.assertEqual(response['status'], 'ERROR') finally: yield self.simulator.stop() @defer.inlineCallbacks def test_get_driver_proc(self): """ Test the methods for retreiving the driver process directly from the instrument agent. """ response = yield self.IAClient.get_from_CI([IA.driver_address]) self.assertNotEqual(response, None) """ Not the best test or logic, but see if the format is at least close Need a better way to get at the process id of the driver...maybe out of the registry? """ self.assertEqual(str(response[IA.driver_address]).rsplit('.', 1)[0], str(self.svc_id).rsplit('.', 1)[0]) @defer.inlineCallbacks def test_status(self): """ Test to see if the status response is correct @todo Do we even need this function? """ response = yield self.IAClient.get_status(['some_arg']) self.assert_(isinstance(response, dict)) self.assertEqual(response['status'], "OK") self.assertEqual(response['value'], 'a-ok') @defer.inlineCallbacks def test_translator(self): """ Test to see if the translator function is coming back cleanly @todo make this not a stub when we can pass functions through AMQP """ raise unittest.SkipTest('Needs Refactor of LifeCycle State and Resource Descriptions') yield
class TestResourceAgent(IonTestCase): @defer.inlineCallbacks def setUp(self): yield self._start_container() # use some sort of agent...doesnt really matter what kind, does it processes = [{ 'name': 'testAgent', 'module': 'ion.agents.instrumentagents.SBE49_IA', 'class': 'SBE49InstrumentAgent' }, { 'name': 'agent_registry', 'module': 'ion.services.coi.agent_registry', 'class': 'AgentRegistryService' }] self.sup = yield self._spawn_processes(processes) self.svc_id = self.sup.get_child_id('testAgent') self.rr_id = self.sup.get_child_id('agent_registry') # Start a client (for the RPC) self.RAClient = ResourceAgentClient(proc=self.sup, target=self.svc_id) # RR Client is ,,,,,desired only for testing self.reg_client = AgentRegistryClient(proc=self.sup) yield self.reg_client.clear_registry() # need any non-generic resource...use an instrument agent one for now self.res_desc = \ InstrumentAgentResourceDescription.create_new_resource() #self.res_desc.version = '1.23' self.res_desc.name = 'I am a test IA resource description' self.res_inst = InstrumentAgentResourceInstance.create_new_resource() self.res_inst.driver_process_id = 'something_for_now.1' self.res_inst.name = 'I am an instantiation of a test IA resource' @defer.inlineCallbacks def tearDown(self): yield self._stop_container() @defer.inlineCallbacks def test_reg_direct(self): registered_agent_desc = \ yield self.reg_client.register_agent_definition(self.res_desc) # Not committed, so not equal, but parts should be self.assertNotEqual(registered_agent_desc, self.res_desc) self.assertEqual(registered_agent_desc.RegistryIdentity, self.res_desc.RegistryIdentity) registered_agent_instance = \ yield self.reg_client.register_agent_instance(self.res_inst) # Not committed, so not equal, but parts should be self.assertNotEqual(registered_agent_instance, self.res_inst) self.assertEqual(registered_agent_instance.RegistryIdentity, self.res_inst.RegistryIdentity) recv_agent_desc = \ yield self.reg_client.get_agent_definition(self.res_desc) self.assertEqual(recv_agent_desc, registered_agent_desc) self.assertEqual(recv_agent_desc.RegistryIdentity, self.res_desc.RegistryIdentity) # Not committed, so not equal self.assertNotEqual(recv_agent_desc, self.res_desc) recv_agent_inst = \ yield self.reg_client.get_agent_instance(self.res_inst) self.assertEqual(recv_agent_inst, registered_agent_instance) # Not commiteed, so not equal, but parts should be self.assertNotEqual(recv_agent_inst, self.res_inst) self.assertEqual(recv_agent_inst.RegistryIdentity, self.res_inst.RegistryIdentity) @defer.inlineCallbacks def test_registration_with_definitions(self): reg_id = yield self.RAClient.register_resource(self.res_inst) orig_result = yield self.RAClient.get_resource_instance() self.assertNotEqual(orig_result, None) self.assertNotEqual(orig_result, self.res_inst) self.assertNotEqual(orig_result.RegistryCommit, self.res_inst.RegistryCommit) self.assertEqual(reg_id.RegistryCommit, '') self.assertNotEqual(orig_result.RegistryCommit, reg_id.RegistryCommit) self.assertEqual(reg_id.RegistryIdentity, orig_result.RegistryIdentity) # Verify the reference is the same result = yield self.RAClient.get_resource_ref() self.assertEqual(result, reg_id) # test update/repeat reg if a different instance new_res_inst = yield self.RAClient.get_resource_instance() new_res_inst.name = "REPLACED TestAgentInstance" new_res_inst.driver_process_id = 'something_else.1' # Even pulling it, modifiying it, then re-registering makes a new one new_result = yield self.RAClient.get_resource_instance() new_result.name = "UPDATED TestAgentInstance" new_result.driver_process_id = 'something_else.2' new_reg_ref = yield self.RAClient.register_resource(new_res_inst) self.assertNotEqual(reg_id, new_reg_ref) new_result2 = yield self.RAClient.get_resource_instance() self.assertNotEqual(new_result2.RegistryIdentity, orig_result.RegistryIdentity) self.assertNotEqual(new_result2.RegistryCommit, orig_result.RegistryCommit) self.assertNotEqual(new_result2.name, orig_result.name) self.assertEqual(new_result2.name, new_res_inst.name) self.assertEqual(new_result2.driver_process_id, new_res_inst.driver_process_id) self.assertNotEqual(new_result2.name, new_result.name) @defer.inlineCallbacks def test_agent_self_registration(self): reg_id = yield self.RAClient.register_resource() result = yield self.RAClient.get_resource_instance() self.assertNotEqual(result, None) self.assertEqual(reg_id.RegistryCommit, '') self.assertNotEqual(result.RegistryCommit, reg_id.RegistryCommit) self.assertEqual(reg_id.RegistryIdentity, result.RegistryIdentity) # Verify the reference is the same result = yield self.RAClient.get_resource_ref() self.assertEqual(result, reg_id) # Make A new agent to verify we have 2 processes = [{ 'name': 'testAgent2', 'module': 'ion.agents.instrumentagents.SBE49_IA', 'class': 'SBE49InstrumentAgent' }] sup2 = yield self._spawn_processes(processes) svc_id2 = self.sup.get_child_id('testAgent2') # Start a client (for the RPC) RAClient2 = ResourceAgentClient(proc=sup2, target=svc_id2) # test update/repeat reg if a different instance yield RAClient2.register_resource() refinst2 = yield RAClient2.get_resource_instance() refinst1 = yield self.RAClient.get_resource_ref() self.assertNotEqual(refinst1.RegistryCommit, refinst2.RegistryCommit) self.assertNotEqual(refinst1.RegistryIdentity, refinst2.RegistryIdentity) self.assertEqual(refinst1.RegistryCommit, result.RegistryCommit) self.assertEqual(refinst1.RegistryIdentity, result.RegistryIdentity) @defer.inlineCallbacks def test_lifecycle(self): registered_res = yield self.RAClient.register_resource(self.res_inst) self.assertNotEqual(registered_res, None) result = yield self.RAClient.get_resource_ref() self.assertEqual(result, registered_res) active_state = LCState('active') inactive_state = LCState('inactive') result = yield self.RAClient.set_lifecycle_state(active_state) self.assertEqual(result, active_state) result = yield self.RAClient.get_lifecycle_state() self.assertEqual(result, active_state) result = yield self.RAClient.set_lifecycle_state(inactive_state) ref = yield self.RAClient.get_resource_ref() self.assertNotEqual(ref, None) self.assertEqual(ref, registered_res) result = yield self.RAClient.get_lifecycle_state() self.assertEqual(result, inactive_state)
class TestResourceAgent(IonTestCase): @defer.inlineCallbacks def setUp(self): yield self._start_container() # use some sort of agent...doesnt really matter what kind, does it processes = [ {'name':'testAgent', 'module':'ion.agents.instrumentagents.SBE49_IA', 'class':'SBE49InstrumentAgent'}, {'name':'agent_registry', 'module':'ion.services.coi.agent_registry', 'class':'AgentRegistryService'} ] self.sup = yield self._spawn_processes(processes) self.svc_id = self.sup.get_child_id('testAgent') self.rr_id = self.sup.get_child_id('agent_registry') # Start a client (for the RPC) self.RAClient = ResourceAgentClient(proc=self.sup, target=self.svc_id) # RR Client is ,,,,,desired only for testing self.reg_client = AgentRegistryClient(proc=self.sup) yield self.reg_client.clear_registry() # need any non-generic resource...use an instrument agent one for now self.res_desc = \ InstrumentAgentResourceDescription.create_new_resource() #self.res_desc.version = '1.23' self.res_desc.name = 'I am a test IA resource description' self.res_inst = InstrumentAgentResourceInstance.create_new_resource() self.res_inst.driver_process_id = 'something_for_now.1' self.res_inst.name = 'I am an instantiation of a test IA resource' @defer.inlineCallbacks def tearDown(self): yield self._stop_container() @defer.inlineCallbacks def test_reg_direct(self): registered_agent_desc = \ yield self.reg_client.register_agent_definition(self.res_desc) # Not committed, so not equal, but parts should be self.assertNotEqual(registered_agent_desc, self.res_desc) self.assertEqual(registered_agent_desc.RegistryIdentity, self.res_desc.RegistryIdentity) registered_agent_instance = \ yield self.reg_client.register_agent_instance(self.res_inst) # Not committed, so not equal, but parts should be self.assertNotEqual(registered_agent_instance, self.res_inst) self.assertEqual(registered_agent_instance.RegistryIdentity, self.res_inst.RegistryIdentity) recv_agent_desc = \ yield self.reg_client.get_agent_definition(self.res_desc) self.assertEqual(recv_agent_desc, registered_agent_desc) self.assertEqual(recv_agent_desc.RegistryIdentity, self.res_desc.RegistryIdentity) # Not committed, so not equal self.assertNotEqual(recv_agent_desc, self.res_desc) recv_agent_inst = \ yield self.reg_client.get_agent_instance(self.res_inst) self.assertEqual(recv_agent_inst, registered_agent_instance) # Not commiteed, so not equal, but parts should be self.assertNotEqual(recv_agent_inst, self.res_inst) self.assertEqual(recv_agent_inst.RegistryIdentity, self.res_inst.RegistryIdentity) @defer.inlineCallbacks def test_registration_with_definitions(self): reg_id = yield self.RAClient.register_resource(self.res_inst) orig_result = yield self.RAClient.get_resource_instance() self.assertNotEqual(orig_result, None) self.assertNotEqual(orig_result, self.res_inst) self.assertNotEqual(orig_result.RegistryCommit, self.res_inst.RegistryCommit) self.assertEqual(reg_id.RegistryCommit, '') self.assertNotEqual(orig_result.RegistryCommit, reg_id.RegistryCommit) self.assertEqual(reg_id.RegistryIdentity, orig_result.RegistryIdentity) # Verify the reference is the same result = yield self.RAClient.get_resource_ref() self.assertEqual(result, reg_id) # test update/repeat reg if a different instance new_res_inst = yield self.RAClient.get_resource_instance() new_res_inst.name = "REPLACED TestAgentInstance" new_res_inst.driver_process_id = 'something_else.1' # Even pulling it, modifiying it, then re-registering makes a new one new_result = yield self.RAClient.get_resource_instance() new_result.name = "UPDATED TestAgentInstance" new_result.driver_process_id = 'something_else.2' new_reg_ref = yield self.RAClient.register_resource(new_res_inst) self.assertNotEqual(reg_id, new_reg_ref) new_result2 = yield self.RAClient.get_resource_instance() self.assertNotEqual(new_result2.RegistryIdentity, orig_result.RegistryIdentity) self.assertNotEqual(new_result2.RegistryCommit, orig_result.RegistryCommit) self.assertNotEqual(new_result2.name, orig_result.name) self.assertEqual(new_result2.name, new_res_inst.name) self.assertEqual(new_result2.driver_process_id, new_res_inst.driver_process_id) self.assertNotEqual(new_result2.name, new_result.name) @defer.inlineCallbacks def test_agent_self_registration(self): reg_id = yield self.RAClient.register_resource() result = yield self.RAClient.get_resource_instance() self.assertNotEqual(result, None) self.assertEqual(reg_id.RegistryCommit, '') self.assertNotEqual(result.RegistryCommit, reg_id.RegistryCommit) self.assertEqual(reg_id.RegistryIdentity, result.RegistryIdentity) # Verify the reference is the same result = yield self.RAClient.get_resource_ref() self.assertEqual(result, reg_id) # Make A new agent to verify we have 2 processes = [{'name':'testAgent2', 'module':'ion.agents.instrumentagents.SBE49_IA', 'class':'SBE49InstrumentAgent'}] sup2 = yield self._spawn_processes(processes) svc_id2 = self.sup.get_child_id('testAgent2') # Start a client (for the RPC) RAClient2 = ResourceAgentClient(proc=sup2, target=svc_id2) # test update/repeat reg if a different instance yield RAClient2.register_resource() refinst2 = yield RAClient2.get_resource_instance() refinst1 = yield self.RAClient.get_resource_ref() self.assertNotEqual(refinst1.RegistryCommit, refinst2.RegistryCommit) self.assertNotEqual(refinst1.RegistryIdentity, refinst2.RegistryIdentity) self.assertEqual(refinst1.RegistryCommit, result.RegistryCommit) self.assertEqual(refinst1.RegistryIdentity, result.RegistryIdentity) @defer.inlineCallbacks def test_lifecycle(self): registered_res = yield self.RAClient.register_resource(self.res_inst) self.assertNotEqual(registered_res, None) result = yield self.RAClient.get_resource_ref() self.assertEqual(result, registered_res) active_state = LCState('active') inactive_state = LCState('inactive') result = yield self.RAClient.set_lifecycle_state(active_state) self.assertEqual(result, active_state) result = yield self.RAClient.get_lifecycle_state() self.assertEqual(result, active_state) result = yield self.RAClient.set_lifecycle_state(inactive_state) ref = yield self.RAClient.get_resource_ref() self.assertNotEqual(ref, None) self.assertEqual(ref, registered_res) result = yield self.RAClient.get_lifecycle_state() self.assertEqual(result, inactive_state)