apexdevkit 0.2.1__py3-none-any.whl

apexdevkit/repository/database.py

@@ -0,0 +1,90 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, ContextManager, Iterable, Protocol, Self
+
+_RawData = dict[str, Any]
+
+
+@dataclass
+class Database:
+    connector: Connector
+
+    command: DatabaseCommand = field(init=False)
+
+    def execute(self, command: DatabaseCommand) -> Self:
+        self.command = command
+
+        return self
+
+    def fetch_none(self) -> None:
+        with self.connector.connect() as connection:
+            cursor: Cursor = connection.cursor()
+            cursor.execute(self.command.value, self.command.payload)
+            cursor.close()
+
+    def fetch_one(self) -> _RawData:
+        with self.connector.connect() as connection:
+            cursor: Cursor = connection.cursor()
+            cursor.execute(self.command.value, self.command.payload)
+            raw = cursor.fetchone()
+            cursor.close()
+
+        return dict(raw or {})
+
+    def fetch_all(self) -> Iterable[_RawData]:
+        with self.connector.connect() as connection:
+            cursor: Cursor = connection.cursor()
+            cursor.execute(self.command.value, self.command.payload)
+            raw = cursor.fetchall()
+            cursor.close()
+
+        return list(raw)
+
+
+class Connector(Protocol):  # pragma: no cover
+    def connect(self) -> ContextManager[Connection]:
+        pass
+
+
+class Connection(Protocol):  # pragma: no cover
+    def cursor(self) -> Cursor:
+        pass
+
+
+class Cursor(Protocol):  # pragma: no cover
+    def execute(self, *args: Any, **kwargs: Any) -> Any:
+        pass
+
+    def executemany(self, *args: Any, **kwargs: Any) -> Any:
+        pass
+
+    def fetchone(self, *args: Any, **kwargs: Any) -> Any:
+        pass
+
+    def fetchall(self, *args: Any, **kwargs: Any) -> Any:
+        pass
+
+    def close(self) -> None:
+        pass
+
+
+@dataclass
+class DatabaseCommand:
+    value: str
+    payload: _RawData | list[_RawData] = field(init=False, default_factory=dict)
+
+    def with_data(self, value: _RawData | None = None, **fields: Any) -> Self:
+        assert isinstance(self.payload, dict)
+        self.payload.update(value or {})
+        self.payload.update(fields)
+
+        return self
+
+    def with_collection(self, value: list[_RawData]) -> Self:
+        self.payload = value
+
+        return self
+
+    def __str__(self) -> str:  # pragma: no cover
+        return self.value

apexdevkit/repository/in_memory.py

@@ -0,0 +1,106 @@
+from copy import deepcopy
+from dataclasses import dataclass, field
+from typing import Any, Generic, Iterable, Iterator, Protocol, Self, TypeVar
+
+from apexdevkit.error import Criteria, DoesNotExistError, ExistsError
+
+
+class _Item(Protocol):
+    @property
+    def id(self) -> Any:
+        pass
+
+
+ItemT = TypeVar("ItemT", bound=_Item)
+
+
+class _Formatter(Protocol[ItemT]):
+    def load(self, raw: dict[str, Any]) -> ItemT:
+        pass
+
+    def dump(self, item: ItemT) -> dict[str, Any]:
+        pass
+
+
+@dataclass
+class InMemoryRepository(Generic[ItemT]):
+    formatter: _Formatter[ItemT]
+    items: dict[str, dict[str, Any]] = field(default_factory=dict)
+
+    _uniques: list[Criteria] = field(init=False, default_factory=list)
+    _search_by: list[str] = field(init=False, default_factory=list)
+
+    def __post_init__(self) -> None:
+        self._search_by = ["id", *self._search_by]
+
+    def with_searchable(self, attribute: str) -> Self:
+        self._search_by.append(attribute)
+
+        return self
+
+    def with_unique(self, criteria: Criteria) -> Self:
+        self._uniques.append(criteria)
+
+        return self
+
+    def with_seeded(self, *items: ItemT) -> Self:
+        for item in items:
+            self.create(item)
+        return self
+
+    def create_many(self, items: list[ItemT]) -> None:
+        for item in items:
+            self.create(item)
+
+    def create(self, item: ItemT) -> None:
+        self._ensure_does_not_exist(item)
+        self.items[str(item.id)] = deepcopy(self.formatter.dump(item))
+
+    def _ensure_does_not_exist(self, new: ItemT) -> None:
+        for existing in self:
+            error = ExistsError(existing)
+
+            for criteria in self._uniques:
+                if criteria(new) == criteria(existing):
+                    error.with_duplicate(criteria)
+
+            error.fire()
+
+        assert str(new.id) not in self.items, f"Item with id<{new.id}> already exists"
+
+    def read(self, item_id: Any) -> ItemT:
+        for item in self:
+            for attribute in self._search_by:
+                if getattr(item, attribute) == item_id:
+                    return item
+
+        raise DoesNotExistError(item_id)
+
+    def update(self, item: ItemT) -> None:
+        self.delete(item.id)
+        self.create(item)
+
+    def update_many(self, items: list[ItemT]) -> None:
+        for item in items:
+            self.update(item)
+
+    def delete(self, item_id: Any) -> None:
+        try:
+            del self.items[str(item_id)]
+        except KeyError:
+            raise DoesNotExistError(item_id)
+
+    def search(self, **kwargs: Any) -> Iterable[ItemT]:
+        items = []
+
+        for item in self.items.values():
+            if kwargs.items() <= item.items():
+                items.append(self.formatter.load(item))
+
+        return items
+
+    def __iter__(self) -> Iterator[ItemT]:
+        yield from [self.formatter.load(deepcopy(raw)) for raw in self.items.values()]
+
+    def __len__(self) -> int:
+        return len(self.items)

apexdevkit/testing/__init__.py

@@ -0,0 +1,9 @@
+from apexdevkit.testing.database import FakeConnector
+from apexdevkit.testing.rest import RestCollection, RestfulName, RestResource
+
+__all__ = [
+    "FakeConnector",
+    "RestCollection",
+    "RestfulName",
+    "RestResource",
+]

apexdevkit/testing/database.py

@@ -0,0 +1,42 @@
+from contextlib import nullcontext
+from dataclasses import dataclass, field
+from typing import Any, ContextManager, Self
+
+from apexdevkit.repository import DatabaseCommand
+
+
+@dataclass
+class FakeConnector:
+    commands: list[tuple[str, Any]] = field(default_factory=list)
+    results: list[Any] = field(init=False, default_factory=list)
+
+    def with_result(self, values: Any) -> Self:
+        self.results = [values, *self.results]
+
+        return self
+
+    def execute(self, command: str, data: Any) -> None:
+        self.commands.append((command, data))
+
+    def executemany(self, command: str, data_list: list[Any]) -> None:
+        self.commands.extend([(command, data) for data in data_list])
+
+    def fetchone(self) -> dict[str, Any]:
+        return self.results.pop()  # type: ignore
+
+    def fetchall(self) -> list[dict[str, Any]]:
+        return self.results.pop()  # type: ignore
+
+    def connect(self) -> ContextManager[Self]:
+        return nullcontext(self)
+
+    def cursor(self) -> Self:
+        return self
+
+    def close(self) -> None:
+        pass
+
+    def assert_contains(self, command: DatabaseCommand, at_index: int = 0) -> None:
+        query, data = self.commands[at_index]
+
+        assert command == DatabaseCommand(query).with_data(data)

apexdevkit/testing/rest.py

@@ -0,0 +1,310 @@
+from __future__ import annotations
+
+from abc import abstractmethod
+from dataclasses import dataclass, field
+from functools import cached_property
+from typing import Any, Iterable, Self
+from uuid import UUID
+from warnings import warn
+
+import httpx
+from fastapi.testclient import TestClient
+
+from apexdevkit.http import HttpUrl, JsonDict
+
+
+@dataclass
+class RestResource:
+    http: TestClient
+    name: RestfulName
+
+    def create_one(self) -> CreateOne:
+        return CreateOne(self.name, self.http)
+
+    def read_one(self) -> ReadOne:
+        return ReadOne(self.name, self.http)
+
+    def read_all(self) -> ReadAll:
+        return ReadAll(self.name, self.http)
+
+    def update_one(self) -> UpdateOne:
+        return UpdateOne(self.name, self.http)
+
+    def update_many(self) -> UpdateMany:
+        return UpdateMany(self.name, self.http)
+
+    def create_many(self) -> CreateMany:
+        return CreateMany(self.name, self.http)
+
+    def delete_one(self) -> DeleteOne:
+        return DeleteOne(self.name, self.http)
+
+
+@dataclass
+class RestCollection(RestResource):
+    def sub_resource(self, name: str) -> RestItem:
+        return RestItem(
+            TestClient(
+                self.http.app,
+                base_url=HttpUrl(str(self.http.base_url)) + self.name.plural,
+            ),
+            RestfulName(name),
+        )
+
+
+@dataclass
+class RestItem(RestResource):
+    def sub_resource(self, name: str) -> RestItem:
+        return RestItem(
+            TestClient(
+                self.http.app,
+                base_url=HttpUrl(str(self.http.base_url)) + self.name.singular,
+            ),
+            RestfulName(name),
+        )
+
+
+@dataclass
+class RestfulName:
+    singular: str
+
+    plural: str = ""
+
+    def __post_init__(self) -> None:
+        self.plural = self.plural or as_plural(self.singular)
+
+    def __add__(self, other: str) -> str:
+        return HttpUrl(self.plural) + other
+
+
+def as_plural(singular: str) -> str:
+    if singular.endswith("y"):
+        return singular[:-1] + "ies"
+
+    return singular + "s"
+
+
+@dataclass
+class RestRequest:
+    resource: RestfulName
+    http: TestClient
+
+    @abstractmethod
+    @cached_property
+    def response(self) -> httpx.Response:  # pragma: no cover
+        pass
+
+    def unpack(self) -> JsonDict:
+        return JsonDict(self.response.json()["data"][self.resource.singular])
+
+    def unpack_many(self) -> Iterable[JsonDict]:
+        items = self.response.json()["data"][self.resource.plural]
+
+        return [JsonDict(item) for item in items]
+
+    def ensure(self) -> RestResponse:
+        return RestResponse(
+            resource=self.resource,
+            json=JsonDict(self.response.json()),
+            http_code=self.response.status_code,
+        )
+
+
+@dataclass
+class CreateOne(RestRequest):
+    data: JsonDict = field(init=False)
+
+    def from_data(self, value: JsonDict) -> Self:
+        self.data = value
+
+        return self
+
+    @cached_property
+    def response(self) -> httpx.Response:
+        return self.http.post(self.resource + "", json=dict(self.data))
+
+
+@dataclass
+class ReadOne(RestRequest):
+    item_id: str | UUID = field(init=False)
+
+    @cached_property
+    def response(self) -> httpx.Response:
+        return self.http.get(self.resource + str(self.item_id))
+
+    def with_id(self, value: str | UUID) -> Self:
+        self.item_id = str(value)
+
+        return self
+
+
+@dataclass
+class ReadAll(RestRequest):
+    params: dict[str, Any] = field(init=False, default_factory=dict)
+
+    @cached_property
+    def response(self) -> httpx.Response:
+        return self.http.get(self.resource + "", params=self.params)
+
+    def with_params(self, **kwargs: Any) -> Self:
+        self.params = {**kwargs}
+
+        return self
+
+
+@dataclass
+class UpdateOne(RestRequest):
+    item_id: str | UUID = field(init=False)
+    data: JsonDict = field(init=False)
+
+    @cached_property
+    def response(self) -> httpx.Response:
+        return self.http.patch(self.resource + str(self.item_id), json=dict(self.data))
+
+    def with_id(self, value: str | UUID) -> Self:
+        self.item_id = str(value)
+
+        return self
+
+    def and_data(self, value: JsonDict) -> Self:
+        self.data = value
+
+        return self
+
+
+@dataclass
+class CreateMany(RestRequest):
+    data: list[JsonDict] = field(default_factory=list)
+
+    @cached_property
+    def response(self) -> httpx.Response:
+        return self.http.post(
+            self.resource + "batch",
+            json={self.resource.plural: [dict(data) for data in self.data]},
+        )
+
+    def from_data(self, value: JsonDict) -> Self:
+        self.data.append(value)
+
+        return self
+
+    def and_data(self, value: JsonDict) -> Self:
+        return self.from_data(value)
+
+
+@dataclass
+class UpdateMany(RestRequest):
+    data: list[JsonDict] = field(default_factory=list)
+
+    @cached_property
+    def response(self) -> httpx.Response:
+        return self.http.patch(
+            self.resource + "",
+            json={self.resource.plural: [dict(data) for data in self.data]},
+        )
+
+    def from_data(self, value: JsonDict) -> Self:
+        self.data.append(value)
+
+        return self
+
+    def and_data(self, value: JsonDict) -> Self:
+        return self.from_data(value)
+
+
+@dataclass
+class DeleteOne(RestRequest):
+    item_id: str | UUID = field(init=False)
+
+    @cached_property
+    def response(self) -> httpx.Response:
+        return self.http.delete(self.resource + str(self.item_id))
+
+    def with_id(self, value: str | UUID) -> Self:
+        self.item_id = str(value)
+
+        return self
+
+
+@dataclass
+class RestResponse:
+    resource: RestfulName
+    json: JsonDict
+    http_code: int
+
+    def fail(self) -> Self:
+        return self.with_status("fail")
+
+    def success(self) -> Self:
+        return self.with_status("success")
+
+    def with_status(self, value: str) -> Self:
+        assert self.json.value_of("status").to(str) == value
+
+        return self
+
+    def with_code(self, value: int) -> Self:
+        assert self.http_code == value
+        assert self.json.value_of("code").to(int) == value
+
+        return self
+
+    def message(self, value: str) -> Self:
+        return self.with_message(value)
+
+    def and_message(self, value: str) -> Self:
+        return self.with_message(value)
+
+    def with_message(self, value: str) -> Self:
+        assert self.json.value_of("error").to(dict) == {"message": value}
+
+        return self
+
+    def and_data(self, *values: JsonDict) -> Self:  # pragma: no cover
+        warn(
+            (
+                "The 'and_data' method is deprecated. "
+                "Please use 'and_item' or 'and_collection' instead."
+            )
+        )
+        if len(values) == 1:
+            return self.with_item(values[0])
+
+        return self.with_collection(list(values))
+
+    def and_item(self, value: Any) -> Self:
+        return self.with_item(value)
+
+    def with_item(self, value: Any) -> Self:
+        return self.with_data(
+            **{
+                self.resource.singular: dict(value)
+                if isinstance(value, JsonDict)
+                else value
+            }
+        )
+
+    def and_collection(self, value: list[Any]) -> Self:
+        return self.with_collection(value)
+
+    def with_collection(self, values: list[Any]) -> Self:
+        return self.with_data(
+            **{
+                self.resource.plural: [
+                    dict(value) if isinstance(value, JsonDict) else value
+                    for value in values
+                ],
+            },
+            count=len(values),
+        )
+
+    def and_no_data(self) -> Self:
+        return self.no_data()
+
+    def no_data(self) -> Self:
+        return self.with_data()
+
+    def with_data(self, **kwargs: Any) -> Self:
+        assert self.json.value_of("data").to(dict) == {**kwargs}
+
+        return self