TJWaterServerBinary/tests/api/test_regions_endpoints.py

from typing import Any

from fastapi.testclient import TestClient

from tests.conftest import build_test_app, install_stub, load_module_from_path


class DummyChangeSet:
    def __init__(self, operations=None):
        if operations is None:
            self.operations = []
        elif isinstance(operations, dict):
            self.operations = [operations]
        else:
            self.operations = operations


def _noop(*args, **kwargs):
    return None


def _load_regions_module(monkeypatch):
    install_stub(monkeypatch, "app.services", package=True)
    install_stub(
        monkeypatch,
        "app.services.tjnetwork",
        {
            "Any": Any,
            "ChangeSet": DummyChangeSet,
            "add_district_metering_area": _noop,
            "add_region": _noop,
            "add_service_area": _noop,
            "add_virtual_district": _noop,
            "calculate_district_metering_area_for_network": lambda *args, **kwargs: [],
            "calculate_district_metering_area_for_nodes": lambda *args, **kwargs: [],
            "calculate_district_metering_area_for_region": lambda *args, **kwargs: [],
            "calculate_service_area": lambda network: [],
            "calculate_virtual_district": lambda *args, **kwargs: {},
            "delete_district_metering_area": _noop,
            "delete_region": _noop,
            "delete_service_area": _noop,
            "delete_virtual_district": _noop,
            "generate_district_metering_area": _noop,
            "generate_service_area": _noop,
            "generate_sub_district_metering_area": _noop,
            "generate_virtual_district": _noop,
            "get_all_district_metering_area_ids": lambda network: [],
            "get_all_district_metering_areas": lambda network: [],
            "get_all_service_areas": lambda network: [],
            "get_all_virtual_districts": lambda network: [],
            "get_district_metering_area": lambda network, area_id: {},
            "get_district_metering_area_schema": lambda network: {},
            "get_region": lambda network, region_id: {},
            "get_region_schema": lambda network: {},
            "get_service_area": lambda network, area_id: {},
            "get_service_area_schema": lambda network: {},
            "get_virtual_district": lambda network, area_id: {},
            "get_virtual_district_schema": lambda network: {},
            "set_district_metering_area": _noop,
            "set_region": _noop,
            "set_service_area": _noop,
            "set_virtual_district": _noop,
        },
    )
    return load_module_from_path(
        "tests_regions_endpoints_module",
        "app/api/v1/endpoints/network/regions.py",
    )


def test_removed_routes_are_absent_and_return_404(monkeypatch):
    module = _load_regions_module(monkeypatch)
    client = TestClient(build_test_app(module.router, "/api/v1"))

    openapi = client.get("/openapi.json").json()

    assert "/api/v1/calculateregion/" not in openapi["paths"]
    assert "/api/v1/getallregions/" not in openapi["paths"]
    assert "/api/v1/generateregion/" not in openapi["paths"]
    assert "/api/v1/calculatedistrictmeteringarea/" not in openapi["paths"]
    assert client.get("/api/v1/calculateregion/", params={"network": "demo", "time_index": 0}).status_code == 404
    assert client.get("/api/v1/calculatedistrictmeteringarea/", params={"network": "demo"}).status_code == 404


def test_calculate_service_area_contract_uses_only_network(monkeypatch):
    module = _load_regions_module(monkeypatch)
    calls = []
    monkeypatch.setattr(
        module,
        "calculate_service_area",
        lambda network: calls.append(network) or [{"source-1": ["n1", "n2"]}],
    )
    client = TestClient(build_test_app(module.router, "/api/v1"))

    response = client.get(
        "/api/v1/calculateservicearea/",
        params={"network": "demo", "time_index": 5},
    )
    schema = client.get("/openapi.json").json()

    assert response.status_code == 200
    assert response.json() == [{"source-1": ["n1", "n2"]}]
    assert calls == ["demo"]
    parameter_names = [
        item["name"]
        for item in schema["paths"]["/api/v1/calculateservicearea/"]["get"]["parameters"]
    ]
    assert parameter_names == ["network"]


def test_add_district_metering_area_converts_boundary_to_tuples(monkeypatch):
    module = _load_regions_module(monkeypatch)
    captured = {}

    def fake_add(network, change_set):
        captured["network"] = network
        captured["boundary"] = change_set.operations[0]["boundary"]
        return {"ok": True}

    monkeypatch.setattr(module, "add_district_metering_area", fake_add)
    client = TestClient(build_test_app(module.router, "/api/v1"))

    response = client.post(
        "/api/v1/adddistrictmeteringarea/",
        params={"network": "demo"},
        json={"id": "dma-1", "boundary": [[1, 2], [3, 4], [1, 2]]},
    )

    assert response.status_code == 200
    assert captured == {
        "network": "demo",
        "boundary": [(1, 2), (3, 4), (1, 2)],
    }


def test_generate_virtual_district_reads_centers_from_body(monkeypatch):
    module = _load_regions_module(monkeypatch)
    captured = {}

    def fake_generate(network, centers, inflate_delta):
        captured["args"] = (network, centers, inflate_delta)
        return {"generated": True}

    monkeypatch.setattr(module, "generate_virtual_district", fake_generate)
    client = TestClient(build_test_app(module.router, "/api/v1"))

    response = client.post(
        "/api/v1/generatevirtualdistrict/",
        params={"network": "demo", "inflate_delta": 0.75},
        json={"centers": ["J1", "J2"]},
    )

    assert response.status_code == 200
    assert captured["args"] == ("demo", ["J1", "J2"], 0.75)