def testReturnsMatchingCandidateIfSignalRightReceived(self):
        carCandidates = [100, 200]
        inputTracker = InputTracker(MagicMock(), MagicMock())
        inputTracker.getSignal = MagicMock(return_value=Signal.THROTTLE_RIGHT)

        self.thing = UserSignalsHeuristics(carCandidates, inputTracker)
        self.thing.withFallback(MagicMock())

        car = self.thing.guessCar()
        self.assertEqual(car, 200, 'Did not return signaled candidate')
    def testCallsFallbackWithoutSignalReceived(self):
        carCandidates = [100, 200]
        inputTracker = InputTracker(MagicMock(), MagicMock())
        inputTracker.getSignal = MagicMock(return_value=None)

        self.thing = UserSignalsHeuristics(carCandidates, inputTracker)
        fallback = MagicMock()
        fallback.guessCar = MagicMock(return_value=100)
        self.thing.withFallback(fallback)

        car = self.thing.guessCar()

        fallback.guessCar.assert_called_once()
        self.assertEqual(car, 100, 'Did not return fallback guess')
class TestInputTracker(unittest.TestCase):

    def __init__(self, methodName):
        unittest.TestCase.__init__(self, methodName)

    def setUp(self):
        self.speedTracker = MagicMock()
        self.speedTracker.getTopSpeed = MagicMock(return_value = 0)
        self.notify = MagicMock()
        self.thing = InputTracker(self.speedTracker, self.notify)

    def tearDown(self):
        pass

    def testNoSignalBeforeData(self):
        self.assertIsNone(self.thing.input, 'Input must be initially None')
        self.assertIsNone(self.thing.signal, 'Signal must be initially None')

    def testIsSignalLeft(self):
        self.assertTrue(self.thing.isSignalLeft(0.6, -0.6))

    def testIsSignalRight(self):
        self.assertTrue(self.thing.isSignalRight(0.6, 0.6))

    def testIsNoSignal(self):
        thing = self.thing

        throttle = 0.6
        steer = -0.2
        self.assertFalse(thing.isSignalLeft(throttle, steer))
        self.assertFalse(thing.isSignalRight(throttle, steer))

        throttle = 0.6
        steer= 0.2
        self.assertFalse(thing.isSignalLeft(throttle, steer))
        self.assertFalse(thing.isSignalRight(throttle, steer))

        throttle = 0.2
        steer = -0.6
        self.assertFalse(thing.isSignalLeft(throttle, steer))
        self.assertFalse(thing.isSignalRight(throttle, steer))

        throttle = 0.2
        steer = 0.6
        self.assertFalse(thing.isSignalLeft(throttle, steer))
        self.assertFalse(thing.isSignalRight(throttle, steer))

    def testNoTrackingIfNotEnabled(self):
        self.thing.enabled = True
        stats = [0] * fieldCount

        self.thing.track(stats)
        self.speedTracker.getTopSpeed.assert_called_once()
        self.speedTracker.getTopSpeed.reset_mock()

        self.thing.enabled = False
        self.thing.track(stats)
        self.speedTracker.getTopSpeed.assert_not_called()

    def testSignalLeftOnlyAfterInputGone(self):
        self.notify.assert_not_called()
        self.speedTracker.getTopSpeed = MagicMock(return_value = 0)
        stats = [0] * fieldCount
        stats[29] = 0.6
        stats[30] = -0.6

        self.thing.track(stats)
        self.assertEqual(self.thing.input, Signal.THROTTLE_LEFT)
        self.notify.assert_called_once()
        self.assertIsNone(self.thing.signal)

        stats[29] = 0.0
        self.thing.track(stats)
        self.assertIsNone(self.thing.input)
        self.notify.assert_called_once()
        self.assertEqual(self.thing.signal, Signal.THROTTLE_LEFT)

    def testSignalRightOnlyAfterInputGone(self):
        self.notify.assert_not_called()
        self.speedTracker.getTopSpeed = MagicMock(return_value = 0)
        stats = [0] * fieldCount
        stats[29] = 0.6
        stats[30] = 0.6

        self.thing.track(stats)
        self.assertEqual(self.thing.input, Signal.THROTTLE_RIGHT)
        self.notify.assert_called_once()
        self.assertIsNone(self.thing.signal)

        stats[29] = 0.0
        self.thing.track(stats)
        self.assertIsNone(self.thing.input)
        self.notify.assert_called_once()
        self.assertEqual(self.thing.signal, Signal.THROTTLE_RIGHT)
 def setUp(self):
     self.speedTracker = MagicMock()
     self.speedTracker.getTopSpeed = MagicMock(return_value = 0)
     self.notify = MagicMock()
     self.thing = InputTracker(self.speedTracker, self.notify)