def test_start_stop(self):
env = Simulation(device=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_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_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_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_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_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_None_control_server_is_None(self):
env = Simulation(device=Mock(), control_server=None)
self.assertIsNone(env.control_server)
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_setups_empty(self):
sim = Simulation(device=Mock(), device_builder=None)
self.assertEqual(sim.setups, [])