pyssertive 0.1.0__py3-none-any.whl

pyssertive/db.py

@@ -0,0 +1,51 @@
+"""Database assertion utilities for Django models."""
+
+from collections.abc import Callable, Collection, Generator, Iterator
+from contextlib import contextmanager
+from typing import Any
+
+from django.db import connection
+from django.db.models import Model, QuerySet
+from django.test import TransactionTestCase
+from django.test.utils import CaptureQueriesContext
+
+
+def assert_queryset_equal(
+    actual: QuerySet | list[Any] | Iterator[Any],
+    expected: Collection,
+    *,
+    transform: Callable[[Any], Any] = repr,
+    ordered: bool = True,
+) -> None:
+    TransactionTestCase().assertQuerySetEqual(actual, expected, transform=transform, ordered=ordered)
+
+
+@contextmanager
+def assert_num_queries(expected: int) -> Generator[None, Any, None]:
+    with CaptureQueriesContext(connection) as ctx:
+        yield
+        actual = len(ctx)
+        assert actual == expected, f"Expected {expected} queries, but got {actual}.\nQueries:\n" + "\n".join(
+            q["sql"] for q in ctx.captured_queries
+        )
+
+
+def assert_model_exists(model: type[Model], **filters) -> None:
+    assert model.objects.filter(**filters).exists(), f"{model.__name__} does not exist with filters: {filters}"
+
+
+def assert_model_not_exists(model: type[Model], **filters) -> None:
+    assert not model.objects.filter(**filters).exists(), f"{model.__name__} unexpectedly exists with filters: {filters}"
+
+
+def assert_model_count(model: type[Model], expected: int, **filters) -> None:
+    actual = model.objects.filter(**filters).count()
+    assert actual == expected, f"Expected {expected} records for {model.__name__}, got {actual}"
+
+
+def assert_model_soft_deleted(model: type[Model], **filters) -> None:
+    """Assumes model uses soft-deletion with a `deleted_at` datetime field."""
+    obj = model.objects.filter(**filters).first()
+    assert obj is not None, f"{model.__name__} does not exist with filters: {filters}"
+    assert hasattr(obj, "deleted_at"), f"{model.__name__} has no 'deleted_at' field"
+    assert obj.deleted_at is not None, f"{model.__name__} is not soft deleted"

pyssertive/http/__init__.py

@@ -0,0 +1,8 @@
+from pyssertive.http.client import FluentHttpAssertClient, FluentResponse
+from pyssertive.http.request import RequestBuilder
+
+__all__ = [
+    "FluentHttpAssertClient",
+    "FluentResponse",
+    "RequestBuilder",
+]

pyssertive/http/assertions.py

@@ -0,0 +1,317 @@
+from __future__ import annotations
+
+import html
+import json
+import re
+from typing import Any, Self
+from urllib.parse import urlparse
+
+from django.http import HttpResponse
+from django.test import SimpleTestCase
+from django.utils.html import strip_tags
+
+
+class HttpStatusAssertionsMixin:
+    _response: HttpResponse
+
+    def assert_ok(self) -> Self:
+        assert 200 <= self._response.status_code < 300, f"Expected 2xx, got {self._response.status_code}"
+        return self  # type: ignore[return-value]
+
+    def assert_created(self) -> Self:
+        assert self._response.status_code == 201, f"Expected 201 Created, got {self._response.status_code}"
+        return self  # type: ignore[return-value]
+
+    def assert_accepted(self) -> Self:
+        assert self._response.status_code == 202, f"Expected 202 Accepted, got {self._response.status_code}"
+        return self  # type: ignore[return-value]
+
+    def assert_no_content(self) -> Self:
+        assert self._response.status_code == 204, f"Expected 204 No Content, got {self._response.status_code}"
+        return self  # type: ignore[return-value]
+
+    def assert_redirect(self, to: str | None = None) -> Self:
+        assert 300 <= self._response.status_code < 400, f"Expected redirect (3xx), got {self._response.status_code}"
+        if to is not None:
+            location = self._response.headers.get("Location") or self._response.get("Location")
+            assert location, "Redirect location header is missing"
+            expected_path = urlparse(to).path
+            actual_path = urlparse(location).path
+            assert actual_path.endswith(expected_path), f"Expected redirect to '{to}', got '{location}'"
+        return self  # type: ignore[return-value]
+
+    def assert_moved_permanently(self) -> Self:
+        assert self._response.status_code == 301, f"Expected 301 Moved Permanently, got {self._response.status_code}"
+        return self  # type: ignore[return-value]
+
+    def assert_found(self) -> Self:
+        assert self._response.status_code == 302, f"Expected 302 Found (redirect), got {self._response.status_code}"
+        return self  # type: ignore[return-value]
+
+    def assert_see_other(self) -> Self:
+        assert self._response.status_code == 303, f"Expected 303 See Other, got {self._response.status_code}"
+        return self  # type: ignore[return-value]
+
+    def assert_bad_request(self) -> Self:
+        assert self._response.status_code == 400, f"Expected 400 Bad Request, got {self._response.status_code}"
+        return self  # type: ignore[return-value]
+
+    def assert_unauthorized(self) -> Self:
+        assert self._response.status_code == 401, f"Expected 401 Unauthorized, got {self._response.status_code}"
+        return self  # type: ignore[return-value]
+
+    def assert_payment_required(self) -> Self:
+        assert self._response.status_code == 402, f"Expected 402 Payment Required, got {self._response.status_code}"
+        return self  # type: ignore[return-value]
+
+    def assert_forbidden(self) -> Self:
+        assert self._response.status_code == 403, f"Expected 403 Forbidden, got {self._response.status_code}"
+        return self  # type: ignore[return-value]
+
+    def assert_not_found(self) -> Self:
+        assert self._response.status_code == 404, f"Expected 404 Not Found, got {self._response.status_code}"
+        return self  # type: ignore[return-value]
+
+    def assert_method_not_allowed(self) -> Self:
+        assert self._response.status_code == 405, f"Expected 405 Method Not Allowed, got {self._response.status_code}"
+        return self  # type: ignore[return-value]
+
+    def assert_request_timeout(self) -> Self:
+        assert self._response.status_code == 408, f"Expected 408 Request Timeout, got {self._response.status_code}"
+        return self  # type: ignore[return-value]
+
+    def assert_conflict(self) -> Self:
+        assert self._response.status_code == 409, f"Expected 409 Conflict, got {self._response.status_code}"
+        return self  # type: ignore[return-value]
+
+    def assert_gone(self) -> Self:
+        assert self._response.status_code == 410, f"Expected 410 Gone, got {self._response.status_code}"
+        return self  # type: ignore[return-value]
+
+    def assert_unprocessable(self) -> Self:
+        assert self._response.status_code == 422, f"Expected 422 Unprocessable Entity, got {self._response.status_code}"
+        return self  # type: ignore[return-value]
+
+    def assert_too_many_requests(self) -> Self:
+        assert self._response.status_code == 429, f"Expected 429 Too Many Requests, got {self._response.status_code}"
+        return self  # type: ignore[return-value]
+
+    def assert_internal_server_error(self) -> Self:
+        assert self._response.status_code == 500, (
+            f"Expected 500 Internal Server Error, got {self._response.status_code}"
+        )
+        return self  # type: ignore[return-value]
+
+    def assert_service_unavailable(self) -> Self:
+        assert self._response.status_code == 503, f"Expected 503 Service Unavailable, got {self._response.status_code}"
+        return self  # type: ignore[return-value]
+
+    def assert_server_error(self) -> Self:
+        assert 500 <= self._response.status_code < 600, f"Expected 5xx Server Error, got {self._response.status_code}"
+        return self  # type: ignore[return-value]
+
+    def assert_client_error(self) -> Self:
+        assert 400 <= self._response.status_code < 500, f"Expected 4xx Client Error, got {self._response.status_code}"
+        return self  # type: ignore[return-value]
+
+    def assert_status(self, status_code: int) -> Self:
+        assert self._response.status_code == status_code, (
+            f"Expected status {status_code}, got {self._response.status_code}"
+        )
+        return self  # type: ignore[return-value]
+
+
+class HeaderAssertionsMixin:
+    _response: HttpResponse
+
+    def assert_header(self, name: str, value: str) -> Self:
+        actual = self._response.headers.get(name)
+        assert actual == value, f"Expected header '{name}' to be '{value}', got '{actual}'"
+        return self  # type: ignore[return-value]
+
+    def assert_header_contains(self, name: str, fragment: str) -> Self:
+        actual = self._response.headers.get(name)
+        assert actual is not None, f"Expected header '{name}' to exist"
+        assert fragment in actual, f"Expected header '{name}' to contain '{fragment}', got '{actual}'"
+        return self  # type: ignore[return-value]
+
+    def assert_header_missing(self, name: str) -> Self:
+        assert name not in self._response.headers, (
+            f"Expected header '{name}' to be missing, but found: '{self._response.headers.get(name)}'"
+        )
+        return self  # type: ignore[return-value]
+
+    def assert_content_type(self, expected: str) -> Self:
+        actual = self._response.headers.get("Content-Type")
+        assert actual == expected, f"Expected Content-Type '{expected}', got '{actual}'"
+        return self  # type: ignore[return-value]
+
+
+class HTMLContentAssertionsMixin:
+    _response: HttpResponse
+
+    def assert_see(self, text: str) -> Self:
+        body = html.unescape(self._response.content.decode("utf-8", errors="replace"))
+        body = re.sub(r"\s+", " ", body).strip()
+        assert text in body, f"Expected to see '{text}', got: {body}"
+        return self  # type: ignore[return-value]
+
+    def assert_dont_see(self, text: str) -> Self:
+        body = html.unescape(self._response.content.decode("utf-8", errors="replace"))
+        body = re.sub(r"\s+", " ", body).strip()
+        assert text not in body, f"Did not expect to see '{text}', got: {body}"
+        return self  # type: ignore[return-value]
+
+    def assert_see_text(self, text: str) -> Self:
+        plain = html.unescape(strip_tags(self._response.content.decode("utf-8", errors="replace")))
+        plain = re.sub(r"\s+", " ", plain).strip()
+        assert text in plain, f"Expected to see plain text '{text}', got: {plain}"
+        return self  # type: ignore[return-value]
+
+    def assert_dont_see_text(self, text: str) -> Self:
+        plain = html.unescape(strip_tags(self._response.content.decode("utf-8", errors="replace")))
+        plain = re.sub(r"\s+", " ", plain).strip()
+        assert text not in plain, f"Did not expect plain text '{text}', got: {plain}"
+        return self  # type: ignore[return-value]
+
+    def assert_see_in_order(self, texts: list[str]) -> Self:
+        body = html.unescape(self._response.content.decode("utf-8", errors="replace"))
+        body = re.sub(r"\s+", " ", body).strip()
+        last_index = -1
+        last_text = ""
+        for key, text in enumerate(texts):
+            index = body.find(text, last_index + 1)
+            message = "" if last_text == "" else f"after '{last_text}'"
+            assert index != -1, f"'{text}' ({key}) not found {message}"
+            last_index = index
+            last_text = texts[key]
+        return self  # type: ignore[return-value]
+
+    def assert_html_contains(self, html_fragment: str) -> Self:
+        SimpleTestCase().assertInHTML(html_fragment, self._response.content.decode())
+        return self  # type: ignore[return-value]
+
+
+class JsonContentAssertionsMixin:
+    _response: HttpResponse
+
+    def _get_json(self) -> Any:
+        try:
+            return json.loads(self._response.content)
+        except json.JSONDecodeError:
+            raise AssertionError("Response content is not valid JSON") from None
+
+    def _resolve_path(self, data: Any, path: str) -> Any:
+        for part in path.split("."):
+            if isinstance(data, dict):
+                data = data.get(part)
+            elif isinstance(data, list) and part.isdigit():
+                data = data[int(part)]
+            else:
+                raise AssertionError(f"Path '{path}' not found in response JSON")
+        return data
+
+    def assert_json(self) -> Self:
+        self._get_json()
+        return self  # type: ignore[return-value]
+
+    def assert_json_path(self, path: str, expected: Any) -> Self:
+        data = self._get_json()
+        actual = self._resolve_path(data, path)
+        assert actual == expected, f"Expected '{expected}' at path '{path}', got '{actual}'"
+        return self  # type: ignore[return-value]
+
+    def assert_json_fragment(self, fragment: dict) -> Self:
+        data = self._get_json()
+        flat = json.dumps(data)
+        for key, value in fragment.items():
+            pair = f'"{key}": {json.dumps(value)}'
+            assert pair in flat, f"Fragment {key}: {value} not found in response JSON"
+        return self  # type: ignore[return-value]
+
+    def assert_json_missing_fragment(self, fragment: dict) -> Self:
+        data = self._get_json()
+        flat = json.dumps(data)
+        for key, value in fragment.items():
+            pair = f'"{key}": {json.dumps(value)}'
+            assert pair not in flat, f"Unexpected fragment {key}: {value} found in response JSON"
+        return self  # type: ignore[return-value]
+
+    def assert_json_count(self, expected: int, path: str | None = None) -> Self:
+        data = self._get_json()
+        if path:
+            data = self._resolve_path(data, path)
+        assert isinstance(data, list), f"Expected a list at path '{path}', got {type(data)}"
+        assert len(data) == expected, f"Expected {expected} items at '{path}', got {len(data)}"
+        return self  # type: ignore[return-value]
+
+    def assert_exact_json(self, expected: Any) -> Self:
+        data = self._get_json()
+        assert data == expected, f"Expected exact JSON: {expected}, got: {data}"
+        return self  # type: ignore[return-value]
+
+    def assert_json_structure(self, structure: dict) -> Self:
+        data = self._get_json()
+        assert isinstance(data, dict), f"Expected JSON object, got {type(data).__name__}"
+        for key, expected_type in structure.items():
+            assert key in data, f"Key '{key}' missing from JSON response"
+            if expected_type is not None:
+                actual_type = type(data[key])
+                assert isinstance(data[key], expected_type), (
+                    f"Key '{key}' expected type {expected_type.__name__}, got {actual_type.__name__}"
+                )
+        return self  # type: ignore[return-value]
+
+    def assert_json_missing_path(self, path: str) -> Self:
+        data = self._get_json()
+        parts = path.split(".")
+        current = data
+        for part in parts:
+            if isinstance(current, dict):
+                if part not in current:
+                    return self  # type: ignore[return-value]
+                current = current[part]
+            elif isinstance(current, list) and part.isdigit():
+                idx = int(part)
+                if idx >= len(current):
+                    return self  # type: ignore[return-value]
+                current = current[idx]
+            else:
+                return self  # type: ignore[return-value]
+        raise AssertionError(f"Path '{path}' should not exist but has value: {current}")
+
+    def assert_json_is_array(self) -> Self:
+        data = self._get_json()
+        assert isinstance(data, list), f"Expected JSON array, got {type(data).__name__}"
+        return self  # type: ignore[return-value]
+
+    def assert_json_is_object(self) -> Self:
+        data = self._get_json()
+        assert isinstance(data, dict), f"Expected JSON object, got {type(data).__name__}"
+        return self  # type: ignore[return-value]
+
+
+class CookieAssertionsMixin:
+    _response: HttpResponse
+
+    def assert_cookie(self, name: str, value: str | None = None) -> Self:
+        cookies = self._response.cookies
+        assert name in cookies, f"Cookie '{name}' not found. Available cookies: {list(cookies.keys())}"
+        if value is not None:
+            actual = cookies[name].value
+            assert actual == value, f"Cookie '{name}' expected '{value}', got '{actual}'"
+        return self  # type: ignore[return-value]
+
+    def assert_cookie_missing(self, name: str) -> Self:
+        cookies = self._response.cookies
+        assert name not in cookies, f"Cookie '{name}' should not exist but has value '{cookies[name].value}'"
+        return self  # type: ignore[return-value]
+
+    def assert_cookie_expired(self, name: str) -> Self:
+        cookies = self._response.cookies
+        assert name in cookies, f"Cookie '{name}' not found"
+        cookie = cookies[name]
+        max_age = cookie.get("max-age")
+        is_expired = max_age == 0 or max_age == "0" or cookie.value == ""
+        assert is_expired, f"Cookie '{name}' is not expired (max-age={max_age}, value='{cookie.value}')"
+        return self  # type: ignore[return-value]

pyssertive/http/client.py

@@ -0,0 +1,124 @@
+from __future__ import annotations
+
+from typing import Any
+
+from django.http import HttpResponse
+from django.test import Client
+
+from pyssertive.http.assertions import (
+    CookieAssertionsMixin,
+    HeaderAssertionsMixin,
+    HTMLContentAssertionsMixin,
+    HttpStatusAssertionsMixin,
+    JsonContentAssertionsMixin,
+)
+from pyssertive.http.debug import DebugResponseMixin
+from pyssertive.http.django import (
+    FormValidationAssertionsMixin,
+    SessionAssertionsMixin,
+    TemplateContextAssertionsMixin,
+)
+
+
+class FluentResponse(
+    DebugResponseMixin,
+    SessionAssertionsMixin,
+    CookieAssertionsMixin,
+    TemplateContextAssertionsMixin,
+    FormValidationAssertionsMixin,
+    HTMLContentAssertionsMixin,
+    JsonContentAssertionsMixin,
+    HeaderAssertionsMixin,
+    HttpStatusAssertionsMixin,
+):
+    """
+    Fluent assertion wrapper for Django HTTP responses.
+
+    Example::
+
+        response = client.get('/api/users/')
+        FluentResponse(response).assert_ok().assert_json().assert_json_path('count', 10)
+    """
+
+    def __init__(self, response: HttpResponse) -> None:
+        self._response: HttpResponse = response
+
+    def __getattr__(self, name: str) -> Any:
+        return getattr(self._response, name)
+
+    @property
+    def wrapped(self) -> HttpResponse:
+        return self._response
+
+    @property
+    def status_code(self) -> int:
+        return self._response.status_code
+
+    @property
+    def content(self) -> bytes:
+        return self._response.content
+
+    @property
+    def headers(self) -> Any:
+        return self._response.headers
+
+    @property
+    def cookies(self) -> Any:
+        return self._response.cookies
+
+    @property
+    def charset(self) -> str | None:
+        return self._response.charset
+
+    @property
+    def reason_phrase(self) -> str:
+        return self._response.reason_phrase
+
+
+class FluentHttpAssertClient:
+    """
+    Fluent wrapper for Django's test client.
+
+    Example::
+
+        client = FluentHttpAssertClient(Client())
+        client.get('/api/').assert_ok().assert_json()
+    """
+
+    def __init__(self, base_client: Client) -> None:
+        self._client: Client = base_client
+
+    def get(self, *args: Any, **kwargs: Any) -> FluentResponse:
+        response = self._client.get(*args, **kwargs)
+        return FluentResponse(response)
+
+    def post(self, *args: Any, **kwargs: Any) -> FluentResponse:
+        response = self._client.post(*args, **kwargs)
+        return FluentResponse(response)
+
+    def put(self, *args: Any, **kwargs: Any) -> FluentResponse:
+        response = self._client.put(*args, **kwargs)
+        return FluentResponse(response)
+
+    def patch(self, *args: Any, **kwargs: Any) -> FluentResponse:
+        response = self._client.patch(*args, **kwargs)
+        return FluentResponse(response)
+
+    def delete(self, *args: Any, **kwargs: Any) -> FluentResponse:
+        response = self._client.delete(*args, **kwargs)
+        return FluentResponse(response)
+
+    def head(self, *args: Any, **kwargs: Any) -> FluentResponse:
+        response = self._client.head(*args, **kwargs)
+        return FluentResponse(response)
+
+    def options(self, *args: Any, **kwargs: Any) -> FluentResponse:
+        response = self._client.options(*args, **kwargs)
+        return FluentResponse(response)
+
+    def trace(self, *args: Any, **kwargs: Any) -> FluentResponse:
+        response = self._client.trace(*args, **kwargs)
+        return FluentResponse(response)
+
+    def __getattr__(self, name: str) -> Any:
+        return getattr(self._client, name)

pyssertive/http/debug.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+import json
+import pprint
+from json import JSONDecodeError
+from typing import Self
+
+from django.http import HttpResponse
+
+
+class DebugResponseMixin:
+    _response: HttpResponse
+
+    def dump(self, content_format: str | None = None) -> Self:
+        content_type = content_format or self._response.headers.get("Content-Type", "")
+
+        print("\n[Response Dump - format:", content_type, "]")
+        print("[Status]", self._response.status_code)
+        print("[Headers]", dict(self._response.headers))
+
+        match content_type:
+            case "application/json":
+                try:
+                    pprint.pprint(json.loads(self._response.content))
+                except JSONDecodeError:
+                    print("[Invalid JSON]", self._response.content.decode(errors="replace"))
+            case "text/plain":
+                print(self._response.content.decode(errors="replace"))
+            case _:
+                print(repr(self._response.content))
+
+        return self  # type: ignore[return-value]
+
+    def dump_headers(self) -> Self:
+        print("\n[Response Headers]")
+        for key, value in self._response.headers.items():
+            print(f"  {key}: {value}")
+        return self  # type: ignore[return-value]
+
+    def dump_json(self) -> Self:
+        print("\n[Response JSON]")
+        try:
+            data = json.loads(self._response.content)
+            print(json.dumps(data, indent=2, default=str))
+        except JSONDecodeError:
+            raise AssertionError("Response content is not valid JSON") from None
+        return self  # type: ignore[return-value]
+
+    def dump_session(self) -> Self:
+        print("\n[Session Data]")
+        if not hasattr(self._response, "wsgi_request"):
+            print("  (no request context available)")
+            return self  # type: ignore[return-value]
+        session = dict(self._response.wsgi_request.session)
+        if session:
+            for key, value in session.items():
+                print(f"  {key}: {value!r}")
+        else:
+            print("  (empty)")
+        return self  # type: ignore[return-value]
+
+    def dump_cookies(self) -> Self:
+        print("\n[Response Cookies]")
+        cookies = self._response.cookies
+        if cookies:
+            for name, cookie in cookies.items():
+                print(f"  {name}: {cookie.value}")
+                if cookie.get("max-age"):
+                    print(f"    max-age: {cookie['max-age']}")
+                if cookie.get("path"):  # pragma: no branch
+                    print(f"    path: {cookie['path']}")
+        else:
+            print("  (none)")
+        return self  # type: ignore[return-value]
+
+    def dd(self) -> None:
+        self.dump()
+        raise RuntimeError("dd() called - stopping execution")

pyssertive/http/django.py

@@ -0,0 +1,86 @@
+from __future__ import annotations
+
+from typing import Any, Self
+
+from django.forms import Form
+from django.forms.formsets import BaseFormSet
+from django.http import HttpResponse
+from django.template.response import TemplateResponse
+from django.test import SimpleTestCase
+
+
+class TemplateContextAssertionsMixin:
+    _response: HttpResponse
+
+    def assert_template_used(self, template_name: str) -> Self:
+        SimpleTestCase().assertTemplateUsed(self._response, template_name)
+        return self  # type: ignore[return-value]
+
+    def assert_template_not_used(self, template_name: str) -> Self:
+        SimpleTestCase().assertTemplateNotUsed(self._response, template_name)
+        return self  # type: ignore[return-value]
+
+    def assert_context_has(self, key: str) -> Self:
+        assert hasattr(self._response, "context") and self._response.context is not None, "Response has no context"
+        assert key in self._response.context, f"Expected context to contain '{key}'"
+        return self  # type: ignore[return-value]
+
+    def assert_context_equals(self, key: str, expected: object) -> Self:
+        assert hasattr(self._response, "context") and self._response.context is not None, "Response has no context"
+        assert key in self._response.context, f"Expected context to contain '{key}'"
+        actual = self._response.context[key]
+        assert actual == expected, f"Expected context['{key}'] == {expected}, got {actual}"
+        return self  # type: ignore[return-value]
+
+
+class FormValidationAssertionsMixin:
+    _response: HttpResponse
+
+    def assert_form_error(self, form: str, field: str, error: str | list[str]) -> Self:
+        assert isinstance(self._response, TemplateResponse), "Response must be a TemplateResponse"
+        assert hasattr(self._response, "context"), "Response has no context"
+        assert form in self._response.context, f"'{form}' not found in response context"
+
+        form_obj = self._response.context[form]
+        assert isinstance(form_obj, Form), f"Context variable '{form}' is not a Form instance"
+
+        SimpleTestCase().assertFormError(form_obj, field, error)
+        return self  # type: ignore[return-value]
+
+    def assert_formset_error(self, formset: str, form_index: int, field: str, error: str | list[str]) -> Self:
+        assert isinstance(self._response, TemplateResponse), "Response must be a TemplateResponse"
+        assert hasattr(self._response, "context"), "Response has no context"
+        assert formset in self._response.context, f"'{formset}' not found in response context"
+
+        formset_obj = self._response.context[formset]
+        assert isinstance(formset_obj, BaseFormSet), f"Context variable '{formset}' is not a FormSet instance"
+
+        SimpleTestCase().assertFormSetError(formset_obj, form_index, field, error)
+        return self  # type: ignore[return-value]
+
+
+class SessionAssertionsMixin:
+    _response: HttpResponse
+
+    def _get_session(self) -> dict:
+        if not hasattr(self._response, "wsgi_request"):
+            raise AssertionError("Response has no request context (use Client, not RequestFactory)")
+        return dict(self._response.wsgi_request.session)
+
+    def assert_session_has(self, key: str, value: Any = None) -> Self:
+        session = self._get_session()
+        assert key in session, f"Session key '{key}' not found. Available keys: {list(session.keys())}"
+        if value is not None:
+            assert session[key] == value, f"Session key '{key}' expected '{value}', got '{session[key]}'"
+        return self  # type: ignore[return-value]
+
+    def assert_session_missing(self, key: str) -> Self:
+        session = self._get_session()
+        assert key not in session, f"Session key '{key}' should not exist but has value '{session[key]}'"
+        return self  # type: ignore[return-value]
+
+    def assert_session_has_all(self, keys: list[str]) -> Self:
+        session = self._get_session()
+        missing = [k for k in keys if k not in session]
+        assert not missing, f"Session missing keys: {missing}. Available keys: {list(session.keys())}"
+        return self  # type: ignore[return-value]

pyssertive/http/request.py

@@ -0,0 +1,130 @@
+from __future__ import annotations
+
+from typing import Any
+
+from django.contrib.auth.models import AbstractBaseUser
+from django.http import HttpRequest
+from django.test import RequestFactory
+
+
+class RequestBuilder:
+    """
+    Fluent builder for creating HttpRequest objects using Django's RequestFactory.
+
+    Useful for unit testing views directly without going through the full
+    HTTP request/response cycle (bypasses middleware and URL routing).
+
+    Example::
+
+        from pyssertive.http.request import RequestBuilder
+
+        request = (
+            RequestBuilder()
+            .with_method("POST")
+            .with_path("/api/users/")
+            .with_body({"name": "John"})
+            .with_user(user)
+            .with_cookie("session", "abc123")
+            .with_meta("HTTP_X_FORWARDED_FOR", "192.168.1.1")
+            .build()
+        )
+        response = my_view(request)
+    """
+
+    def __init__(
+        self,
+        rf: RequestFactory | None = None,
+        method: str = "GET",
+        path: str = "/",
+        data: dict[str, Any] | None = None,
+    ) -> None:
+        self.rf = rf or RequestFactory()
+        self.method = method.upper()
+        self.path = path
+        self.data = data or {}
+        self.user: AbstractBaseUser | None = None
+        self.cookies: dict[str, str] = {}
+        self.meta: dict[str, Any] = {}
+        self.headers: dict[str, str] = {}
+        self.custom_properties: dict[str, Any] = {}
+
+    def with_method(self, method: str) -> RequestBuilder:
+        self.method = method.upper()
+        return self
+
+    def with_path(self, path: str) -> RequestBuilder:
+        self.path = path
+        return self
+
+    def with_data(self, data: dict[str, Any]) -> RequestBuilder:
+        self.data = data
+        return self
+
+    def with_body(self, data: dict[str, Any]) -> RequestBuilder:
+        if self.method not in ["POST", "PUT", "PATCH"]:
+            raise ValueError(f"Cannot set body on {self.method} request")
+        self.data = data
+        return self
+
+    def with_query_string(self, params: dict[str, Any]) -> RequestBuilder:
+        self.data = params
+        return self
+
+    def with_user(self, user: AbstractBaseUser) -> RequestBuilder:
+        self.user = user
+        return self
+
+    def with_cookie(self, key: str, value: Any) -> RequestBuilder:
+        self.cookies[key] = str(value)
+        return self
+
+    def with_cookies(self, cookies: dict[str, Any]) -> RequestBuilder:
+        for key, value in cookies.items():
+            self.cookies[key] = str(value)
+        return self
+
+    def with_meta(self, key: str, value: Any) -> RequestBuilder:
+        self.meta[key] = str(value)
+        return self
+
+    def with_header(self, key: str, value: str) -> RequestBuilder:
+        self.headers[key] = value
+        return self
+
+    def with_headers(self, headers: dict[str, str]) -> RequestBuilder:
+        self.headers.update(headers)
+        return self
+
+    def with_property(self, name: str, value: Any) -> RequestBuilder:
+        self.custom_properties[name] = value
+        return self
+
+    def build(self) -> HttpRequest:
+        method_map = {
+            "GET": self.rf.get,
+            "POST": self.rf.post,
+            "PUT": self.rf.put,
+            "PATCH": self.rf.patch,
+            "DELETE": self.rf.delete,
+            "HEAD": self.rf.head,
+            "OPTIONS": self.rf.options,
+        }
+
+        if self.method not in method_map:
+            raise ValueError(f"Unsupported HTTP method: {self.method}")
+
+        request = method_map[self.method](self.path, self.data, headers=self.headers)
+
+        if self.user:
+            request.user = self.user
+
+        for key, value in self.cookies.items():
+            request.COOKIES[key] = value
+
+        for key, value in self.meta.items():
+            request.META[key] = value
+
+        for key, value in self.custom_properties.items():
+            setattr(request, key, value)
+
+        return request

pyssertive-0.1.0.dist-info/METADATA

@@ -0,0 +1,151 @@
+Metadata-Version: 2.4
+Name: pyssertive
+Version: 0.1.0
+Summary: Fluent, chainable assertions for Django tests. Inspired by Laravel's elegant testing API.
+Author-email: Unay Santisteban <usantisteban@outlook.com>
+License: Apache-2.0
+Project-URL: Homepage, https://github.com/usantisteban/pyssertive
+Project-URL: Repository, https://github.com/usantisteban/pyssertive.git
+Project-URL: Issues, https://github.com/usantisteban/pyssertive/issues
+Keywords: django,testing,assertions,fluent,pytest
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Framework :: Django
+Classifier: Framework :: Django :: 4.2
+Classifier: Framework :: Django :: 5.0
+Classifier: Framework :: Django :: 5.1
+Classifier: Framework :: Pytest
+Classifier: Topic :: Software Development :: Testing
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: Django>=4.2
+Dynamic: license-file
+
+# pyssertive
+
+[![Build Status](https://github.com/othercodes/pyssertive/actions/workflows/test.yml/badge.svg)](https://github.com/othercodes/pyssertive/actions/workflows/test.yml)
+
+Fluent, chainable assertions for Django tests. Inspired by Laravel's elegant testing API.
+
+## Features
+
+- Fluent, chainable API for readable test assertions
+- HTTP status code assertions (2xx, 3xx, 4xx, 5xx)
+- JSON response validation with path navigation
+- HTML content assertions
+- Template and context assertions
+- Form and formset error assertions
+- Session and cookie assertions
+- Header assertions
+- Debug helpers for test development
+
+## Requirements
+
+- Python 3.11+
+- Django 4.2+
+
+## Installation
+
+```bash
+pip install pyssertive
+```
+
+## Usage
+
+### Basic Example
+
+```python
+import pytest
+from pyssertive.http import FluentHttpAssertClient
+
+@pytest.fixture
+def client():
+    from django.test import Client
+    return FluentHttpAssertClient(Client())
+
+@pytest.mark.django_db
+def test_user_api(client):
+    response = client.get("/api/users/")
+    
+    response.assert_ok()\
+        .assert_json()\
+        .assert_json_path("count", 10)\
+        .assert_header("Content-Type", "application/json")
+```
+
+### HTTP Status Assertions
+
+```python
+response.assert_ok()              # 2xx
+response.assert_created()         # 201
+response.assert_not_found()       # 404
+response.assert_forbidden()       # 403
+response.assert_redirect("/login/")
+response.assert_status(418)       # Any status code
+```
+
+### JSON Assertions
+
+```python
+response.assert_json()\
+    .assert_json_path("user.name", "John")\
+    .assert_json_fragment({"status": "active"})\
+    .assert_json_count(5, path="items")\
+    .assert_json_structure({"id": int, "name": str})\
+    .assert_json_is_array()
+```
+
+### Session and Cookie Assertions
+
+```python
+response.assert_session_has("user_id", 123)\
+    .assert_session_missing("temp_token")\
+    .assert_cookie("session_id")\
+    .assert_cookie_missing("tracking")
+```
+
+### Template Assertions
+
+```python
+response.assert_template_used("users/list.html")\
+    .assert_context_has("users")\
+    .assert_context_equals("page", 1)
+```
+
+### Debug Helpers
+
+```python
+response.dump()           # Print full response
+response.dump_json()      # Pretty print JSON
+response.dump_headers()   # Print headers
+response.dump_session()   # Print session data
+response.dd()             # Dump and die (raises exception)
+```
+
+### Database Assertions
+
+```python
+from pyssertive.db import (
+    assert_model_exists,
+    assert_model_count,
+    assert_num_queries,
+)
+
+assert_model_exists(User, username="john")
+assert_model_count(User, 5)
+
+with assert_num_queries(2):
+    list(User.objects.all())
+```
+
+## License
+
+Apache License 2.0

pyssertive-0.1.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+pyssertive/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pyssertive/db.py,sha256=SOA10V_KtkVAik_K3QMlCMPUzwssVd4tibJP_7_D6Jg,2056
+pyssertive/http/__init__.py,sha256=u4qK0THIBSb_D-aEeMN6pltz4r9oZmFqhADMJgkAoXw,214
+pyssertive/http/assertions.py,sha256=6sKRfEZYzHPwsD9eVxeTm9dGENv9C5MJqc0RTU0Mjmc,14615
+pyssertive/http/client.py,sha256=1zxNIVtP0SPDG_PhwBXgURG6OVumC4u9H3S9KSYr5uo,3529
+pyssertive/http/debug.py,sha256=_BYv2XAp55yVRPew86ty-Koq881ABFIf9gfwX00zlR4,2799
+pyssertive/http/django.py,sha256=btiyhpvrcEVk_0curGjCEhfGZ2_Zg9F9B0yups9DVrg,4130
+pyssertive/http/request.py,sha256=XXlPvNqwB8LDYb5UgsZW2k-esrTflbEvaD3VAtnMJL4,3942
+pyssertive-0.1.0.dist-info/licenses/LICENSE,sha256=CUvt2ilcBwKAfRAnoA4RNPTLcdUj3En21LPK9YkFMGg,11358
+pyssertive-0.1.0.dist-info/METADATA,sha256=ZrWuebALpMR4If-gJCnRu-irDR7CO3RnYLFEiVN2Odo,3995
+pyssertive-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pyssertive-0.1.0.dist-info/top_level.txt,sha256=bvu8OTqOlhnCqyRciyMafB5DegDKjIv6l0RPdQQtgxE,11
+pyssertive-0.1.0.dist-info/RECORD,,

pyssertive-0.1.0.dist-info/WHEEL

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

pyssertive-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "{}"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright {yyyy} {name of copyright owner}
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

pyssertive-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+pyssertive