resurf-models 0.1.0__tar.gz

resurf_models-0.1.0/.gitignore

@@ -0,0 +1,76 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+*.egg-info/
+*.egg
+.eggs/
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+# Python setuptools build dirs — anchored so they don't sweep up
+# legitimate nested "lib/" dirs (e.g. frontend/src/lib).
+/lib/
+/lib64/
+parts/
+sdist/
+var/
+wheels/
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+.coverage
+htmlcov/
+.tox/
+.hypothesis/
+
+# Virtual environments
+.venv/
+venv/
+env/
+ENV/
+
+# Node
+node_modules/
+.pnpm-store/
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+
+# Build outputs
+dist/
+build/
+*.tsbuildinfo
+.parcel-cache/
+.next/
+.vite/
+.turbo/
+
+# Editors
+.vscode/
+.idea/
+*.swp
+*.swo
+.DS_Store
+
+# Project-specific
+trajectories/
+*.sqlite
+*.sqlite-shm
+*.sqlite-wal
+sites/shop_v1/seed/snapshots/*.sqlite
+sites/shop_v1/backend/data/
+
+# Env
+.env
+.env.local
+.env.*.local
+
+# Playwright
+playwright-report/
+test-results/

resurf_models-0.1.0/PKG-INFO

@@ -0,0 +1,28 @@
+Metadata-Version: 2.4
+Name: resurf-models
+Version: 0.1.0
+Summary: Shared SQLModel schema and seed logic for resurf sites
+Author: The resurf contributors
+License: Apache-2.0
+Keywords: agents,ai,evaluation,resurf
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.11
+Requires-Dist: faker>=24.0
+Requires-Dist: pydantic>=2.6
+Requires-Dist: sqlmodel>=0.0.16
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# resurf-models
+
+Shared SQLModel schema and deterministic seed data for resurf sites.
+
+This package is imported by both the site backend (FastAPI) and the resurf SDK so that:
+- There is exactly one source of truth for the data schema
+- `success_fn` predicates in tasks can read backend state via the same models the site writes
+- Seeded fixtures are byte-for-byte reproducible across the SDK and the site
+
+Each site has its own subpackage (e.g. `resurf_models.shop_v1`).

resurf_models-0.1.0/README.md

@@ -0,0 +1,10 @@
+# resurf-models
+
+Shared SQLModel schema and deterministic seed data for resurf sites.
+
+This package is imported by both the site backend (FastAPI) and the resurf SDK so that:
+- There is exactly one source of truth for the data schema
+- `success_fn` predicates in tasks can read backend state via the same models the site writes
+- Seeded fixtures are byte-for-byte reproducible across the SDK and the site
+
+Each site has its own subpackage (e.g. `resurf_models.shop_v1`).

resurf_models-0.1.0/pyproject.toml

@@ -0,0 +1,30 @@
+# SPDX-License-Identifier: Apache-2.0
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "resurf-models"
+version = "0.1.0"
+description = "Shared SQLModel schema and seed logic for resurf sites"
+readme = "README.md"
+requires-python = ">=3.11"
+license = { text = "Apache-2.0" }
+authors = [{ name = "The resurf contributors" }]
+keywords = ["resurf", "ai", "agents", "evaluation"]
+classifiers = [
+    "License :: OSI Approved :: Apache Software License",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+]
+dependencies = [
+    "sqlmodel>=0.0.16",
+    "pydantic>=2.6",
+    "faker>=24.0",
+]
+
+[project.optional-dependencies]
+dev = ["pytest>=8.0"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["resurf_models"]

resurf_models-0.1.0/resurf_models/__init__.py

@@ -0,0 +1,4 @@
+# SPDX-License-Identifier: Apache-2.0
+"""Shared SQLModel schema and seed logic for resurf sites."""
+
+__version__ = "0.1.0"

resurf_models-0.1.0/resurf_models/shop_v1/__init__.py

@@ -0,0 +1,38 @@
+# SPDX-License-Identifier: Apache-2.0
+"""shop_v1 schema and seed logic."""
+
+from .models import (
+    Address,
+    Cart,
+    CartItem,
+    Category,
+    Coupon,
+    EventLog,
+    Order,
+    OrderItem,
+    PaymentAttempt,
+    Product,
+    Return,
+    Session,
+    User,
+)
+from .seed import seed_database
+from .state import StateReader
+
+__all__ = [
+    "Address",
+    "Cart",
+    "CartItem",
+    "Category",
+    "Coupon",
+    "EventLog",
+    "Order",
+    "OrderItem",
+    "PaymentAttempt",
+    "Product",
+    "Return",
+    "Session",
+    "StateReader",
+    "User",
+    "seed_database",
+]

resurf_models-0.1.0/resurf_models/shop_v1/models.py

@@ -0,0 +1,179 @@
+# SPDX-License-Identifier: Apache-2.0
+"""SQLModel schema for shop_v1.
+
+This module is the single source of truth for shop_v1's data shape. The site
+backend writes to it; the resurf SDK reads from it for success_fn
+predicates. Keep field semantics stable across versions where possible.
+"""
+
+from __future__ import annotations
+
+from datetime import datetime
+
+from sqlmodel import Field, SQLModel
+
+# ---------------------------------------------------------------------------
+# Catalog
+# ---------------------------------------------------------------------------
+
+
+class Category(SQLModel, table=True):
+    id: int | None = Field(default=None, primary_key=True)
+    slug: str = Field(unique=True, index=True)
+    name: str
+    description: str = ""
+
+
+class Product(SQLModel, table=True):
+    id: int | None = Field(default=None, primary_key=True)
+    slug: str = Field(unique=True, index=True)
+    name: str = Field(index=True)
+    description: str
+    short_description: str
+    price_cents: int
+    currency: str = "USD"
+    stock: int = 0
+    image_url: str
+    category_id: int = Field(foreign_key="category.id", index=True)
+    rating: float = 0.0
+    rating_count: int = 0
+    tags: str = ""  # comma-separated for cheap filtering
+
+
+# ---------------------------------------------------------------------------
+# Users / sessions
+# ---------------------------------------------------------------------------
+
+
+class User(SQLModel, table=True):
+    id: int | None = Field(default=None, primary_key=True)
+    email: str = Field(unique=True, index=True)
+    password_hash: str
+    full_name: str
+    created_at: datetime = Field(default_factory=datetime.utcnow)
+
+
+class Address(SQLModel, table=True):
+    id: int | None = Field(default=None, primary_key=True)
+    user_id: int = Field(foreign_key="user.id", index=True)
+    label: str = "home"
+    full_name: str
+    line1: str
+    line2: str = ""
+    city: str
+    state: str
+    postal_code: str
+    country: str = "US"
+    is_default: bool = False
+
+
+class Session(SQLModel, table=True):
+    id: int | None = Field(default=None, primary_key=True)
+    token: str = Field(unique=True, index=True)
+    user_id: int | None = Field(default=None, foreign_key="user.id", index=True)
+    csrf_token: str
+    created_at: datetime = Field(default_factory=datetime.utcnow)
+    expires_at: datetime
+
+
+# ---------------------------------------------------------------------------
+# Cart
+# ---------------------------------------------------------------------------
+
+
+class Cart(SQLModel, table=True):
+    id: int | None = Field(default=None, primary_key=True)
+    session_token: str = Field(unique=True, index=True)
+    user_id: int | None = Field(default=None, foreign_key="user.id", index=True)
+    coupon_code: str | None = None
+    cart_coupon_attempt: str | None = None  # last code typed in *cart-side* input (does not apply)
+    updated_at: datetime = Field(default_factory=datetime.utcnow)
+
+
+class CartItem(SQLModel, table=True):
+    id: int | None = Field(default=None, primary_key=True)
+    cart_id: int = Field(foreign_key="cart.id", index=True)
+    product_id: int = Field(foreign_key="product.id", index=True)
+    quantity: int
+
+
+# ---------------------------------------------------------------------------
+# Coupons
+# ---------------------------------------------------------------------------
+
+
+class Coupon(SQLModel, table=True):
+    id: int | None = Field(default=None, primary_key=True)
+    code: str = Field(unique=True, index=True)
+    description: str
+    percent_off: int = 0  # 0-100
+    flat_off_cents: int = 0
+    min_subtotal_cents: int = 0
+    expires_at: datetime | None = None
+    active: bool = True
+
+
+# ---------------------------------------------------------------------------
+# Orders
+# ---------------------------------------------------------------------------
+
+
+class Order(SQLModel, table=True):
+    id: int | None = Field(default=None, primary_key=True)
+    user_id: int = Field(foreign_key="user.id", index=True)
+    shipping_address_id: int = Field(foreign_key="address.id")
+    coupon_code: str | None = None
+    subtotal_cents: int
+    discount_cents: int = 0
+    tax_cents: int = 0
+    shipping_cents: int = 0
+    total_cents: int
+    status: str = "pending"  # pending | paid | failed | cancelled | refunded
+    payment_attempts: int = 0
+    last_payment_error: str | None = None
+    created_at: datetime = Field(default_factory=datetime.utcnow)
+    paid_at: datetime | None = None
+
+
+class OrderItem(SQLModel, table=True):
+    id: int | None = Field(default=None, primary_key=True)
+    order_id: int = Field(foreign_key="order.id", index=True)
+    product_id: int = Field(foreign_key="product.id")
+    product_name: str  # snapshot
+    unit_price_cents: int
+    quantity: int
+
+
+class PaymentAttempt(SQLModel, table=True):
+    id: int | None = Field(default=None, primary_key=True)
+    order_id: int = Field(foreign_key="order.id", index=True)
+    card_last4: str
+    outcome: str  # success | declined | timeout | 3ds_required
+    error_code: str | None = None
+    created_at: datetime = Field(default_factory=datetime.utcnow)
+
+
+class Return(SQLModel, table=True):
+    id: int | None = Field(default=None, primary_key=True)
+    order_id: int = Field(foreign_key="order.id", index=True)
+    user_id: int = Field(foreign_key="user.id", index=True)
+    reason: str
+    status: str = "requested"  # requested | approved | rejected | refunded
+    created_at: datetime = Field(default_factory=datetime.utcnow)
+
+
+class EventLog(SQLModel, table=True):
+    """Generic append-only event log so navigation/interaction tasks can be SQL-checkable.
+
+    Examples:
+        type='product_view', detail='{"slug": "acme-bluetooth-speaker"}'
+        type='search', detail='{"q": "speaker"}'
+        type='cart_open', detail='{"path": "/cart"}'
+    """
+
+    id: int | None = Field(default=None, primary_key=True)
+    session_token: str | None = Field(default=None, index=True)
+    user_id: int | None = Field(default=None, foreign_key="user.id", index=True)
+    type: str = Field(index=True)
+    detail: str = ""  # JSON-encoded
+    created_at: datetime = Field(default_factory=datetime.utcnow)

resurf_models-0.1.0/resurf_models/shop_v1/seed.py

@@ -0,0 +1,263 @@
+# SPDX-License-Identifier: Apache-2.0
+"""Deterministic seed data for shop_v1.
+
+A given seed integer produces byte-for-byte identical data. This is the
+foundation of reproducibility: tasks reference seeded objects by name/slug
+and success_fn predicates run against a known initial state.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import random
+from datetime import datetime
+
+from faker import Faker
+from sqlmodel import Session as DBSession
+from sqlmodel import SQLModel, create_engine, select
+
+from .models import (
+    Address,
+    Category,
+    Coupon,
+    Product,
+    User,
+)
+
+# Hand-curated category list so seeds are stable and tasks are easy to write.
+CATEGORIES = [
+    ("audio", "Audio", "Headphones, speakers, and earbuds."),
+    ("wearables", "Wearables", "Smartwatches and fitness trackers."),
+    ("home", "Home", "Smart home, lighting, and small appliances."),
+    ("fragrance", "Fragrance", "Perfumes, colognes, and home scents."),
+    ("apparel", "Apparel", "Tops, bottoms, and accessories."),
+    ("outdoors", "Outdoors", "Bags, bottles, and gear."),
+]
+
+# A small set of hand-picked anchor products that tasks reference by name.
+# These are guaranteed to exist in every seed and have predictable attributes.
+ANCHOR_PRODUCTS = [
+    {
+        "slug": "acme-bluetooth-speaker",
+        "name": "Acme Bluetooth Speaker",
+        "category": "audio",
+        "price_cents": 7999,
+        "stock": 25,
+        "tags": "bluetooth,portable,wireless",
+        "rating": 4.5,
+        "rating_count": 312,
+    },
+    {
+        "slug": "acme-pro-headphones",
+        "name": "Acme Pro Headphones",
+        "category": "audio",
+        "price_cents": 24999,
+        "stock": 12,
+        "tags": "noise-cancelling,wireless,over-ear",
+        "rating": 4.7,
+        "rating_count": 856,
+    },
+    {
+        "slug": "lumen-smart-bulb",
+        "name": "Lumen Smart Bulb",
+        "category": "home",
+        "price_cents": 1499,
+        "stock": 0,  # deliberately out of stock
+        "tags": "smart-home,led,wifi",
+        "rating": 4.2,
+        "rating_count": 198,
+    },
+    {
+        "slug": "trailmate-water-bottle",
+        "name": "TrailMate Water Bottle",
+        "category": "outdoors",
+        "price_cents": 2999,
+        "stock": 80,
+        "tags": "stainless,insulated,outdoor",
+        "rating": 4.6,
+        "rating_count": 421,
+    },
+    {
+        "slug": "northwood-pulse-watch",
+        "name": "Northwood Pulse Watch",
+        "category": "wearables",
+        "price_cents": 19999,
+        "stock": 8,
+        "tags": "smartwatch,fitness,heart-rate",
+        "rating": 4.4,
+        "rating_count": 267,
+    },
+    {
+        "slug": "saffron-no-7-eau-de-parfum",
+        "name": "Saffron No.7 Eau de Parfum",
+        "category": "fragrance",
+        "price_cents": 8999,
+        "stock": 30,
+        "tags": "unisex,floral,50ml",
+        "rating": 4.3,
+        "rating_count": 144,
+    },
+    {
+        "slug": "saffron-no-7-travel-spray",
+        "name": "Saffron No.7 Travel Spray",
+        "category": "fragrance",
+        "price_cents": 3499,
+        "stock": 50,
+        "tags": "unisex,floral,10ml",
+        "rating": 4.1,
+        "rating_count": 88,
+    },
+]
+
+# Coupons that tasks reference by name. SUMMER15 is the canonical example.
+COUPONS = [
+    {
+        "code": "SUMMER15",
+        "description": "15% off your order",
+        "percent_off": 15,
+        "min_subtotal_cents": 0,
+    },
+    {
+        "code": "WELCOME10",
+        "description": "$10 off orders over $50",
+        "percent_off": 0,
+        "flat_off_cents": 1000,
+        "min_subtotal_cents": 5000,
+    },
+    {
+        "code": "FRAGRANCE20",
+        "description": "20% off fragrance",
+        "percent_off": 20,
+        "min_subtotal_cents": 0,
+    },
+    {
+        "code": "EXPIRED5",
+        "description": "Expired test coupon",
+        "percent_off": 5,
+        "expires_at": datetime(2020, 1, 1),
+        "active": False,
+    },
+]
+
+
+def _password_hash(plaintext: str) -> str:
+    # Trivial hash for synthetic data. The site backend uses argon2 for real
+    # password verification; this just gives us a stable hash in the seed file.
+    return "test$" + hashlib.sha256(plaintext.encode()).hexdigest()
+
+
+def seed_database(database_url: str, seed: int = 42) -> None:
+    """Wipe and reseed the database. Idempotent for a given seed integer."""
+    engine = create_engine(database_url)
+    SQLModel.metadata.drop_all(engine)
+    SQLModel.metadata.create_all(engine)
+
+    fake = Faker()
+    Faker.seed(seed)
+    rng = random.Random(seed)
+
+    with DBSession(engine) as db:
+        # Categories
+        cats: dict[str, Category] = {}
+        for slug, name, desc in CATEGORIES:
+            c = Category(slug=slug, name=name, description=desc)
+            db.add(c)
+            cats[slug] = c
+        db.flush()
+
+        # Anchor products
+        for ap in ANCHOR_PRODUCTS:
+            p = Product(
+                slug=ap["slug"],
+                name=ap["name"],
+                description=fake.paragraph(nb_sentences=4),
+                short_description=fake.sentence(nb_words=12),
+                price_cents=ap["price_cents"],
+                stock=ap["stock"],
+                image_url=f"/static/products/{ap['slug']}.jpg",
+                category_id=cats[ap["category"]].id,  # type: ignore[arg-type]
+                rating=ap["rating"],
+                rating_count=ap["rating_count"],
+                tags=ap["tags"],
+            )
+            db.add(p)
+
+        # Filler products so the catalog is realistic-feeling, not 7 items.
+        for _ in range(60):
+            cat_slug = rng.choice(list(cats.keys()))
+            name = fake.unique.catch_phrase()[:48]
+            slug = name.lower().replace(" ", "-").replace("/", "-").replace(",", "")[:64]
+            db.add(
+                Product(
+                    slug=slug,
+                    name=name,
+                    description=fake.paragraph(nb_sentences=3),
+                    short_description=fake.sentence(nb_words=10),
+                    price_cents=rng.randint(999, 49999),
+                    stock=rng.randint(0, 100),
+                    image_url=f"/static/products/placeholder-{rng.randint(1, 12)}.jpg",
+                    category_id=cats[cat_slug].id,  # type: ignore[arg-type]
+                    rating=round(rng.uniform(3.0, 5.0), 1),
+                    rating_count=rng.randint(0, 1500),
+                    tags=",".join(fake.words(nb=3, unique=True)),
+                )
+            )
+
+        # Coupons
+        for c in COUPONS:
+            db.add(Coupon(**c))
+
+        # The seeded test user
+        user = User(
+            email="alex@example.com",
+            password_hash=_password_hash("password123"),
+            full_name="Alex Doe",
+            created_at=datetime(2025, 1, 1),
+        )
+        db.add(user)
+        db.flush()
+
+        # Default address
+        db.add(
+            Address(
+                user_id=user.id,  # type: ignore[arg-type]
+                label="home",
+                full_name="Alex Doe",
+                line1="100 Test Street",
+                city="San Francisco",
+                state="CA",
+                postal_code="94110",
+                country="US",
+                is_default=True,
+            )
+        )
+        # A second address so "saved address" tasks have something to disambiguate
+        db.add(
+            Address(
+                user_id=user.id,  # type: ignore[arg-type]
+                label="work",
+                full_name="Alex Doe",
+                line1="500 Market Street",
+                line2="Floor 14",
+                city="San Francisco",
+                state="CA",
+                postal_code="94105",
+                country="US",
+                is_default=False,
+            )
+        )
+
+        db.commit()
+
+
+def seeded_user_id(database_url: str) -> int:
+    """Convenience helper: returns the id of the seeded test user."""
+    engine = create_engine(database_url)
+    with DBSession(engine) as db:
+        u = db.exec(select(User).where(User.email == "alex@example.com")).first()
+        if u is None or u.id is None:
+            raise RuntimeError("Seeded user not found; run seed_database first.")
+        return u.id
+
+
+__all__ = ["ANCHOR_PRODUCTS", "CATEGORIES", "COUPONS", "seed_database", "seeded_user_id"]

resurf_models-0.1.0/resurf_models/shop_v1/state.py

@@ -0,0 +1,133 @@
+# SPDX-License-Identifier: Apache-2.0
+"""State reader for shop_v1 success_fn predicates.
+
+The resurf SDK uses StateReader to evaluate task success against the
+backend SQLite file directly, bypassing the HTTP layer. This is what makes
+deterministic eval possible: no flaky DOM scraping for "did the order go
+through?", just a SQL query against shared models.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from sqlalchemy import text
+from sqlmodel import Session as DBSession
+from sqlmodel import create_engine, select
+
+from .models import (
+    Address,
+    Cart,
+    CartItem,
+    Coupon,
+    Order,
+    OrderItem,
+    PaymentAttempt,
+    Product,
+    Return,
+    User,
+)
+from .seed import seeded_user_id
+
+
+class StateReader:
+    """Read-only view of the shop_v1 database for success predicates."""
+
+    def __init__(self, database_url: str) -> None:
+        self.database_url = database_url
+        self._engine = create_engine(database_url)
+
+    # ------------------------------------------------------------------
+    # Generic helpers used by YAML state_predicate tasks
+    # ------------------------------------------------------------------
+
+    def query_scalar(self, sql: str, **bindings: Any) -> Any:
+        """Run a raw SQL query and return the first column of the first row."""
+        with self._engine.connect() as conn:
+            row = conn.execute(text(sql), bindings).first()
+            if row is None:
+                return None
+            return row[0]
+
+    def query_rows(self, sql: str, **bindings: Any) -> list[dict[str, Any]]:
+        """Run a raw SQL query and return all rows as dicts."""
+        with self._engine.connect() as conn:
+            result = conn.execute(text(sql), bindings)
+            return [dict(row._mapping) for row in result]
+
+    def default_bindings(self) -> dict[str, Any]:
+        """Useful named parameters that tasks can reference (e.g. :seeded_user_id)."""
+        return {"seeded_user_id": seeded_user_id(self.database_url)}
+
+    # ------------------------------------------------------------------
+    # Typed accessors used by Python escape-hatch success_fn implementations
+    # ------------------------------------------------------------------
+
+    def orders_for_seeded_user(self, status: str | None = None) -> list[Order]:
+        with DBSession(self._engine) as db:
+            stmt = select(Order).where(Order.user_id == seeded_user_id(self.database_url))
+            if status is not None:
+                stmt = stmt.where(Order.status == status)
+            return list(db.exec(stmt).all())
+
+    def latest_order_for_seeded_user(self) -> Order | None:
+        with DBSession(self._engine) as db:
+            stmt = (
+                select(Order)
+                .where(Order.user_id == seeded_user_id(self.database_url))
+                .order_by(Order.created_at.desc())  # type: ignore[attr-defined]
+            )
+            return db.exec(stmt).first()
+
+    def order_items(self, order_id: int) -> list[OrderItem]:
+        with DBSession(self._engine) as db:
+            return list(db.exec(select(OrderItem).where(OrderItem.order_id == order_id)).all())
+
+    def payment_attempts(self, order_id: int) -> list[PaymentAttempt]:
+        with DBSession(self._engine) as db:
+            return list(
+                db.exec(select(PaymentAttempt).where(PaymentAttempt.order_id == order_id)).all()
+            )
+
+    def product_by_name(self, name: str) -> Product | None:
+        with DBSession(self._engine) as db:
+            return db.exec(select(Product).where(Product.name == name)).first()
+
+    def product_by_slug(self, slug: str) -> Product | None:
+        with DBSession(self._engine) as db:
+            return db.exec(select(Product).where(Product.slug == slug)).first()
+
+    def coupon(self, code: str) -> Coupon | None:
+        with DBSession(self._engine) as db:
+            return db.exec(select(Coupon).where(Coupon.code == code)).first()
+
+    def cart_for_session(self, session_token: str) -> Cart | None:
+        with DBSession(self._engine) as db:
+            return db.exec(select(Cart).where(Cart.session_token == session_token)).first()
+
+    def cart_items(self, cart_id: int) -> list[CartItem]:
+        with DBSession(self._engine) as db:
+            return list(db.exec(select(CartItem).where(CartItem.cart_id == cart_id)).all())
+
+    def returns_for_seeded_user(self) -> list[Return]:
+        with DBSession(self._engine) as db:
+            return list(
+                db.exec(
+                    select(Return).where(Return.user_id == seeded_user_id(self.database_url))
+                ).all()
+            )
+
+    def addresses_for_seeded_user(self) -> list[Address]:
+        with DBSession(self._engine) as db:
+            return list(
+                db.exec(
+                    select(Address).where(Address.user_id == seeded_user_id(self.database_url))
+                ).all()
+            )
+
+    def all_users(self) -> list[User]:
+        with DBSession(self._engine) as db:
+            return list(db.exec(select(User)).all())
+
+
+__all__ = ["StateReader"]

resurf_models-0.1.0/tests/test_seed.py

@@ -0,0 +1,82 @@
+# SPDX-License-Identifier: Apache-2.0
+"""Tests for shop_v1 seed determinism and schema."""
+
+from __future__ import annotations
+
+import os
+import tempfile
+
+from resurf_models.shop_v1 import StateReader, seed_database
+from resurf_models.shop_v1.models import Coupon, Product, User
+from sqlmodel import Session as DBSession
+from sqlmodel import create_engine, select
+
+
+def _fresh_db() -> str:
+    fd, path = tempfile.mkstemp(suffix=".sqlite")
+    os.close(fd)
+    return f"sqlite:///{path}"
+
+
+def test_seed_creates_anchor_products():
+    url = _fresh_db()
+    seed_database(url, seed=42)
+    engine = create_engine(url)
+    with DBSession(engine) as db:
+        slugs = {p.slug for p in db.exec(select(Product)).all()}
+    assert "acme-bluetooth-speaker" in slugs
+    assert "lumen-smart-bulb" in slugs
+    assert "trailmate-water-bottle" in slugs
+
+
+def test_seed_is_deterministic():
+    url1 = _fresh_db()
+    url2 = _fresh_db()
+    seed_database(url1, seed=42)
+    seed_database(url2, seed=42)
+    e1 = create_engine(url1)
+    e2 = create_engine(url2)
+    with DBSession(e1) as db1, DBSession(e2) as db2:
+        prods1 = sorted(p.slug for p in db1.exec(select(Product)).all())
+        prods2 = sorted(p.slug for p in db2.exec(select(Product)).all())
+    assert prods1 == prods2
+
+
+def test_seeded_user_exists():
+    url = _fresh_db()
+    seed_database(url, seed=42)
+    engine = create_engine(url)
+    with DBSession(engine) as db:
+        u = db.exec(select(User).where(User.email == "alex@example.com")).first()
+    assert u is not None
+    assert u.full_name == "Alex Doe"
+
+
+def test_state_reader_orders_for_user():
+    url = _fresh_db()
+    seed_database(url, seed=42)
+    sr = StateReader(url)
+    orders = sr.orders_for_seeded_user()
+    # Fresh seed => no orders yet
+    assert orders == []
+
+
+def test_lumen_is_out_of_stock():
+    url = _fresh_db()
+    seed_database(url, seed=42)
+    engine = create_engine(url)
+    with DBSession(engine) as db:
+        p = db.exec(select(Product).where(Product.slug == "lumen-smart-bulb")).first()
+    assert p is not None
+    assert p.stock == 0
+
+
+def test_summer15_coupon_active():
+    url = _fresh_db()
+    seed_database(url, seed=42)
+    engine = create_engine(url)
+    with DBSession(engine) as db:
+        c = db.exec(select(Coupon).where(Coupon.code == "SUMMER15")).first()
+    assert c is not None
+    assert c.percent_off == 15
+    assert c.active is True