def test_not_implemented_errors(self): adapter = Adapter() self.assertRaises(NotImplementedError, adapter.start_server) self.assertRaises(NotImplementedError, adapter.stop_server) self.assertRaises(NotImplementedError, getattr, adapter, 'is_running') assertRaisesNothing(self, adapter.handle, 0)
def test_construct_control_server(self, mock_control_server_type, exposed_object_mock): exposed_object_mock.return_value = 'test' assertRaisesNothing(self, Simulation, device=Mock(), control_server='localhost:10000') mock_control_server_type.assert_called_once_with( {'device': 'test', 'simulation': 'test', 'interface': 'test'}, 'localhost:10000')
def test_add_exposed_object(self): exposed_objects = ExposedObjectCollection({}) obj = DummyObject() assertRaisesNothing(self, exposed_objects.add_object, ExposedObject(obj, ('setTest', 'getTest')), 'testObject') exposed_objects['testObject.getTest'](41, 11) obj.getTest.assert_called_once_with(41, 11)
def test_remove_adapter(self): collection = AdapterCollection(DummyAdapter('foo')) self.assertSetEqual(set(collection.protocols), {'foo'}) self.assertRaises(RuntimeError, collection.remove_adapter, 'bar') assertRaisesNothing(self, collection.remove_adapter, 'foo') self.assertEqual(len(collection.protocols), 0)
def test_overriding_undefined_data_fails(self): assertRaisesNothing( self, MockStateMachineDevice, override_initial_data={'existing_member': 2.0}) smd = MockStateMachineDevice(override_initial_data={'existing_member': 2.0}) self.assertEqual(smd.existing_member, 2.0) self.assertRaises(AttributeError, MockStateMachineDevice, override_initial_data={'nonexisting_member': 1.0})
def test_process_does_not_block(self): mock_socket = Mock() mock_socket.recv_unicode.side_effect = zmq.Again() server = ControlServer(None, connection_string='127.0.0.1:10000') server._socket = mock_socket assertRaisesNothing(self, server.process) mock_socket.recv_unicode.assert_has_calls([call(flags=zmq.NOBLOCK)])
def test_overriding_undefined_data_fails(self): assertRaisesNothing(self, MockStateMachineDevice, override_initial_data={'existing_member': 2.0}) smd = MockStateMachineDevice( override_initial_data={'existing_member': 2.0}) self.assertEqual(smd.existing_member, 2.0) self.assertRaises(AttributeError, MockStateMachineDevice, override_initial_data={'nonexisting_member': 1.0})
def test_remove_object(self): exposed_objects = ExposedObjectCollection({}) own_functions_count = len(exposed_objects) obj = DummyObject() exposed_objects.add_object(obj, 'testObject') self.assertListEqual(exposed_objects.get_objects(), ['testObject']) assertRaisesNothing(self, exposed_objects.remove_object, 'testObject') self.assertEqual(len(exposed_objects), own_functions_count) self.assertRaises(RuntimeError, exposed_objects.remove_object, 'does_not_exist')
def test_add_plain_object(self): exposed_objects = ExposedObjectCollection({}) obj = DummyObject() assertRaisesNothing(self, exposed_objects.add_object, obj, 'testObject') # There should be :api, get_objects, testObject:api, testObject.a:get, testObject.a:set, # testObject.b:get, testObject.b:set, testObject.getTest, testObject.setTest self.assertEqual(len(exposed_objects), 9) exposed_objects['testObject.getTest'](34, 55) obj.getTest.assert_called_once_with(34, 55)
def test_construct_control_server(self, mock_control_server_type, exposed_object_mock): exposed_object_mock.return_value = 'test' assertRaisesNothing(self, Simulation, device=Mock(), control_server='localhost:10000') mock_control_server_type.assert_called_once_with( { 'device': 'test', 'simulation': 'test', 'interface': 'test' }, 'localhost:10000')
def test_add_adapter(self): collection = AdapterCollection() self.assertEqual(len(collection.protocols), 0) assertRaisesNothing(self, collection.add_adapter, DummyAdapter('foo')) self.assertEqual(len(collection.protocols), 1) self.assertSetEqual(set(collection.protocols), {'foo'}) assertRaisesNothing(self, collection.add_adapter, DummyAdapter('bar')) self.assertEqual(len(collection.protocols), 2) self.assertSetEqual(set(collection.protocols), {'foo', 'bar'}) self.assertRaises(RuntimeError, collection.add_adapter, DummyAdapter('bar'))
def test_set_parameters(self): class TestDevice(object): foo = 10 bar = 'str' def baz(self): pass dev = TestDevice() sim = Simulation(device=dev) assertRaisesNothing(self, sim.set_device_parameters, {'foo': 5, 'bar': 'test'}) self.assertEqual(dev.foo, 5) self.assertEqual(dev.bar, 'test') self.assertRaises(RuntimeError, sim.set_device_parameters, {'not_existing': 45}) self.assertRaises(RuntimeError, sim.set_device_parameters, {'baz': 4})
def test_not_implemented_errors(self): # Construction of the base class should not be possible self.assertRaises(NotImplementedError, StateMachineDevice) mandatory_methods = { '_get_state_handlers': Mock(return_value={'test': MagicMock()}), '_get_initial_state': Mock(return_value='test'), '_get_transition_handlers': Mock( return_value={('test', 'test'): Mock(return_value=True)}) } # If any of the mandatory methods is missing, a NotImplementedError must be raised for methods in itertools.combinations(mandatory_methods.items(), 2): with patch.multiple('lewis.devices.StateMachineDevice', **dict(methods)): self.assertRaises(NotImplementedError, StateMachineDevice) # If all are implemented, no exception should be raised with patch.multiple('lewis.devices.StateMachineDevice', **mandatory_methods): assertRaisesNothing(self, StateMachineDevice)
def test_control_server_setter(self, control_server_mock, exposed_object_mock): # The return value (= instance of ControlServer) must be specified control_server_mock.return_value = Mock() exposed_object_mock.return_value = 'test' env = Simulation(device=Mock()) assertRaisesNothing(self, setattr, env, 'control_server', '127.0.0.1:10001') control_server_mock.assert_called_once_with( {'device': 'test', 'simulation': 'test', 'interface': 'test'}, '127.0.0.1:10001') control_server_mock.reset_mock() assertRaisesNothing(self, setattr, env, 'control_server', None) self.assertIsNone(env.control_server) set_simulation_running(env) # Can set new control server even when simulation is running: assertRaisesNothing(self, setattr, env, 'control_server', '127.0.0.1:10002') # The server is started automatically when the simulation is running control_server_mock.assert_called_once_with( {'device': 'test', 'simulation': 'test', 'interface': 'test'}, '127.0.0.1:10002') # The instance must have one call to start_server control_server_mock.return_value.assert_has_calls([call.start_server()]) # Can not replace control server when simulation is running self.assertRaises(RuntimeError, setattr, env, 'control_server', '127.0.0.1:10003')
def test_pump_command(self): linkam = LinkamT95StreamInterface() linkam_device = SimulatedLinkamT95() linkam.device = linkam_device linkam_device.process() # Initialize # Issue T command to get into stopped state linkam.get_status() linkam_device.process() # Set up to cool from 24.0 C to 4.0 C at 20.00 C/min linkam.set_rate('2000') linkam.set_limit('40') linkam.start() linkam_device.process() # Since the pump feature is not fully implemented, # we can only make sure all valid input is accepted assertRaisesNothing(self, linkam.pump_command, 'm0') # Manual linkam_device.process() for int_value, char_value in enumerate( "0123456789:;<=>?@ABCDEFGHIJKLMN"): assertRaisesNothing(self, linkam.pump_command, char_value) # Characters mean speeds 0 - 30 linkam_device.process() status_bytes = linkam.get_status() self.assertEqual( status_bytes[2], chr(0x80 | int_value)) # Verify Pump Status Byte reflects speed assertRaisesNothing(self, linkam.pump_command, 'a0') # Auto linkam_device.process()
def test_pump_command(self): linkam = LinkamT95StreamInterface() linkam_device = SimulatedLinkamT95() linkam.device = linkam_device linkam_device.process() # Initialize # Issue T command to get into stopped state linkam.get_status() linkam_device.process() # Set up to cool from 24.0 C to 4.0 C at 20.00 C/min linkam.set_rate('2000') linkam.set_limit('40') linkam.start() linkam_device.process() # Since the pump feature is not fully implemented, # we can only make sure all valid input is accepted assertRaisesNothing(self, linkam.pump_command, 'm0') # Manual linkam_device.process() for int_value, char_value in enumerate("0123456789:;<=>?@ABCDEFGHIJKLMN"): assertRaisesNothing( self, linkam.pump_command, char_value) # Characters mean speeds 0 - 30 linkam_device.process() status_bytes = linkam.get_status() self.assertEqual( status_bytes[2], chr(0x80 | int_value)) # Verify Pump Status Byte reflects speed assertRaisesNothing(self, linkam.pump_command, 'a0') # Auto linkam_device.process()
def test_set_parameters(self): class TestDevice(object): foo = 10 bar = 'str' def baz(self): pass dev = TestDevice() sim = Simulation(device=dev) assertRaisesNothing(self, sim.set_device_parameters, { 'foo': 5, 'bar': 'test' }) self.assertEqual(dev.foo, 5) self.assertEqual(dev.bar, 'test') self.assertRaises(RuntimeError, sim.set_device_parameters, {'not_existing': 45}) self.assertRaises(RuntimeError, sim.set_device_parameters, {'baz': 4})
def test_not_implemented_errors(self): # Construction of the base class should not be possible self.assertRaises(NotImplementedError, StateMachineDevice) mandatory_methods = { '_get_state_handlers': Mock(return_value={'test': MagicMock()}), '_get_initial_state': Mock(return_value='test'), '_get_transition_handlers': Mock(return_value={('test', 'test'): Mock(return_value=True)}) } # If any of the mandatory methods is missing, a NotImplementedError must be raised for methods in itertools.combinations(mandatory_methods.items(), 2): with patch.multiple('lewis.devices.StateMachineDevice', **dict(methods)): self.assertRaises(NotImplementedError, StateMachineDevice) # If all are implemented, no exception should be raised with patch.multiple('lewis.devices.StateMachineDevice', **mandatory_methods): assertRaisesNothing(self, StateMachineDevice)
def test_pause_resume(self): env = Simulation(device=Mock()) self.assertFalse(env.is_started) self.assertFalse(env.is_paused) # env is not running, so it can't be paused self.assertRaises(RuntimeError, env.pause) # Fake start of simulation, we don't need to care how this happened set_simulation_running(env) self.assertTrue(env.is_started) self.assertFalse(env.is_paused) assertRaisesNothing(self, env.pause) self.assertTrue(env.is_started) self.assertTrue(env.is_paused) assertRaisesNothing(self, env.resume) # now it's running, so it can't be resumed again self.assertRaises(RuntimeError, env.resume)
def test_pause_resume(self): env = Simulation(device=Mock()) self.assertFalse(env.is_started) self.assertFalse(env.is_paused) # env is not running, so it can't be paused self.assertRaises(RuntimeError, env.pause) # Fake start of simulation, we don't need to care how this happened set_simulation_running(env) self.assertTrue(env.is_started) self.assertFalse(env.is_paused) assertRaisesNothing(self, env.pause) self.assertTrue(env.is_started) self.assertTrue(env.is_paused) assertRaisesNothing(self, env.resume) # now it's running, so it can't be resumed again self.assertRaises(RuntimeError, env.resume)
def test_silent_mode(self): class Foo(object): bar = 0 @check_limits(0, 15, silent=True) def set_bar(self, new_bar): self.bar = new_bar f = Foo() assertRaisesNothing(self, f.set_bar, 0) assertRaisesNothing(self, f.set_bar, 15) assertRaisesNothing(self, f.set_bar, -3) assertRaisesNothing(self, f.set_bar, 16) # Updates must have been ignored. self.assertEqual(f.bar, 15)
def test_invalid_initial_override_fails(self): assertRaisesNothing(self, MockStateMachineDevice) assertRaisesNothing(self, MockStateMachineDevice, override_initial_state='init') assertRaisesNothing(self, MockStateMachineDevice, override_initial_state='test') self.assertRaises(RuntimeError, MockStateMachineDevice, override_initial_state='invalid')
def test_speed_range(self): env = Simulation(device=Mock()) assertRaisesNothing(self, setattr, env, 'speed', 3.0) self.assertEqual(env.speed, 3.0) assertRaisesNothing(self, setattr, env, 'speed', 0.1) self.assertEqual(env.speed, 0.1) assertRaisesNothing(self, setattr, env, 'speed', 0.0) self.assertEqual(env.speed, 0.0) self.assertRaises(ValueError, setattr, env, 'speed', -0.5)
def test_cycle_delay_range(self): env = Simulation(device=Mock()) assertRaisesNothing(self, setattr, env, 'cycle_delay', 0.2) self.assertEqual(env.cycle_delay, 0.2) assertRaisesNothing(self, setattr, env, 'cycle_delay', 2.0) self.assertEqual(env.cycle_delay, 2.0) assertRaisesNothing(self, setattr, env, 'cycle_delay', 0.0) self.assertEqual(env.cycle_delay, 0.0) self.assertRaises(ValueError, setattr, env, 'cycle_delay', -4)
def test_speed_range(self): env = Simulation(device=Mock()) assertRaisesNothing(self, setattr, env, 'speed', 3.0) self.assertEqual(env.speed, 3.0) assertRaisesNothing(self, setattr, env, 'speed', 0.1) self.assertEqual(env.speed, 0.1) assertRaisesNothing(self, setattr, env, 'speed', 0.0) self.assertEqual(env.speed, 0.0) self.assertRaises(ValueError, setattr, env, 'speed', -0.5)
def test_cycle_delay_range(self): env = Simulation(device=Mock()) assertRaisesNothing(self, setattr, env, 'cycle_delay', 0.2) self.assertEqual(env.cycle_delay, 0.2) assertRaisesNothing(self, setattr, env, 'cycle_delay', 2.0) self.assertEqual(env.cycle_delay, 2.0) assertRaisesNothing(self, setattr, env, 'cycle_delay', 0.0) self.assertEqual(env.cycle_delay, 0.0) self.assertRaises(ValueError, setattr, env, 'cycle_delay', -4)
def test_static_limits(self): class Foo(object): bar = 0 @check_limits(0, 15) def set_bar(self, new_bar): self.bar = new_bar f = Foo() assertRaisesNothing(self, f.set_bar, 0) assertRaisesNothing(self, f.set_bar, 15) assertRaisesNothing(self, f.set_bar, 7) self.assertRaises(LimitViolationException, f.set_bar, -3) self.assertRaises(LimitViolationException, f.set_bar, 16)
def test_control_server_setter(self, control_server_mock, exposed_object_mock): # The return value (= instance of ControlServer) must be specified control_server_mock.return_value = Mock() exposed_object_mock.return_value = 'test' env = Simulation(device=Mock()) assertRaisesNothing(self, setattr, env, 'control_server', '127.0.0.1:10001') control_server_mock.assert_called_once_with( { 'device': 'test', 'simulation': 'test', 'interface': 'test' }, '127.0.0.1:10001') control_server_mock.reset_mock() assertRaisesNothing(self, setattr, env, 'control_server', None) self.assertIsNone(env.control_server) set_simulation_running(env) # Can set new control server even when simulation is running: assertRaisesNothing(self, setattr, env, 'control_server', '127.0.0.1:10002') # The server is started automatically when the simulation is running control_server_mock.assert_called_once_with( { 'device': 'test', 'simulation': 'test', 'interface': 'test' }, '127.0.0.1:10002') # The instance must have one call to start_server control_server_mock.return_value.assert_has_calls( [call.start_server()]) # Can not replace control server when simulation is running self.assertRaises(RuntimeError, setattr, env, 'control_server', '127.0.0.1:10003')
def test_transition_override_construction(self): assertRaisesNothing( self, SimulatedLinkamT95, override_transitions={('init', 'stopped'): lambda: True})
def test_state_override_construction(self): assertRaisesNothing( self, SimulatedLinkamT95, override_states={'started': DefaultStartedState()})
def test_default_construction(self): assertRaisesNothing(self, SimulatedLinkamT95)
def test_options(self): assertRaisesNothing(self, DummyAdapter, 'protocol', options={'bar': 2, 'foo': 3}) self.assertRaises(LewisException, DummyAdapter, 'protocol', options={'invalid': False})
def test_upper_lower_only(self): class Foo(object): bar = 0 baz = 1 @check_limits(upper=15) def set_bar(self, new_bar): self.bar = new_bar @check_limits(lower=0) def set_baz(self, new_baz): self.baz = new_baz f = Foo() assertRaisesNothing(self, f.set_bar, 0) assertRaisesNothing(self, f.set_bar, 15) assertRaisesNothing(self, f.set_bar, -5) self.assertRaises(LimitViolationException, f.set_bar, 16) assertRaisesNothing(self, f.set_baz, 0) assertRaisesNothing(self, f.set_baz, 15) assertRaisesNothing(self, f.set_baz, 16) self.assertRaises(LimitViolationException, f.set_baz, -5)
def test_init(self): assertRaisesNothing(self, DeviceRegistry, self._tmp_package_name) self.assertRaises(LewisException, DeviceRegistry, str(uuid4()))
def test_localhost_does_not_raise_socket_error(self): assertRaisesNothing(self, ControlServer, object_map=None, connection_string='localhost:10000')
def test_init(self): assertRaisesNothing(self, DeviceBuilder, self.module) builder = DeviceBuilder(self.module) self.assertEqual(builder.name, self.module.__name__)
def test_property_limits(self): class Foo(object): bar = 0 bar_min = 0 bar_max = 15 @check_limits('bar_min', 'bar_max') def set_bar(self, new_bar): self.bar = new_bar f = Foo() assertRaisesNothing(self, f.set_bar, 0) assertRaisesNothing(self, f.set_bar, 15) self.assertRaises(LimitViolationException, f.set_bar, -3) self.assertRaises(LimitViolationException, f.set_bar, 16) f.bar_min = -3 f.bar_max = 16 assertRaisesNothing(self, f.set_bar, -3) assertRaisesNothing(self, f.set_bar, 16) f.bar_min = None f.bar_max = None assertRaisesNothing(self, f.set_bar, 123232224) assertRaisesNothing(self, f.set_bar, -352622234)
def test_default_construction(self): assertRaisesNothing(self, SimulatedJulabo)
def test_state_override_construction(self): assertRaisesNothing(self, SimulatedLinkamT95, override_states={'started': DefaultStartedState()})
def test_default_construction(self): assertRaisesNothing(self, SimulatedLinkamT95)
def test_invalid_initial_override_fails(self): assertRaisesNothing(self, MockStateMachineDevice) assertRaisesNothing(self, MockStateMachineDevice, override_initial_state='init') assertRaisesNothing(self, MockStateMachineDevice, override_initial_state='test') self.assertRaises(RuntimeError, MockStateMachineDevice, override_initial_state='invalid')
def test_transition_override_construction(self): assertRaisesNothing(self, SimulatedLinkamT95, override_transitions={ ('init', 'stopped'): lambda: True })
def test_default_construction(self): assertRaisesNothing(self, SimulatedJulabo)