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)
