def test_disconnect_device(self, sleep_mock):
adapter_mock = Mock()
env = Simulation(device=Mock(), adapter=adapter_mock)
# connected device calls adapter_mock
env._process_cycle(0.5)
adapter_mock.assert_has_calls([call.handle(env.cycle_delay)])
sleep_mock.assert_not_called()
adapter_mock.reset_mock()
sleep_mock.reset_mock()
# disconnected device calls sleep_mock
env.disconnect_device()
env._process_cycle(0.5)
sleep_mock.assert_has_calls([call.handle(env.cycle_delay)])
adapter_mock.assert_not_called()
adapter_mock.reset_mock()
sleep_mock.reset_mock()
# re-connecting returns to previous behavior
env.connect_device()
env._process_cycle(0.5)
adapter_mock.assert_has_calls([call.handle(env.cycle_delay)])
sleep_mock.assert_not_called()
def test_start_stop(self):
env = Simulation(device=Mock(), adapter=Mock())
with patch.object(env, '_process_cycle', side_effect=lambda x: env.stop()) as mock_cycle:
env.start()
mock_cycle.assert_has_calls([call(0.0)])
def test_setups(self):
class MockBuilder:
setups = {"foo": 1, "bar": 2}
sim = Simulation(device=Mock(), device_builder=MockBuilder())
self.assertEqual(set(sim.setups), {"foo", "bar"})
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'
device_mock = Mock()
env = Simulation(device=device_mock, adapter=Mock())
assertRaisesNothing(self, setattr, env, 'control_server', '127.0.0.1:10001')
control_server_mock.assert_called_once_with(
{'device': device_mock, 'simulation': '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': device_mock, 'simulation': '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_setups(self):
class MockBuilder(object):
setups = {'foo': 1, 'bar': 2}
sim = Simulation(device=Mock(), device_builder=MockBuilder())
self.assertEqual(set(sim.setups), {'foo', 'bar'})
def test_device_documentation_returns_adapter_documentation(self):
adapter_mock = Mock()
adapter_mock.documentation = 'test'
env = Simulation(device=Mock(), adapter=adapter_mock)
doc = env.device_documentation
self.assertEqual(doc, 'test')
def test_process_cycle_calls_process_simulation(self):
device_mock = Mock()
env = Simulation(device=device_mock)
set_simulation_running(env)
env._process_cycle(0.5)
device_mock.assert_has_calls([call.process(0.5)])
self.assertEqual(env.cycles, 1)
self.assertEqual(env.runtime, 0.5)
def test_process_calls_control_server(self):
env = Simulation(device=Mock())
control_mock = Mock()
env._control_server = control_mock
set_simulation_running(env)
env._process_cycle(0.5)
control_mock.assert_has_calls([call.process()])
def test_process_cycle_returns_elapsed_time(self, elapsed_seconds_mock):
env = Simulation(device=Mock())
# It doesn't matter what happens in the simulation cycle, here we
# only care how long it took.
with patch.object(env, "_process_simulation_cycle"):
elapsed_seconds_mock.return_value = 0.5
delta = env._process_cycle(0.0)
elapsed_seconds_mock.assert_called_once_with(ANY)
self.assertEqual(delta, 0.5)
def test_process_cycle_changes_runtime_status(self, elapsed_seconds_mock):
env = Simulation(device=Mock())
with patch.object(env, "_process_simulation_cycle"):
self.assertEqual(env.uptime, 0.0)
set_simulation_running(env)
elapsed_seconds_mock.return_value = 0.5
env._process_cycle(0.0)
self.assertEqual(env.uptime, 0.5)
def test_connect_disconnect_exceptions(self):
env = Simulation(device=Mock(), adapter=Mock())
self.assertTrue(env.device_connected)
assertRaisesNothing(self, env.disconnect_device)
self.assertFalse(env.device_connected)
self.assertRaises(RuntimeError, env.disconnect_device)
assertRaisesNothing(self, env.connect_device)
self.assertTrue(env.device_connected)
self.assertRaises(RuntimeError, env.connect_device)
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_start_starts_control_server(self):
env = Simulation(device=Mock())
control_server_mock = Mock()
env._control_server = control_server_mock
def process_cycle_side_effect(delta):
env.stop()
env._process_cycle = Mock(side_effect=process_cycle_side_effect)
env.start()
control_server_mock.assert_has_calls([call.start_server()])
def test_process_simulation_cycle_applies_speed(self):
device_mock = Mock()
env = Simulation(device=device_mock)
set_simulation_running(env)
env.speed = 2.0
env._process_cycle(0.5)
device_mock.assert_has_calls([call.process(1.0)])
self.assertEqual(env.cycles, 1)
self.assertEqual(env.runtime, 1.0)
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_process_cycle_calls_sleep_if_paused(self):
device_mock = Mock()
env = Simulation(device=device_mock)
set_simulation_running(env)
env.pause()
# simulation paused, device should not be called
env._process_cycle(0.5)
device_mock.assert_not_called()
env.resume()
# simulation is running now, device should be called
env._process_cycle(0.5)
device_mock.assert_has_calls([call.process(0.5)])
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 do_run_simulation(argument_list=None):
arguments = parser.parse_args(argument_list or sys.argv[1:])
if arguments.version:
print(__version__)
return
if arguments.add_path is not None:
sys.path.append(os.path.abspath(arguments.add_path))
device_registry = DeviceRegistry(arguments.device_package)
if not arguments.device:
devices = [
'Please specify a device to simulate. The following devices are available:'
]
for dev in device_registry.devices:
devices.append(' ' + dev)
print('\n'.join(devices))
return
device_builder = device_registry.device_builder(arguments.device)
if arguments.list_protocols:
print('\n'.join(device_builder.protocols))
return
device = device_builder.create_device(arguments.setup)
interface = device_builder.create_interface(
arguments.protocol, device=device, arguments=arguments.adapter_args)
if arguments.show_interface:
print(interface.documentation)
return
simulation = Simulation(device=device,
adapter=interface,
control_server=arguments.rpc_host)
simulation.cycle_delay = arguments.cycle_delay
simulation.speed = arguments.speed
simulation.start()
def test_switch_setup(self):
class MockBuilder(object):
setups = {'foo': None}
def create_device(self, setup):
if setup == 'foo':
return setup
raise RuntimeError('Error')
adapter_mock = MagicMock()
sim = Simulation(device=Mock(),
adapters=adapter_mock,
device_builder=MockBuilder())
sim.switch_setup('foo')
self.assertEqual(sim._device, 'foo')
self.assertRaises(RuntimeError, sim.switch_setup, 'bar')
def test_switch_setup(self):
class MockBuilder:
setups = {"foo": None}
def create_device(self, setup):
if setup == "foo":
return setup
raise RuntimeError("Error")
adapter_mock = MagicMock()
sim = Simulation(device=Mock(),
adapters=adapter_mock,
device_builder=MockBuilder())
sim.switch_setup("foo")
self.assertEqual(sim._device, "foo")
self.assertRaises(RuntimeError, sim.switch_setup, "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_set_parameters(self):
class TestDevice:
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_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_None_control_server_is_None(self):
env = Simulation(device=Mock(), control_server=None)
self.assertIsNone(env.control_server)
def test_setups_empty(self):
sim = Simulation(device=Mock(), device_builder=None)
self.assertEqual(sim.setups, [])