apexdevkit 2.0.1__tar.gz → 2.1.1__tar.gz

{apexdevkit-2.0.1 → apexdevkit-2.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: apexdevkit
-Version: 2.0.1
+Version: 2.1.1
 Summary: Apex Development Tools for python.
 License-File: LICENSE
 Author: Apex Dev
@@ -10,10 +10,11 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
 Requires-Dist: fastapi
 Requires-Dist: pydantic
 Requires-Dist: pymssql (==2.*)
-Requires-Dist: pypebbles (==0.2.*)
+Requires-Dist: pypebbles (==0.3.*)
 Requires-Dist: python-dotenv
 Requires-Dist: sentry-sdk[fastapi]
 Requires-Dist: uvicorn

{apexdevkit-2.0.1 → apexdevkit-2.1.1}/apexdevkit/repository/sql/connector.py

@@ -3,7 +3,6 @@ from __future__ import annotations
 import sqlite3
 from contextlib import AbstractContextManager
 from dataclasses import dataclass
-from functools import cached_property
 from typing import Any
 
 import pymssql
@@ -18,25 +17,10 @@ class SqliteFileConnector:
     dsn: str = Environment().inject(variable="DSN")
 
     def connect(self) -> AbstractContextManager[Connection]:
-        connection = sqlite3.connect(self.dsn)
+        connection = sqlite3.connect(self.dsn, autocommit=True)
         connection.row_factory = sqlite3.Row
 
-        return connection
-
-
-@dataclass(frozen=True)
-class SqliteInMemoryConnector:
-    dsn: str = ":memory:"
-
-    def connect(self) -> AbstractContextManager[Connection]:
-        return self._connection
-
-    @cached_property
-    def _connection(self) -> AbstractContextManager[Connection]:
-        connection = sqlite3.connect(self.dsn, check_same_thread=False)
-        connection.row_factory = sqlite3.Row
-
-        return connection
+        return ConnectionContextManager(connection)
 
 
 @dataclass(frozen=True)

apexdevkit-2.1.1/apexdevkit/repository/sql/sqlite/__init__.py

@@ -0,0 +1,8 @@
+from .repository import SqliteRepository
+from .table import SqliteTableBuilder, SqlTable
+
+__all__ = [
+    "SqliteRepository",
+    "SqliteTableBuilder",
+    "SqlTable",
+]

apexdevkit-2.1.1/apexdevkit/testing.py

@@ -0,0 +1,157 @@
+from __future__ import annotations
+
+from collections.abc import Collection
+from dataclasses import dataclass, field, replace
+from typing import Any, Self
+
+from pypebbles import JsonDict
+from pypebbles.http import (
+    HttpDispatcher,
+    HttpMethod,
+    HttpRequest,
+    HttpResponse,
+    HttpTransport,
+)
+
+from apexdevkit.fastapi.name import RestfulName
+
+
+@dataclass(frozen=True)
+class RestRequest:
+    request: HttpRequest = HttpRequest()
+
+    def with_params(self, **params: Any) -> RestRequest:
+        return replace(self, request=self.request.with_params(params))
+
+    def with_data(self, value: JsonDict) -> RestRequest:
+        return replace(self, request=self.request.with_json(value))
+
+    def sub_resource(self, name: RestfulName) -> RestRequest:
+        return replace(self, request=self.request.with_endpoint(name.plural))
+
+    def item(self, with_id: Any) -> RestRequest:
+        return replace(self, request=self.request.with_endpoint(str(with_id)))
+
+    def using(self, transport: RestTransport) -> RestDispatcher:
+        return RestDispatcher(request=self.request, transport=transport)
+
+
+@dataclass(frozen=True)
+class RestTransport:
+    resource: RestfulName
+    transport: HttpTransport[HttpResponse]
+
+    def deliver(self, request: HttpRequest, using: HttpMethod) -> StatusProbe:
+        return StatusProbe(
+            resource=self.resource,
+            response=self.transport.deliver(request, using),
+        )
+
+
+@dataclass(frozen=True)
+class RestResponse:
+    resource: RestfulName
+
+    raw: JsonDict = field(default_factory=JsonDict)
+
+    def __call__(self, raw: JsonDict) -> RestResponse:
+        return replace(self, raw=raw)
+
+    def status(self) -> str:
+        return self.raw.value_of("status").to(str)
+
+    def code(self) -> int:
+        return self.raw.value_of("code").to(int)
+
+    def message(self) -> str:
+        return self.error().value_of("message").to(str)
+
+    def error(self) -> JsonDict:
+        return self.raw.value_of("error").to(JsonDict)
+
+    def item(self) -> JsonDict:
+        return self.data().value_of(self.resource.singular).to(JsonDict)
+
+    def collection(self) -> Collection[JsonDict]:
+        return self.data().value_of(self.resource.plural).to(list)
+
+    def count(self) -> int:
+        return self.data().value_of("count").to(int)
+
+    def data(self) -> JsonDict:
+        return self.raw.value_of("data").to(JsonDict)
+
+
+@dataclass(frozen=True)
+class StatusProbe:
+    resource: RestfulName
+    response: HttpResponse
+
+    def ensure(self, http_code: int) -> ResponseProbe:
+        assert self.response.status == http_code
+
+        return ResponseProbe(self.response.load(RestResponse(self.resource)))
+
+
+@dataclass(frozen=True)
+class ResponseProbe:
+    response: RestResponse
+
+    def and_api_fail(self) -> Self:
+        return self.with_status("fail")
+
+    def and_api_success(self) -> Self:
+        return self.with_status("success")
+
+    def with_status(self, value: str) -> Self:
+        assert self.response.status() == value
+
+        return self
+
+    def with_code(self, value: int) -> Self:
+        assert self.response.code() == value
+
+        return self
+
+    def and_message(self, value: str) -> Self:
+        return self.with_message(value)
+
+    def with_message(self, value: str) -> Self:
+        assert self.response.message() == value, self.response.raw
+
+        return self
+
+    def and_item(self, value: Any) -> Self:
+        return self.with_item(value)
+
+    def with_item(self, value: Any) -> Self:
+        assert self.response.item() == value, self.response.raw
+
+        return self
+
+    def and_collection(self, values: Collection[Any]) -> Self:
+        return self.with_collection(values)
+
+    def with_collection(self, values: Collection[Any]) -> Self:
+        assert self.response.collection() == values, self.response.raw
+        assert self.response.count() == len(values)
+
+        return self
+
+
+@dataclass(frozen=True)
+class RestDispatcher(HttpDispatcher[StatusProbe]):
+    def create(self) -> StatusProbe:
+        return self.dispatch(HttpMethod.post)
+
+    def read(self) -> StatusProbe:
+        return self.dispatch(HttpMethod.get)
+
+    def update(self) -> StatusProbe:
+        return self.dispatch(HttpMethod.patch)
+
+    def delete(self) -> StatusProbe:
+        return self.dispatch(HttpMethod.delete)
+
+    def replace(self) -> StatusProbe:
+        return self.dispatch(HttpMethod.put)

{apexdevkit-2.0.1 → apexdevkit-2.1.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "apexdevkit"
-version = "2.0.1"
+version = "2.1.1"
 description = "Apex Development Tools for python."
 readme = "README.md"
 authors = [
@@ -16,7 +16,7 @@ pymssql = "2.*"
 pydantic = "*"
 sentry-sdk = { extras = ["fastapi"], version = "*" }
 uvicorn = "*"
-pypebbles = "0.2.*"
+pypebbles = "0.3.*"
 
 [tool.poetry.group.dev.dependencies]
 apexcodexpy = "0.7.1"
@@ -79,5 +79,5 @@ show_missing = true
 
 [tool.pytest]
 env = [
-    "ECHO_SERVER=http://localhost:8080"
+    "ECHO_SERVER=http://localhost:8080",
 ]

apexdevkit-2.0.1/apexdevkit/repository/sql/sqlite/__init__.py

@@ -1,7 +0,0 @@
-from apexdevkit.repository.sql.sqlite.repository import SqliteRepository
-from apexdevkit.repository.sql.sqlite.table import SqliteTableBuilder
-
-__all__ = [
-    "SqliteRepository",
-    "SqliteTableBuilder",
-]