def test_cheapest(self, mocker):
mocker.patch('delivery.views.route.Route.validate_cheapest_input')
mocker.patch('delivery.views.route.Route.calculate_expenses')
expected = RouteModel(**self.mock_data)
input = {}
input.update(self.mock_data)
input['gas_price'] = 1
input['truck_autonomy'] = 1
session = UnifiedAlchemyMagicMock(data=[
(
[mock.call.query(RouteModel),
mock.call.filter(RouteModel.map == self.mock_data['map'])],
[expected]
),
])
route = Route(session)
result = route.cheapest(input)
route.calculate_expenses.assert_called_once()
assert list(result.keys()) == ['route', 'cost']
assert self.mock_data['origin'] in list(result['route'])
assert self.mock_data['destination'] in list(result['route'])
def route_cheapest(map: str,
origin: str,
destination: str,
truck_autonomy: float,
gas_price: float,
db: Session = Depends(async_session)):
route = Route(db)
try:
data_input = {
'map': map,
'origin': origin,
'destination': destination,
'truck_autonomy': truck_autonomy,
'gas_price': gas_price
}
data = route.cheapest(data_input)
return RouteCheapestSchema(**data)
except ValueError as e:
logger.error(e)
raise HTTPException(
status_code=400,
detail=str(e),
)
except Exception as e:
logger.error(e)
raise HTTPException(
status_code=400,
detail="Error to retrive the cheapest route.",
)
def test_validate_map_exception(self):
expected = []
session = UnifiedAlchemyMagicMock(data=[
(
[mock.call.query(RouteModel.id),
mock.call.filter(RouteModel.map == self.mock_data['map']),
],
expected,
),
])
route = Route(session)
with pytest.raises(ValueError, match='This map does not exists.'):
route.validate_map(self.mock_data['map'])
def test_validate_map(self):
expected = 10
session = UnifiedAlchemyMagicMock(data=[
(
[mock.call.query(RouteModel.id),
mock.call.filter(RouteModel.map == self.mock_data['map'])],
[expected]
),
])
route = Route(session)
route.validate_map(self.mock_data['map'])
session.query.return_value.filter.\
assert_called_once_with(RouteModel.map == self.mock_data['map'])
def new_route(input: RouteSchema, db: Session = Depends(async_session)):
route = Route(db)
try:
new_route = route.create(input)
return new_route
except ValueError as e:
logger.error(e)
raise HTTPException(
status_code=400,
detail=str(e),
)
except Exception as e:
logger.error(e)
raise HTTPException(
status_code=400,
detail="Error to create a new route.",
)
def test_validate_input(self):
expected = False
route_schema = RouteSchema(**self.mock_data)
session = UnifiedAlchemyMagicMock(data=[
(
[mock.call.query(RouteModel.id),
mock.call.filter(
RouteModel.map == self.mock_data['map'],
RouteModel.origin == self.mock_data['origin'],
RouteModel.destination == self.mock_data['destination'])],
[expected]
),
])
route = Route(session)
valid_input = route.validate_input(route_schema)
assert valid_input == expected
def test_calculate_cost(self):
gas_price = 1
truck_autonomy = 1
distance = 0
expected = 0
result = Route.calculate_expenses(gas_price, truck_autonomy, distance)
assert result == expected
def test_validate_destination_exception(self):
expected = []
session = UnifiedAlchemyMagicMock(data=[
(
[mock.call.query(RouteModel.id),
mock.call.filter(
RouteModel.map == self.mock_data['map'],
RouteModel.destination == self.mock_data['destination'])
],
expected,
),
])
route = Route(session)
msg = 'This destination on this map does not exists.'
with pytest.raises(ValueError, match=msg):
route.validate_destination(
self.mock_data['map'], self.mock_data['destination']
)
def test_validate_cheapest_input(self, mocker):
session = AlchemyMagicMock()
route = Route(session)
spy_map = mocker.spy(route, 'validate_map')
spy_origin = mocker.spy(route, 'validate_origin')
spy_destination = mocker.spy(route, 'validate_destination')
mocker.patch('delivery.views.route.Route.validate_map')
mocker.patch('delivery.views.route.Route.validate_origin')
mocker.patch('delivery.views.route.Route.validate_destination')
route.validate_cheapest_input(self.mock_data)
map = self.mock_data['map']
spy_map.assert_called_once_with(map)
spy_origin.assert_called_once_with(map, self.mock_data['origin'])
spy_destination.assert_called_once_with(
map, self.mock_data['destination']
)