spud-testing 0.1.0__tar.gz

spud_testing-0.1.0/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,37 @@
+# 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/pyproject.toml

@@ -0,0 +1,18 @@
+[project]
+name = "spud-testing"
+version = "0.1.0"
+requires-python = ">=3.10"
+dependencies = ["httpx"]
+description = "A lightweight Python toolkit for API testing"
+readme = "README.md"
+
+[build-system]
+requires = ["setuptools"]
+build-backend = "setuptools.build_meta"
+
+[project.optional-dependencies]
+dev = ["pytest", "mypy", "ruff"]
+
+[tool.mypy]
+mypy_path = "src"
+explicit_package_bases = true

spud_testing-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

spud_testing-0.1.0/src/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_testing-0.1.0/src/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_testing-0.1.0/src/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_testing-0.1.0/src/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_testing-0.1.0/src/spud/exceptions.py

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

spud_testing-0.1.0/src/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_testing-0.1.0/src/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_testing-0.1.0/src/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_testing-0.1.0/src/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/src/spud_testing.egg-info/PKG-INFO

@@ -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/src/spud_testing.egg-info/SOURCES.txt

@@ -0,0 +1,22 @@
+LICENSE
+README.md
+pyproject.toml
+src/spud/__init__.py
+src/spud/api_client.py
+src/spud/api_response.py
+src/spud/endpoint.py
+src/spud/exceptions.py
+src/spud/httpx_transport.py
+src/spud/raw_response_protocol.py
+src/spud/response_checks.py
+src/spud/transport_protocol.py
+src/spud_testing.egg-info/PKG-INFO
+src/spud_testing.egg-info/SOURCES.txt
+src/spud_testing.egg-info/dependency_links.txt
+src/spud_testing.egg-info/requires.txt
+src/spud_testing.egg-info/top_level.txt
+tests/test_api_client.py
+tests/test_api_response.py
+tests/test_endpoint.py
+tests/test_httpx_transport.py
+tests/test_response_checks.py

spud_testing-0.1.0/src/spud_testing.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

spud_testing-0.1.0/src/spud_testing.egg-info/requires.txt

@@ -0,0 +1,6 @@
+httpx
+
+[dev]
+pytest
+mypy
+ruff

spud_testing-0.1.0/src/spud_testing.egg-info/top_level.txt

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

spud_testing-0.1.0/tests/test_api_client.py

@@ -0,0 +1,189 @@
+from unittest.mock import Mock, create_autospec
+
+import pytest
+
+from spud import api_client, httpx_transport, raw_response_protocol, transport_protocol
+from spud.api_response import ApiResponse
+from spud.raw_response_protocol import RawResponseProtocol
+from spud.transport_protocol import TransportProtocol
+
+
+@pytest.mark.parametrize("base_url", ["http://google.com/", "http://google.com///"])
+def test_base_url_removes_trailing_slash(base_url):
+    transport = create_autospec(spec=TransportProtocol, instance=True)
+    client = api_client.ApiClient(base_url, transport)
+    assert client.base_url == "http://google.com"
+
+
+def test_get_raises_value_error_when_path_has_no_leading_slash():
+    transport = create_autospec(spec=TransportProtocol, instance=True)
+    client = api_client.ApiClient("http://google.com", transport)
+    with pytest.raises(ValueError):
+        client.get("search")
+    transport.request.assert_not_called()
+
+
+def test_get_delegates_to_transport():
+    headers = {"Authorization": "Bearer Token..."}
+    params = {"q": 123}
+    fake_raw_response = object()
+    transport = create_autospec(spec=TransportProtocol, instance=True)
+    client = api_client.ApiClient("http://google.com", transport)
+    transport.request.return_value = fake_raw_response
+    response = client.get("/search", params=params, headers=headers)
+    assert response.raw is fake_raw_response
+    transport.request.assert_called_once_with(
+        method="GET",
+        url="http://google.com/search",
+        params=params,
+        headers=headers,
+        json=None,
+    )
+
+
+def test_post_delegates_to_transport():
+    json = {"name": "Ruslan", "age": 30}
+    headers = {"Authorization": "Bearer token"}
+    fake_raw_response = object()
+    transport = create_autospec(spec=TransportProtocol, instance=True)
+    client = api_client.ApiClient("http://google.com", transport)
+    transport.request.return_value = fake_raw_response
+    response = client.post("/create", json=json, headers=headers)
+    assert response.raw is fake_raw_response
+    transport.request.assert_called_once_with(
+        method="POST",
+        url="http://google.com/create",
+        json=json,
+        headers=headers,
+        params=None,
+    )
+
+
+def test_status_code_returns_raw_response_status_code():
+    status_code = 201
+    raw_response_mock = Mock(spec=RawResponseProtocol)
+    raw_response_mock.status_code = status_code
+    response = ApiResponse(raw_response_mock)
+    assert status_code == response.status_code
+
+
+def test_headers_returns_raw_response_headers():
+    headers = {"Authorization": "Bearer token"}
+    raw_response_mock = Mock(spec=RawResponseProtocol)
+    raw_response_mock.headers = headers
+    response = ApiResponse(raw_response_mock)
+    assert headers == response.headers
+
+
+def test_text_returns_raw_response_text():
+    text = "text"
+    raw_response_mock = Mock(spec=RawResponseProtocol)
+    raw_response_mock.text = text
+    response = ApiResponse(raw_response_mock)
+    assert text == response.text
+
+
+def test_json_returns_raw_response_json():
+    json = {"name": "Ruslan", "age": 30}
+    raw_response_mock = Mock(spec=RawResponseProtocol)
+    raw_response_mock.json.return_value = json
+    response = ApiResponse(raw_response_mock)
+    assert json == response.json()
+
+
+@pytest.mark.parametrize(
+    "method_name, expected_method, kwargs",
+    [
+        (
+            "post",
+            "POST",
+            {"json": {"status": "ok"}, "headers": {"Authorization": "Bearer token"}},
+        ),
+        (
+            "get",
+            "GET",
+            {"params": {"q": 123}, "headers": {"Authorization": "Bearer token"}},
+        ),
+        (
+            "put",
+            "PUT",
+            {"json": {"status": "ok"}, "headers": {"Authorization": "Bearer token"}},
+        ),
+        (
+            "patch",
+            "PATCH",
+            {"json": {"status": "ok"}, "headers": {"Authorization": "Bearer token"}},
+        ),
+        (
+            "delete",
+            "DELETE",
+            {"headers": {"Authorization": "Bearer token"}, "params": {"q": 123}},
+        ),
+    ],
+)
+def test_method_deligates_to_transport(method_name, expected_method, kwargs):
+    transport = create_autospec(spec=TransportProtocol, instance=True)
+    raw_response_mock = Mock(spec=RawResponseProtocol)
+    transport.request.return_value = raw_response_mock
+    client = api_client.ApiClient("http://google.com", transport)
+    method = getattr(client, method_name)
+    response = method(path="/search", **kwargs)
+    transport.request.assert_called_once_with(
+        method=expected_method,
+        url="http://google.com/search",
+        json=kwargs.get("json"),
+        headers=kwargs.get("headers"),
+        params=kwargs.get("params"),
+    )
+    assert response.raw is raw_response_mock
+
+
+def test_request_with_default_transport():
+    client = api_client.ApiClient("http://google.com")
+    assert isinstance(client.transport, httpx_transport.HttpxTransport)
+
+
+def test_api_client_uses_default_headers():
+    transport = create_autospec(
+        spec=transport_protocol.TransportProtocol, instance=True
+    )
+    raw_response_mock = Mock(spec=raw_response_protocol.RawResponseProtocol)
+    transport.request.return_value = raw_response_mock
+    headers = {"Authorization": "Bearer abc"}
+    client = api_client.ApiClient(
+        "http://google.com", transport=transport, headers=headers
+    )
+    client.get("/orders")
+    transport.request.assert_called_once_with(
+        method="GET",
+        url="http://google.com/orders",
+        params=None,
+        headers=headers,
+        json=None,
+    )
+
+
+def test_request_headers_override_and_extend_default_headers():
+    transport = create_autospec(
+        spec=transport_protocol.TransportProtocol, instance=True
+    )
+    raw_response_mock = Mock(spec=raw_response_protocol.RawResponseProtocol)
+    transport.request.return_value = raw_response_mock
+    headers = {"Authorization": "Bearer abc", "X-App": "Mobile"}
+    request_headers = {"X-Request-ID": "123", "X-App": "Web"}
+    expected_headers = {
+        "Authorization": "Bearer abc",
+        "X-Request-ID": "123",
+        "X-App": "Web",
+    }
+    client = api_client.ApiClient(
+        "http://google.com", transport=transport, headers=headers
+    )
+    client.get("/orders", headers=request_headers)
+    transport.request.assert_called_once_with(
+        method="GET",
+        url="http://google.com/orders",
+        params=None,
+        headers=expected_headers,
+        json=None,
+    )

spud_testing-0.1.0/tests/test_api_response.py

@@ -0,0 +1,12 @@
+from unittest.mock import Mock
+
+from spud import ApiResponse, response_checks
+
+
+def test_api_response_lazily_caches_response_checks():
+    raw_response_mock = Mock()
+    response = ApiResponse(raw_response_mock)
+    check = response.check
+    assert isinstance(check, response_checks.ResponseChecks)
+    assert check.response is response
+    assert response.check is check

spud_testing-0.1.0/tests/test_endpoint.py

@@ -0,0 +1,69 @@
+from unittest.mock import Mock, create_autospec
+
+import pytest
+
+from spud import (
+    api_client,
+    api_response,
+    endpoint,
+    raw_response_protocol,
+    transport_protocol,
+)
+
+
+def test_endpoint_stores_provided_api_client():
+    client = api_client.ApiClient(base_url="https://google.com")
+    endpoint_test = endpoint.Endpoint(client=client)
+    assert endpoint_test.client is client
+
+
+def test_endpoint_subclass_requires_path():
+    with pytest.raises(TypeError):
+
+        class BrokenEndpoint(endpoint.Endpoint):
+            pass
+
+
+def test_endpoint_path_must_be_string():
+    with pytest.raises(TypeError):
+
+        class BrokenEndpoint(endpoint.Endpoint):
+            path = 123
+
+
+def test_endpoint_subclass_has_inherits_path():
+    class OrdersEndpoint(endpoint.Endpoint):
+        path = "/orders"
+
+    class EndpointSubclass(OrdersEndpoint):
+        pass
+
+    assert EndpointSubclass.path == OrdersEndpoint.path
+
+
+def test_usability():
+    class OrdersEndpoint(endpoint.Endpoint):
+        path = "/orders"
+
+        def get_order(self, order_id):
+            path = self.path + "/" + order_id
+            response = self.client.get(path=path)
+            return response
+
+    transport = create_autospec(
+        spec=transport_protocol.TransportProtocol, instance=True
+    )
+    raw_response_mock = Mock(spec=raw_response_protocol.RawResponseProtocol)
+    transport.request.return_value = raw_response_mock
+    client = api_client.ApiClient(base_url="http://google.com", transport=transport)
+    orders = OrdersEndpoint(client)
+    response = orders.get_order("123")
+    transport.request.assert_called_once_with(
+        method="GET",
+        url="http://google.com/orders/123",
+        params=None,
+        headers=None,
+        json=None,
+    )
+    assert isinstance(response, api_response.ApiResponse)
+    assert response.raw is raw_response_mock

spud_testing-0.1.0/tests/test_httpx_transport.py

@@ -0,0 +1,36 @@
+from typing import Any
+from unittest.mock import Mock
+
+import httpx
+
+from spud import httpx_transport
+
+
+class FakeResponse:
+    def __init__(self):
+        self.headers = {}
+
+    status_code = 200
+    text = "text"
+
+    def json(self) -> Any:
+        return {"status": "ok"}
+
+
+def test_request_httpx(monkeypatch):
+    url = "http://google.com/"
+    headers = {"Authorization": "Bearer Token..."}
+    params = {"q": 123}
+    json = {"status": "ok"}
+    request_httpx_mock = Mock()
+    fake_response = FakeResponse()
+    request_httpx_mock.return_value = fake_response
+    monkeypatch.setattr(httpx, "request", request_httpx_mock)
+    transport = httpx_transport.HttpxTransport()
+    response = transport.request(
+        method="POST", url=url, headers=headers, params=params, json=json
+    )
+    request_httpx_mock.assert_called_once_with(
+        method="POST", url=url, headers=headers, params=params, json=json
+    )
+    assert response is fake_response

spud_testing-0.1.0/tests/test_response_checks.py

@@ -0,0 +1,330 @@
+from unittest.mock import Mock
+
+import pytest
+
+from spud import api_response, exceptions, raw_response_protocol
+from spud.response_checks import parse_json_path
+
+
+def test_check_status_passes_when_status_matches():
+    raw_response_mock = Mock(spec=raw_response_protocol.RawResponseProtocol)
+    raw_response_mock.status_code = 200
+
+    response = api_response.ApiResponse(raw_response_mock)
+
+    response.check.status(200)
+
+
+def test_check_status_error_when_status_not_matches():
+    raw_response_mock = Mock(spec=raw_response_protocol.RawResponseProtocol)
+    raw_response_mock.status_code = 500
+
+    response = api_response.ApiResponse(raw_response_mock)
+
+    with pytest.raises(
+        exceptions.SpudCheckError,
+        match=r"^Expected status 200, got 500 Internal Server Error",
+    ):
+        response.check.status(200)
+
+
+def test_check_got_uncommon_status():
+    raw_response_mock = Mock(spec=raw_response_protocol.RawResponseProtocol)
+    raw_response_mock.status_code = 599
+
+    response = api_response.ApiResponse(raw_response_mock)
+
+    with pytest.raises(
+        exceptions.SpudCheckError, match=r"^Expected status 200, got 599$"
+    ):
+        response.check.status(200)
+
+
+def test_json_path_checks_nested_field():
+    raw_response_mock = Mock(spec=raw_response_protocol.RawResponseProtocol)
+    raw_response_mock.json.return_value = {"customer": {"name": "Alex"}}
+
+    response = api_response.ApiResponse(raw_response_mock)
+
+    response.check.json_path("customer.name", "Alex")
+
+
+def test_json_path_not_have_field():
+    raw_response_mock = Mock(spec=raw_response_protocol.RawResponseProtocol)
+    raw_response_mock.json.return_value = {"customer": {"name": "Alex"}}
+
+    response = api_response.ApiResponse(raw_response_mock)
+
+    with pytest.raises(
+        exceptions.SpudCheckError, match=r"^JSON path 'customer\.age' not found$"
+    ):
+        response.check.json_path("customer.age", 25)
+
+
+def test_json_path_raises_when_intermediate_value_is_none():
+    raw_response_mock = Mock(spec=raw_response_protocol.RawResponseProtocol)
+    raw_response_mock.json.return_value = {"customer": None}
+
+    response = api_response.ApiResponse(raw_response_mock)
+
+    with pytest.raises(
+        exceptions.SpudCheckError, match=r"^JSON path 'customer\.age' not found$"
+    ):
+        response.check.json_path("customer.age", 25)
+
+
+def test_json_path_accepts_none_as_expected_value():
+    raw_response_mock = Mock(spec=raw_response_protocol.RawResponseProtocol)
+    raw_response_mock.json.return_value = {"customer": None}
+
+    response = api_response.ApiResponse(raw_response_mock)
+
+    response.check.json_path(path="customer", expected=None)
+
+
+def test_json_checks_array_element():
+    raw_response_mock = Mock(spec=raw_response_protocol.RawResponseProtocol)
+    raw_response_mock.json.return_value = {
+        "orders": [{"id": 101, "status": "created"}, {"id": 102, "status": "paid"}]
+    }
+
+    response = api_response.ApiResponse(raw_response_mock)
+
+    response.check.json_path(path="orders[0].status", expected="created")
+
+
+def test_parse_json_path_with_nested_keys():
+    result = parse_json_path("customer.name")
+    assert result == ["customer", "name"]
+
+
+def test_parse_json_path_with_array_index():
+    result = parse_json_path("orders[0].status")
+    assert result == ["orders", 0, "status"]
+
+
+def test_json_path_raises_when_index_out_of_range():
+    raw_response_mock = Mock(spec=raw_response_protocol.RawResponseProtocol)
+    raw_response_mock.json.return_value = {"orders": [{"id": 101}]}
+
+    response = api_response.ApiResponse(raw_response_mock)
+
+    with pytest.raises(
+        exceptions.SpudCheckError, match=r"^JSON path 'orders\[5\]\.id' not found$"
+    ):
+        response.check.json_path(path="orders[5].id", expected=101)
+
+
+def test_json_path_checks_included_array():
+    raw_response_mock = Mock(spec=raw_response_protocol.RawResponseProtocol)
+    raw_response_mock.json.return_value = {
+        "orders": [{"items": [{"id": 101}, {"id": 102}]}]
+    }
+
+    response = api_response.ApiResponse(raw_response_mock)
+
+    response.check.json_path(path="orders[0].items[1].id", expected=102)
+
+
+def test_json_path_included_matrix():
+    result = parse_json_path("matrix[0][1]")
+    assert result == ["matrix", 0, 1]
+
+
+def test_json_path_raises_value_error():
+    with pytest.raises(
+        ValueError,
+        match=r"^Invalid JSON path 'orders\[abc\]': array index must be an integer$",
+    ):
+        parse_json_path("orders[abc]")
+
+
+def test_json_path_raises_with_empty_index():
+    with pytest.raises(
+        ValueError,
+        match=r"^Invalid JSON path 'orders\[\]': array index cannot be empty$",
+    ):
+        parse_json_path("orders[]")
+
+
+def test_json_path_raises_with_unclosed_brackets():
+    with pytest.raises(
+        ValueError, match=r"^Invalid JSON path 'orders\[0': unclosed bracket$"
+    ):
+        parse_json_path("orders[0")
+
+
+def test_json_path_raises_with_unexpected_closing_brackets():
+    with pytest.raises(
+        ValueError, match=r"^Invalid JSON path 'orders0\]': unexpected closing bracket$"
+    ):
+        parse_json_path("orders0]")
+
+
+def test_json_parse_without_separator_after_closing_bracket():
+    with pytest.raises(
+        ValueError,
+        match=r"^Invalid JSON path 'order\[0\]status': expected separator after closing bracket$",
+    ):
+        parse_json_path("order[0]status")
+
+
+def test_json_parse_supports_negative_index():
+    raw_response_mock = Mock(spec=raw_response_protocol.RawResponseProtocol)
+    raw_response_mock.json.return_value = {
+        "orders": [{"id": 101}, {"id": 102}, {"id": 103}]
+    }
+
+    response = api_response.ApiResponse(raw_response_mock)
+
+    response.check.json_path(path="orders[-1].id", expected=103)
+
+
+def test_json_parse_raises_for_negative_index_out_of_range():
+    raw_response_mock = Mock(spec=raw_response_protocol.RawResponseProtocol)
+    raw_response_mock.json.return_value = {
+        "orders": [{"id": 101}, {"id": 102}, {"id": 103}]
+    }
+
+    response = api_response.ApiResponse(raw_response_mock)
+
+    with pytest.raises(exceptions.SpudCheckError):
+        response.check.json_path(path="orders[-4].id", expected=103)
+
+
+def test_json_parse_support_omitted_path():
+    raw_response_mock = Mock(spec=raw_response_protocol.RawResponseProtocol)
+    raw_response_mock.json.return_value = {"orders": [{"id": 101}, {"id": 102}]}
+
+    response = api_response.ApiResponse(raw_response_mock)
+
+    response.check.json_path(expected={"orders": [{"id": 101}, {"id": 102}]})
+
+
+def test_json_parse_raises_without_required_argument():
+    raw_response_mock = Mock(spec=raw_response_protocol.RawResponseProtocol)
+    raw_response_mock.json.return_value = {"orders": [{"id": 101}, {"id": 102}]}
+
+    response = api_response.ApiResponse(raw_response_mock)
+
+    with pytest.raises(
+        TypeError, match=r"^json_path\(\) missing required argument: expected$"
+    ):
+        response.check.json_path()
+
+
+def test_json_parse_raises_with_double_dot_in_path():
+    with pytest.raises(
+        ValueError, match=r"^Invalid JSON path 'user..name': empty path segment$"
+    ):
+        parse_json_path("user..name")
+
+
+def test_json_parse_raises_when_path_ended_with_dot():
+    with pytest.raises(
+        ValueError, match=r"^Invalid JSON path 'user.': empty path segment$"
+    ):
+        parse_json_path("user.")
+
+
+def test_json_parse_raises_when_path_has_bracket_inside_bracket():
+    with pytest.raises(
+        ValueError,
+        match=r"^Invalid JSON path 'order\[\[0\]\]': unexpected opening bracket$",
+    ):
+        parse_json_path("order[[0]]")
+
+
+def test_json_parse_raises_without_separator():
+    with pytest.raises(
+        ValueError,
+        match=r"^Invalid JSON path 'orders.\[0\]': unexpected opening bracket$",
+    ):
+        parse_json_path("orders.[0]")
+
+
+def test_json_parse_with_double_dots():
+    with pytest.raises(
+        ValueError,
+        match=r"^Invalid JSON path 'orders\[0\]..status': empty path segment$",
+    ):
+        parse_json_path("orders[0]..status")
+
+
+def test_json_parse_raises_when_path_starts_with_dot():
+    with pytest.raises(
+        ValueError, match=r"^Invalid JSON path '.user': empty path segment$"
+    ):
+        parse_json_path(".user")
+
+
+def test_json_parse_raises_with_float_in_path():
+    with pytest.raises(
+        ValueError,
+        match=r"^Invalid JSON path 'orders\[0.1\]': array index must be integer$",
+    ):
+        parse_json_path("orders[0.1]")
+
+
+def test_json_parse_index_correctly():
+    assert parse_json_path("[0]")
+
+
+@pytest.mark.parametrize(
+    "actual, expected",
+    [
+        ({"active": True}, {"active": 1}),
+        ({"users": [{"active": True}]}, ({"users": [{"active": 1}]})),
+        (1, 1.0),
+    ],
+)
+def test_json_path_raises_with_type_not_equal(actual, expected):
+    raw_response_mock = Mock(spec=raw_response_protocol.RawResponseProtocol)
+    raw_response_mock.json.return_value = actual
+
+    response = api_response.ApiResponse(raw_response_mock)
+
+    with pytest.raises(exceptions.SpudCheckError):
+        response.check.json_path(expected=expected)
+
+
+@pytest.mark.parametrize(
+    "actual, expected",
+    [({"users": [{"active": True}]}, ({"users": [{"active": True}]}))],
+)
+def test_json_path_passes_with_equal_type(actual, expected):
+    raw_response_mock = Mock(spec=raw_response_protocol.RawResponseProtocol)
+    raw_response_mock.json.return_value = actual
+
+    response = api_response.ApiResponse(raw_response_mock)
+
+    response.check.json_path(expected=expected)
+
+
+@pytest.mark.parametrize("actual, expected", [([1, 2], [1])])
+def test_json_path_raises_for_different_list_lengths(actual, expected):
+    raw_response_mock = Mock(spec=raw_response_protocol.RawResponseProtocol)
+    raw_response_mock.json.return_value = actual
+
+    response = api_response.ApiResponse(raw_response_mock)
+
+    with pytest.raises(exceptions.SpudCheckError):
+        response.check.json_path(expected=expected)
+
+
+def test_response_checks_support_method_chaining():
+    raw_response_mock = Mock(spec=raw_response_protocol.RawResponseProtocol)
+    raw_response_mock.status_code = 200
+    raw_response_mock.json.return_value = {"user": {"name": "Alice"}}
+
+    response = api_response.ApiResponse(raw_response_mock)
+
+    response.check.status(200).json_path("user.name", "Alice")
+    response.check.json_path("user.name", "Alice").status(200)
+
+
+def test_spud_check_error_public_import():
+    from spud import SpudCheckError
+    from spud.exceptions import SpudCheckError as InternalSpudCheckError
+
+    assert SpudCheckError is InternalSpudCheckError