spud-testing 0.1.0__py3-none-any.whl

spud/__init__.py

@@ -0,0 +1,7 @@
+from .api_client import ApiClient
+from .api_response import ApiResponse
+from .endpoint import Endpoint
+from .exceptions import SpudCheckError
+from .response_checks import ResponseChecks
+
+__all__ = ["ApiClient", "ApiResponse", "Endpoint", "ResponseChecks", "SpudCheckError"]

spud/api_client.py

@@ -0,0 +1,82 @@
+from collections.abc import Mapping
+from typing import Any
+
+from . import api_response, httpx_transport, transport_protocol
+from .transport_protocol import HttpMethod
+
+
+class ApiClient:
+    def __init__(
+        self,
+        base_url: str,
+        transport: transport_protocol.TransportProtocol | None = None,
+        headers: Mapping[str, str] | None = None,
+    ) -> None:
+        self.base_url = base_url.rstrip("/")
+        if transport is None:
+            self.transport: transport_protocol.TransportProtocol = (
+                httpx_transport.HttpxTransport()
+            )
+        else:
+            self.transport = transport
+        self.headers = headers
+
+    def get(
+        self,
+        path: str,
+        params: Mapping[str, Any] | None = None,
+        headers: Mapping[str, str] | None = None,
+    ) -> api_response.ApiResponse:
+        return self.request(method="GET", path=path, params=params, headers=headers)
+
+    def post(
+        self, path: str, json: Any = None, headers: Mapping[str, str] | None = None
+    ) -> api_response.ApiResponse:
+        return self.request(method="POST", path=path, json=json, headers=headers)
+
+    def put(
+        self, path: str, json: Any = None, headers: Mapping[str, str] | None = None
+    ) -> api_response.ApiResponse:
+        return self.request(method="PUT", path=path, json=json, headers=headers)
+
+    def patch(
+        self, path: str, json: Any = None, headers: Mapping[str, str] | None = None
+    ) -> api_response.ApiResponse:
+        return self.request(method="PATCH", path=path, json=json, headers=headers)
+
+    def delete(
+        self,
+        path: str,
+        headers: Mapping[str, str] | None = None,
+        params: Mapping[str, Any] | None = None,
+    ) -> api_response.ApiResponse:
+        return self.request(method="DELETE", path=path, headers=headers, params=params)
+
+    def request(
+        self,
+        method: HttpMethod,
+        path: str,
+        params: Mapping[str, Any] | None = None,
+        headers: Mapping[str, str] | None = None,
+        json: Any = None,
+    ) -> api_response.ApiResponse:
+        if not path.startswith("/"):
+            raise ValueError("Path should start with '/'")
+        if headers is None:
+            effective_headers = self.headers
+        else:
+            if self.headers is None:
+                effective_headers = headers
+            else:
+                update_headers = dict(self.headers)
+                update_headers.update(headers)
+                effective_headers = update_headers
+
+        raw_response = self.transport.request(
+            method=method,
+            url=self.base_url + path,
+            params=params,
+            headers=effective_headers,
+            json=json,
+        )
+        return api_response.ApiResponse(raw_response)

spud/api_response.py

@@ -0,0 +1,31 @@
+from typing import Any
+
+from spud import raw_response_protocol, response_checks
+
+
+class ApiResponse:
+    def __init__(self, raw_response: raw_response_protocol.RawResponseProtocol) -> None:
+        self.raw = raw_response
+        self._checker = None
+
+    def json(self) -> Any:
+        return self.raw.json()
+
+    @property
+    def status_code(self):
+        return self.raw.status_code
+
+    @property
+    def headers(self):
+        return self.raw.headers
+
+    @property
+    def text(self):
+        return self.raw.text
+
+    @property
+    def check(self):
+        if self._checker is None:
+            checker = response_checks.ResponseChecks(response=self)
+            self._checker = checker
+        return self._checker

spud/endpoint.py

@@ -0,0 +1,15 @@
+from . import api_client
+
+
+class Endpoint:
+    path: str
+
+    def __init__(self, client: api_client.ApiClient) -> None:
+        self.client = client
+
+    def __init_subclass__(cls, **kwargs):
+        super().__init_subclass__(**kwargs)
+        if not hasattr(cls, "path"):
+            raise TypeError("Endpoint subclass must define 'path'")
+        if not isinstance(cls.path, str):
+            raise TypeError("Endpoint path must be a string")

spud/exceptions.py

@@ -0,0 +1,2 @@
+class SpudCheckError(AssertionError):
+    pass

spud/httpx_transport.py

@@ -0,0 +1,21 @@
+from collections.abc import Mapping
+from typing import Any
+
+import httpx
+
+from . import raw_response_protocol
+from .transport_protocol import HttpMethod
+
+
+class HttpxTransport:
+    def request(
+        self,
+        method: HttpMethod,
+        url: str,
+        params: Mapping[str, Any] | None = None,
+        headers: Mapping[str, str] | None = None,
+        json: Any = None,
+    ) -> raw_response_protocol.RawResponseProtocol:
+        return httpx.request(
+            method=method, url=url, params=params, headers=headers, json=json
+        )

spud/raw_response_protocol.py

@@ -0,0 +1,18 @@
+from collections.abc import Mapping
+from typing import Any, Protocol
+
+
+class RawResponseProtocol(Protocol):
+    @property
+    def headers(self):
+        return Mapping[str, str]
+
+    @property
+    def text(self):
+        return self.text
+
+    @property
+    def status_code(self) -> int:
+        return self.status_code
+
+    def json(self) -> Any: ...

spud/response_checks.py

@@ -0,0 +1,134 @@
+from http import HTTPStatus
+from typing import TYPE_CHECKING, Any
+
+from spud.exceptions import SpudCheckError
+
+_MISSING = object()
+
+
+class ResponseChecks:
+    if TYPE_CHECKING:
+        from . import api_response
+
+    def __init__(self, response: "api_response.ApiResponse") -> None:
+        self.response = response
+
+    def status(self, expected_status: int) -> "ResponseChecks":
+        status = self.response.status_code
+        phrase = f"Expected status {expected_status}, got {status}"
+        if status != expected_status:
+            try:
+                phrase = phrase + f" {HTTPStatus(status).phrase}"
+            except ValueError:
+                pass
+
+            raise SpudCheckError(phrase)
+        return self
+
+    def json_path(self, path: str = "", expected: Any = _MISSING) -> "ResponseChecks":
+        if expected is _MISSING:
+            raise TypeError("json_path() missing required argument: expected")
+        current = self.response.json()
+        for key in parse_json_path(path=path):
+            if not (
+                (isinstance(current, dict) and isinstance(key, str))
+                or (isinstance(current, list) and isinstance(key, int))
+            ):
+                raise SpudCheckError(f"JSON path {path!r} not found")
+
+            try:
+                if isinstance(current, dict) and isinstance(key, str):
+                    current = current[key]
+                elif isinstance(current, list) and isinstance(key, int):
+                    current = current[key]
+            except (KeyError, IndexError):
+                raise SpudCheckError(f"JSON path {path!r} not found") from None
+        if not self.json_equal(current, expected):
+            raise SpudCheckError(f"expected {expected!r}, got {current!r}")
+        return self
+
+    def json_equal(self, actual: Any, expected: Any) -> bool:
+        if type(actual) != type(expected):
+            return False
+        if isinstance(actual, dict):
+            if actual.keys() != expected.keys():
+                return False
+            for key in actual:
+                if not self.json_equal(actual[key], expected[key]):
+                    return False
+            return True
+        if isinstance(actual, list):
+            if len(actual) != len(expected):
+                return False
+            for actual_item, expected_item in zip(actual, expected):
+                if not self.json_equal(actual_item, expected_item):
+                    return False
+            return True
+        return actual == expected
+
+
+def parse_json_path(path: str) -> list[str | int]:
+    tokens: list[str | int] = []
+    buffer = ""
+    inside_brackets = False
+    after_closing_bracket = False
+    if path.endswith("."):
+        raise ValueError(f"Invalid JSON path {path!r}: empty path segment")
+    for index, char in enumerate(path):
+        if char == "[":
+            if inside_brackets:
+                raise ValueError(
+                    f"Invalid JSON path {path!r}: unexpected opening bracket"
+                )
+            if index > 0 and path[index - 1] == ".":
+                raise ValueError(
+                    f"Invalid JSON path {path!r}: unexpected opening bracket"
+                )
+            if buffer:
+                tokens.append(buffer)
+                buffer = ""
+            inside_brackets = True
+            after_closing_bracket = False
+            continue
+        if char == "]":
+            if not inside_brackets:
+                raise ValueError(
+                    f"Invalid JSON path {path!r}: unexpected closing bracket"
+                )
+            if buffer:
+                try:
+                    tokens.append(int(buffer))
+                except ValueError:
+                    raise ValueError(
+                        f"Invalid JSON path {path!r}: array index must be an integer"
+                    ) from None
+            else:
+                raise ValueError(
+                    f"Invalid JSON path {path!r}: array index cannot be empty"
+                ) from None
+            buffer = ""
+            inside_brackets = False
+            after_closing_bracket = True
+            continue
+        if char == ".":
+            if inside_brackets:
+                raise ValueError(
+                    f"Invalid JSON path {path!r}: array index must be integer"
+                )
+            if buffer == "" and not after_closing_bracket:
+                raise ValueError(f"Invalid JSON path {path!r}: empty path segment")
+            if buffer:
+                tokens.append(buffer)
+                buffer = ""
+            after_closing_bracket = False
+            continue
+        if after_closing_bracket:
+            raise ValueError(
+                f"Invalid JSON path {path!r}: expected separator after closing bracket"
+            )
+        buffer += char
+    if buffer:
+        tokens.append(buffer)
+    if inside_brackets:
+        raise ValueError(f"Invalid JSON path {path!r}: unclosed bracket")
+    return tokens

spud/transport_protocol.py

@@ -0,0 +1,17 @@
+from collections.abc import Mapping
+from typing import Any, Literal, Protocol
+
+from spud import raw_response_protocol
+
+HttpMethod = Literal["GET", "POST", "PUT", "PATCH", "DELETE"]
+
+
+class TransportProtocol(Protocol):
+    def request(
+        self,
+        method: HttpMethod,
+        url: str,
+        params: Mapping[str, Any] | None = None,
+        headers: Mapping[str, str] | None = None,
+        json: Any = None,
+    ) -> raw_response_protocol.RawResponseProtocol: ...

spud_testing-0.1.0.dist-info/METADATA

@@ -0,0 +1,51 @@
+Metadata-Version: 2.4
+Name: spud-testing
+Version: 0.1.0
+Summary: A lightweight Python toolkit for API testing
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: httpx
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Dynamic: license-file
+
+# SPUD
+Stop planting the same test framework over and over again.
+
+Spud is a Python testing framework for QA engineers who don't want to rebuild the same setup every time they join a new project.
+
+It comes with the stuff you usually end up writing anyway, but doesn't lock you into one way of doing things. Use what you need, replace what you don't, or build on top of it.
+
+Plant once. Grow tests.
+
+## Installation 
+```bash
+pip install spud-testing
+```
+
+## Quick start
+```python
+from spud import ApiClient
+
+client = ApiClient(base_url="https://jsonplaceholder.typicode.com")
+
+response = client.get("/users/1")
+
+response.check.status(200).json_path("id", 1)
+
+print(response.json())
+```
+
+## Features
+- HTTP methods: GET, POST, PUT, PATCH, DELETE
+- Configurable base URL and request headers
+- Query parameters and JSON request bodies
+- Pluggable HTTP transport (httpx by default)
+- HTTP status assertions
+- JSON path assertions with nested objects and arrays
+- Strict JSON value comparison
+- Chainable response assertions
+

spud_testing-0.1.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+spud/__init__.py,sha256=7MLLJyWFlVmWAkJyDIErFOsrhmvDv-MyAyh-nj3JyXA,274
+spud/api_client.py,sha256=JDKxjFp0UjRNXx0KOPfr548smKCqhaL5hT-0aJYLEfw,2791
+spud/api_response.py,sha256=C-w2vXGFL-WkNOTppSnx6JjMRP1X2Uqojj-vyzaUYYM,725
+spud/endpoint.py,sha256=bKxoUSKa7Efnrkg99BB8_SYKwp4d2QZxRM5qS4aBe5g,445
+spud/exceptions.py,sha256=BvxUGGCTlcSe7o7t2XwlLTsR4GKBjY_HMonMci3a-nU,47
+spud/httpx_transport.py,sha256=YCz8D-ITfBBYs_8jv4DBtRaldNrF4bs-GCZI1g8O7FU,549
+spud/raw_response_protocol.py,sha256=hfKaH0kfjvxYU_rmodDKsxjzFcBNPdxIXZqA4sHCQvM,351
+spud/response_checks.py,sha256=ihAZf1J_VlQaB-ziFVQ0vpJdrHnpe_OLO93MS9Qh-iQ,4967
+spud/transport_protocol.py,sha256=oIJWIjJ4U7Y0VoAPvKkNvwoWWdCHfWofu_Gq67aM65k,476
+spud_testing-0.1.0.dist-info/licenses/LICENSE,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+spud_testing-0.1.0.dist-info/METADATA,sha256=TGG0QYtdnLfzOfdEuL78_7LNrXQGYmOlBloC_H_GsqY,1390
+spud_testing-0.1.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+spud_testing-0.1.0.dist-info/top_level.txt,sha256=sKnJPX1Z6zmvB6P2wc9pO7l_GNtZzeqLYSAAL-HTr44,5
+spud_testing-0.1.0.dist-info/RECORD,,

spud_testing-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

spud_testing-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+spud