def create_not_plugin(name, can_parse_command_string):
plugin = mock()
plugin.canParseCommandString = mock(
return_value=can_parse_command_string)
plugin.updateSettings = mock()
plugin.name = name
plugin.processCommandString = mock(
return_value='modified cmd string')
return plugin
def test_is_wall_is_false_when_both_distances_are_very_different(self):
ball_sensor = mock(name='ball_sensor')
ball_sensor.distance.return_value = 10.5
wall_sensor = mock(name='wall_sensor')
wall_sensor.distance.return_value = 50
brain = Brains(ball_sensor, wall_sensor, None, None)
self.assertFalse(brain.is_wall())
ball_sensor.dispose()
wall_sensor.dispose()
def test_distance_returns_distance_in_centimeters(self):
self.pin_tracking_state = 0
gpio = mock(name='gpio')
gpio.input = mock(side_effect=self.simulate_pin_sunny_day_scenario)
sensor = DistanceSensor(gpio, 1, 2)
sensor.timeout = 0.95
distance = sensor.distance()
#not very valid test, but is better than nothing
print(distance)
self.assertTrue(distance > 5)
self.assertTrue(distance < 150)
gpio.dispose()
def test_can_stop_find_ball_right_command_while_running(self):
wheels = mock(name='wheels')
wheels.turn_left.assert_not_called() # double check no side effects
wheels.turn_right.assert_not_called() # ensure no side effects
with patch('__main__.Brains.keep_finding_the_ball',
new_callable=PropertyMock) as mock_keep_finding:
brain = Brains(None, None, wheels, None)
brain.is_wall = mock(return_value=True)
mock_keep_finding.side_effect = [True, True, True, False]
brain.find_ball_right()
wheels.turn_right.assert_any_call()
wheels.stop.assert_any_call()
wheels.dispose()
def test_distance_throws_a_time_out_error_when_timeout_limit_is_reached(
self):
self.pin_tracking_state = 0
gpio = mock(name='gpio')
gpio.input = mock(
side_effect=self.simulate_pin_going_high_after_one_second)
sensor = DistanceSensor(gpio, 1, 2)
sensor.timeout = 0.95
try:
sensor.distance()
except TimeoutError as e:
self.assertEqual(e.args[0], sensor.timeout_message)
gpio.dispose()
def test_can_stop_find_ball_left_command_while_running(self):
wheels = mock(name='wheels')
with patch('__main__.Brains.keep_finding_the_ball',
new_callable=PropertyMock) as mock_keep_finding:
brain = Brains(None, None, wheels, None)
brain.is_wall = mock(return_value=True)
mock_keep_finding.side_effect = [True, True, True, False]
brain.find_ball_left()
#if we do not have a runaway loop then this appears to work
wheels.turn_left.assert_any_call()
wheels.stop.assert_any_call()
wheels.dispose()
def test_is_wall_is_true_when_both_sensors_report_close_to_same_distance(
self):
ball_sensor = mock(name='ball_sensor')
ball_sensor.distance.return_value = 10.5
wall_sensor = mock(name='wall_sensor')
wall_sensor.distance.return_value = 10
brain = Brains(ball_sensor, wall_sensor, None, None)
self.assertTrue(brain.is_wall())
ball_sensor.dispose()
wall_sensor.dispose()
def test_is_wall_stops_find_ball_left_command(self):
wheels = mock(name='wheels')
wheels.turn_left.assert_not_called() # double check no side effects
brain = Brains(None, None, wheels, None)
brain.is_wall = mock(side_effect=[True, True, True, False])
#method under test
brain.find_ball_left()
wheels.turn_left.assert_any_call()
wheels.stop.assert_any_call()
wheels.dispose()
def create_not_plugin_manager():
not_plugin_manager = mock()
self.plugin1 = create_not_plugin('plugin1', True)
self.plugin2 = create_not_plugin('plugin2', False)
self.plugin3 = create_not_plugin('plugin3', False)
self.plugin4 = create_not_plugin('plugin4', False)
not_plugin_manager.getPlugins = mock(
return_value={
'plugin1': self.plugin1,
'plugin2': self.plugin2,
'plugin3': self.plugin3,
'plugin4': self.plugin4
})
return not_plugin_manager
def test_drive_to_strike_zone_when_the_ball_is_already_in_strike_zone_nothing_happens(
self):
ball_sensor = mock(name='ball_sensor')
ball_sensor.distance.return_value = 10.5
wall_sensor = mock(name='wall_sensor')
wall_sensor.distance.return_value = 60
wheels = mock(name='wheels')
brain = Brains(ball_sensor, wall_sensor, wheels, None)
brain.strike_zone_center = 10
#method under test
brain.drive_to_strike_zone()
wheels.foward.assert_not_called()
wheels.backward.assert_not_called()
wheels.dispose()
def test_drive_to_strike_zone_goes_foward(self, patched_time_sleep):
ball_sensor = mock(name='ball_sensor')
ball_sensor.distance.return_value = 50
wall_sensor = mock(name='wall_sensor')
wall_sensor.distance.return_value = 60
wheels = mock(name='wheels')
brain = Brains(ball_sensor, wall_sensor, wheels, None)
#method under test
brain.drive_to_strike_zone()
wheels.foward.assert_called()
wheels.dispose()
ball_sensor.dispose()
wall_sensor.dispose()
def test_can_open_or_close_servo_1(self):
servo_hat = mock(name='servo_hat')
servo1_pin = 6 #hat pin 6
servo2_pin = 7 #hat pin 7
grabber = Grabber(servo_hat, servo1_pin, servo1_pin)
grabber.servo_1_open_or_close()
servo_hat.setPWM.assert_called()
servo_hat.dispose()
def test_backward(self):
pwm = mock(name='pwm')
wheels = ServoWheels(pwm, 2, 3)
wheels.backward()
pwm.setPWM.assert_any_call(2, 0, 600)
pwm.setPWM.assert_any_call(3, 0, 150)
#print(pwm.mock_calls)
pwm.dispose()
def test_stop_stops_both_servos(self):
pwm = mock(name='pwm')
wheels = ServoWheels(pwm, 2, 3)
wheels.stop()
#print(pwm.mock_calls)
pwm.setPWM.assert_any_call(2, 0, 375.0)
pwm.setPWM.assert_any_call(3, 0, 375.0)
pwm.dispose()
def test_can_turn_right(self):
pwm = mock(name='pwm')
wheels = ServoWheels(pwm, 2, 3)
wheels.turn_right()
pwm.setPWM.assert_any_call(2, 0, 600)
pwm.setPWM.assert_any_call(3, 0, 600)
#print(pwm.mock_calls)
pwm.dispose()
def test_find_ball_right_command_hides_the_striker(self):
ball_sensor = mock(name='ball_sensor')
ball_sensor.distance.return_value = 10.5
wall_sensor = mock(name='wall_sensor')
wall_sensor.distance.return_value = 60
wheels = mock(name='wheels')
wheels.turn_left.assert_not_called() # double check no side effects
striker = mock(name="striker")
brain = Brains(ball_sensor, wall_sensor, wheels, striker)
#_keep_finding_the_ball is normally true, setting to false is best way to test
brain._keep_finding_the_ball = False
brain.find_ball_right()
striker.hide_striker.assert_any_call()
#cleanup
wheels.dispose()
striker.dispose()
def test_switch_left_right_commands_swaps_commands(self):
pwm = mock(name='pwm')
wheels = ServoWheels(pwm, 2, 3)
wheels.switch_left_right_commands = True
wheels.turn_left()
pwm.setPWM.assert_any_call(2, 0, 600)
pwm.setPWM.assert_any_call(3, 0, 600)
#print(pwm.mock_calls)
pwm.dispose()
def test_drive_to_strike_zone_hides_the_striker(self):
ball_sensor = mock(name='ball_sensor')
ball_sensor.distance.return_value = 10.5
wall_sensor = mock(name='wall_sensor')
wall_sensor.distance.return_value = 60
wheels = mock(name='wheels')
wheels.turn_left.assert_not_called() # double check no side effects
striker = mock(name="striker")
brain = Brains(ball_sensor, wall_sensor, wheels, striker)
brain.drive_to_strike_zone()
striker.hide_striker.assert_any_call()
#cleanup
wheels.dispose()
striker.dispose()
ball_sensor.dispose()
wall_sensor.dispose()
def test_backward_with_rever_command_set(self):
pwm = mock(name='pwm')
wheels = ServoWheels(pwm, 2, 3)
wheels.switch_foward_backward_commands = True
wheels.backward()
pwm.setPWM.assert_any_call(2, 0, 150)
pwm.setPWM.assert_any_call(3, 0, 600)
#print(pwm.mock_calls)
pwm.dispose()
def test_find_ball_left_command_ensure_default_keep_finding_is_set_to_true(
self):
wheels = mock(name='wheels')
wheels.turn_left.assert_not_called() # double check no side effects
brain = Brains(None, None, wheels, None)
#_keep_finding_the_ball is normally true, setting to false is best way to test
brain._keep_finding_the_ball = False
# iterate through a few trues, then a false.
brain.is_wall = mock(side_effect=[True, True, True, False])
#call the method under test
brain.find_ball_left()
wheels.turn_left.assert_any_call()
wheels.stop.assert_any_call()
#cleanup
wheels.dispose()
def test_open_or_close_servo_2_flips_last_state(self):
servo_hat = mock(name='servo_hat')
grabber = Grabber(servo_hat, 6, 7, servo_min=400, servo_max=450)
grabber.servo_2_last_state = 1 #just ensuring default for test
#ensure starting value
self.assertEqual(1, grabber.servo_2_last_state)
#method under test
grabber.servo_2_open_or_close()
#prove the value was changed
self.assertEqual(0, grabber.servo_2_last_state)
servo_hat.dispose()
def test_hide_striker_can_reverse_the_default_setting(self):
gpio = mock()
servo_hat = mock()
wedge_motor = mock()
striker = StrikerCommands(gpio,
10,
11,
servo_hat,
wedge_motor,
12,
rotate_min=250,
rotate_max=400,
min_is_hidden=False)
#method under test
striker.hide_striker()
servo_hat.setPWM.assert_called_with(12, 0, 400)
servo_hat.dispose()
gpio.dispose()
servo_hat.dispose()
wedge_motor.dispose()
def test_open_or_close_servo_1_called_executes_specific_pwm_calls(self):
servo_hat = mock(name='servo_hat')
grabber = Grabber(servo_hat, 6, 7, servo_min=400, servo_max=450)
grabber.servo_1_last_state = 0
grabber.servo_1_open_or_close()
servo_hat.setPWM.assert_called()
expected_calls = [
call(6, 0, 445),
call(6, 0, 440),
call(6, 0, 435),
call(6, 0, 430),
call(6, 0, 425),
call(6, 0, 420),
call(6, 0, 415),
call(6, 0, 410),
call(6, 0, 405),
call(6, 0, 400)
]
servo_hat.setPWM.assert_has_calls(expected_calls, any_order=False)
servo_hat.dispose()
def test_can_lift_up_ball(self):
servo_hat = mock(name='servo_hat')
lifter = ServoSettings(pin_number=8, min_setting=350, max_setting=375)
grabber = Grabber(servo_hat,
6,
7,
lifter,
servo_min=400,
servo_max=450)
grabber.lift_up_or_down()
expected_calls = [
call(8, 0, 350),
call(8, 0, 355),
call(8, 0, 360),
call(8, 0, 365),
call(8, 0, 370),
call(8, 0, 375)
]
servo_hat.setPWM.assert_has_calls(expected_calls, any_order=False)
def test_open_or_close_servo_2_called_executes_specific_pwm_calls(self):
servo_hat = mock(name='servo_hat')
grabber = Grabber(servo_hat, 6, 7, servo_min=400, servo_max=450)
grabber.servo_2_last_state = 1 #just ensuring default for test
#method under test
grabber.servo_2_open_or_close()
expected_calls = [
call(7, 0, 400),
call(7, 0, 405),
call(7, 0, 410),
call(7, 0, 415),
call(7, 0, 420),
call(7, 0, 425),
call(7, 0, 430),
call(7, 0, 435),
call(7, 0, 440),
call(7, 0, 445),
call(7, 0, 450)
]
servo_hat.setPWM.assert_has_calls(expected_calls, any_order=False)
servo_hat.dispose()
def test_config_not_found(path):
with patch('yab2ux.load_config_file', mock(return_value=None)):
assert load_config(path) == (None, None)
def test_export_fbx(outpath, config_with_params, root):
with patch("yab2ux.makedirs", mock()) as makedirs:
with patch("yab2ux.bl_to_fbx", mock()) as bl_to_fbx:
do_export_fbx(outpath, config_with_params, root)
makedirs.assert_called_with('/project/models', exist_ok=True)
bl_to_fbx.assert_called_with('/project/models/turnip.fbx', foo='bar')
def setUp(self):
self.pwm = mock(name='pwm')
self.real = ServoBasics(self.pwm, servo_min=160, servo_max=230)
# et retouren toujours un mock. Il est possible d'appeler n'importe quel
# méthode et retournera toujors un mock
from unittest.mock import MagicMock # ou from mock import MagicMock
mock = MagicMock()
print(mock)
print(mock())
print(mock(1, True, [Exception, {}]))
print(mock.foo())
print(mock.nimporte().nawak().je().te().dis())
print(mock + mock - 10000)
# Il est possible de faire en sorte qu'ils aient un comportement spécifique.
mock.you = MagicMock(side_effect=ValueError('mofo !')) # un callable marche aussi
#mock.you() # Provoque une ValueError
mock.mock = MagicMock(return_value="moooooooooock")
print(mock.mock())
# Il est possible de combiner de vrai objets avec des mock
class maClasse:
def func1(self):
print("coucou")
def func2(self):
print("COCORICO")
oo = maClasse()
oo.func1 = MagicMock()
print(oo.func1("POKEMON !!").split() + 33)
print(oo.func2())
def create_not_mappers_manager():
not_mappers_manager = mock()
