typosaurus-sandbox/tests/test_api.py

# retoor <retoor@molodetz.nl>

import unittest

from fastapi.testclient import TestClient

from typosaurus_sandbox.app import App

client = TestClient(App)


class TestHealthEndpoint(unittest.TestCase):

    def test_health_returns_ok(self) -> None:
        response = client.get("/health")
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.json(), {"status": "ok"})


class TestCalculatorAddEndpoint(unittest.TestCase):

    def test_add_positive_integers(self) -> None:
        response = client.post("/api/v1/calculator/add", json={"left": 3, "right": 5})
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.json(), {"result": 8})

    def test_add_negative_integers(self) -> None:
        response = client.post("/api/v1/calculator/add", json={"left": -3, "right": -5})
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.json(), {"result": -8})

    def test_add_invalid_input_returns_422(self) -> None:
        response = client.post("/api/v1/calculator/add", json={"left": "abc", "right": 5})
        self.assertEqual(response.status_code, 422)

    def test_add_missing_field_returns_422(self) -> None:
        response = client.post("/api/v1/calculator/add", json={"left": 3})
        self.assertEqual(response.status_code, 422)


class TestCalculatorSubtractEndpoint(unittest.TestCase):

    def test_subtract_positive(self) -> None:
        response = client.post("/api/v1/calculator/subtract", json={"left": 10, "right": 3})
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.json(), {"result": 7})

    def test_subtract_negative_result(self) -> None:
        response = client.post("/api/v1/calculator/subtract", json={"left": 3, "right": 10})
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.json(), {"result": -7})

    def test_subtract_invalid_input_returns_422(self) -> None:
        response = client.post("/api/v1/calculator/subtract", json={"left": 10, "right": None})
        self.assertEqual(response.status_code, 422)

    def test_subtract_missing_left_returns_422(self) -> None:
        response = client.post("/api/v1/calculator/subtract", json={"right": 3})
        self.assertEqual(response.status_code, 422)

    def test_subtract_missing_right_returns_422(self) -> None:
        response = client.post("/api/v1/calculator/subtract", json={"left": 10})
        self.assertEqual(response.status_code, 422)


class TestCalculatorClampEndpoint(unittest.TestCase):

    def test_clamp_value_below_low(self) -> None:
        response = client.post("/api/v1/calculator/clamp", json={"value": -5, "low": 0, "high": 10})
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.json(), {"result": 0})

    def test_clamp_value_above_high(self) -> None:
        response = client.post("/api/v1/calculator/clamp", json={"value": 15, "low": 0, "high": 10})
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.json(), {"result": 10})

    def test_clamp_value_in_range(self) -> None:
        response = client.post("/api/v1/calculator/clamp", json={"value": 5, "low": 0, "high": 10})
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.json(), {"result": 5.0})

    def test_clamp_invalid_input_returns_422(self) -> None:
        response = client.post("/api/v1/calculator/clamp", json={"value": "x", "low": 0, "high": 10})
        self.assertEqual(response.status_code, 422)

    def test_clamp_low_greater_than_high_returns_422(self) -> None:
        response = client.post("/api/v1/calculator/clamp", json={"value": 5, "low": 10, "high": 0})
        self.assertEqual(response.status_code, 422)

    def test_clamp_missing_low_returns_422(self) -> None:
        response = client.post("/api/v1/calculator/clamp", json={"value": 5, "high": 10})
        self.assertEqual(response.status_code, 422)

    def test_clamp_missing_high_returns_422(self) -> None:
        response = client.post("/api/v1/calculator/clamp", json={"value": 5, "low": 0})
        self.assertEqual(response.status_code, 422)


class TestCalculatorClampToByteEndpoint(unittest.TestCase):

    def test_clamp_to_byte_within_range(self) -> None:
        response = client.post("/api/v1/calculator/clamp-to-byte", json={"value": 128})
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.json(), {"result": 128})

    def test_clamp_to_byte_below_zero(self) -> None:
        response = client.post("/api/v1/calculator/clamp-to-byte", json={"value": -10})
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.json(), {"result": 0})

    def test_clamp_to_byte_above_255(self) -> None:
        response = client.post("/api/v1/calculator/clamp-to-byte", json={"value": 300})
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.json(), {"result": 255})

    def test_clamp_to_byte_invalid_input_returns_422(self) -> None:
        response = client.post("/api/v1/calculator/clamp-to-byte", json={"value": "abc"})
        self.assertEqual(response.status_code, 422)


class TestCalculatorAverageEndpoint(unittest.TestCase):

    def test_average_positive_values(self) -> None:
        response = client.post("/api/v1/calculator/average", json={"values": [1, 2, 3, 4, 5]})
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.json(), {"result": 3.0})

    def test_average_single_value(self) -> None:
        response = client.post("/api/v1/calculator/average", json={"values": [5]})
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.json(), {"result": 5.0})

    def test_average_negative_values(self) -> None:
        response = client.post("/api/v1/calculator/average", json={"values": [-10, -20, -30]})
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.json(), {"result": -20.0})

    def test_average_empty_returns_422(self) -> None:
        response = client.post("/api/v1/calculator/average", json={"values": []})
        self.assertEqual(response.status_code, 422)

    def test_average_invalid_input_returns_422(self) -> None:
        response = client.post("/api/v1/calculator/average", json={"values": ["a", "b"]})
        self.assertEqual(response.status_code, 422)

    def test_average_missing_field_returns_422(self) -> None:
        response = client.post("/api/v1/calculator/average", json={})
        self.assertEqual(response.status_code, 422)


class TestCalculatorMedianEndpoint(unittest.TestCase):

    def test_median_odd_length(self) -> None:
        response = client.post("/api/v1/calculator/median", json={"values": [1, 3, 5]})
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.json(), {"result": 3.0})

    def test_median_even_length(self) -> None:
        response = client.post("/api/v1/calculator/median", json={"values": [1, 2, 3, 4]})
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.json(), {"result": 2.5})

    def test_median_single_element(self) -> None:
        response = client.post("/api/v1/calculator/median", json={"values": [7]})
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.json(), {"result": 7.0})

    def test_median_unsorted_input(self) -> None:
        response = client.post("/api/v1/calculator/median", json={"values": [3, 1, 2]})
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.json(), {"result": 2.0})

    def test_median_empty_returns_422(self) -> None:
        response = client.post("/api/v1/calculator/median", json={"values": []})
        self.assertEqual(response.status_code, 422)

    def test_median_invalid_input_returns_422(self) -> None:
        response = client.post("/api/v1/calculator/median", json={"values": ["a"]})
        self.assertEqual(response.status_code, 422)

    def test_median_missing_field_returns_422(self) -> None:
        response = client.post("/api/v1/calculator/median", json={})
        self.assertEqual(response.status_code, 422)


class TestCalculatorVarianceEndpoint(unittest.TestCase):

    def test_variance_known_set(self) -> None:
        response = client.post("/api/v1/calculator/variance", json={"values": [1, 2, 3, 4, 5]})
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.json(), {"result": 2.0})

    def test_variance_constant_values(self) -> None:
        response = client.post("/api/v1/calculator/variance", json={"values": [1.0, 1.0, 1.0]})
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.json(), {"result": 0.0})

    def test_variance_single_element(self) -> None:
        response = client.post("/api/v1/calculator/variance", json={"values": [42.0]})
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.json(), {"result": 0.0})

    def test_variance_empty_returns_422(self) -> None:
        response = client.post("/api/v1/calculator/variance", json={"values": []})
        self.assertEqual(response.status_code, 422)

    def test_variance_invalid_input_returns_422(self) -> None:
        response = client.post("/api/v1/calculator/variance", json={"values": ["a", "b", "c"]})
        self.assertEqual(response.status_code, 422)

    def test_variance_missing_field_returns_422(self) -> None:
        response = client.post("/api/v1/calculator/variance", json={})
        self.assertEqual(response.status_code, 422)


class TestCalculatorPercentageEndpoint(unittest.TestCase):

    def test_percentage_half(self) -> None:
        response = client.post("/api/v1/calculator/percentage", json={"value": 50, "total": 100})
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.json(), {"result": 50.0})

    def test_percentage_quarter(self) -> None:
        response = client.post("/api/v1/calculator/percentage", json={"value": 25, "total": 100})
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.json(), {"result": 25.0})

    def test_percentage_zero_value(self) -> None:
        response = client.post("/api/v1/calculator/percentage", json={"value": 0, "total": 100})
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.json(), {"result": 0.0})

    def test_percentage_total_zero_returns_422(self) -> None:
        response = client.post("/api/v1/calculator/percentage", json={"value": 50, "total": 0})
        self.assertEqual(response.status_code, 422)

    def test_percentage_invalid_input_returns_422(self) -> None:
        response = client.post("/api/v1/calculator/percentage", json={"value": "abc", "total": 100})
        self.assertEqual(response.status_code, 422)

    def test_percentage_missing_value_returns_422(self) -> None:
        response = client.post("/api/v1/calculator/percentage", json={"total": 100})
        self.assertEqual(response.status_code, 422)

    def test_percentage_missing_total_returns_422(self) -> None:
        response = client.post("/api/v1/calculator/percentage", json={"value": 50})
        self.assertEqual(response.status_code, 422)