conftest.py

from typing import Any

from gso.services.kentik_client import NewKentikDevice


class MockedNetboxClient:
    class BaseMockObject:
        def __init__(self, **kwargs):
            for key, value in kwargs.items():
                setattr(self, key, value)

    def get_device_by_name(self):
        return self.BaseMockObject(id=1, name="test")

    @staticmethod
    def get_interface_by_name_and_device(interface_name: str, device_name: str):
        return {
            "name": f"{interface_name}",
            "module": {"display": f"Module{interface_name}"},
            "description": f"Description{interface_name}-{device_name}",
        }

    @staticmethod
    def get_available_lags() -> list[str]:
        return [f"lag-{lag}" for lag in range(1, 5)]

    @staticmethod
    def get_available_services_lags() -> list[str]:
        return [f"lag-{lag}" for lag in range(21, 50)]

    @staticmethod
    def get_available_interfaces():
        interfaces = []
        for interface in range(5):
            interface_data = {
                "name": f"Interface{interface}",
                "module": {"display": f"Module{interface}"},
                "description": f"Description{interface}",
            }
            interfaces.append(interface_data)
        return interfaces

    def create_interface(self):
        return self.BaseMockObject(id=1, name="test")

    def attach_interface_to_lag(self):
        return self.BaseMockObject(id=1, name="test")

    def reserve_interface(self):
        return self.BaseMockObject(id=1, name="test")

    @staticmethod
    def allocate_interface():
        return {"id": 1, "name": "test"}

    def free_interface(self):
        return self.BaseMockObject(id=1, name="test")

    @staticmethod
    def detach_interfaces_from_lag():
        return None

    @staticmethod
    def delete_interface():
        return None

    def get_available_lags_in_range(self):
        return self.get_available_lags()


class MockedSharePointClient:
    class BaseMockObject:
        def __init__(self, **kwargs):
            for key, value in kwargs.items():
                setattr(self, key, value)

    @staticmethod
    def add_list_item(list_name: str, fields: dict[str, str]) -> str:
        return f"http://{list_name}/{fields.popitem()}"


class MockedKentikClient:
    class BaseMockObject:
        def __init__(self, **kwargs):
            for key, value in kwargs.items():
                setattr(self, key, value)

    @staticmethod
    def get_devices() -> list[dict[str, Any]]:
        return [{"id": 0, "device_name": "device-1.internal"}, {"id": 1, "device_name": "device-2.internal"}]

    @staticmethod
    def get_device(device_id: str) -> dict[str, Any]:
        return {"id": device_id, "device_name": "device-1.internal"}

    @staticmethod
    def get_device_by_name(fqdn: str) -> dict[str, Any]:
        return {"id": 0, "device_name": fqdn}

    @staticmethod
    def get_sites() -> list[dict[str, Any]]:
        return [{"id": 0, "site_name": "AMS"}, {"id": 1, "site_name": "BRU"}, {"id": 2, "site_name": "LUX"}]

    @staticmethod
    def get_site_by_name(site_name: str) -> dict[str, Any]:
        return {"id": 0, "site_name": site_name}

    @staticmethod
    def get_plans() -> list[dict[str, Any]]:
        return [{"id": 0, "plan_name": "kentik-plan-1"}, {"id": 1, "plan_name": "kentik-plan-2"}]

    @staticmethod
    def get_plan(plan_id: int) -> dict[str, Any]:
        return {"id": plan_id, "plan_name": "kentik-mocked-plan"}

    @staticmethod
    def get_plan_by_name(plan_name: str) -> dict[str, Any]:
        return {"id": 0, "plan_name": plan_name}

    @staticmethod
    def create_device(device: NewKentikDevice) -> dict[str, Any]:
        return device.model_dump()

    @staticmethod
    def update_device(device_id: int, updated_device: dict[str, Any]) -> dict[str, Any]:
        return {"id": device_id, **updated_device}

    @staticmethod
    def remove_device(device_id: int, *, archive: bool) -> None:
        pass

    @staticmethod
    def remove_device_by_fqdn(fqdn: str, *, archive: bool) -> None:
        pass