def test_add_get(self): good_cmd = Command(name="some_name") result = self.cmd_dict.get_command("some_name") self.assert_(not isinstance(result, Command)) self.cmd_dict.add_command(good_cmd) result = self.cmd_dict.get_command("some_name") self.assert_(isinstance(result, Command)) # exception cases bad_cmd = Command(name=1) self.assertRaises(InstrumentParameterException, self.cmd_dict.add_command, bad_cmd) self.assertRaises(InstrumentParameterException, self.cmd_dict.add_command, "bad_command") self.assertEqual(self.cmd_dict.get_command(None), None) self.assertEqual(self.cmd_dict.get_command("bad"), None)
def test_generate_config_metadata_json(self): """ Tests generate of the metadata structure """ self.protocol._param_dict.add("foo", r'foo=(.*)', lambda match: int(match.group(1)), lambda x: str(x), direct_access=True, default_value=10) self.protocol._param_dict.add("bar", r'bar=(.*)', lambda match: int(match.group(1)), lambda x: str(x), direct_access=False, default_value=15) self.protocol._cmd_dict.add( "cmd1", timeout=60, arguments=[CommandArgument("coeff"), CommandArgument("delay")]) # different way of creating things, possibly more clear in some cases # and allows for testing arg and command later cmd2_arg1 = CommandArgument("trigger") cmd2 = Command("cmd2", arguments=[cmd2_arg1]) self.protocol._cmd_dict.add_command(cmd2) self.protocol._driver_dict.add(DriverDictKey.VENDOR_SW_COMPATIBLE, True) # Now do the real testing result = self.protocol.get_config_metadata_dict() self.assert_(isinstance(result[ConfigMetadataKey.DRIVER], dict)) self.assert_(isinstance(result[ConfigMetadataKey.COMMANDS], dict)) self.assert_(isinstance(result[ConfigMetadataKey.PARAMETERS], dict)) self.assertEquals(result[ConfigMetadataKey.DRIVER], {DriverDictKey.VENDOR_SW_COMPATIBLE: True}) # Check a few in the cmd list...the leaves in the structure are # tested in the cmd dict test cases self.assert_("cmd1" in result[ConfigMetadataKey.COMMANDS].keys()) self.assert_("cmd2" in result[ConfigMetadataKey.COMMANDS].keys()) # Check a few in the param list...the leaves in the structure are # tested in the param dict test cases self.assert_("foo" in result[ConfigMetadataKey.PARAMETERS].keys()) self.assert_("bar" in result[ConfigMetadataKey.PARAMETERS].keys())
def setUp(self): #self.param_dict = None self.cmd_dict = ProtocolCommandDict() self.cmd_dict.add("cmd1", timeout=60, display_name="Command 1", description="Execute a foo on the instrument", return_type="bool", return_units="Success", return_description="Success (true) or failure (false)", arguments=[CommandArgument( name="coeff", required=True, display_name="coefficient", description="The coefficient to use for calculation", type=CommandDictType.FLOAT, value_description="Should be between 1.97 and 2.34" ), CommandArgument( name="delay", required=False, display_name="delay time", description="The delay time to wait before executing", type=CommandDictType.FLOAT, units="seconds", value_description="Should be between 1.0 and 3.3 in increments of 0.1" ) ] ) # different way of creating things, possibly more clear in some cases # and allows for testing arg and command later self.cmd2_arg1 = CommandArgument(name="trigger", required=True, display_name="sensor trigger", description="The trigger value to use for calculation", type=CommandDictType.INT, value_description="Should be between 1 and 20" ) self.cmd2 = Command("cmd2", display_name="Command 2", description="The second test command", return_type=CommandDictType.INT, return_units="counts", return_description="The number of items encountered during the run.", arguments=[self.cmd2_arg1]) self.cmd_dict.add_command(self.cmd2) self.param_dict = self.cmd_dict # link for ease of parent class operation self.target_arg_schema = """{ "description": "The trigger value to use for calculation", "display_name": "sensor trigger", "required": true, "value": { "description": "Should be between 1 and 20", "type": "int" } }""" self.target_cmd_schema = """{ "arguments": { "trigger": { "description": "The trigger value to use for calculation", "display_name": "sensor trigger", "required": true, "value": { "description": "Should be between 1 and 20", "type": "int" } } }, "description": "The second test command", "display_name": "Command 2", "return": { "description": "The number of items encountered during the run.", "type": "int", "units": "counts" }, "timeout": 10 }""" self.target_schema = """{ "cmd1": { "arguments": { "coeff": { "description": "The coefficient to use for calculation", "display_name": "coefficient", "required": true, "value": { "description": "Should be between 1.97 and 2.34", "type": "float" } }, "delay": { "description": "The delay time to wait before executing", "display_name": "delay time", "required": false, "value": { "description": "Should be between 1.0 and 3.3 in increments of 0.1", "type": "float", "units": "seconds" } } }, "description": "Execute a foo on the instrument", "display_name": "Command 1", "return": { "description": "Success (true) or failure (false)", "type": "bool", "units": "Success" }, "timeout": 60 }, "cmd2": { "arguments": { "trigger": { "description": "The trigger value to use for calculation", "display_name": "sensor trigger", "required": true, "value": { "description": "Should be between 1 and 20", "type": "int" } } }, "description": "The second test command", "display_name": "Command 2", "return": { "description": "The number of items encountered during the run.", "type": "int", "units": "counts" }, "timeout": 10 } }""" self.test_yaml = '''
class TestUnitProtocolCommandDict(TestUnitStringsDict): """ Test cases for instrument driver class. Functions in this class provide instrument driver unit tests and provide a tutorial on use of the driver interface. """ __test__ = True def setUp(self): #self.param_dict = None self.cmd_dict = ProtocolCommandDict() self.cmd_dict.add("cmd1", timeout=60, display_name="Command 1", description="Execute a foo on the instrument", return_type="bool", return_units="Success", return_description="Success (true) or failure (false)", arguments=[CommandArgument( name="coeff", required=True, display_name="coefficient", description="The coefficient to use for calculation", type=CommandDictType.FLOAT, value_description="Should be between 1.97 and 2.34" ), CommandArgument( name="delay", required=False, display_name="delay time", description="The delay time to wait before executing", type=CommandDictType.FLOAT, units="seconds", value_description="Should be between 1.0 and 3.3 in increments of 0.1" ) ] ) # different way of creating things, possibly more clear in some cases # and allows for testing arg and command later self.cmd2_arg1 = CommandArgument(name="trigger", required=True, display_name="sensor trigger", description="The trigger value to use for calculation", type=CommandDictType.INT, value_description="Should be between 1 and 20" ) self.cmd2 = Command("cmd2", display_name="Command 2", description="The second test command", return_type=CommandDictType.INT, return_units="counts", return_description="The number of items encountered during the run.", arguments=[self.cmd2_arg1]) self.cmd_dict.add_command(self.cmd2) self.param_dict = self.cmd_dict # link for ease of parent class operation self.target_arg_schema = """{ "description": "The trigger value to use for calculation", "display_name": "sensor trigger", "required": true, "value": { "description": "Should be between 1 and 20", "type": "int" } }""" self.target_cmd_schema = """{ "arguments": { "trigger": { "description": "The trigger value to use for calculation", "display_name": "sensor trigger", "required": true, "value": { "description": "Should be between 1 and 20", "type": "int" } } }, "description": "The second test command", "display_name": "Command 2", "return": { "description": "The number of items encountered during the run.", "type": "int", "units": "counts" }, "timeout": 10 }""" self.target_schema = """{ "cmd1": { "arguments": { "coeff": { "description": "The coefficient to use for calculation", "display_name": "coefficient", "required": true, "value": { "description": "Should be between 1.97 and 2.34", "type": "float" } }, "delay": { "description": "The delay time to wait before executing", "display_name": "delay time", "required": false, "value": { "description": "Should be between 1.0 and 3.3 in increments of 0.1", "type": "float", "units": "seconds" } } }, "description": "Execute a foo on the instrument", "display_name": "Command 1", "return": { "description": "Success (true) or failure (false)", "type": "bool", "units": "Success" }, "timeout": 60 }, "cmd2": { "arguments": { "trigger": { "description": "The trigger value to use for calculation", "display_name": "sensor trigger", "required": true, "value": { "description": "Should be between 1 and 20", "type": "int" } } }, "description": "The second test command", "display_name": "Command 2", "return": { "description": "The number of items encountered during the run.", "type": "int", "units": "counts" }, "timeout": 10 } }""" self.test_yaml = ''' parameters: { dummy: stuff } commands: { bad_command: { description: "bad command" }, cmd1: { arguments: { coeff: { description: "Cmd1Coeff", display_name: "C1co", value: { description: "C1coDesc", units: "counts", type: "float" } }, }, description: "C1Desc", display_name: "C1", return: { description: "C1Ret", type: "C1RetType", units: "C1RetUnit" }, }, cmd2: { arguments: { trigger: { description: "C2TriggerDesc", display_name: "C2TriggerDisp", value: { description: "C2TriggerValueDesc", type: "C2TriggerType", units: "C2Units" } }, test: { description: "C2TestDesc", display_name: "C2TestDisp", value: { description: "C2TestValueDesc", type: "C2TestType", units: "C2TestUnits" } }, }, description: "C2Desc", display_name: "C2Disp", return: { description: "C2RetDesc", type: "C2RetType", units: "C2RetUnits" }, } } ''' def test_sub_schema_generation(self): result_dict = self.cmd2_arg1.generate_dict() self.assertEqual(json.dumps(result_dict, indent=4, sort_keys=True), self.target_arg_schema) result_dict = self.cmd2.generate_dict() self.assertEqual(json.dumps(result_dict, indent=4, sort_keys=True), self.target_cmd_schema) def test_schema_dict_generation(self): """ Tests that a dict is created that can then be JSONified """ result = self.cmd_dict.generate_dict() json_result = json.dumps(result, indent=4, sort_keys=True) self.assertEqual(json_result, self.target_schema) def test_empty_schema(self): self.cmd_dict = ProtocolCommandDict() result = self.cmd_dict.generate_dict() self.assertEqual(result, {}) def test_argument_exceptions(self): self.assertRaises(InstrumentParameterException, Command, "foo", arguments="bad_arg") self.assertRaises(InstrumentParameterException, Command, "foo", arguments=["bad arg"]) def test_add_get(self): good_cmd = Command(name="some_name") result = self.cmd_dict.get_command("some_name") self.assert_(not isinstance(result, Command)) self.cmd_dict.add_command(good_cmd) result = self.cmd_dict.get_command("some_name") self.assert_(isinstance(result, Command)) # exception cases bad_cmd = Command(name=1) self.assertRaises(InstrumentParameterException, self.cmd_dict.add_command, bad_cmd) self.assertRaises(InstrumentParameterException, self.cmd_dict.add_command, "bad_command") self.assertEqual(self.cmd_dict.get_command(None), None) self.assertEqual(self.cmd_dict.get_command("bad"), None) def _assert_metadata_change(self): new_dict = self.param_dict.generate_dict() log.debug("Generated dictionary: %s", new_dict) self.assertEqual(new_dict["cmd1"][CommandDictKey.DESCRIPTION], "C1Desc") self.assertEqual(new_dict["cmd1"][CommandDictKey.DISPLAY_NAME], "C1") self.assertEqual(new_dict["cmd1"][CommandDictKey.ARGUMENTS]['coeff'][CommandDictKey.DESCRIPTION], "Cmd1Coeff") self.assertEqual(new_dict["cmd1"][CommandDictKey.ARGUMENTS]['coeff'][CommandDictKey.DISPLAY_NAME], "C1co") self.assertEqual(new_dict["cmd1"][CommandDictKey.ARGUMENTS]['coeff'][CommandDictKey.VALUE][CommandDictKey.UNITS], "counts") self.assertEqual(new_dict["cmd1"][CommandDictKey.ARGUMENTS]['coeff'][CommandDictKey.VALUE][CommandDictKey.DESCRIPTION], "C1coDesc") self.assertEqual(new_dict["cmd1"][CommandDictKey.ARGUMENTS]['coeff'][CommandDictKey.VALUE][CommandDictKey.TYPE], "float") # Should come from hard code self.assertEqual(new_dict["cmd1"][CommandDictKey.ARGUMENTS]['delay'][CommandDictKey.DESCRIPTION], "The delay time to wait before executing") self.assertEqual(new_dict["cmd1"][CommandDictKey.ARGUMENTS]['delay'][CommandDictKey.DISPLAY_NAME], "delay time") self.assertEqual(new_dict["cmd1"][CommandDictKey.ARGUMENTS]['delay'][CommandDictKey.VALUE][CommandDictKey.UNITS], "seconds") self.assertEqual(new_dict["cmd1"][CommandDictKey.ARGUMENTS]['delay'][CommandDictKey.VALUE][CommandDictKey.DESCRIPTION], "Should be between 1.0 and 3.3 in increments of 0.1") self.assertEqual(new_dict["cmd1"][CommandDictKey.ARGUMENTS]['delay'][CommandDictKey.VALUE][CommandDictKey.TYPE], "float") # Command 1 return values self.assertEqual(new_dict["cmd1"][CommandDictKey.RETURN][CommandDictKey.DESCRIPTION], "C1Ret") self.assertEqual(new_dict["cmd1"][CommandDictKey.RETURN][CommandDictKey.UNITS], "C1RetUnit") self.assertEqual(new_dict["cmd1"][CommandDictKey.RETURN][CommandDictKey.TYPE], "C1RetType") self.assertEqual(new_dict["cmd2"][CommandDictKey.DESCRIPTION], "C2Desc") self.assertEqual(new_dict["cmd2"][CommandDictKey.DISPLAY_NAME], "C2Disp") self.assertEqual(new_dict["cmd2"][CommandDictKey.ARGUMENTS]['trigger'][CommandDictKey.DESCRIPTION], "C2TriggerDesc") self.assertEqual(new_dict["cmd2"][CommandDictKey.ARGUMENTS]['trigger'][CommandDictKey.DISPLAY_NAME], "C2TriggerDisp") self.assertEqual(new_dict["cmd2"][CommandDictKey.ARGUMENTS]['trigger'][CommandDictKey.VALUE][CommandDictKey.DESCRIPTION], "C2TriggerValueDesc") self.assertEqual(new_dict["cmd2"][CommandDictKey.ARGUMENTS]['trigger'][CommandDictKey.VALUE][CommandDictKey.TYPE], "C2TriggerType") self.assertEqual(new_dict["cmd2"][CommandDictKey.ARGUMENTS]['trigger'][CommandDictKey.VALUE][CommandDictKey.UNITS], "C2Units") # Should come from hard code # Command 2 return values self.assertEqual(new_dict["cmd2"][CommandDictKey.RETURN][CommandDictKey.DESCRIPTION], "C2RetDesc") self.assertEqual(new_dict["cmd2"][CommandDictKey.RETURN][CommandDictKey.UNITS], "C2RetUnits") self.assertEqual(new_dict["cmd2"][CommandDictKey.RETURN][CommandDictKey.TYPE], "C2RetType") # shouldnt be any extra arguments, either self.assertFalse('test' in new_dict["cmd2"][CommandDictKey.ARGUMENTS]) self.assertFalse('bad_command' in new_dict)