feat(e2e): add comprehensive E2E testing infrastructure

- Add e2e-keel HTTP app with SQLite testing endpoints
- Implement automated test orchestration with e2e-run script
- Add query parameter support for flexible user creation
- Include smoke test workflow with build → run → test → shutdown
- Update documentation with E2E testing instructions
- Mark SQL Spin SQLite adapter as complete in roadmap

The E2E app provides HTTP endpoints for setup, user management, and
transaction testing against SQLite. The automated script handles the
full lifecycle including background app startup, readiness checks,
and cleanup. This enables comprehensive behavioral testing of the
SQL adapter implementation.

Author: marclove

.gitignore

@@ -43,3 +43,4 @@ BRAINSTORMING.md
 
 *.db
 apps/**/.spin/logs/
+/apps/e2e-keel/.spin

CLAUDE.md

@@ -105,3 +105,8 @@ Notes for code changes:
 - Keep changes minimal and focused on requested scopes.
 - Align with WIT contracts and layer boundaries.
 - Prefer adding tasks to `justfile` for repeatable workflows.
+
+## Component Status (Phase 2)
+- `components/infrastructure/sql-spin-sqlite`: implements `sql.wit` using Spin SQLite (query/execute/transactions).
+- `apps/e2e-keel`: runnable HTTP app for behavioral E2E testing against SQLite.
+- Spin capabilities are configured in component manifests; prefer `Connection::open_default()` with a declared `default` binding.

README.md

@@ -48,6 +48,13 @@ just transpile
 just test              # workspace tests (unit + BDD)
 # or target a single crate
 just test-crate sql-sqlite
+
+# E2E app (HTTP): build and run
+just spin-build apps/e2e-keel
+just spin-up apps/e2e-keel
+
+# Smoke tests against the running E2E app
+just e2e-smoke
 ```
 
 ## Spin Quickstart
@@ -156,7 +163,7 @@ These options provide much of the desired operational functionality out of the b
 - ✅ Project structure and WIT interfaces  
 - ✅ BDD testing framework
 - ✅ Spin Framework integration foundation
-- 🚧 SQL Spin SQLite adapter implementation
+- ✅ SQL Spin SQLite adapter (query/execute/transactions)
 - 🚧 Complete infrastructure component suite
 
 **Phase 3 (Platform Services)** - Next: Spin-native platform services (observability, security, rate-limiting)
@@ -188,6 +195,13 @@ Spin helpers:
 - spin-cloud-login: Authenticate with Fermyon Cloud.
 - spin-cloud-deploy [dir='.']: Deploy a Spin app to Fermyon Cloud.
 
+E2E helpers:
+- e2e-smoke: Runs setup, creates two users, lists users, then tests commit/rollback
+- e2e-setup / e2e-user / e2e-users / e2e-txn-commit / e2e-txn-rollback: Individual endpoints
+
+E2E app location:
+- apps/e2e-keel (HTTP routes exercising SQLite flows)
+
 ## Community
 
 - **GitHub Issues**: [Report bugs, request features, ask questions](https://github.com/marclove/keel/issues)

apps/e2e-keel/Cargo.toml

@@ -13,4 +13,4 @@ serde = { workspace = true }
 serde_json = { workspace = true }
 spin-sdk = "3"
 tracing = { workspace = true }
-
+urlencoding = "2"

apps/e2e-keel/spin.toml

@@ -18,6 +18,12 @@ allowed_outbound_hosts = []
 sqlite_databases = ["default"]
 environment = { SPIN_SQLITE_DB_default = "sqlite:dev.db" }
 
+# spin-test integration is paused pending alignment on WIT versions
+# [component.e2e-api.tool.spin-test]
+# source = "tests-rs/target/wasm32-wasip1/release/wasm_test.wasm"
+# build = "(cargo component --version >/dev/null 2>&1 || cargo install cargo-component --locked) && cargo component build --release --target-dir=target"
+# workdir = "tests-rs"
+
 [component.e2e-api.build]
 command = "cargo build --target wasm32-wasip2 --release"
 watch = ["src/**/*.rs", "Cargo.toml"]

apps/e2e-keel/src/lib.rs

@@ -1,6 +1,7 @@
 use anyhow::Result;
 use serde::{Deserialize, Serialize};
 use spin_sdk::{http::{Method, Request, Response}, http_component, sqlite::{Connection, Value}};
+use urlencoding::decode;
 
 #[derive(Serialize, Deserialize)]
 struct ApiResponse<T> {
@@ -14,11 +15,13 @@ fn handle_e2e(req: Request) -> Result<Response> {
     let path = req.path_and_query().unwrap_or("/");
     let method = req.method();
     match (method, path) {
-        (m, "/setup") if *m == Method::Post => setup(),
+        // Allow GET for setup/txn for spin-test convenience
+        (m, "/setup") if *m == Method::Post || *m == Method::Get => setup(),
         (m, "/users") if *m == Method::Post => create_user(req),
         (m, "/users") if *m == Method::Get => list_users(),
-        (m, "/txn/commit") if *m == Method::Post => txn_commit(),
-        (m, "/txn/rollback") if *m == Method::Post => txn_rollback(),
+        (m, "/test/users-add") if *m == Method::Get => users_add_via_query(req),
+        (m, "/txn/commit") if *m == Method::Post || *m == Method::Get => txn_commit(),
+        (m, "/txn/rollback") if *m == Method::Post || *m == Method::Get => txn_rollback(),
         _ => json(404, &ApiResponse::<()> { ok: false, data: None, error: Some("not found".into()) }),
     }
 }
@@ -71,6 +74,37 @@ fn list_users() -> Result<Response> {
     json(200, &ApiResponse { ok: true, data: Some(users), error: None })
 }
 
+fn users_add_via_query(req: Request) -> Result<Response> {
+    let db = Connection::open_default()?;
+    let qs = req.path_and_query().unwrap_or("");
+    let mut name: Option<String> = None;
+    let mut email: Option<String> = None;
+    if let Some(idx) = qs.find('?') {
+        let q = &qs[idx+1..];
+        for pair in q.split('&') {
+            let mut it = pair.splitn(2, '=');
+            if let (Some(k), Some(v)) = (it.next(), it.next()) {
+                let v = decode(v).unwrap_or_default().to_string();
+                match k {
+                    "name" => name = Some(v),
+                    "email" => email = Some(v),
+                    _ => {}
+                }
+            }
+        }
+    }
+    match (name, email) {
+        (Some(n), Some(e)) => {
+            db.execute(
+                "INSERT INTO users (name, email) VALUES (?, ?)",
+                &[Value::Text(n), Value::Text(e)],
+            )?;
+            json(200, &ApiResponse::<()> { ok: true, data: None, error: None })
+        }
+        _ => json(400, &ApiResponse::<()> { ok: false, data: None, error: Some("missing name or email".into()) })
+    }
+}
+
 fn txn_commit() -> Result<Response> {
     let db = Connection::open_default()?;
     db.execute("DELETE FROM accounts", &[])?;

justfile

@@ -204,6 +204,10 @@ e2e-txn-commit:
 e2e-txn-rollback:
     curl -fsS -X POST "{{ e2e_url }}/txn/rollback"
 
+# Orchestrate build → run → smoke test → shutdown, propagating exit code
+e2e-run:
+    E2E_URL={{ e2e_url }} bash scripts/e2e-run.sh
+
 # Create a new Spin app from a template
 
 # Usage: just spin-new http-rust my-app

scripts/e2e-run.sh

@@ -0,0 +1,52 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Base URL for the app; default to Spin's default if not provided
+E2E_URL="${E2E_URL:-http://127.0.0.1:3000}"
+
+APP_DIR="apps/e2e-keel"
+LOG_DIR="$APP_DIR/.spin"
+PID_FILE="$LOG_DIR/e2e-run.pid"
+LOG_FILE="$LOG_DIR/e2e-run.log"
+
+echo "[e2e-run] Building app..."
+just spin-build "$APP_DIR"
+
+echo "[e2e-run] Starting app in background (logging to $LOG_FILE)..."
+mkdir -p "$LOG_DIR"
+(
+  cd "$APP_DIR"
+  spin up > ".spin/e2e-run.log" 2>&1 & echo $! > ".spin/e2e-run.pid"
+)
+PID="$(cat "$APP_DIR/.spin/e2e-run.pid")"
+cleanup() {
+  if kill -0 "$PID" >/dev/null 2>&1; then
+    echo "[e2e-run] Stopping app (pid $PID)"
+    kill "$PID" || true
+    # Give Spin a moment to shutdown
+    sleep 0.5 || true
+  fi
+}
+trap cleanup EXIT
+
+echo "[e2e-run] Waiting for readiness at $E2E_URL/users ..."
+ready=0
+for i in $(seq 1 60); do
+  if curl -fsS "$E2E_URL/users" >/dev/null 2>&1; then ready=1; break; fi
+  sleep 0.25
+done
+
+if [ "$ready" -ne 1 ]; then
+  echo "[e2e-run] App did not become ready. Recent log:"
+  tail -n 100 "$APP_DIR/.spin/e2e-run.log" || true
+  exit 1
+fi
+
+echo "[e2e-run] Running smoke tests..."
+if just e2e-smoke; then
+  rc=0
+else
+  rc=$?
+fi
+
+exit "$rc"