def setUp(self): """ Startup the container and start the agent. """ super(DataSetQualificationTestCase, self).setUp() self.instrument_agent_manager = InstrumentAgentClient() self.instrument_agent_manager.start_container( deploy_file=self.test_config.container_deploy_file) self.container = self.instrument_agent_manager.container gevent.sleep(5) log.debug("Packet Config: %s", self.test_config.agent_packet_config) self.data_subscribers = InstrumentAgentDataSubscribers( packet_config=self.test_config.agent_packet_config, ) self.event_subscribers = InstrumentAgentEventSubscribers( instrument_agent_resource_id=self.test_config.agent_resource_id) self.init_dataset_agent_client() self.event_subscribers.events_received = [] self.data_subscribers.start_data_subscribers() log.debug("********* setUp complete. Begin Testing *********") self.addCleanup(self._end_test)
def setUp(self): """ Startup the container and start the agent. """ super(DataSetQualificationTestCase, self).setUp() self.instrument_agent_manager = InstrumentAgentClient() self.instrument_agent_manager.start_container(deploy_file=self.test_config.container_deploy_file) self.container = self.instrument_agent_manager.container log.debug("Packet Config: %s", self.test_config.agent_packet_config) self.data_subscribers = InstrumentAgentDataSubscribers( packet_config=self.test_config.agent_packet_config, ) self.event_subscribers = InstrumentAgentEventSubscribers(instrument_agent_resource_id=self.test_config.agent_resource_id) self.init_dataset_agent_client() self.event_subscribers.events_received = [] self.data_subscribers.start_data_subscribers() log.debug("********* setUp complete. Begin Testing *********") self.addCleanup(self._end_test)
def start_container(self): """ Start up the capability container, port agent and the IA client """ self.init_comm_config() self.init_port_agent() self.instrument_agent_manager = InstrumentAgentClient(); self.instrument_agent_manager.start_container() self.init_instrument_agent_client()
def setUp(self): """ @brief Setup test cases. """ log.debug("InstrumentDriverQualificationTestCase setUp") InstrumentDriverTestCase.setUp(self) self.port_agent = self.test_config.port_agent self.instrument_agent_manager = InstrumentAgentClient(); self.instrument_agent_manager.start_container(deploy_file=self.test_config.container_deploy_file) self.container = self.instrument_agent_manager.container self.data_subscribers = InstrumentAgentDataSubscribers( packet_config=self.test_config.instrument_agent_packet_config, encoding=self.test_config.instrument_agent_stream_encoding, stream_definition=self.test_config.instrument_agent_stream_definition ) self.event_subscribers = InstrumentAgentEventSubscribers() self.init_instrument_agent_client()
def setUp(self): """ @brief Setup test cases. """ log.debug("#ROGER# does setUp get called?") InstrumentDriverTestCase.setUp(self) self.port_agent = self.test_config.port_agent self.instrument_agent_manager = InstrumentAgentClient(); self.instrument_agent_manager.start_container(deploy_file=self.test_config.container_deploy_file) self.container = self.instrument_agent_manager.container log.debug("#ROGER# in setUp self.test_config.instrument_agent_packet_config = " + str(self.test_config.instrument_agent_packet_config)) self.data_subscribers = InstrumentAgentDataSubscribers( packet_config=self.test_config.instrument_agent_packet_config, encoding=self.test_config.instrument_agent_stream_encoding, stream_definition=self.test_config.instrument_agent_stream_definition ) log.debug("InstrumentDriverQualificationTestCase setUp Problem BELOW") self.event_subscribers = InstrumentAgentEventSubscribers(instrument_agent_resource_id=self.test_config.instrument_agent_resource_id) log.debug("InstrumentDriverQualificationTestCase setUp Problem ABOVE") self.init_instrument_agent_client()
class DataSetQualificationTestCase(DataSetTestCase): """ Base class for dataset driver unit tests """ def setUp(self): """ Startup the container and start the agent. """ super(DataSetQualificationTestCase, self).setUp() self.instrument_agent_manager = InstrumentAgentClient() self.instrument_agent_manager.start_container( deploy_file=self.test_config.container_deploy_file) self.container = self.instrument_agent_manager.container log.debug("Packet Config: %s", self.test_config.agent_packet_config) self.data_subscribers = InstrumentAgentDataSubscribers( packet_config=self.test_config.agent_packet_config, ) self.event_subscribers = InstrumentAgentEventSubscribers( instrument_agent_resource_id=self.test_config.agent_resource_id) self.init_dataset_agent_client() self.event_subscribers.events_received = [] self.data_subscribers.start_data_subscribers() log.debug("********* setUp complete. Begin Testing *********") self.addCleanup(self._end_test) def _end_test(self): """ Cleanup after the test completes or fails """ log.debug("Starting test cleanup") self.assert_reset() self.event_subscribers.stop() self.data_subscribers.stop_data_subscribers() self.instrument_agent_manager.stop_container() log.debug("Test complete and all cleaned up.") def init_dataset_agent_client(self): log.info("Start Dataset Agent Client") # Start instrument agent client. self.instrument_agent_manager.start_client( name=self.test_config.agent_name, module=self.test_config.agent_module, cls=self.test_config.agent_class, config=self._agent_config(), resource_id=self.test_config.agent_resource_id, deploy_file=self.test_config.container_deploy_file, bootmode='reset') self.dataset_agent_client = self.instrument_agent_manager.instrument_agent_client def get_samples(self, stream_name, sample_count=1, timeout=10): """ listen on a stream until 'sample_count' samples are read and return a list of all samples read. If the required number of samples aren't read then throw an exception. Note that this method does not clear the sample queue for the stream. This should be done explicitly by the caller. However, samples that are consumed by this method are removed. @raise SampleTimeout - if the required number of samples aren't read """ result = [] start_time = time.time() i = 1 log.debug("Fetch %d sample(s) from stream '%s'" % (sample_count, stream_name)) while (len(result) < sample_count): if (self.data_subscribers.samples_received.has_key(stream_name) and len( self.data_subscribers.samples_received.get( stream_name))): log.trace("get_samples() received sample #%d!", i) result.append( self.data_subscribers.samples_received[stream_name].pop(0)) i += 1 # Check for timeout if (start_time + timeout < time.time()): raise SampleTimeout() if (not self.data_subscribers.samples_received.has_key(stream_name) or len( self.data_subscribers.samples_received.get( stream_name)) == 0): log.debug( "No samples in the queue, sleep for a bit to let the queue fill up" ) gevent.sleep(.2) log.debug("get_samples() complete. returning %d records", sample_count) return result def assert_sample_queue_size(self, stream_name, size): """ Verify that a queue has size samples in it. """ if (not self.data_subscribers.samples_received.has_key(stream_name) and size == 0): return self.assertTrue( self.data_subscribers.samples_received.has_key(stream_name), msg="Sample queue does not exists") self.assertEqual( len(self.data_subscribers.samples_received.get(stream_name)), size) def assert_data_values(self, particles, dataset_definition_file): """ Verify particles match the particles defined in the definition file """ rs_file = self._get_source_data_file(dataset_definition_file) rs = ResultSet(rs_file) self.assertTrue(rs.verify(particles)) def assert_initialize(self, final_state=ResourceAgentState.STREAMING): ''' Walk through DSA states to get to streaming mode from uninitialized ''' log.debug("Initialize DataSet agent") cmd = AgentCommand(command=ResourceAgentEvent.INITIALIZE) retval = self.dataset_agent_client.execute_agent(cmd) state = self.dataset_agent_client.get_agent_state() self.assertEqual(state, ResourceAgentState.INACTIVE) log.info("Sent INITIALIZE; DSA state = %s", state) log.debug("DataSet agent go active") cmd = AgentCommand(command=ResourceAgentEvent.GO_ACTIVE) retval = self.dataset_agent_client.execute_agent(cmd) state = self.dataset_agent_client.get_agent_state() log.info("Sent GO_ACTIVE; DSA state = %s", state) self.assertEqual(state, ResourceAgentState.IDLE) log.debug("DataSet agent run") cmd = AgentCommand(command=ResourceAgentEvent.RUN) retval = self.dataset_agent_client.execute_agent(cmd) state = self.dataset_agent_client.get_agent_state() log.info("Sent RUN; DSA state = %s", state) self.assertEqual(state, ResourceAgentState.COMMAND) if final_state == ResourceAgentState.STREAMING: self.assert_start_sampling() def assert_stop_sampling(self): ''' transition to command. Must be called from streaming ''' state = self.dataset_agent_client.get_agent_state() self.assertEqual(state, ResourceAgentState.STREAMING) log.debug("DataSet agent stop sampling") cmd = AgentCommand(command=DriverEvent.STOP_AUTOSAMPLE) retval = self.dataset_agent_client.execute_resource(cmd) state = self.dataset_agent_client.get_agent_state() log.info("Sent START SAMPLING; DSA state = %s", state) self.assertEqual(state, ResourceAgentState.COMMAND) def assert_start_sampling(self): ''' transition to sampling. Must be called from command ''' state = self.dataset_agent_client.get_agent_state() self.assertEqual(state, ResourceAgentState.COMMAND) log.debug("DataSet agent start sampling") cmd = AgentCommand(command=DriverEvent.START_AUTOSAMPLE) retval = self.dataset_agent_client.execute_resource(cmd) state = self.dataset_agent_client.get_agent_state() log.info("Sent START SAMPLING; DSA state = %s", state) self.assertEqual(state, ResourceAgentState.STREAMING) def assert_reset(self): ''' Put the instrument back in uninitialized ''' agent_state = self.dataset_agent_client.get_agent_state() log.debug("Resetting agent: current state: %s", agent_state) if agent_state != ResourceAgentState.UNINITIALIZED: cmd = AgentCommand(command=ResourceAgentEvent.RESET) retval = self.dataset_agent_client.execute_agent(cmd) state = self.dataset_agent_client.get_agent_state() log.debug("Resetting agent: final state: %s", state) def assert_agent_state(self, target_state): """ Verify the current agent state @param target_state: What we expect the agent state to be """ state = self.dataset_agent_client.get_agent_state() self.assertEqual(state, target_state) def assert_agent_command(self, command, args=None, timeout=None): """ Verify an agent command @param command: driver command to execute @param args: kwargs to pass to the agent command object """ cmd = AgentCommand(command=command, kwargs=args) retval = self.instrument_agent_client.execute_agent(cmd, timeout=timeout) def assert_resource_command(self, command, args=None, timeout=None): """ Verify a resource command @param command: driver command to execute @param args: kwargs to pass to the agent command object """ cmd = AgentCommand(command=command, kwargs=args) retval = self.dataset_agent_client.execute_resource(cmd) def assert_state_change(self, target_agent_state, timeout=10): """ Verify the agent and resource states change as expected within the timeout Fail if the state doesn't change to the expected state. @param target_agent_state: State we expect the agent to be in @param timeout: how long to wait for the driver to change states """ to = gevent.Timeout(timeout) to.start() done = False agent_state = None try: while (not done): agent_state = self.dataset_agent_client.get_agent_state() log.error("Current agent state: %s", agent_state) if (agent_state == target_agent_state): log.debug("Current state match: %s", agent_state) done = True if not done: log.debug( "state mismatch, waiting for state to transition.") gevent.sleep(1) except Timeout: log.error( "Failed to transition agent state to %s, current state: %s", target_agent_state, agent_state) self.fail("Failed to transition state.") finally: to.cancel() def assert_event_received(self, event_object_type, timeout=10): """ Verify an event has been received of a sepecific type @param event_object_type: Event object we are looking for @param timeout: how long to wait """ to = gevent.Timeout(timeout) to.start() done = False try: while (not done): for event in self.event_subscribers.events_received: log.debug("Event: %s", event) if isinstance(event, event_object_type): done = True if not done: log.debug( "target event not detected, sleep a bit to let events happen" ) gevent.sleep(1) except Timeout: log.error("Failed to find event in queue: %s", event_object_type) log.error("Current event queue: %s", self.event_subscribers._events_received) self.fail("%s event not detected") finally: to.cancel() log.info("Expected event detected: %s", event) def test_initialize(self): """ Test that we can start the container and initialize the dataset agent. """ self.assert_initialize() self.assert_stop_sampling() self.assert_reset() def test_resource_parameters(self): """ verify we can get a resource parameter lists and get/set parameters. """ def sort_capabilities(caps_list): ''' sort a return value into capability buckets. @retval agt_cmds, agt_pars, res_cmds, res_iface, res_pars ''' agt_cmds = [] agt_pars = [] res_cmds = [] res_iface = [] res_pars = [] if len(caps_list) > 0 and isinstance(caps_list[0], AgentCapability): agt_cmds = [ x.name for x in caps_list if x.cap_type == CapabilityType.AGT_CMD ] agt_pars = [ x.name for x in caps_list if x.cap_type == CapabilityType.AGT_PAR ] res_cmds = [ x.name for x in caps_list if x.cap_type == CapabilityType.RES_CMD ] #res_iface = [x.name for x in caps_list if x.cap_type==CapabilityType.RES_IFACE] res_pars = [ x.name for x in caps_list if x.cap_type == CapabilityType.RES_PAR ] elif len(caps_list) > 0 and isinstance(caps_list[0], dict): agt_cmds = [ x['name'] for x in caps_list if x['cap_type'] == CapabilityType.AGT_CMD ] agt_pars = [ x['name'] for x in caps_list if x['cap_type'] == CapabilityType.AGT_PAR ] res_cmds = [ x['name'] for x in caps_list if x['cap_type'] == CapabilityType.RES_CMD ] #res_iface = [x['name'] for x in caps_list if x['cap_type']==CapabilityType.RES_IFACE] res_pars = [ x['name'] for x in caps_list if x['cap_type'] == CapabilityType.RES_PAR ] agt_cmds.sort() agt_pars.sort() res_cmds.sort() res_iface.sort() res_pars.sort() return agt_cmds, agt_pars, res_cmds, res_iface, res_pars log.debug("Initialize the agent") expected_params = [ DriverParameter.BATCHED_PARTICLE_COUNT, DriverParameter.PUBLISHER_POLLING_INTERVAL, DriverParameter.RECORDS_PER_SECOND ] self.assert_initialize(final_state=ResourceAgentState.COMMAND) log.debug("Call get capabilities") retval = self.dataset_agent_client.get_capabilities() log.debug("Capabilities: %s", retval) agt_cmds, agt_pars, res_cmds, res_iface, res_pars = sort_capabilities( retval) self.assertEqual(sorted(res_pars), sorted(expected_params)) self.dataset_agent_client.set_resource( {DriverParameter.RECORDS_PER_SECOND: 20}) reply = self.dataset_agent_client.get_resource(DriverParameter.ALL) log.debug("Get Resource Result: %s", reply) def test_missing_directory(self): """ Test starting the driver when the data directory doesn't exists. This should prevent the driver from going into streaming mode. When the directory is created then we should be able to transition into streaming. """ self.remove_sample_dir() self.assert_initialize(final_state=ResourceAgentState.COMMAND) self.event_subscribers.clear_events() self.assert_resource_command(DriverEvent.START_AUTOSAMPLE) self.assert_state_change(ResourceAgentState.LOST_CONNECTION, 90) self.assert_event_received(ResourceAgentConnectionLostErrorEvent, 10) self.create_data_dir() # Should automatically retry connect and transition to streaming self.assert_state_change(ResourceAgentState.STREAMING, 90) def test_harvester_new_file_exception(self): """ Test an exception raised after the driver is started during the file read. exception callback called. """ config = self._driver_config( )['startup_config']['harvester']['pattern'] filename = config.replace("*", "foo") self.assert_new_file_exception(filename) def assert_new_file_exception(self, filename): self.clear_sample_data() self.create_sample_data(filename, mode=000) self.assert_initialize(final_state=ResourceAgentState.COMMAND) self.event_subscribers.clear_events() self.assert_resource_command(DriverEvent.START_AUTOSAMPLE) self.assert_state_change(ResourceAgentState.LOST_CONNECTION, 90) self.assert_event_received(ResourceAgentConnectionLostErrorEvent, 10) self.clear_sample_data() self.create_sample_data(filename) # Should automatically retry connect and transition to streaming self.assert_state_change(ResourceAgentState.STREAMING, 90)
class DataSetQualificationTestCase(DataSetTestCase): """ Base class for dataset driver unit tests """ def setUp(self): """ Startup the container and start the agent. """ super(DataSetQualificationTestCase, self).setUp() self.instrument_agent_manager = InstrumentAgentClient() self.instrument_agent_manager.start_container(deploy_file=self.test_config.container_deploy_file) self.container = self.instrument_agent_manager.container log.debug("Packet Config: %s", self.test_config.agent_packet_config) self.data_subscribers = InstrumentAgentDataSubscribers( packet_config=self.test_config.agent_packet_config, ) self.event_subscribers = InstrumentAgentEventSubscribers(instrument_agent_resource_id=self.test_config.agent_resource_id) self.init_dataset_agent_client() self.event_subscribers.events_received = [] self.data_subscribers.start_data_subscribers() log.debug("********* setUp complete. Begin Testing *********") self.addCleanup(self._end_test) def _end_test(self): """ Cleanup after the test completes or fails """ log.debug("Starting test cleanup") self.assert_reset() self.event_subscribers.stop() self.data_subscribers.stop_data_subscribers() self.instrument_agent_manager.stop_container() log.debug("Test complete and all cleaned up.") def init_dataset_agent_client(self): log.info("Start Dataset Agent Client") # Start instrument agent client. self.instrument_agent_manager.start_client( name=self.test_config.agent_name, module=self.test_config.agent_module, cls=self.test_config.agent_class, config=self._agent_config(), resource_id=self.test_config.agent_resource_id, deploy_file=self.test_config.container_deploy_file, bootmode='reset' ) self.dataset_agent_client = self.instrument_agent_manager.instrument_agent_client def get_samples(self, stream_name, sample_count = 1, timeout = 10): """ listen on a stream until 'sample_count' samples are read and return a list of all samples read. If the required number of samples aren't read then throw an exception. Note that this method does not clear the sample queue for the stream. This should be done explicitly by the caller. However, samples that are consumed by this method are removed. @raise SampleTimeout - if the required number of samples aren't read """ result = [] start_time = time.time() i = 1 log.debug("Fetch %d sample(s) from stream '%s'" % (sample_count, stream_name)) while(len(result) < sample_count): if(self.data_subscribers.samples_received.has_key(stream_name) and len(self.data_subscribers.samples_received.get(stream_name))): log.trace("get_samples() received sample #%d!", i) result.append(self.data_subscribers.samples_received[stream_name].pop(0)) i += 1 # Check for timeout if(start_time + timeout < time.time()): raise SampleTimeout() if(not self.data_subscribers.samples_received.has_key(stream_name) or len(self.data_subscribers.samples_received.get(stream_name)) == 0): log.debug("No samples in the queue, sleep for a bit to let the queue fill up") gevent.sleep(.2) log.debug("get_samples() complete. returning %d records", sample_count) return result def assert_sample_queue_size(self, stream_name, size): """ Verify that a queue has size samples in it. """ if(not self.data_subscribers.samples_received.has_key(stream_name) and size == 0): return self.assertTrue(self.data_subscribers.samples_received.has_key(stream_name), msg="Sample queue does not exists") self.assertEqual(len(self.data_subscribers.samples_received.get(stream_name)), size) def assert_data_values(self, particles, dataset_definition_file): """ Verify particles match the particles defined in the definition file """ rs_file = self._get_source_data_file(dataset_definition_file) rs = ResultSet(rs_file) self.assertTrue(rs.verify(particles)) def assert_initialize(self, final_state = ResourceAgentState.STREAMING): ''' Walk through DSA states to get to streaming mode from uninitialized ''' log.debug("Initialize DataSet agent") cmd = AgentCommand(command=ResourceAgentEvent.INITIALIZE) retval = self.dataset_agent_client.execute_agent(cmd) state = self.dataset_agent_client.get_agent_state() self.assertEqual(state, ResourceAgentState.INACTIVE) log.info("Sent INITIALIZE; DSA state = %s", state) log.debug("DataSet agent go active") cmd = AgentCommand(command=ResourceAgentEvent.GO_ACTIVE) retval = self.dataset_agent_client.execute_agent(cmd) state = self.dataset_agent_client.get_agent_state() log.info("Sent GO_ACTIVE; DSA state = %s", state) self.assertEqual(state, ResourceAgentState.IDLE) log.debug("DataSet agent run") cmd = AgentCommand(command=ResourceAgentEvent.RUN) retval = self.dataset_agent_client.execute_agent(cmd) state = self.dataset_agent_client.get_agent_state() log.info("Sent RUN; DSA state = %s", state) self.assertEqual(state, ResourceAgentState.COMMAND) if final_state == ResourceAgentState.STREAMING: self.assert_start_sampling() def assert_stop_sampling(self): ''' transition to command. Must be called from streaming ''' state = self.dataset_agent_client.get_agent_state() self.assertEqual(state, ResourceAgentState.STREAMING) log.debug("DataSet agent stop sampling") cmd = AgentCommand(command=DriverEvent.STOP_AUTOSAMPLE) retval = self.dataset_agent_client.execute_resource(cmd) state = self.dataset_agent_client.get_agent_state() log.info("Sent START SAMPLING; DSA state = %s", state) self.assertEqual(state, ResourceAgentState.COMMAND) def assert_start_sampling(self): ''' transition to sampling. Must be called from command ''' state = self.dataset_agent_client.get_agent_state() self.assertEqual(state, ResourceAgentState.COMMAND) log.debug("DataSet agent start sampling") cmd = AgentCommand(command=DriverEvent.START_AUTOSAMPLE) retval = self.dataset_agent_client.execute_resource(cmd) state = self.dataset_agent_client.get_agent_state() log.info("Sent START SAMPLING; DSA state = %s", state) self.assertEqual(state, ResourceAgentState.STREAMING) def assert_reset(self): ''' Put the instrument back in uninitialized ''' agent_state = self.dataset_agent_client.get_agent_state() log.debug("Resetting agent: current state: %s", agent_state) if agent_state != ResourceAgentState.UNINITIALIZED: cmd = AgentCommand(command=ResourceAgentEvent.RESET) retval = self.dataset_agent_client.execute_agent(cmd) state = self.dataset_agent_client.get_agent_state() log.debug("Resetting agent: final state: %s", state) def assert_agent_state(self, target_state): """ Verify the current agent state @param target_state: What we expect the agent state to be """ state = self.dataset_agent_client.get_agent_state() self.assertEqual(state, target_state) def assert_agent_command(self, command, args=None, timeout=None): """ Verify an agent command @param command: driver command to execute @param args: kwargs to pass to the agent command object """ cmd = AgentCommand(command=command, kwargs=args) retval = self.instrument_agent_client.execute_agent(cmd, timeout=timeout) def assert_resource_command(self, command, args=None, timeout=None): """ Verify a resource command @param command: driver command to execute @param args: kwargs to pass to the agent command object """ cmd = AgentCommand(command=command, kwargs=args) retval = self.dataset_agent_client.execute_resource(cmd) def assert_state_change(self, target_agent_state, timeout=10): """ Verify the agent and resource states change as expected within the timeout Fail if the state doesn't change to the expected state. @param target_agent_state: State we expect the agent to be in @param timeout: how long to wait for the driver to change states """ to = gevent.Timeout(timeout) to.start() done = False agent_state = None try: while(not done): agent_state = self.dataset_agent_client.get_agent_state() log.error("Current agent state: %s", agent_state) if(agent_state == target_agent_state): log.debug("Current state match: %s", agent_state) done = True if not done: log.debug("state mismatch, waiting for state to transition.") gevent.sleep(1) except Timeout: log.error("Failed to transition agent state to %s, current state: %s", target_agent_state, agent_state) self.fail("Failed to transition state.") finally: to.cancel() def assert_event_received(self, event_object_type, timeout=10): """ Verify an event has been received of a sepecific type @param event_object_type: Event object we are looking for @param timeout: how long to wait """ to = gevent.Timeout(timeout) to.start() done = False try: while(not done): for event in self.event_subscribers.events_received: log.debug("Event: %s", event) if isinstance(event, event_object_type): done = True if not done: log.debug("target event not detected, sleep a bit to let events happen") gevent.sleep(1) except Timeout: log.error("Failed to find event in queue: %s", event_object_type) log.error("Current event queue: %s", self.event_subscribers._events_received) self.fail("%s event not detected") finally: to.cancel() log.info("Expected event detected: %s", event) def test_initialize(self): """ Test that we can start the container and initialize the dataset agent. """ self.assert_initialize() self.assert_stop_sampling() self.assert_reset() def test_resource_parameters(self): """ verify we can get a resource parameter lists and get/set parameters. """ def sort_capabilities(caps_list): ''' sort a return value into capability buckets. @retval agt_cmds, agt_pars, res_cmds, res_iface, res_pars ''' agt_cmds = [] agt_pars = [] res_cmds = [] res_iface = [] res_pars = [] if len(caps_list)>0 and isinstance(caps_list[0], AgentCapability): agt_cmds = [x.name for x in caps_list if x.cap_type==CapabilityType.AGT_CMD] agt_pars = [x.name for x in caps_list if x.cap_type==CapabilityType.AGT_PAR] res_cmds = [x.name for x in caps_list if x.cap_type==CapabilityType.RES_CMD] #res_iface = [x.name for x in caps_list if x.cap_type==CapabilityType.RES_IFACE] res_pars = [x.name for x in caps_list if x.cap_type==CapabilityType.RES_PAR] elif len(caps_list)>0 and isinstance(caps_list[0], dict): agt_cmds = [x['name'] for x in caps_list if x['cap_type']==CapabilityType.AGT_CMD] agt_pars = [x['name'] for x in caps_list if x['cap_type']==CapabilityType.AGT_PAR] res_cmds = [x['name'] for x in caps_list if x['cap_type']==CapabilityType.RES_CMD] #res_iface = [x['name'] for x in caps_list if x['cap_type']==CapabilityType.RES_IFACE] res_pars = [x['name'] for x in caps_list if x['cap_type']==CapabilityType.RES_PAR] agt_cmds.sort() agt_pars.sort() res_cmds.sort() res_iface.sort() res_pars.sort() return agt_cmds, agt_pars, res_cmds, res_iface, res_pars log.debug("Initialize the agent") expected_params = [DriverParameter.BATCHED_PARTICLE_COUNT, DriverParameter.PUBLISHER_POLLING_INTERVAL, DriverParameter.RECORDS_PER_SECOND] self.assert_initialize(final_state=ResourceAgentState.COMMAND) log.debug("Call get capabilities") retval = self.dataset_agent_client.get_capabilities() log.debug("Capabilities: %s", retval) agt_cmds, agt_pars, res_cmds, res_iface, res_pars = sort_capabilities(retval) self.assertEqual(sorted(res_pars), sorted(expected_params)) self.dataset_agent_client.set_resource({DriverParameter.RECORDS_PER_SECOND: 20}) reply = self.dataset_agent_client.get_resource(DriverParameter.ALL) log.debug("Get Resource Result: %s", reply) def test_missing_directory(self): """ Test starting the driver when the data directory doesn't exists. This should prevent the driver from going into streaming mode. When the directory is created then we should be able to transition into streaming. """ self.remove_sample_dir() self.assert_initialize(final_state=ResourceAgentState.COMMAND) self.event_subscribers.clear_events() self.assert_resource_command(DriverEvent.START_AUTOSAMPLE) self.assert_state_change(ResourceAgentState.LOST_CONNECTION, 90) self.assert_event_received(ResourceAgentConnectionLostErrorEvent, 10) self.create_data_dir() # Should automatically retry connect and transition to streaming self.assert_state_change(ResourceAgentState.STREAMING, 90) def test_harvester_new_file_exception(self): """ Test an exception raised after the driver is started during the file read. exception callback called. """ config = self._driver_config()['startup_config']['harvester']['pattern'] filename = config.replace("*", "foo") self.assert_new_file_exception(filename) def assert_new_file_exception(self, filename): self.clear_sample_data() self.create_sample_data(filename, mode=000) self.assert_initialize(final_state=ResourceAgentState.COMMAND) self.event_subscribers.clear_events() self.assert_resource_command(DriverEvent.START_AUTOSAMPLE) self.assert_state_change(ResourceAgentState.LOST_CONNECTION, 90) self.assert_event_received(ResourceAgentConnectionLostErrorEvent, 10) self.clear_sample_data() self.create_sample_data(filename) # Should automatically retry connect and transition to streaming self.assert_state_change(ResourceAgentState.STREAMING, 90)
class InstrumentDriverQualificationTestCase(InstrumentDriverTestCase): @classmethod def setUpClass(cls): cls.init_port_agent() @classmethod def tearDownClass(cls): cls.stop_port_agent() def setUp(self): """ @brief Setup test cases. """ log.debug("InstrumentDriverQualificationTestCase setUp") InstrumentDriverTestCase.setUp(self) self.port_agent = self.test_config.port_agent self.instrument_agent_manager = InstrumentAgentClient(); self.instrument_agent_manager.start_container(deploy_file=self.test_config.container_deploy_file) self.container = self.instrument_agent_manager.container self.data_subscribers = InstrumentAgentDataSubscribers( packet_config=self.test_config.instrument_agent_packet_config, encoding=self.test_config.instrument_agent_stream_encoding, stream_definition=self.test_config.instrument_agent_stream_definition ) self.event_subscribers = InstrumentAgentEventSubscribers() self.init_instrument_agent_client() def init_instrument_agent_client(self): log.info("Start Instrument Agent Client") # A callback for processing subscribed-to data. ''' def consume_data(message, headers): log.info('Subscriber received data message: %s.', str(message)) self.samples_received.append(message) if self.no_samples and self.no_samples == len(self.samples_received): self.async_data_result.set() ''' # Driver config driver_config = { 'dvr_mod' : self.test_config.driver_module, 'dvr_cls' : self.test_config.driver_class, 'process_type' : self.test_config.driver_process_type, 'workdir' : self.test_config.working_dir, 'comms_config' : self.port_agent_comm_config() } # Create agent config. agent_config = { 'driver_config' : driver_config, 'stream_config' : self.data_subscribers.stream_config, 'agent' : {'resource_id': self.test_config.instrument_agent_resource_id}, 'test_mode' : True ## Enable a poison pill. If the spawning process dies ## shutdown the daemon process. } # Start instrument agent client. self.instrument_agent_manager.start_client( name=self.test_config.instrument_agent_name, module=self.test_config.instrument_agent_module, cls=self.test_config.instrument_agent_class, config=agent_config, resource_id=self.test_config.instrument_agent_resource_id, deploy_file=self.test_config.container_deploy_file ) self.instrument_agent_client = self.instrument_agent_manager.instrument_agent_client def tearDown(self): """ @brief Test teardown """ log.debug("InstrumentDriverQualificationTestCase tearDown") self.instrument_agent_manager.stop_container() InstrumentDriverTestCase.tearDown(self) def test_common_qualification(self): self.assertTrue(1) def test_instrument_agent_common_state_model_lifecycle(self): """ @brief Test agent state transitions. This test verifies that the instrument agent can properly command the instrument through the following states. @todo Once direct access settles down and works again, re-enable direct access. KNOWN COMMANDS -> RESULTANT STATES: * power_up -> UNINITIALIZED * power_down -> POWERED_DOWN * initialize -> INACTIVE * reset -> UNINITIALIZED * go_active -> IDLE * go_inactive -> INACTIVE * run -> OBSERVATORY * clear -> IDLE * pause -> STOPPED * resume -> OBSERVATORY * go_streaming -> STREAMING * go_direct_access -> DIRECT_ACCESS * go_observatory -> OBSERVATORY * get_current_state -> gives current state. * start_transaction (NA) * end_transaction (NA) STATES ACHIEVED: * InstrumentAgentState.POWERED_DOWN * InstrumentAgentState.UNINITIALIZED * InstrumentAgentState.INACTIVE * InstrumentAgentState.IDLE * InstrumentAgentState.OBSERVATORY * InstrumentAgentState.STREAMING * InstrumentAgentState.DIRECT_ACCESS * InstrumentAgentState.STOPPED above that are common to all devices go into common, others go into instrument specific ?? when we get it, we can add: ?? get_current_capabilitys <- instrument specific A side effect of this testing is verification that the events emitted by the agent conform to those expected by the system. """ cmd = AgentCommand(command='power_down') retval = self.instrument_agent_client.execute_agent(cmd) cmd = AgentCommand(command='get_current_state') retval = self.instrument_agent_client.execute_agent(cmd) state = retval.result self.assertEqual(state, InstrumentAgentState.POWERED_DOWN) cmd = AgentCommand(command='power_up') retval = self.instrument_agent_client.execute_agent(cmd) cmd = AgentCommand(command='get_current_state') retval = self.instrument_agent_client.execute_agent(cmd) state = retval.result self.assertEqual(state, InstrumentAgentState.UNINITIALIZED) cmd = AgentCommand(command='initialize') retval = self.instrument_agent_client.execute_agent(cmd) cmd = AgentCommand(command='get_current_state') retval = self.instrument_agent_client.execute_agent(cmd) state = retval.result self.assertEqual(state, InstrumentAgentState.INACTIVE) cmd = AgentCommand(command='go_active') retval = self.instrument_agent_client.execute_agent(cmd) cmd = AgentCommand(command='get_current_state') retval = self.instrument_agent_client.execute_agent(cmd) state = retval.result self.assertEqual(state, InstrumentAgentState.IDLE) log.debug("Instrument active. Verify RQ-634") cmd = AgentCommand(command='go_inactive') retval = self.instrument_agent_client.execute_agent(cmd) cmd = AgentCommand(command='get_current_state') retval = self.instrument_agent_client.execute_agent(cmd) state = retval.result self.assertEqual(state, InstrumentAgentState.INACTIVE) # ...and put it back to where it should be... cmd = AgentCommand(command='go_active') retval = self.instrument_agent_client.execute_agent(cmd) cmd = AgentCommand(command='get_current_state') retval = self.instrument_agent_client.execute_agent(cmd) state = retval.result self.assertEqual(state, InstrumentAgentState.IDLE) cmd = AgentCommand(command='run') retval = self.instrument_agent_client.execute_agent(cmd) cmd = AgentCommand(command='get_current_state') retval = self.instrument_agent_client.execute_agent(cmd) state = retval.result self.assertEqual(state, InstrumentAgentState.OBSERVATORY) # Begin streaming. cmd = AgentCommand(command='go_streaming') retval = self.instrument_agent_client.execute_agent(cmd) cmd = AgentCommand(command='get_current_state') retval = self.instrument_agent_client.execute_agent(cmd) state = retval.result self.assertEqual(state, InstrumentAgentState.STREAMING) log.debug("Enterered streaming mode. Verify RQ-636") # Halt streaming. cmd = AgentCommand(command='go_observatory') retval = self.instrument_agent_client.execute_agent(cmd) cmd = AgentCommand(command='get_current_state') retval = self.instrument_agent_client.execute_agent(cmd) state = retval.result self.assertEqual(state, InstrumentAgentState.OBSERVATORY) # go direct access cmd = AgentCommand(command='go_direct_access', kwargs={'session_type':DirectAccessTypes.telnet, #kwargs={'session_type':DirectAccessTypes.vsp, 'session_timeout':600, 'inactivity_timeout':600}) retval = self.instrument_agent_client.execute_agent(cmd) log.debug("5***** go_direct_access retval=" + str(retval.result)) cmd = AgentCommand(command='get_current_state') retval = self.instrument_agent_client.execute_agent(cmd) state = retval.result self.assertEqual(state, InstrumentAgentState.DIRECT_ACCESS) # Halt DA. cmd = AgentCommand(command='go_observatory') retval = self.instrument_agent_client.execute_agent(cmd) cmd = AgentCommand(command='get_current_state') retval = self.instrument_agent_client.execute_agent(cmd) state = retval.result self.assertEqual(state, InstrumentAgentState.OBSERVATORY) cmd = AgentCommand(command='pause') retval = self.instrument_agent_client.execute_agent(cmd) cmd = AgentCommand(command='get_current_state') retval = self.instrument_agent_client.execute_agent(cmd) state = retval.result self.assertEqual(state, InstrumentAgentState.STOPPED) cmd = AgentCommand(command='resume') retval = self.instrument_agent_client.execute_agent(cmd) cmd = AgentCommand(command='get_current_state') retval = self.instrument_agent_client.execute_agent(cmd) state = retval.result self.assertEqual(state, InstrumentAgentState.OBSERVATORY) cmd = AgentCommand(command='clear') retval = self.instrument_agent_client.execute_agent(cmd) cmd = AgentCommand(command='get_current_state') retval = self.instrument_agent_client.execute_agent(cmd) state = retval.result self.assertEqual(state, InstrumentAgentState.IDLE) cmd = AgentCommand(command='run') retval = self.instrument_agent_client.execute_agent(cmd) cmd = AgentCommand(command='get_current_state') retval = self.instrument_agent_client.execute_agent(cmd) state = retval.result self.assertEqual(state, InstrumentAgentState.OBSERVATORY) cmd = AgentCommand(command='pause') retval = self.instrument_agent_client.execute_agent(cmd) cmd = AgentCommand(command='get_current_state') retval = self.instrument_agent_client.execute_agent(cmd) state = retval.result self.assertEqual(state, InstrumentAgentState.STOPPED) cmd = AgentCommand(command='clear') retval = self.instrument_agent_client.execute_agent(cmd) cmd = AgentCommand(command='get_current_state') retval = self.instrument_agent_client.execute_agent(cmd) state = retval.result self.assertEqual(state, InstrumentAgentState.IDLE) cmd = AgentCommand(command='reset') retval = self.instrument_agent_client.execute_agent(cmd) cmd = AgentCommand(command='get_current_state') retval = self.instrument_agent_client.execute_agent(cmd) state = retval.result self.assertEqual(state, InstrumentAgentState.UNINITIALIZED) def test_instrument_agent_to_instrument_driver_connectivity(self): """ @brief This test verifies that the instrument agent can talk to the instrument driver. The intent of this is to be a ping to the driver layer. """ log.debug("IA client = " + str(self.instrument_agent_client)) cmd = AgentCommand(command='power_down') retval = self.instrument_agent_client.execute_agent(cmd) cmd = AgentCommand(command='get_current_state') retval = self.instrument_agent_client.execute_agent(cmd) state = retval.result self.assertEqual(state, InstrumentAgentState.POWERED_DOWN) cmd = AgentCommand(command='power_up') retval = self.instrument_agent_client.execute_agent(cmd) cmd = AgentCommand(command='get_current_state') retval = self.instrument_agent_client.execute_agent(cmd) state = retval.result self.assertEqual(state, InstrumentAgentState.UNINITIALIZED) cmd = AgentCommand(command='initialize') retval = self.instrument_agent_client.execute_agent(cmd) cmd = AgentCommand(command='get_current_state') retval = self.instrument_agent_client.execute_agent(cmd) state = retval.result cmd = AgentCommand(command='go_layer_ping') retval = self.instrument_agent_client.execute_agent(cmd) cmd = AgentCommand(command='get_current_state') retval = self.instrument_agent_client.execute_agent(cmd) state = retval.result self.assertEqual(state, InstrumentAgentState.LAYER_PING) log.debug("***** If i get here i am in LAYER_PING state....") cmd = AgentCommand(command='helo_agent', kwargs={'message': 'PING-AGENT'}) retval = self.instrument_agent_client.execute_agent(cmd) self.assertEqual(retval.result, "PONG-PING-AGENT") cmd = AgentCommand(command='helo_driver', kwargs={'message': 'PING-DRIVER'}) retval = self.instrument_agent_client.execute_agent(cmd) self.assertEqual(retval.result, 'process_echo: PING-DRIVER') cmd = AgentCommand(command='go_inactive') retval = self.instrument_agent_client.execute_agent(cmd) cmd = AgentCommand(command='get_current_state') retval = self.instrument_agent_client.execute_agent(cmd) state = retval.result log.debug("***** retval2 = " + str(retval)) self.assertEqual(state, InstrumentAgentState.INACTIVE) log.debug("***** If i get here i am in POWERED_DOWN state....") def test_instrument_error_code_enum(self): """ @brief check InstErrorCode for consistency """ self.assertTrue(self.check_for_reused_values(InstErrorCode)) pass def test_driver_connection_state_enum(self): """ @brief check DriverConnectionState for consistency @todo this check should also be a device specific for drivers like Trhph """ # self.assertEqual(TrhphDriverState.UNCONFIGURED, DriverConnectionState.UNCONFIGURED) # self.assertEqual(TrhphDriverState.DISCONNECTED, DriverConnectionState.DISCONNECTED) # self.assertEqual(TrhphDriverState.CONNECTED, DriverConnectionState.CONNECTED) self.assertTrue(self.check_for_reused_values(DriverConnectionState)) def test_instrument_agent_event_enum(self): self.assertTrue(self.check_for_reused_values(InstrumentAgentEvent)) def test_instrument_agent_state_enum(self): self.assertTrue(self.check_for_reused_values(InstrumentAgentState)) def check_for_reused_values(self, obj): """ @author Roger Unwin @brief verifies that no two definitions resolve to the same value. @returns True if no reused values """ match = 0 outer_match = 0 for i in [v for v in dir(obj) if not callable(getattr(obj,v))]: if i.startswith('_') == False: outer_match = outer_match + 1 for j in [x for x in dir(obj) if not callable(getattr(obj,x))]: if i.startswith('_') == False: if getattr(obj, i) == getattr(obj, j): match = match + 1 log.debug(str(i) + " == " + j + " (Looking for reused values)") # If this assert fails, then two of the enumerations have an identical value... return match == outer_match def test_driver_async_event_enum(self): """ @ brief ProtocolState enum test 1. test that SBE37ProtocolState matches the expected enums from DriverProtocolState. 2. test that multiple distinct states do not resolve back to the same string. """ self.assertTrue(self.check_for_reused_values(DriverAsyncEvent)) @unittest.skip("Transaction management not yet implemented") def test_transaction_management_messages(self): """ @brief This tests the start_transaction and end_transaction methods. https://confluence.oceanobservatories.org/display/syseng/CIAD+MI+SV+Instrument+Agent+Interface#CIADMISVInstrumentAgentInterface-Transactionmanagementmessages * start_transaction(acq_timeout,exp_timeout) * end_transaction(transaction_id) * transaction_id See: ion/services/mi/instrument_agent.py UPDATE: stub it out fill in later when its available ... place holder TODO: """ pass def de_dupe(self, list_in): unique_set = Set(item for item in list_in) return [(item) for item in unique_set] def test_driver_notification_messages(self): """ @brief This tests event messages from the driver. The following test moves the IA through all its states. As it does this, event messages are generated and caught. These messages are then compared with a list of expected messages to insure that the proper messages have been generated. """ # Clear off any events from before this test so we have consistent state self._events_received = [] expected_events = [] expected_events.append('Agent entered state: INSTRUMENT_AGENT_STATE_POWERED_DOWN') expected_events.append('Agent entered state: INSTRUMENT_AGENT_STATE_UNINITIALIZED') expected_events.append('Agent entered state: INSTRUMENT_AGENT_STATE_INACTIVE') expected_events.append('New driver state: DRIVER_STATE_DISCONNECTED') expected_events.append('New driver state: DRIVER_STATE_DISCONNECTED') expected_events.append('New driver state: DRIVER_STATE_UNKNOWN') expected_events.append('New driver configuration:') expected_events.append('New driver state: DRIVER_STATE_COMMAND') expected_events.append('Agent entered state: INSTRUMENT_AGENT_STATE_IDLE') expected_events.append('New driver state: DRIVER_STATE_DISCONNECTED') expected_events.append('Agent entered state: INSTRUMENT_AGENT_STATE_INACTIVE') expected_events.append('New driver state: DRIVER_STATE_UNCONFIGURED') expected_events.append('New driver state: DRIVER_STATE_DISCONNECTED') expected_events.append('New driver state: DRIVER_STATE_DISCONNECTED') expected_events.append('New driver state: DRIVER_STATE_UNKNOWN') expected_events.append('New driver configuration:') expected_events.append('New driver state: DRIVER_STATE_COMMAND') expected_events.append('Agent entered state: INSTRUMENT_AGENT_STATE_IDLE') expected_events.append('Agent entered state: INSTRUMENT_AGENT_STATE_OBSERVATORY') expected_events.append('New driver state: DRIVER_STATE_AUTOSAMPLE') expected_events.append('Agent entered state: INSTRUMENT_AGENT_STATE_STREAMING') expected_events.append('New driver configuration:') expected_events.append('New driver state: DRIVER_STATE_COMMAND') expected_events.append('New driver state: DRIVER_STATE_DIRECT_ACCESS') expected_events.append('Agent entered state: INSTRUMENT_AGENT_STATE_DIRECT_ACCESS') expected_events.append('New driver state: DRIVER_STATE_COMMAND') expected_events.append('Agent entered state: INSTRUMENT_AGENT_STATE_OBSERVATORY') expected_events.append('Agent entered state: INSTRUMENT_AGENT_STATE_STOPPED') expected_events.append('Agent entered state: INSTRUMENT_AGENT_STATE_OBSERVATORY') expected_events.append('Agent entered state: INSTRUMENT_AGENT_STATE_IDLE') expected_events.append('Agent entered state: INSTRUMENT_AGENT_STATE_OBSERVATORY') expected_events.append('Agent entered state: INSTRUMENT_AGENT_STATE_STOPPED') expected_events.append('Agent entered state: INSTRUMENT_AGENT_STATE_IDLE') expected_events.append('New driver state: DRIVER_STATE_DISCONNECTED') expected_events.append('New driver state: DRIVER_STATE_UNCONFIGURED') expected_events.append('Agent entered state: INSTRUMENT_AGENT_STATE_UNINITIALIZED') cmd = AgentCommand(command='power_down') retval = self.instrument_agent_client.execute_agent(cmd) cmd = AgentCommand(command='power_up') retval = self.instrument_agent_client.execute_agent(cmd) cmd = AgentCommand(command='initialize') retval = self.instrument_agent_client.execute_agent(cmd) cmd = AgentCommand(command='go_active') retval = self.instrument_agent_client.execute_agent(cmd) cmd = AgentCommand(command='go_inactive') retval = self.instrument_agent_client.execute_agent(cmd) cmd = AgentCommand(command='go_active') retval = self.instrument_agent_client.execute_agent(cmd) cmd = AgentCommand(command='run') retval = self.instrument_agent_client.execute_agent(cmd) # Begin streaming. cmd = AgentCommand(command='go_streaming') retval = self.instrument_agent_client.execute_agent(cmd) # Halt streaming. cmd = AgentCommand(command='go_observatory') retval = self.instrument_agent_client.execute_agent(cmd) # go direct access cmd = AgentCommand(command='go_direct_access', kwargs={'session_type':DirectAccessTypes.telnet, #kwargs={'session_type':DirectAccessTypes.vsp, 'session_timeout':600, 'inactivity_timeout':600}) retval = self.instrument_agent_client.execute_agent(cmd) log.debug("RETVAL = " + str(retval)) # Halt DA. cmd = AgentCommand(command='go_observatory') retval = self.instrument_agent_client.execute_agent(cmd) cmd = AgentCommand(command='pause') retval = self.instrument_agent_client.execute_agent(cmd) cmd = AgentCommand(command='resume') retval = self.instrument_agent_client.execute_agent(cmd) cmd = AgentCommand(command='clear') retval = self.instrument_agent_client.execute_agent(cmd) cmd = AgentCommand(command='run') retval = self.instrument_agent_client.execute_agent(cmd) cmd = AgentCommand(command='pause') retval = self.instrument_agent_client.execute_agent(cmd) cmd = AgentCommand(command='clear') retval = self.instrument_agent_client.execute_agent(cmd) cmd = AgentCommand(command='reset') retval = self.instrument_agent_client.execute_agent(cmd) raw_events = [] log.warn("ROGER *********************EVENTS " + str(self.event_subscribers.events_received)) for x in self.event_subscribers.events_received: if x.description.find("New driver configuration:") >= 0: raw_events.append("New driver configuration:") log.warn("ROGER *********************APPENDING " + "New driver configuration:") else: raw_events.append(str(x.description)) log.warn("ROGER *********************APPENDING " + str(x.description)) log.debug("raw_events[] = " + str(raw_events)) for x in sorted(raw_events): log.debug(str(x) + " ?in (expected_events) = " + str(x in expected_events)) self.assertTrue(x in expected_events) for x in sorted(expected_events): log.debug(str(x) + " ?in (raw_events) = " + str(x in raw_events)) # in incomplete drivers, 2 of the states are not reached. if x != "New driver configuration:" and x != 'New driver state: DRIVER_STATE_AUTOSAMPLE': self.assertTrue(x in raw_events) # assert we got the expected number of events num_expected = len(self.de_dupe(expected_events)) num_actual = len(self.de_dupe(raw_events)) self.assertTrue(num_actual <= num_expected) # in incomplete drivers, 2 of the states are not reached. # ("New driver configuration:" and 'New driver state: DRIVER_STATE_AUTOSAMPLE') self.assertTrue(num_actual >= (num_expected - 2)) # FAIL AssertionError: 37 != 38 pass def test_instrument_driver_to_physical_instrument_interoperability(self): """ @Brief this test is the integreation test test_connect but run through the agent. On a seabird sbe37 this results in a ds and dc command being sent. """ cmd = AgentCommand(command='initialize') retval = self.instrument_agent_client.execute_agent(cmd) cmd = AgentCommand(command='get_current_state') retval = self.instrument_agent_client.execute_agent(cmd) state = retval.result self.assertEqual(state, InstrumentAgentState.INACTIVE) cmd = AgentCommand(command='go_active') retval = self.instrument_agent_client.execute_agent(cmd) # Test the driver is configured for comms. cmd = AgentCommand(command='get_current_state') retval = self.instrument_agent_client.execute_agent(cmd) state = retval.result self.assertEqual(state, InstrumentAgentState.IDLE) pass @unittest.skip("Driver.get_device_signature not yet implemented") def test_get_device_signature(self): """ @Brief this test will call get_device_signature once that is implemented in the driver """ pass def test_initialize(self): """ Test agent initialize command. This causes creation of driver process and transition to inactive. """ cmd = AgentCommand(command='get_current_state') retval = self.instrument_agent_client.execute_agent(cmd) state = retval.result self.assertEqual(state, InstrumentAgentState.UNINITIALIZED) cmd = AgentCommand(command='initialize') retval = self.instrument_agent_client.execute_agent(cmd) cmd = AgentCommand(command='get_current_state') retval = self.instrument_agent_client.execute_agent(cmd) state = retval.result self.assertEqual(state, InstrumentAgentState.INACTIVE) cmd = AgentCommand(command='reset') retval = self.instrument_agent_client.execute_agent(cmd) cmd = AgentCommand(command='get_current_state') retval = self.instrument_agent_client.execute_agent(cmd) state = retval.result self.assertEqual(state, InstrumentAgentState.UNINITIALIZED)
class DataSetQualificationTestCase(DataSetTestCase): """ Base class for dataset driver unit tests """ def setUp(self): """ Startup the container and start the agent. """ super(DataSetQualificationTestCase, self).setUp() self.instrument_agent_manager = InstrumentAgentClient() self.instrument_agent_manager.start_container(deploy_file=self.test_config.container_deploy_file) self.container = self.instrument_agent_manager.container gevent.sleep(5) log.debug("Packet Config: %s", self.test_config.agent_packet_config) self.data_subscribers = InstrumentAgentDataSubscribers( packet_config=self.test_config.agent_packet_config, ) self.event_subscribers = InstrumentAgentEventSubscribers(instrument_agent_resource_id=self.test_config.agent_resource_id) self.init_dataset_agent_client() self.event_subscribers.events_received = [] self.data_subscribers.start_data_subscribers() log.debug("********* setUp complete. Begin Testing *********") self.addCleanup(self._end_test) def _end_test(self): """ Cleanup after the test completes or fails """ self.assert_reset() self.event_subscribers.stop() self.data_subscribers.stop_data_subscribers() self.instrument_agent_manager.stop_container() log.debug("Test complete and all cleaned up.") def init_dataset_agent_client(self): log.info("Start Dataset Agent Client") # Start instrument agent client. self.instrument_agent_manager.start_client( name=self.test_config.agent_name, module=self.test_config.agent_module, cls=self.test_config.agent_class, config=self._agent_config(), resource_id=self.test_config.agent_resource_id, deploy_file=self.test_config.container_deploy_file, bootmode='reset' ) self.dataset_agent_client = self.instrument_agent_manager.instrument_agent_client def get_samples(self, stream_name, sample_count = 1, timeout = 10): """ listen on a stream until 'sample_count' samples are read and return a list of all samples read. If the required number of samples aren't read then throw an exception. Note that this method does not clear the sample queue for the stream. This should be done explicitly by the caller. However, samples that are consumed by this method are removed. @raise SampleTimeout - if the required number of samples aren't read """ result = [] start_time = time.time() i = 1 log.debug("Fetch %d sample(s) from stream '%s'" % (sample_count, stream_name)) while(len(result) < sample_count): if(self.data_subscribers.samples_received.has_key(stream_name) and len(self.data_subscribers.samples_received.get(stream_name))): log.trace("get_samples() received sample #%d!", i) result.append(self.data_subscribers.samples_received[stream_name].pop()) i += 1 # Check for timeout if(start_time + timeout < time.time()): raise SampleTimeout() if(not self.data_subscribers.samples_received.has_key(stream_name) or len(self.data_subscribers.samples_received.get(stream_name)) == 0): log.debug("No samples in the queue, sleep for a bit to let the queue fill up") gevent.sleep(.2) log.debug("get_samples() complete. returning %d records", sample_count) return result def assert_sample_queue_size(self, stream_name, size): """ Verify that a queue has size samples in it. """ if(not self.data_subscribers.samples_received.has_key(stream_name) and size == 0): return self.assertTrue(self.data_subscribers.samples_received.has_key(stream_name), msg="Sample queue does not exists") self.assertEqual(len(self.data_subscribers.samples_received.get(stream_name)), size) def assert_data_values(self, particles, dataset_definition_file): """ Verify particles match the particles defined in the definition file """ rs_file = self._get_source_data_file(dataset_definition_file) rs = ResultSet(rs_file) self.assertTrue(rs.verify(particles)) def assert_initialize(self, final_state = ResourceAgentState.STREAMING): ''' Walk through DSA states to get to streaming mode from uninitialized ''' log.debug("Initialize DataSet agent") cmd = AgentCommand(command=ResourceAgentEvent.INITIALIZE) retval = self.dataset_agent_client.execute_agent(cmd) state = self.dataset_agent_client.get_agent_state() self.assertEqual(state, ResourceAgentState.INACTIVE) log.info("Sent INITIALIZE; DSA state = %s", state) log.debug("DataSet agent go active") cmd = AgentCommand(command=ResourceAgentEvent.GO_ACTIVE) retval = self.dataset_agent_client.execute_agent(cmd) state = self.dataset_agent_client.get_agent_state() log.info("Sent GO_ACTIVE; DSA state = %s", state) self.assertEqual(state, ResourceAgentState.IDLE) log.debug("DataSet agent run") cmd = AgentCommand(command=ResourceAgentEvent.RUN) retval = self.dataset_agent_client.execute_agent(cmd) state = self.dataset_agent_client.get_agent_state() log.info("Sent RUN; DSA state = %s", state) self.assertEqual(state, ResourceAgentState.COMMAND) if final_state == ResourceAgentState.STREAMING: self.assert_start_sampling() def assert_stop_sampling(self): ''' transition to command. Must be called from streaming ''' state = self.dataset_agent_client.get_agent_state() self.assertEqual(state, ResourceAgentState.STREAMING) log.debug("DataSet agent stop sampling") cmd = AgentCommand(command=DriverEvent.STOP_AUTOSAMPLE) retval = self.dataset_agent_client.execute_resource(cmd) state = self.dataset_agent_client.get_agent_state() log.info("Sent START SAMPLING; DSA state = %s", state) self.assertEqual(state, ResourceAgentState.COMMAND) def assert_start_sampling(self): ''' transition to sampling. Must be called from command ''' state = self.dataset_agent_client.get_agent_state() self.assertEqual(state, ResourceAgentState.COMMAND) log.debug("DataSet agent start sampling") cmd = AgentCommand(command=DriverEvent.START_AUTOSAMPLE) retval = self.dataset_agent_client.execute_resource(cmd) state = self.dataset_agent_client.get_agent_state() log.info("Sent START SAMPLING; DSA state = %s", state) self.assertEqual(state, ResourceAgentState.STREAMING) def assert_reset(self): ''' Put the instrument back in uninitialized ''' agent_state = self.dataset_agent_client.get_agent_state() if agent_state != ResourceAgentState.UNINITIALIZED: cmd = AgentCommand(command=ResourceAgentEvent.RESET) retval = self.dataset_agent_client.execute_agent(cmd) state = self.dataset_agent_client.get_agent_state() self.assertEqual(state, ResourceAgentState.UNINITIALIZED) def assert_agent_state(self, target_state): """ Verify the current agent state @param target_state: What we expect the agent state to be """ state = self.dataset_agent_client.get_agent_state() self.assertEqual(state, target_state) def assert_agent_command(self, command, args=None, timeout=None): """ Verify an agent command @param command: driver command to execute @param args: kwargs to pass to the agent command object """ cmd = AgentCommand(command=command, kwargs=args) retval = self.instrument_agent_client.execute_agent(cmd, timeout=timeout) def assert_resource_command(self, command, args=None, timeout=None): """ Verify a resource command @param command: driver command to execute @param args: kwargs to pass to the agent command object """ cmd = AgentCommand(command=command, kwargs=args) retval = self.dataset_agent_client.execute_resource(cmd) def assert_state_change(self, target_agent_state, timeout=10): """ Verify the agent and resource states change as expected within the timeout Fail if the state doesn't change to the expected state. @param target_agent_state: State we expect the agent to be in @param timeout: how long to wait for the driver to change states """ to = gevent.Timeout(timeout) to.start() done = False agent_state = None try: while(not done): agent_state = self.dataset_agent_client.get_agent_state() log.error("Current agent state: %s", agent_state) if(agent_state == target_agent_state): log.debug("Current state match: %s", agent_state) done = True if not done: log.debug("state mismatch, waiting for state to transition.") gevent.sleep(1) except Timeout: log.error("Failed to transition agent state to %s, current state: %s", target_agent_state, agent_state) self.fail("Failed to transition state.") finally: to.cancel() def assert_event_received(self, event_object_type, timeout=10): """ Verify an event has been received of a sepecific type @param event_object_type: Event object we are looking for @param timeout: how long to wait """ to = gevent.Timeout(timeout) to.start() done = False try: while(not done): for event in self.event_subscribers.events_received: log.debug("Event: %s", event) if isinstance(event, event_object_type): done = True if not done: log.debug("target event not detected, sleep a bit to let events happen") gevent.sleep(1) except Timeout: log.error("Failed to find event in queue: %s", event_object_type) log.error("Current event queue: %s", self.event_subscribers._events_received) self.fail("%s event not detected") finally: to.cancel() log.info("Expected event detected: %s", event)
def setUp(self): """ Setup the test case """ self.ia_client = InstrumentAgentClient()
class TestIAStart(MiUnitTest): """ Test the instrument agent startup """ def setUp(self): """ Setup the test case """ self.ia_client = InstrumentAgentClient() def test_container_rabbitmq(self): """ Test that rabbitmq can be started @TODO This test should start/stop rabbitmq and couch in setup, as it leaves the system in a bad state. """ self.ia_client.start_rabbitmq_server() pid = self.ia_client._read_pidfile( self.ia_client._pid_filename("rabbitmq")) self.assertTrue(pid) self.ia_client.start_rabbitmq_server() new_pid = self.ia_client._read_pidfile( self.ia_client._pid_filename("rabbitmq")) self.assertEqual(pid, new_pid) self.ia_client.stop_rabbitmq_server() pid = self.ia_client._read_pidfile( self.ia_client._pid_filename("rabbitmq")) self.assertFalse(pid) def test_container_couchdb(self): """Test that couchdb can be started""" self.ia_client.start_couchdb() pid = self.ia_client._read_pidfile( self.ia_client._pid_filename("couchdb")) self.assertTrue(pid) self.ia_client.start_couchdb() new_pid = self.ia_client._read_pidfile( self.ia_client._pid_filename("couchdb")) self.assertEqual(pid, new_pid) self.ia_client.stop_couchdb() pid = self.ia_client._read_pidfile( self.ia_client._pid_filename("couchdb")) self.assertFalse(pid) def test_container_start(self): """Test that a container can be started""" self.ia_client.start_container() self.assertTrue(self.ia_client.container) self.ia_client.stop_container() self.assertFalse(self.ia_client.container) def test_data_subscriber(self): """ Test that we can build data subscribers using the packet config from the IDK """ data_subscriber = InstrumentAgentDataSubscribers()
class DirectAccessServer(): """ Main class for running the start driver process. """ port_agent = None instrument_agent_manager = None instrument_agent_client = None monitor_process = None def __init__(self, launch_monitor=False): """ Setup the direct access server """ # Currently we are pulling the driver config information from the driver tests. There is a better way to do # this, but we are time crunched. TODO: Fix this! generator = DriverGenerator(Metadata()) __import__(generator.test_modulename()) self.test_config = InstrumentDriverTestConfig() # Test to ensure we have initialized our test config if not self.test_config.initialized: raise TestNotInitialized(msg="Tests non initialized. Missing InstrumentDriverTestCase.initalize(...)?") self.launch_monitor = launch_monitor def __del__(self): """ Destructor to cleanup all the processes we started to run DA """ log.info("tearing down agents and containers") log.debug("killing the capability container") if self.instrument_agent_manager: self.instrument_agent_manager.stop_container() log.debug("killing the port agent") if self.port_agent: self.port_agent.stop() if self.monitor_process: log.debug("killing the monitor process") self.monitor_process.kill() def start_container(self): """ Start up the capability container, port agent and the IA client """ self.init_comm_config() self.init_port_agent() self.instrument_agent_manager = InstrumentAgentClient(); self.instrument_agent_manager.start_container() self.init_instrument_agent_client() def comm_config_file(self): """ @brief Return the path the the driver comm config yaml file. @return if comm_config.yml exists return the full path """ repo_dir = Config().get('working_repo') driver_path = self.test_config.driver_module p = re.compile('\.') driver_path = p.sub('/', driver_path) abs_path = "%s/%s/%s" % (repo_dir, os.path.dirname(driver_path), CommConfig.config_filename()) log.debug(abs_path) return abs_path def init_comm_config(self): """ @brief Create the comm config object by reading the comm_config.yml file. """ log.info("Initialize comm config") config_file = self.comm_config_file() log.debug( " -- reading comm config from: %s" % config_file ) if not os.path.exists(config_file): raise TestNoCommConfig(msg="Missing comm config. Try running start_driver or switch_driver") self.comm_config = CommConfig.get_config_from_file(config_file) def init_port_agent(self): """ @brief Launch the driver process and driver client. This is used in the integration and qualification tests. The port agent abstracts the physical interface with the instrument. @retval return the pid to the logger process """ log.info("Startup Port Agent") config = { 'device_addr' : self.comm_config.device_addr, 'device_port' : self.comm_config.device_port, 'command_port': self.comm_config.command_port, 'data_port': self.comm_config.data_port, 'process_type': PortAgentProcessType.UNIX, 'log_level': 5, } self.port_agent = PortAgentProcess.launch_process(config, timeout = 60, test_mode = True) port = self.port_agent.get_data_port() pid = self.port_agent.get_pid() log.info('Started port agent pid %s listening at port %s' % (pid, port)) if self.launch_monitor: self.logfile = self.port_agent.port_agent.logfname log.info('Started port agent pid %s listening at port %s' % (pid, port)) log.info("data log: %s" % self.logfile) self.monitor_process = launch_data_monitor(self.logfile) def stop_port_agent(self): """ Stop the port agent. """ if self.port_agent: self.port_agent.stop() if self.monitor_process: self.monitor_process.kill() def init_instrument_agent_client(self): """ Start up the instrument agent client. """ log.info("Start Instrument Agent Client") # Port config port = self.port_agent.get_data_port() port_config = { 'addr': 'localhost', 'port': port } # Driver config driver_config = { 'dvr_mod' : self.test_config.driver_module, 'dvr_cls' : self.test_config.driver_class, 'process_type' : self.test_config.driver_process_type, 'workdir' : self.test_config.working_dir, 'comms_config' : port_config } # Create agent config. agent_config = { 'driver_config' : driver_config, 'stream_config' : {}, 'agent' : {'resource_id': self.test_config.instrument_agent_resource_id}, 'test_mode' : True ## Enable a poison pill. If the spawning process dies ## shutdown the daemon process. } # Start instrument agent client. self.instrument_agent_manager.start_client( name=self.test_config.instrument_agent_name, module=self.test_config.instrument_agent_module, cls=self.test_config.instrument_agent_class, config=agent_config, resource_id=self.test_config.instrument_agent_resource_id, deploy_file=self.test_config.container_deploy_file ) self.instrument_agent_client = self.instrument_agent_manager.instrument_agent_client def _start_da(self, type): """ The actual work to start up a DA session. """ self.start_container() log.info("--- Starting DA server ---") #cmd = AgentCommand(command=ResourceAgentEvent.POWER_DOWN) #retval = self.instrument_agent_client.execute_agent(cmd) #log.debug("retval: %s", retval) #cmd = AgentCommand(command=ResourceAgentEvent.GET_RESOURCE_STATE) #retval = self.instrument_agent_client.execute_agent(cmd) #log.debug("retval: %s", retval) #cmd = AgentCommand(command=ResourceAgentEvent.POWER_UP) #retval = self.instrument_agent_client.execute_agent(cmd) #log.debug("retval: %s", retval) #cmd = AgentCommand(command=ResourceAgentEvent.GET_RESOURCE_STATE) #retval = self.instrument_agent_client.execute_agent(cmd) #log.debug("retval: %s", retval) cmd = AgentCommand(command=ResourceAgentEvent.INITIALIZE) retval = self.instrument_agent_client.execute_agent(cmd) log.debug("retval: %s", retval) cmd = AgentCommand(command=ResourceAgentEvent.GET_RESOURCE_STATE) retval = self.instrument_agent_client.execute_agent(cmd) log.debug("retval: %s", retval) cmd = AgentCommand(command=ResourceAgentEvent.GO_ACTIVE) retval = self.instrument_agent_client.execute_agent(cmd) log.debug("retval: %s", retval) cmd = AgentCommand(command=ResourceAgentEvent.GET_RESOURCE_STATE) retval = self.instrument_agent_client.execute_agent(cmd) log.debug("retval: %s", retval) cmd = AgentCommand(command=ResourceAgentEvent.RUN) retval = self.instrument_agent_client.execute_agent(cmd) log.debug("retval: %s", retval) cmd = AgentCommand(command=ResourceAgentEvent.GET_RESOURCE_STATE) retval = self.instrument_agent_client.execute_agent(cmd) log.debug("retval: %s", retval) cmd = AgentCommand(command=ResourceAgentEvent.GO_DIRECT_ACCESS, kwargs={'session_type': type, 'session_timeout': TIMEOUT, 'inactivity_timeout': TIMEOUT}) retval = self.instrument_agent_client.execute_agent(cmd) log.debug("retval: %s", retval) ip_address = retval.result['ip_address'] port= retval.result['port'] token= retval.result['token'] cmd = AgentCommand(command=ResourceAgentEvent.GET_RESOURCE_STATE) retval = self.instrument_agent_client.execute_agent(cmd) log.debug("retval: %s", retval) ia_state = retval.result log.debug("IA State: %s", ia_state) if ia_state == DriverProtocolState.DIRECT_ACCESS: print "Direct access server started, IP: %s Port: %s" % (ip_address, port) if token: print "Token: %s" % token while ia_state == DriverProtocolState.DIRECT_ACCESS: cmd = AgentCommand(command=ResourceAgentEvent.GET_RESOURCE_STATE) retval = self.instrument_agent_client.execute_agent(cmd) ia_state = retval.result gevent.sleep(.1) else: log.error("Failed to start DA server (%s)" % ia_state) def start_telnet_server(self): """ @brief Run the telnet server """ self._start_da(DirectAccessTypes.telnet) def start_vps_server(self): """ @brief run the vps server """ self._start_da(DirectAccessTypes.vsp)
def setUp(self): """ Setup the test case """ self.ia_client = InstrumentAgentClient()
class TestIAStart(unittest.TestCase): """ Test the instrument agent startup """ def setUp(self): """ Setup the test case """ self.ia_client = InstrumentAgentClient() def test_container_rabbitmq(self): """Test that rabbitmq can be started""" self.ia_client.start_rabbitmq_server() pid = self.ia_client._read_pidfile(self.ia_client._pid_filename("rabbitmq")) self.assertTrue(pid) self.ia_client.start_rabbitmq_server() new_pid = self.ia_client._read_pidfile(self.ia_client._pid_filename("rabbitmq")) self.assertEqual(pid, new_pid) self.ia_client.stop_rabbitmq_server() pid = self.ia_client._read_pidfile(self.ia_client._pid_filename("rabbitmq")) self.assertFalse(pid) def test_container_couchdb(self): """Test that couchdb can be started""" self.ia_client.start_couchdb() pid = self.ia_client._read_pidfile(self.ia_client._pid_filename("couchdb")) self.assertTrue(pid) self.ia_client.start_couchdb() new_pid = self.ia_client._read_pidfile(self.ia_client._pid_filename("couchdb")) self.assertEqual(pid, new_pid) self.ia_client.stop_couchdb() pid = self.ia_client._read_pidfile(self.ia_client._pid_filename("couchdb")) self.assertFalse(pid) def test_container_start(self): """Test that a container can be started""" self.ia_client.start_container() self.assertTrue(self.ia_client.container) self.ia_client.stop_container() self.assertFalse(self.ia_client.container)
class DataSetQualificationTestCase(DataSetTestCase): """ Base class for dataset driver unit tests """ def setUp(self): """ Startup the container and start the agent. """ super(DataSetQualificationTestCase, self).setUp() self.instrument_agent_manager = InstrumentAgentClient() self.instrument_agent_manager.start_container( deploy_file=self.test_config.container_deploy_file) self.container = self.instrument_agent_manager.container gevent.sleep(5) log.debug("Packet Config: %s", self.test_config.agent_packet_config) self.data_subscribers = InstrumentAgentDataSubscribers( packet_config=self.test_config.agent_packet_config, ) self.event_subscribers = InstrumentAgentEventSubscribers( instrument_agent_resource_id=self.test_config.agent_resource_id) self.init_dataset_agent_client() self.event_subscribers.events_received = [] self.data_subscribers.start_data_subscribers() log.debug("********* setUp complete. Begin Testing *********") self.addCleanup(self._end_test) def _end_test(self): """ Cleanup after the test completes or fails """ self.assert_reset() self.event_subscribers.stop() self.data_subscribers.stop_data_subscribers() self.instrument_agent_manager.stop_container() log.debug("Test complete and all cleaned up.") def init_dataset_agent_client(self): log.info("Start Dataset Agent Client") # Start instrument agent client. self.instrument_agent_manager.start_client( name=self.test_config.agent_name, module=self.test_config.agent_module, cls=self.test_config.agent_class, config=self._agent_config(), resource_id=self.test_config.agent_resource_id, deploy_file=self.test_config.container_deploy_file, bootmode='reset') self.dataset_agent_client = self.instrument_agent_manager.instrument_agent_client def get_samples(self, stream_name, sample_count=1, timeout=10): """ listen on a stream until 'sample_count' samples are read and return a list of all samples read. If the required number of samples aren't read then throw an exception. Note that this method does not clear the sample queue for the stream. This should be done explicitly by the caller. However, samples that are consumed by this method are removed. @raise SampleTimeout - if the required number of samples aren't read """ result = [] start_time = time.time() i = 1 log.debug("Fetch %d sample(s) from stream '%s'" % (sample_count, stream_name)) while (len(result) < sample_count): if (self.data_subscribers.samples_received.has_key(stream_name) and len( self.data_subscribers.samples_received.get( stream_name))): log.trace("get_samples() received sample #%d!", i) result.append( self.data_subscribers.samples_received[stream_name].pop()) i += 1 # Check for timeout if (start_time + timeout < time.time()): raise SampleTimeout() if (not self.data_subscribers.samples_received.has_key(stream_name) or len( self.data_subscribers.samples_received.get( stream_name)) == 0): log.debug( "No samples in the queue, sleep for a bit to let the queue fill up" ) gevent.sleep(.2) log.debug("get_samples() complete. returning %d records", sample_count) return result def assert_sample_queue_size(self, stream_name, size): """ Verify that a queue has size samples in it. """ if (not self.data_subscribers.samples_received.has_key(stream_name) and size == 0): return self.assertTrue( self.data_subscribers.samples_received.has_key(stream_name), msg="Sample queue does not exists") self.assertEqual( len(self.data_subscribers.samples_received.get(stream_name)), size) def assert_data_values(self, particles, dataset_definition_file): """ Verify particles match the particles defined in the definition file """ rs_file = self._get_source_data_file(dataset_definition_file) rs = ResultSet(rs_file) self.assertTrue(rs.verify(particles)) def assert_initialize(self, final_state=ResourceAgentState.STREAMING): ''' Walk through DSA states to get to streaming mode from uninitialized ''' log.debug("Initialize DataSet agent") cmd = AgentCommand(command=ResourceAgentEvent.INITIALIZE) retval = self.dataset_agent_client.execute_agent(cmd) state = self.dataset_agent_client.get_agent_state() self.assertEqual(state, ResourceAgentState.INACTIVE) log.info("Sent INITIALIZE; DSA state = %s", state) log.debug("DataSet agent go active") cmd = AgentCommand(command=ResourceAgentEvent.GO_ACTIVE) retval = self.dataset_agent_client.execute_agent(cmd) state = self.dataset_agent_client.get_agent_state() log.info("Sent GO_ACTIVE; DSA state = %s", state) self.assertEqual(state, ResourceAgentState.IDLE) log.debug("DataSet agent run") cmd = AgentCommand(command=ResourceAgentEvent.RUN) retval = self.dataset_agent_client.execute_agent(cmd) state = self.dataset_agent_client.get_agent_state() log.info("Sent RUN; DSA state = %s", state) self.assertEqual(state, ResourceAgentState.COMMAND) if final_state == ResourceAgentState.STREAMING: self.assert_start_sampling() def assert_stop_sampling(self): ''' transition to command. Must be called from streaming ''' state = self.dataset_agent_client.get_agent_state() self.assertEqual(state, ResourceAgentState.STREAMING) log.debug("DataSet agent stop sampling") cmd = AgentCommand(command=DriverEvent.STOP_AUTOSAMPLE) retval = self.dataset_agent_client.execute_resource(cmd) state = self.dataset_agent_client.get_agent_state() log.info("Sent START SAMPLING; DSA state = %s", state) self.assertEqual(state, ResourceAgentState.COMMAND) def assert_start_sampling(self): ''' transition to sampling. Must be called from command ''' state = self.dataset_agent_client.get_agent_state() self.assertEqual(state, ResourceAgentState.COMMAND) log.debug("DataSet agent start sampling") cmd = AgentCommand(command=DriverEvent.START_AUTOSAMPLE) retval = self.dataset_agent_client.execute_resource(cmd) state = self.dataset_agent_client.get_agent_state() log.info("Sent START SAMPLING; DSA state = %s", state) self.assertEqual(state, ResourceAgentState.STREAMING) def assert_reset(self): ''' Put the instrument back in uninitialized ''' agent_state = self.dataset_agent_client.get_agent_state() if agent_state != ResourceAgentState.UNINITIALIZED: cmd = AgentCommand(command=ResourceAgentEvent.RESET) retval = self.dataset_agent_client.execute_agent(cmd) state = self.dataset_agent_client.get_agent_state() self.assertEqual(state, ResourceAgentState.UNINITIALIZED) def assert_agent_state(self, target_state): """ Verify the current agent state @param target_state: What we expect the agent state to be """ state = self.dataset_agent_client.get_agent_state() self.assertEqual(state, target_state) def assert_agent_command(self, command, args=None, timeout=None): """ Verify an agent command @param command: driver command to execute @param args: kwargs to pass to the agent command object """ cmd = AgentCommand(command=command, kwargs=args) retval = self.instrument_agent_client.execute_agent(cmd, timeout=timeout) def assert_resource_command(self, command, args=None, timeout=None): """ Verify a resource command @param command: driver command to execute @param args: kwargs to pass to the agent command object """ cmd = AgentCommand(command=command, kwargs=args) retval = self.dataset_agent_client.execute_resource(cmd) def assert_state_change(self, target_agent_state, timeout=10): """ Verify the agent and resource states change as expected within the timeout Fail if the state doesn't change to the expected state. @param target_agent_state: State we expect the agent to be in @param timeout: how long to wait for the driver to change states """ to = gevent.Timeout(timeout) to.start() done = False agent_state = None try: while (not done): agent_state = self.dataset_agent_client.get_agent_state() log.error("Current agent state: %s", agent_state) if (agent_state == target_agent_state): log.debug("Current state match: %s", agent_state) done = True if not done: log.debug( "state mismatch, waiting for state to transition.") gevent.sleep(1) except Timeout: log.error( "Failed to transition agent state to %s, current state: %s", target_agent_state, agent_state) self.fail("Failed to transition state.") finally: to.cancel() def assert_event_received(self, event_object_type, timeout=10): """ Verify an event has been received of a sepecific type @param event_object_type: Event object we are looking for @param timeout: how long to wait """ to = gevent.Timeout(timeout) to.start() done = False try: while (not done): for event in self.event_subscribers.events_received: log.debug("Event: %s", event) if isinstance(event, event_object_type): done = True if not done: log.debug( "target event not detected, sleep a bit to let events happen" ) gevent.sleep(1) except Timeout: log.error("Failed to find event in queue: %s", event_object_type) log.error("Current event queue: %s", self.event_subscribers._events_received) self.fail("%s event not detected") finally: to.cancel() log.info("Expected event detected: %s", event)
class InstrumentDriverQualificationTestCase(InstrumentDriverTestCase): @classmethod def setUpClass(cls): cls.init_port_agent() @classmethod def tearDownClass(cls): cls.stop_port_agent() def setUp(self): """ @brief Setup test cases. """ log.debug("#ROGER# does setUp get called?") InstrumentDriverTestCase.setUp(self) self.port_agent = self.test_config.port_agent self.instrument_agent_manager = InstrumentAgentClient(); self.instrument_agent_manager.start_container(deploy_file=self.test_config.container_deploy_file) self.container = self.instrument_agent_manager.container log.debug("#ROGER# in setUp self.test_config.instrument_agent_packet_config = " + str(self.test_config.instrument_agent_packet_config)) self.data_subscribers = InstrumentAgentDataSubscribers( packet_config=self.test_config.instrument_agent_packet_config, encoding=self.test_config.instrument_agent_stream_encoding, stream_definition=self.test_config.instrument_agent_stream_definition ) log.debug("InstrumentDriverQualificationTestCase setUp Problem BELOW") self.event_subscribers = InstrumentAgentEventSubscribers(instrument_agent_resource_id=self.test_config.instrument_agent_resource_id) log.debug("InstrumentDriverQualificationTestCase setUp Problem ABOVE") self.init_instrument_agent_client() def init_instrument_agent_client(self): log.info("Start Instrument Agent Client") # Driver config driver_config = { 'dvr_mod' : self.test_config.driver_module, 'dvr_cls' : self.test_config.driver_class, 'workdir' : self.test_config.working_dir, 'process_type' : self.test_config.driver_process_type, 'comms_config' : self.port_agent_comm_config() } # Create agent config. agent_config = { 'driver_config' : driver_config, 'stream_config' : self.data_subscribers.stream_config, 'agent' : {'resource_id': self.test_config.instrument_agent_resource_id}, 'test_mode' : True ## Enable a poison pill. If the spawning process dies ## shutdown the daemon process. } # ROGER message_headers # Start instrument agent client. self.instrument_agent_manager.start_client( name=self.test_config.instrument_agent_name, module=self.test_config.instrument_agent_module, cls=self.test_config.instrument_agent_class, config=agent_config, resource_id=self.test_config.instrument_agent_resource_id, deploy_file=self.test_config.container_deploy_file ) self.instrument_agent_client = self.instrument_agent_manager.instrument_agent_client def tearDown(self): """ @brief Test teardown """ log.debug("InstrumentDriverQualificationTestCase tearDown") self.instrument_agent_manager.stop_container() InstrumentDriverTestCase.tearDown(self) def test_common_qualification(self): self.assertTrue(1) # FIXED @patch.dict(CFG, {'endpoint':{'receive':{'timeout': 1200}}}) def test_instrument_agent_common_state_model_lifecycle(self): """ @brief Test agent state transitions. This test verifies that the instrument agent can properly command the instrument through the following states. @todo Once direct access settles down and works again, re-enable direct access. COMMANDS TESTED *ResourceAgentEvent.INITIALIZE *ResourceAgentEvent.RESET *ResourceAgentEvent.GO_ACTIVE *ResourceAgentEvent.RUN *ResourceAgentEvent.PAUSE *ResourceAgentEvent.RESUME *ResourceAgentEvent.GO_COMMAND *ResourceAgentEvent.GO_DIRECT_ACCESS *ResourceAgentEvent.GO_INACTIVE *ResourceAgentEvent.PING_RESOURCE *ResourceAgentEvent.CLEAR COMMANDS NOT TESTED * ResourceAgentEvent.GET_RESOURCE_STATE * ResourceAgentEvent.GET_RESOURCE * ResourceAgentEvent.SET_RESOURCE * ResourceAgentEvent.EXECUTE_RESOURCE STATES ACHIEVED: * ResourceAgentState.UNINITIALIZED * ResourceAgentState.INACTIVE * ResourceAgentState.IDLE' * ResourceAgentState.STOPPED * ResourceAgentState.COMMAND * ResourceAgentState.DIRECT_ACCESS STATES NOT ACHIEVED: * ResourceAgentState.STREAMING * ResourceAgentState.TEST * ResourceAgentState.CALIBRATE * ResourceAgentState.BUSY """ state = self.instrument_agent_client.get_agent_state() self.assertEqual(state, ResourceAgentState.UNINITIALIZED) cmd = AgentCommand(command=ResourceAgentEvent.INITIALIZE) retval = self.instrument_agent_client.execute_agent(cmd) state = self.instrument_agent_client.get_agent_state() self.assertEqual(state, ResourceAgentState.INACTIVE) cmd = AgentCommand(command=ResourceAgentEvent.GO_ACTIVE) retval = self.instrument_agent_client.execute_agent(cmd) state = self.instrument_agent_client.get_agent_state() self.assertEqual(state, ResourceAgentState.IDLE) cmd = AgentCommand(command=ResourceAgentEvent.GO_INACTIVE) retval = self.instrument_agent_client.execute_agent(cmd) state = self.instrument_agent_client.get_agent_state() self.assertEqual(state, ResourceAgentState.INACTIVE) cmd = AgentCommand(command=ResourceAgentEvent.GO_ACTIVE) retval = self.instrument_agent_client.execute_agent(cmd) state = self.instrument_agent_client.get_agent_state() self.assertEqual(state, ResourceAgentState.IDLE) # Works but doesnt return anything useful when i tried. #cmd = AgentCommand(command=ResourceAgentEvent.GET_RESOURCE_STATE) #retval = self.instrument_agent_client.execute_agent(cmd) # works! retval = self.instrument_agent_client.ping_resource() retval = self.instrument_agent_client.ping_agent() cmd = AgentCommand(command=ResourceAgentEvent.PING_RESOURCE) retval = self.instrument_agent_client.execute_agent(cmd) self.assertTrue("ping from resource ppid" in retval.result) state = self.instrument_agent_client.get_agent_state() self.assertEqual(state, ResourceAgentState.IDLE) cmd = AgentCommand(command=ResourceAgentEvent.RUN) retval = self.instrument_agent_client.execute_agent(cmd) state = self.instrument_agent_client.get_agent_state() self.assertEqual(state, ResourceAgentState.COMMAND) cmd = AgentCommand(command=ResourceAgentEvent.RESET) retval = self.instrument_agent_client.execute_agent(cmd) state = self.instrument_agent_client.get_agent_state() self.assertEqual(state, ResourceAgentState.UNINITIALIZED) cmd = AgentCommand(command=ResourceAgentEvent.INITIALIZE) retval = self.instrument_agent_client.execute_agent(cmd) state = self.instrument_agent_client.get_agent_state() self.assertEqual(state, ResourceAgentState.INACTIVE) cmd = AgentCommand(command=ResourceAgentEvent.GO_ACTIVE) retval = self.instrument_agent_client.execute_agent(cmd) state = self.instrument_agent_client.get_agent_state() self.assertEqual(state, ResourceAgentState.IDLE) cmd = AgentCommand(command=ResourceAgentEvent.RUN) retval = self.instrument_agent_client.execute_agent(cmd) state = self.instrument_agent_client.get_agent_state() self.assertEqual(state, ResourceAgentState.COMMAND) cmd = AgentCommand(command=ResourceAgentEvent.PAUSE) retval = self.instrument_agent_client.execute_agent(cmd) state = self.instrument_agent_client.get_agent_state() self.assertEqual(state, ResourceAgentState.STOPPED) cmd = AgentCommand(command=ResourceAgentEvent.RESUME) retval = self.instrument_agent_client.execute_agent(cmd) state = self.instrument_agent_client.get_agent_state() self.assertEqual(state, ResourceAgentState.COMMAND) cmd = AgentCommand(command=ResourceAgentEvent.CLEAR) retval = self.instrument_agent_client.execute_agent(cmd) state = self.instrument_agent_client.get_agent_state() self.assertEqual(state, ResourceAgentState.IDLE) cmd = AgentCommand(command=ResourceAgentEvent.RUN) retval = self.instrument_agent_client.execute_agent(cmd) state = self.instrument_agent_client.get_agent_state() self.assertEqual(state, ResourceAgentState.COMMAND) cmd = AgentCommand(command=ResourceAgentEvent.GO_DIRECT_ACCESS, #kwargs={'session_type': DirectAccessTypes.telnet, kwargs={'session_type':DirectAccessTypes.vsp, 'session_timeout':600, 'inactivity_timeout':600}) retval = self.instrument_agent_client.execute_agent(cmd) # assert it is as long as expected 4149CB23-AF1D-43DF-8688-DDCD2B8E435E self.assertTrue(36 == len(retval.result['token'])) state = self.instrument_agent_client.get_agent_state() self.assertEqual(state, ResourceAgentState.DIRECT_ACCESS) cmd = AgentCommand(command=ResourceAgentEvent.GO_COMMAND) retval = self.instrument_agent_client.execute_agent(cmd) state = self.instrument_agent_client.get_agent_state() self.assertEqual(state, ResourceAgentState.COMMAND) cmd = AgentCommand(command=ResourceAgentEvent.RESET) retval = self.instrument_agent_client.execute_agent(cmd) state = self.instrument_agent_client.get_agent_state() self.assertEqual(state, ResourceAgentState.UNINITIALIZED) # FIXED def test_instrument_agent_to_instrument_driver_connectivity(self): """ @brief This test verifies that the instrument agent can talk to the instrument driver. The intent of this is to be a ping to the driver layer. """ state = self.instrument_agent_client.get_agent_state() self.assertEqual(state, ResourceAgentState.UNINITIALIZED) cmd = AgentCommand(command=ResourceAgentEvent.INITIALIZE) retval = self.instrument_agent_client.execute_agent(cmd) state = self.instrument_agent_client.get_agent_state() self.assertEqual(state, ResourceAgentState.INACTIVE) cmd = AgentCommand(command=ResourceAgentEvent.GO_ACTIVE) retval = self.instrument_agent_client.execute_agent(cmd) state = self.instrument_agent_client.get_agent_state() self.assertEqual(state, ResourceAgentState.IDLE) retval = self.instrument_agent_client.ping_resource() log.debug("RETVAL = " + str(type(retval))) self.assertTrue("ping from resource ppid" in retval) self.assertTrue("time:" in retval) retval = self.instrument_agent_client.ping_agent() log.debug("RETVAL = " + str(type(retval))) self.assertTrue("ping from InstrumentAgent" in retval) self.assertTrue("time:" in retval) cmd = AgentCommand(command=ResourceAgentEvent.GO_INACTIVE) retval = self.instrument_agent_client.execute_agent(cmd) state = self.instrument_agent_client.get_agent_state() self.assertEqual(state, ResourceAgentState.INACTIVE) def test_instrument_error_code_enum(self): """ @brief check InstErrorCode for consistency @todo did InstErrorCode become redundant in the last refactor? """ self.assertTrue(self.check_for_reused_values(InstErrorCode)) pass def test_driver_connection_state_enum(self): """ @brief check DriverConnectionState for consistency @todo this check should also be a device specific for drivers like Trhph """ # self.assertEqual(TrhphDriverState.UNCONFIGURED, DriverConnectionState.UNCONFIGURED) # self.assertEqual(TrhphDriverState.DISCONNECTED, DriverConnectionState.DISCONNECTED) # self.assertEqual(TrhphDriverState.CONNECTED, DriverConnectionState.CONNECTED) self.assertTrue(self.check_for_reused_values(DriverConnectionState)) # FIXED def test_resource_agent_event_enum(self): self.assertTrue(self.check_for_reused_values(ResourceAgentEvent)) # FIXED def test_resource_agent_state_enum(self): self.assertTrue(self.check_for_reused_values(ResourceAgentState)) def check_for_reused_values(self, obj): """ @author Roger Unwin @brief verifies that no two definitions resolve to the same value. @returns True if no reused values """ match = 0 outer_match = 0 for i in [v for v in dir(obj) if not callable(getattr(obj,v))]: if i.startswith('_') == False: outer_match = outer_match + 1 for j in [x for x in dir(obj) if not callable(getattr(obj,x))]: if i.startswith('_') == False: if getattr(obj, i) == getattr(obj, j): match = match + 1 log.debug(str(i) + " == " + j + " (Looking for reused values)") # If this assert fails, then two of the enumerations have an identical value... return match == outer_match def test_driver_async_event_enum(self): """ @ brief ProtocolState enum test 1. test that SBE37ProtocolState matches the expected enums from DriverProtocolState. 2. test that multiple distinct states do not resolve back to the same string. """ self.assertTrue(self.check_for_reused_values(DriverAsyncEvent)) @unittest.skip("Transaction management not yet implemented") def test_transaction_management_messages(self): """ @brief This tests the start_transaction and end_transaction methods. https://confluence.oceanobservatories.org/display/syseng/CIAD+MI+SV+Instrument+Agent+Interface#CIADMISVInstrumentAgentInterface-Transactionmanagementmessages * start_transaction(acq_timeout,exp_timeout) * end_transaction(transaction_id) * transaction_id See: ion/services/mi/instrument_agent.py UPDATE: stub it out fill in later when its available ... place holder TODO: """ pass def de_dupe(self, list_in): unique_set = Set(item for item in list_in) return [(item) for item in unique_set] @patch.dict(CFG, {'endpoint':{'receive':{'timeout': 1200}}}) def test_driver_notification_messages(self): """ @brief This tests event messages from the driver. The following test moves the IA through all its states. As it does this, event messages are generated and caught. These messages are then compared with a list of expected messages to insure that the proper messages have been generated. """ # Clear off any events from before this test so we have consistent state self.event_subscribers.events_received = [] expected_events = [ 'AgentState=RESOURCE_AGENT_STATE_INACTIVE', 'AgentCommand=RESOURCE_AGENT_EVENT_INITIALIZE', 'ResourceState=DRIVER_STATE_DISCONNECTED', 'ResourceState=DRIVER_STATE_DISCONNECTED', 'ResourceState=DRIVER_STATE_UNKNOWN', 'ResourceConfig', 'ResourceState=DRIVER_STATE_COMMAND', 'AgentState=RESOURCE_AGENT_STATE_IDLE', 'AgentCommand=RESOURCE_AGENT_EVENT_GO_ACTIVE', 'AgentState=RESOURCE_AGENT_STATE_COMMAND', 'AgentCommand=RESOURCE_AGENT_EVENT_RUN', 'AgentCommand=RESOURCE_AGENT_PING_RESOURCE', 'ResourceState=DRIVER_STATE_DISCONNECTED', 'ResourceState=DRIVER_STATE_UNCONFIGURED', 'AgentState=RESOURCE_AGENT_STATE_UNINITIALIZED', 'AgentCommand=RESOURCE_AGENT_EVENT_RESET', 'AgentState=RESOURCE_AGENT_STATE_INACTIVE', 'AgentCommand=RESOURCE_AGENT_EVENT_INITIALIZE', 'ResourceState=DRIVER_STATE_DISCONNECTED', 'ResourceState=DRIVER_STATE_DISCONNECTED', 'ResourceState=DRIVER_STATE_UNKNOWN', 'ResourceConfig', 'ResourceState=DRIVER_STATE_COMMAND', 'AgentState=RESOURCE_AGENT_STATE_IDLE', 'AgentCommand=RESOURCE_AGENT_EVENT_GO_ACTIVE', 'AgentState=RESOURCE_AGENT_STATE_COMMAND', 'AgentCommand=RESOURCE_AGENT_EVENT_RUN', 'AgentState=RESOURCE_AGENT_STATE_STOPPED', 'AgentCommand=RESOURCE_AGENT_EVENT_PAUSE', 'AgentState=RESOURCE_AGENT_STATE_COMMAND', 'AgentCommand=RESOURCE_AGENT_EVENT_RESUME', 'AgentState=RESOURCE_AGENT_STATE_IDLE', 'AgentCommand=RESOURCE_AGENT_EVENT_CLEAR', 'AgentState=RESOURCE_AGENT_STATE_COMMAND', 'AgentCommand=RESOURCE_AGENT_EVENT_RUN', 'AgentState=RESOUCE_AGENT_STATE_DIRECT_ACCESS', 'AgentCommand=RESOURCE_AGENT_EVENT_GO_DIRECT_ACCESS', 'ResourceState=DRIVER_STATE_DIRECT_ACCESS', 'ResourceState=DRIVER_STATE_COMMAND', 'AgentState=RESOURCE_AGENT_STATE_COMMAND', 'AgentCommand=RESOURCE_AGENT_EVENT_GO_COMMAND', 'ResourceState=DRIVER_STATE_DISCONNECTED', 'ResourceState=DRIVER_STATE_UNCONFIGURED', 'AgentState=RESOURCE_AGENT_STATE_UNINITIALIZED', 'AgentCommand=RESOURCE_AGENT_EVENT_RESET' ] state = self.instrument_agent_client.get_agent_state() self.assertEqual(state, ResourceAgentState.UNINITIALIZED) cmd = AgentCommand(command=ResourceAgentEvent.INITIALIZE) retval = self.instrument_agent_client.execute_agent(cmd) state = self.instrument_agent_client.get_agent_state() self.assertEqual(state, ResourceAgentState.INACTIVE) cmd = AgentCommand(command=ResourceAgentEvent.GO_ACTIVE) retval = self.instrument_agent_client.execute_agent(cmd) state = self.instrument_agent_client.get_agent_state() self.assertEqual(state, ResourceAgentState.IDLE) cmd = AgentCommand(command=ResourceAgentEvent.RUN) retval = self.instrument_agent_client.execute_agent(cmd) state = self.instrument_agent_client.get_agent_state() self.assertEqual(state, ResourceAgentState.COMMAND) retval = self.instrument_agent_client.ping_resource() retval = self.instrument_agent_client.ping_agent() cmd = AgentCommand(command=ResourceAgentEvent.PING_RESOURCE) retval = self.instrument_agent_client.execute_agent(cmd) self.assertTrue("ping from resource ppid" in retval.result) #cmd = AgentCommand(command=ResourceAgentEvent.GO_ACTIVE) #retval = self.instrument_agent_client.execute_agent(cmd) #state = self.instrument_agent_client.get_agent_state() #self.assertEqual(state, ResourceAgentState.IDLE) #cmd = AgentCommand(command=ResourceAgentEvent.RUN) #retval = self.instrument_agent_client.execute_agent(cmd) #state = self.instrument_agent_client.get_agent_state() #self.assertEqual(state, ResourceAgentState.COMMAND) cmd = AgentCommand(command=ResourceAgentEvent.RESET) retval = self.instrument_agent_client.execute_agent(cmd) state = self.instrument_agent_client.get_agent_state() self.assertEqual(state, ResourceAgentState.UNINITIALIZED) cmd = AgentCommand(command=ResourceAgentEvent.INITIALIZE) retval = self.instrument_agent_client.execute_agent(cmd) state = self.instrument_agent_client.get_agent_state() self.assertEqual(state, ResourceAgentState.INACTIVE) cmd = AgentCommand(command=ResourceAgentEvent.GO_ACTIVE) retval = self.instrument_agent_client.execute_agent(cmd) state = self.instrument_agent_client.get_agent_state() self.assertEqual(state, ResourceAgentState.IDLE) cmd = AgentCommand(command=ResourceAgentEvent.RUN) retval = self.instrument_agent_client.execute_agent(cmd) state = self.instrument_agent_client.get_agent_state() self.assertEqual(state, ResourceAgentState.COMMAND) cmd = AgentCommand(command=ResourceAgentEvent.PAUSE) retval = self.instrument_agent_client.execute_agent(cmd) state = self.instrument_agent_client.get_agent_state() self.assertEqual(state, ResourceAgentState.STOPPED) cmd = AgentCommand(command=ResourceAgentEvent.RESUME) retval = self.instrument_agent_client.execute_agent(cmd) state = self.instrument_agent_client.get_agent_state() self.assertEqual(state, ResourceAgentState.COMMAND) cmd = AgentCommand(command=ResourceAgentEvent.CLEAR) retval = self.instrument_agent_client.execute_agent(cmd) state = self.instrument_agent_client.get_agent_state() self.assertEqual(state, ResourceAgentState.IDLE) cmd = AgentCommand(command=ResourceAgentEvent.RUN) retval = self.instrument_agent_client.execute_agent(cmd) state = self.instrument_agent_client.get_agent_state() self.assertEqual(state, ResourceAgentState.COMMAND) cmd = AgentCommand(command=ResourceAgentEvent.GO_DIRECT_ACCESS, #kwargs={'session_type': DirectAccessTypes.telnet, kwargs={'session_type':DirectAccessTypes.vsp, 'session_timeout':600, 'inactivity_timeout':600}) retval = self.instrument_agent_client.execute_agent(cmd) # assert it is as long as expected 4149CB23-AF1D-43DF-8688-DDCD2B8E435E self.assertTrue(36 == len(retval.result['token'])) state = self.instrument_agent_client.get_agent_state() self.assertEqual(state, ResourceAgentState.DIRECT_ACCESS) cmd = AgentCommand(command=ResourceAgentEvent.GO_COMMAND) retval = self.instrument_agent_client.execute_agent(cmd) state = self.instrument_agent_client.get_agent_state() self.assertEqual(state, ResourceAgentState.COMMAND) cmd = AgentCommand(command=ResourceAgentEvent.RESET) retval = self.instrument_agent_client.execute_agent(cmd) state = self.instrument_agent_client.get_agent_state() self.assertEqual(state, ResourceAgentState.UNINITIALIZED) # # Refactor changed it so no description is ever present. # go with state instead i guess... # log.debug("ROGERROGER got to the end!") raw_events = [] for x in self.event_subscribers.events_received: if str(type(x)) == "<class 'interface.objects.ResourceAgentCommandEvent'>": log.debug(str(type(x)) + " ++********************* AgentCommand=" + str(x.execute_command)) raw_events.append("AgentCommand=" + str(x.execute_command)) elif str(type(x)) == "<class 'interface.objects.ResourceAgentResourceStateEvent'>": log.debug(str(type(x)) + " ++********************* ResourceState=" + str(x.state)) raw_events.append("ResourceState=" + str(x.state)) elif str(type(x)) == "<class 'interface.objects.ResourceAgentStateEvent'>": log.debug(str(type(x)) + " ++********************* AgentState=" + str(x.state)) raw_events.append("AgentState=" + str(x.state)) elif str(type(x)) == "<class 'interface.objects.ResourceAgentResourceConfigEvent'>": log.debug(str(type(x)) + " ++********************* ResourceConfig") raw_events.append("ResourceConfig") else: log.debug(str(type(x)) + " ++********************* " + str(x)) for x in sorted(raw_events): log.debug(str(x) + " ?in (expected_events) = " + str(x in expected_events)) self.assertTrue(x in expected_events) for x in sorted(expected_events): log.debug(str(x) + " ?in (raw_events) = " + str(x in raw_events)) self.assertTrue(x in raw_events) # assert we got the expected number of events num_expected = len(self.de_dupe(expected_events)) num_actual = len(self.de_dupe(raw_events)) log.debug("num_expected = " + str(num_expected) + " num_actual = " + str(num_actual)) self.assertTrue(num_actual == num_expected) pass def test_instrument_driver_to_physical_instrument_interoperability(self): """ @Brief this test is the integreation test test_connect but run through the agent. On a seabird sbe37 this results in a ds and dc command being sent. """ cmd = AgentCommand(command=ResourceAgentEvent.INITIALIZE) retval = self.instrument_agent_client.execute_agent(cmd) state = self.instrument_agent_client.get_agent_state() self.assertEqual(state, ResourceAgentState.INACTIVE) cmd = AgentCommand(command=ResourceAgentEvent.GO_ACTIVE) retval = self.instrument_agent_client.execute_agent(cmd) state = self.instrument_agent_client.get_agent_state() self.assertEqual(state, ResourceAgentState.IDLE) @unittest.skip("Driver.get_device_signature not yet implemented") def test_get_device_signature(self): """ @Brief this test will call get_device_signature once that is implemented in the driver """ pass def test_initialize(self): """ Test agent initialize command. This causes creation of driver process and transition to inactive. """ state = self.instrument_agent_client.get_agent_state() self.assertEqual(state, ResourceAgentState.UNINITIALIZED) cmd = AgentCommand(command=ResourceAgentEvent.INITIALIZE) retval = self.instrument_agent_client.execute_agent(cmd) state = self.instrument_agent_client.get_agent_state() self.assertEqual(state, ResourceAgentState.INACTIVE) cmd = AgentCommand(command=ResourceAgentEvent.RESET) retval = self.instrument_agent_client.execute_agent(cmd) state = self.instrument_agent_client.get_agent_state() self.assertEqual(state, ResourceAgentState.UNINITIALIZED)
class TestIAStart(MiUnitTest): """ Test the instrument agent startup """ def setUp(self): """ Setup the test case """ self.ia_client = InstrumentAgentClient() def test_container_rabbitmq(self): """ Test that rabbitmq can be started @TODO This test should start/stop rabbitmq and couch in setup, as it leaves the system in a bad state. """ self.ia_client.start_rabbitmq_server() pid = self.ia_client._read_pidfile(self.ia_client._pid_filename("rabbitmq")) self.assertTrue(pid) self.ia_client.start_rabbitmq_server() new_pid = self.ia_client._read_pidfile(self.ia_client._pid_filename("rabbitmq")) self.assertEqual(pid, new_pid) self.ia_client.stop_rabbitmq_server() pid = self.ia_client._read_pidfile(self.ia_client._pid_filename("rabbitmq")) self.assertFalse(pid) def test_container_couchdb(self): """Test that couchdb can be started""" self.ia_client.start_couchdb() pid = self.ia_client._read_pidfile(self.ia_client._pid_filename("couchdb")) self.assertTrue(pid) self.ia_client.start_couchdb() new_pid = self.ia_client._read_pidfile(self.ia_client._pid_filename("couchdb")) self.assertEqual(pid, new_pid) self.ia_client.stop_couchdb() pid = self.ia_client._read_pidfile(self.ia_client._pid_filename("couchdb")) self.assertFalse(pid) def test_container_start(self): """Test that a container can be started""" self.ia_client.start_container() self.assertTrue(self.ia_client.container) self.ia_client.stop_container() self.assertFalse(self.ia_client.container) def test_data_subscriber(self): """ Test that we can build data subscribers using the packet config from the IDK """ data_subscriber = InstrumentAgentDataSubscribers()