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()