garage_tests.py

class GarageException(Exception):
    """Garage exceptions base"""


class NoSpaceAvailableError(GarageException):
    """Raises when no space available in garage"""


class Vehicle:
    size = 0

    def __init__(self, name):
        self.name = name


class Car(Vehicle):
    size = 1.0


class Motorcycle(Vehicle):
    size = 0.5


class Garage:
    def __init__(self, size=1.0):
        self._parked_cars = []
        self.__size = size

    @property
    def available_space(self):
        return self.__size

    def park(self, vehicle):
        if vehicle.size > self.__size:
            raise NoSpaceAvailableError()

        self._parked_cars.append(vehicle)
        self.__size -= vehicle.size

    def unpark(self, vehicle):
        for parked_vehicle in self._parked_cars:
            if parked_vehicle == vehicle:
                self._parked_cars.remove(vehicle)
                self.__size += vehicle.size
                return


import unittest


class TestVehicle(unittest.TestCase):
    def setUp(self):
        self.v = Vehicle("Name")

    def test_create_simple_vehicle_object(self):
        """Because Vehicle object is created in setUp we can just
        test it right now"""

        self.assertIsInstance(self.v, Vehicle)
        self.assertEqual(self.v.name, "Name")


class TestCar(unittest.TestCase):
    def test_create_car_object(self):
        c = Car("Toyota")
        self.assertIsInstance(c, Car)
        self.assertIsInstance(c, Vehicle)
        self.assertEqual(c.name, "Toyota")


class TestGarage(unittest.TestCase):
    def setUp(self):
        self.g = Garage()

    def test_create_empty_garage(self):
        self.assertIsInstance(self.g, Garage)
        self.assertListEqual(self.g._parked_cars, [])

    def test_park_one_vehicle(self):
        v = Vehicle("Name")
        self.g.park(v)
        self.assertListEqual(self.g._parked_cars, [v])

    def test_unpark_vehicle(self):
        v = Vehicle("Name")
        self.g.park(v)
        self.g.unpark(v)
        self.assertListEqual(self.g._parked_cars, [])

    def test_park_two_vehicles(self):
        self.g.park(Vehicle("Name"))
        self.g.park(Vehicle("Other"))
        self.assertEqual(len(self.g._parked_cars), 2)

    def test_park_one_car_should_subtract_available_space(self):
        self.g.park(Car("Toyota"))
        self.assertEqual(len(self.g._parked_cars), 1)
        self.assertEqual(self.g.available_space, 0)

    def test_park_one_car_and_unpark_should_add_space(self):
        c = Car("Toyota")
        self.g.park(c)
        self.g.unpark(c)
        self.assertEqual(self.g.available_space, 1)

    def test_no_available_space_should_raise_exception(self):
        self.g.park(Car("Toyota"))
        with self.assertRaises(NoSpaceAvailableError):
            self.g.park(Car("Toyota"))


if __name__ == "__main__":
    unittest.main()