Update WIT definitions, add tests & CI infra

.github/workflows/python-ci.yml

@@ -0,0 +1,39 @@
+name: Python CI
+
+on:
+ push:
+ branches:
+ - main
+ pull_request:
+ branches:
+ - main
+
+jobs:
+ build:
+ runs-on: ubuntu-latest
+ steps:
+ - uses: actions/checkout@v4
+ - name: Set Up Rust Toolchain
+ uses: actions-rust-lang/setup-rust-toolchain@v1
+ with:
+ toolchain: '1.86.0'
+ - name: Set up Python
+ uses: actions/setup-python@v5
+ with:
+ python-version: '3.12'
+ - name: Install uv
+ run: pip install uv
+ - name: Install dependencies
+ run: uv sync
+ - name: Install viceroy
+ run: cargo install --git https://github.com/fastly/Viceroy.git --branch sunfishcode/sync-wit viceroy
+ - name: Build WebAssembly component
+ run: make app.wasm
+ - name: Install dependencies
+ run: uv sync --extra dev --extra test
+ - name: Check formatting
+ run: make format-check
+ - name: Run linting
+ run: make lint
+ - name: Run tests
+ run: make test

.gitignore

@@ -3,6 +3,6 @@
 *.egg-info
 uv.lock
 
-/hello_compute/
+/stubs/
 __pycache__
 app.wasm

Makefile

@@ -1,11 +1,28 @@
 all: app.wasm
 
+STUBS_DIR := stubs
+
 app.wasm: wit/viceroy.wit wit/deps/fastly/compute.wit app.py
-	rm -rf hello_compute
-	uv run componentize-py -d wit -w compute bindings hello_compute
-	uv run componentize-py -d wit -w compute componentize --stub-wasi app -o app.wasm
+	rm -rf ${STUBS_DIR}
+	uv run componentize-py -d wit -w viceroy bindings ${STUBS_DIR}
+	uv run componentize-py -d wit -w viceroy componentize app -o app.wasm
 
 serve: app.wasm
-	viceroy --adapt app.wasm
+	viceroy serve app.wasm
+
+test: app.wasm
+	uv run --extra test pytest
+
+lint:
+	uv run --extra dev ruff check .
+
+lint-fix:
+	uv run --extra dev ruff check --fix .
+
+format:
+	uv run --extra dev ruff format .
+
+format-check:
+	uv run --extra dev ruff format --check .
 
-.PHONY: all serve
+.PHONY: all serve test lint format format-check

README.md

@@ -21,13 +21,6 @@ Currently, this demonstrates…
  native-code compression stdlibs which haven't been compiled against WASI yet.
  Moving componentize-py to a new Python may help, as [WASIp1 is now a Tier 2
  supported platform](https://peps.python.org/pep-0011/#tier-2).
-* It crashes every time something tries to write to stdout or stderr. It may be
- that those aren't in the preopens; adding those to the preopens should be
- possible with changes to Viceroy. We're also using `--stub-wasi` at the
- moment, which means things like `fd_write` are coded to immediately trap; that
- probably doesn't help. Finally, it may be possible to monkeypatch in Python
- and redirect them to a logging endpoint, but our initial attempts were
- unsuccessful.
 
 # Install Dependencies
 
@@ -40,7 +33,33 @@ Currently, this demonstrates…
 # Build and Run
 
 1. `make serve`
-2. Visit http://127.0.0.1:7676/hello/fred in a browser.
+2. Visit http://127.0.0.1:7676/hello/world or http://127.0.0.1:7676/info in a browser.
 
 You are seeing Bottle, a simple Python web framework, run on a Fastly Compute
 worker!
+
+# Testing
+
+```bash
+# Install dependencies and run tests
+uv sync --extra dev --extra test
+make test
+```
+
+The tests automatically build the WebAssembly component, start viceroy, and verify all endpoints work correctly with the WIT APIs.
+
+# Development
+
+```bash
+# Format code
+make format
+
+# Check formatting
+make format-check
+
+# Run linting
+make lint
+
+# Run linting and apply automatic fixes
+make lint-fix
+```

app.py

@@ -1,52 +1,49 @@
+import sys
 from urllib.parse import urlparse
 
-import art
-import bottle
-from bottle import template, Bottle
-
-from wit_world.exports import Reactor as BaseReactor
-from wit_world.imports import log, http_req, http_resp, http_body
+from bottle import Bottle
+from wit_world.exports import HttpIncoming as BaseHttpIncoming
+from wit_world.imports import compute_runtime, http_body, http_resp
 from wit_world.imports.http_resp import send_downstream
 
-
 # Enable a bit more debug logging from the framework.
-bottle.debug(True)
-
 app = Bottle()
-app.catchall = False # bottle backtrace causes issues; use our own.
 
 
 @app.route("/hello/<name>")
-def index(name):
- return template("Hello <pre>{{name}}</pre>", name=art.text2art(name))
+def hello(name):
+ return f"Hello {name}!"
 
 
-def print(*args):
- # hack to allow print locally; so far, monkeypatching
- # sys.stdout/sys.stderr hasn't panned out, so more
- # research required.
- log.write(log_ep, " ".join(args).encode())
+@app.route("/info")
+def info():
+ """Return JSON with request information we can test against"""
+ from bottle import request
 
+ # Get some runtime info we can test
+ vcpu_time = compute_runtime.get_vcpu_ms()
 
-def init():
- global log_ep
- log_ep = log.endpoint_get("")
+ return {
+ "service": "fastly-compute-python",
+ "status": "ok",
+ "message": "Hello from Fastly Compute!",
+ "vcpu_time_ms": vcpu_time,
+ "request_method": request.environ.get("REQUEST_METHOD"),
+ "path_info": request.environ.get("PATH_INFO"),
+ }
 
-class StdErr:
- """File-like object to receive errors and direct them to our logging endpoint"""
-
- def write(self, data: str):
- print(f"wsgi-error: {data}")
 
- def flush(self):
- pass
+@app.route("/error")
+def error():
+ """Endpoint that intentionally raises an exception to test error handling."""
+ raise RuntimeError("This is an intentional error for testing purposes")
 
 
 def serve_wsgi_request(req, body, app):
  """Pass a WSGI application a single request, and adapt its behavior back
  to the Fastly API."""
 
- response = http_resp.new()
+ response = http_resp.Response.new()
  response_body = http_body.new()
 
  def write(body_data: bytes):
@@ -56,56 +53,27 @@ def write(body_data: bytes):
 
  def start_response(status: str, headers: list[tuple], exc_info=None):
  code, _description = status.split(" ", 1)
-http_resp.status_set(response, int(code))
+response.set_status(int(code))
  for header, value in headers:
-http_resp.header_append(response, header.encode(), value.encode())
+ response.append_header(header, value.encode())
  return write
 
- url = urlparse(http_req.uri_get(req, 2048))
+ url = urlparse(req.get_uri(2048))
  environ = {
- "REQUEST_METHOD": http_req.method_get(req, 12),
+ "REQUEST_METHOD": req.get_method(12),
  "PATH_INFO": url.path,
  "QUERY_STRING": url.query,
  "SERVER_NAME": url.hostname,
  "SERVER_PORT": str(url.port),
- "wsgi.errors": StdErr(),
+ "wsgi.errors": sys.stderr,
  }
  for body_chunk in app(environ, start_response):
  # TODO: this would be a good place to stream, but for now we just
  # write to the buffer and send once the handler is done.
  write(body_chunk)
- send_downstream(response, response_body, False)
-
-
-class Reactor(BaseReactor):
- def serve(self, req: int, body: int) -> None:
- init()
- try:
- serve_wsgi_request(req, body, app)
- except Exception as e:
- log_exception(e)
-
-
-def log_exception(e):
- """Pretty-print an exception to our logging endpoint.
-
- Do it without callling format_exc(), which calls stat() to determine whether
- we're in a tty and what its width is. stat() and other fd routines currently
- crash when they try to access stdout or stderr, probably because they are
- not in the preopens.
- """
- try:
- print(f"Exception {type(e).__name__} - {e}")
- print("--- Traceback Follows ---")
-
- current_tb = e.__traceback__
- while current_tb:
- frame = current_tb.tb_frame
- print(
- f" File: {frame.f_code.co_filename}, "
- f"Function: {frame.f_code.co_name}, "
- f"Line: {frame.f_lineno}"
- )
- current_tb = current_tb.tb_next
- except Exception as e2:
- print(f"print_exc failed {e2}")
+ send_downstream(response, response_body)
+
+
+class HttpIncoming(BaseHttpIncoming):
+ def handle(self, request, body):
+ serve_wsgi_request(request, body, app)

fastly_compute/__init__.py

@@ -0,0 +1,7 @@
+"""Fastly Compute SDK for Python.
+
+This package provides a Python SDK for building Fastly Compute services.
+"""
+
+# Testing utilities are available but not imported by default
+# Users can import them explicitly: from fastly_compute.testing import ViceroyTestBase

fastly_compute/pytest_plugin.py

@@ -0,0 +1,31 @@
+"""Pytest plugin for automatic viceroy output on test failures."""
+
+import sys
+
+import pytest
+
+
+@pytest.hookimpl(tryfirst=True, hookwrapper=True)
+def pytest_runtest_makereport(item, call):
+ """Hook to display viceroy output on test failure.
+
+ This hook automatically displays recent viceroy server output
+ when any test fails, making debugging easier.
+ """
+ outcome = yield
+ rep = outcome.get_result()
+
+ # Only show output on test failures during the call phase
+ if rep.when == "call" and rep.failed:
+ # Try to get the viceroy_server fixture from the test
+ if hasattr(item, "funcargs") and "viceroy_server" in item.funcargs:
+ server = item.funcargs["viceroy_server"]
+ if hasattr(server, "output_lines"):
+ print(
+ f"\n=== Viceroy output for failed test: {item.name} ===",
+ file=sys.stderr,
+ )
+ # Show last 15 lines of output
+ for line in server.output_lines[-15:]:
+ print(f" {line}", file=sys.stderr)
+ print("=== End viceroy output ===", file=sys.stderr)

.github/workflows/python-ci.yml

@@ -0,0 +1,39 @@
+name: Python CI
+
+on:
+ push:
+ branches:
+ - main
+ pull_request:
+ branches:
+ - main
+
+jobs:
+ build:
+ runs-on: ubuntu-latest
+ steps:
+ - uses: actions/checkout@v4
+ - name: Set Up Rust Toolchain
+ uses: actions-rust-lang/setup-rust-toolchain@v1
+ with:
+ toolchain: '1.86.0'
+ - name: Set up Python
+ uses: actions/setup-python@v5
+ with:
+ python-version: '3.12'
+ - name: Install uv
+ run: pip install uv
+ - name: Install dependencies
+ run: uv sync
+ - name: Install viceroy
+ run: cargo install --git https://github.com/fastly/Viceroy.git --branch sunfishcode/sync-wit viceroy
+ - name: Build WebAssembly component
+ run: make app.wasm
+ - name: Install dependencies
+ run: uv sync --extra dev --extra test
+ - name: Check formatting
+ run: make format-check
+ - name: Run linting
+ run: make lint
+ - name: Run tests
+ run: make test

.gitignore

@@ -3,6 +3,6 @@
 *.egg-info
 uv.lock
 
-/hello_compute/
+/stubs/
 __pycache__
 app.wasm

Makefile

@@ -1,11 +1,28 @@
 all: app.wasm
 
+STUBS_DIR := stubs
+
 app.wasm: wit/viceroy.wit wit/deps/fastly/compute.wit app.py
-	rm -rf hello_compute
-	uv run componentize-py -d wit -w compute bindings hello_compute
-	uv run componentize-py -d wit -w compute componentize --stub-wasi app -o app.wasm
+	rm -rf ${STUBS_DIR}
+	uv run componentize-py -d wit -w viceroy bindings ${STUBS_DIR}
+	uv run componentize-py -d wit -w viceroy componentize app -o app.wasm
 
 serve: app.wasm
-	viceroy --adapt app.wasm
+	viceroy serve app.wasm
+
+test: app.wasm
+	uv run --extra test pytest
+
+lint:
+	uv run --extra dev ruff check .
+
+lint-fix:
+	uv run --extra dev ruff check --fix .
+
+format:
+	uv run --extra dev ruff format .
+
+format-check:
+	uv run --extra dev ruff format --check .
 
-.PHONY: all serve
+.PHONY: all serve test lint format format-check

README.md

@@ -21,13 +21,6 @@ Currently, this demonstrates…
  native-code compression stdlibs which haven't been compiled against WASI yet.
  Moving componentize-py to a new Python may help, as [WASIp1 is now a Tier 2
  supported platform](https://peps.python.org/pep-0011/#tier-2).
-* It crashes every time something tries to write to stdout or stderr. It may be
- that those aren't in the preopens; adding those to the preopens should be
- possible with changes to Viceroy. We're also using `--stub-wasi` at the
- moment, which means things like `fd_write` are coded to immediately trap; that
- probably doesn't help. Finally, it may be possible to monkeypatch in Python
- and redirect them to a logging endpoint, but our initial attempts were
- unsuccessful.
 
 # Install Dependencies
 
@@ -40,7 +33,33 @@ Currently, this demonstrates…
 # Build and Run
 
 1. `make serve`
-2. Visit http://127.0.0.1:7676/hello/fred in a browser.
+2. Visit http://127.0.0.1:7676/hello/world or http://127.0.0.1:7676/info in a browser.
 
 You are seeing Bottle, a simple Python web framework, run on a Fastly Compute
 worker!
+
+# Testing
+
+```bash
+# Install dependencies and run tests
+uv sync --extra dev --extra test
+make test
+```
+
+The tests automatically build the WebAssembly component, start viceroy, and verify all endpoints work correctly with the WIT APIs.
+
+# Development
+
+```bash
+# Format code
+make format
+
+# Check formatting
+make format-check
+
+# Run linting
+make lint
+
+# Run linting and apply automatic fixes
+make lint-fix
+```

app.py

@@ -1,52 +1,49 @@
+import sys
 from urllib.parse import urlparse
 
-import art
-import bottle
-from bottle import template, Bottle
-
-from wit_world.exports import Reactor as BaseReactor
-from wit_world.imports import log, http_req, http_resp, http_body
+from bottle import Bottle
+from wit_world.exports import HttpIncoming as BaseHttpIncoming
+from wit_world.imports import compute_runtime, http_body, http_resp
 from wit_world.imports.http_resp import send_downstream
 
-
 # Enable a bit more debug logging from the framework.
-bottle.debug(True)
-
 app = Bottle()
-app.catchall = False # bottle backtrace causes issues; use our own.
 
 
 @app.route("/hello/<name>")
-def index(name):
- return template("Hello <pre>{{name}}</pre>", name=art.text2art(name))
+def hello(name):
+ return f"Hello {name}!"
 
 
-def print(*args):
- # hack to allow print locally; so far, monkeypatching
- # sys.stdout/sys.stderr hasn't panned out, so more
- # research required.
- log.write(log_ep, " ".join(args).encode())
+@app.route("/info")
+def info():
+ """Return JSON with request information we can test against"""
+ from bottle import request
 
+ # Get some runtime info we can test
+ vcpu_time = compute_runtime.get_vcpu_ms()
 
-def init():
- global log_ep
- log_ep = log.endpoint_get("")
+ return {
+ "service": "fastly-compute-python",
+ "status": "ok",
+ "message": "Hello from Fastly Compute!",
+ "vcpu_time_ms": vcpu_time,
+ "request_method": request.environ.get("REQUEST_METHOD"),
+ "path_info": request.environ.get("PATH_INFO"),
+ }
 
-class StdErr:
- """File-like object to receive errors and direct them to our logging endpoint"""
-
- def write(self, data: str):
- print(f"wsgi-error: {data}")
 
- def flush(self):
- pass
+@app.route("/error")
+def error():
+ """Endpoint that intentionally raises an exception to test error handling."""
+ raise RuntimeError("This is an intentional error for testing purposes")
 
 
 def serve_wsgi_request(req, body, app):
  """Pass a WSGI application a single request, and adapt its behavior back
  to the Fastly API."""
 
- response = http_resp.new()
+ response = http_resp.Response.new()
  response_body = http_body.new()
 
  def write(body_data: bytes):
@@ -56,56 +53,27 @@ def write(body_data: bytes):
 
  def start_response(status: str, headers: list[tuple], exc_info=None):
  code, _description = status.split(" ", 1)
-http_resp.status_set(response, int(code))
+response.set_status(int(code))
  for header, value in headers:
-http_resp.header_append(response, header.encode(), value.encode())
+ response.append_header(header, value.encode())
  return write
 
- url = urlparse(http_req.uri_get(req, 2048))
+ url = urlparse(req.get_uri(2048))
  environ = {
- "REQUEST_METHOD": http_req.method_get(req, 12),
+ "REQUEST_METHOD": req.get_method(12),
  "PATH_INFO": url.path,
  "QUERY_STRING": url.query,
  "SERVER_NAME": url.hostname,
  "SERVER_PORT": str(url.port),
- "wsgi.errors": StdErr(),
+ "wsgi.errors": sys.stderr,
  }
  for body_chunk in app(environ, start_response):
  # TODO: this would be a good place to stream, but for now we just
  # write to the buffer and send once the handler is done.
  write(body_chunk)
- send_downstream(response, response_body, False)
-
-
-class Reactor(BaseReactor):
- def serve(self, req: int, body: int) -> None:
- init()
- try:
- serve_wsgi_request(req, body, app)
- except Exception as e:
- log_exception(e)
-
-
-def log_exception(e):
- """Pretty-print an exception to our logging endpoint.
-
- Do it without callling format_exc(), which calls stat() to determine whether
- we're in a tty and what its width is. stat() and other fd routines currently
- crash when they try to access stdout or stderr, probably because they are
- not in the preopens.
- """
- try:
- print(f"Exception {type(e).__name__} - {e}")
- print("--- Traceback Follows ---")
-
- current_tb = e.__traceback__
- while current_tb:
- frame = current_tb.tb_frame
- print(
- f" File: {frame.f_code.co_filename}, "
- f"Function: {frame.f_code.co_name}, "
- f"Line: {frame.f_lineno}"
- )
- current_tb = current_tb.tb_next
- except Exception as e2:
- print(f"print_exc failed {e2}")
+ send_downstream(response, response_body)
+
+
+class HttpIncoming(BaseHttpIncoming):
+ def handle(self, request, body):
+ serve_wsgi_request(request, body, app)

fastly_compute/__init__.py

@@ -0,0 +1,7 @@
+"""Fastly Compute SDK for Python.
+
+This package provides a Python SDK for building Fastly Compute services.
+"""
+
+# Testing utilities are available but not imported by default
+# Users can import them explicitly: from fastly_compute.testing import ViceroyTestBase

fastly_compute/pytest_plugin.py

@@ -0,0 +1,31 @@
+"""Pytest plugin for automatic viceroy output on test failures."""
+
+import sys
+
+import pytest
+
+
+@pytest.hookimpl(tryfirst=True, hookwrapper=True)
+def pytest_runtest_makereport(item, call):
+ """Hook to display viceroy output on test failure.
+
+ This hook automatically displays recent viceroy server output
+ when any test fails, making debugging easier.
+ """
+ outcome = yield
+ rep = outcome.get_result()
+
+ # Only show output on test failures during the call phase
+ if rep.when == "call" and rep.failed:
+ # Try to get the viceroy_server fixture from the test
+ if hasattr(item, "funcargs") and "viceroy_server" in item.funcargs:
+ server = item.funcargs["viceroy_server"]
+ if hasattr(server, "output_lines"):
+ print(
+ f"\n=== Viceroy output for failed test: {item.name} ===",
+ file=sys.stderr,
+ )
+ # Show last 15 lines of output
+ for line in server.output_lines[-15:]:
+ print(f" {line}", file=sys.stderr)
+ print("=== End viceroy output ===", file=sys.stderr)

.github/workflows/python-ci.yml

@@ -0,0 +1,39 @@
+name: Python CI
+
+on:
+ push:
+ branches:
+ - main
+ pull_request:
+ branches:
+ - main
+
+jobs:
+ build:
+ runs-on: ubuntu-latest
+ steps:
+ - uses: actions/checkout@v4
+ - name: Set Up Rust Toolchain
+ uses: actions-rust-lang/setup-rust-toolchain@v1
+ with:
+ toolchain: '1.86.0'
+ - name: Set up Python
+ uses: actions/setup-python@v5
+ with:
+ python-version: '3.12'
+ - name: Install uv
+ run: pip install uv
+ - name: Install dependencies
+ run: uv sync
+ - name: Install viceroy
+ run: cargo install --git https://github.com/fastly/Viceroy.git --branch sunfishcode/sync-wit viceroy
+ - name: Build WebAssembly component
+ run: make app.wasm
+ - name: Install dependencies
+ run: uv sync --extra dev --extra test
+ - name: Check formatting
+ run: make format-check
+ - name: Run linting
+ run: make lint
+ - name: Run tests
+ run: make test

.gitignore

@@ -3,6 +3,6 @@
 *.egg-info
 uv.lock
 
-/hello_compute/
+/stubs/
 __pycache__
 app.wasm

Makefile

@@ -1,11 +1,28 @@
 all: app.wasm
 
+STUBS_DIR := stubs
+
 app.wasm: wit/viceroy.wit wit/deps/fastly/compute.wit app.py
-	rm -rf hello_compute
-	uv run componentize-py -d wit -w compute bindings hello_compute
-	uv run componentize-py -d wit -w compute componentize --stub-wasi app -o app.wasm
+	rm -rf ${STUBS_DIR}
+	uv run componentize-py -d wit -w viceroy bindings ${STUBS_DIR}
+	uv run componentize-py -d wit -w viceroy componentize app -o app.wasm
 
 serve: app.wasm
-	viceroy --adapt app.wasm
+	viceroy serve app.wasm
+
+test: app.wasm
+	uv run --extra test pytest
+
+lint:
+	uv run --extra dev ruff check .
+
+lint-fix:
+	uv run --extra dev ruff check --fix .
+
+format:
+	uv run --extra dev ruff format .
+
+format-check:
+	uv run --extra dev ruff format --check .
 
-.PHONY: all serve
+.PHONY: all serve test lint format format-check

README.md

@@ -21,13 +21,6 @@ Currently, this demonstrates…
  native-code compression stdlibs which haven't been compiled against WASI yet.
  Moving componentize-py to a new Python may help, as [WASIp1 is now a Tier 2
  supported platform](https://peps.python.org/pep-0011/#tier-2).
-* It crashes every time something tries to write to stdout or stderr. It may be
- that those aren't in the preopens; adding those to the preopens should be
- possible with changes to Viceroy. We're also using `--stub-wasi` at the
- moment, which means things like `fd_write` are coded to immediately trap; that
- probably doesn't help. Finally, it may be possible to monkeypatch in Python
- and redirect them to a logging endpoint, but our initial attempts were
- unsuccessful.
 
 # Install Dependencies
 
@@ -40,7 +33,33 @@ Currently, this demonstrates…
 # Build and Run
 
 1. `make serve`
-2. Visit http://127.0.0.1:7676/hello/fred in a browser.
+2. Visit http://127.0.0.1:7676/hello/world or http://127.0.0.1:7676/info in a browser.
 
 You are seeing Bottle, a simple Python web framework, run on a Fastly Compute
 worker!
+
+# Testing
+
+```bash
+# Install dependencies and run tests
+uv sync --extra dev --extra test
+make test
+```
+
+The tests automatically build the WebAssembly component, start viceroy, and verify all endpoints work correctly with the WIT APIs.
+
+# Development
+
+```bash
+# Format code
+make format
+
+# Check formatting
+make format-check
+
+# Run linting
+make lint
+
+# Run linting and apply automatic fixes
+make lint-fix
+```

app.py

@@ -1,52 +1,49 @@
+import sys
 from urllib.parse import urlparse
 
-import art
-import bottle
-from bottle import template, Bottle
-
-from wit_world.exports import Reactor as BaseReactor
-from wit_world.imports import log, http_req, http_resp, http_body
+from bottle import Bottle
+from wit_world.exports import HttpIncoming as BaseHttpIncoming
+from wit_world.imports import compute_runtime, http_body, http_resp
 from wit_world.imports.http_resp import send_downstream
 
-
 # Enable a bit more debug logging from the framework.
-bottle.debug(True)
-
 app = Bottle()
-app.catchall = False # bottle backtrace causes issues; use our own.
 
 
 @app.route("/hello/<name>")
-def index(name):
- return template("Hello <pre>{{name}}</pre>", name=art.text2art(name))
+def hello(name):
+ return f"Hello {name}!"
 
 
-def print(*args):
- # hack to allow print locally; so far, monkeypatching
- # sys.stdout/sys.stderr hasn't panned out, so more
- # research required.
- log.write(log_ep, " ".join(args).encode())
+@app.route("/info")
+def info():
+ """Return JSON with request information we can test against"""
+ from bottle import request
 
+ # Get some runtime info we can test
+ vcpu_time = compute_runtime.get_vcpu_ms()
 
-def init():
- global log_ep
- log_ep = log.endpoint_get("")
+ return {
+ "service": "fastly-compute-python",
+ "status": "ok",
+ "message": "Hello from Fastly Compute!",
+ "vcpu_time_ms": vcpu_time,
+ "request_method": request.environ.get("REQUEST_METHOD"),
+ "path_info": request.environ.get("PATH_INFO"),
+ }
 
-class StdErr:
- """File-like object to receive errors and direct them to our logging endpoint"""
-
- def write(self, data: str):
- print(f"wsgi-error: {data}")
 
- def flush(self):
- pass
+@app.route("/error")
+def error():
+ """Endpoint that intentionally raises an exception to test error handling."""
+ raise RuntimeError("This is an intentional error for testing purposes")
 
 
 def serve_wsgi_request(req, body, app):
  """Pass a WSGI application a single request, and adapt its behavior back
  to the Fastly API."""
 
- response = http_resp.new()
+ response = http_resp.Response.new()
  response_body = http_body.new()
 
  def write(body_data: bytes):
@@ -56,56 +53,27 @@ def write(body_data: bytes):
 
  def start_response(status: str, headers: list[tuple], exc_info=None):
  code, _description = status.split(" ", 1)
-http_resp.status_set(response, int(code))
+response.set_status(int(code))
  for header, value in headers:
-http_resp.header_append(response, header.encode(), value.encode())
+ response.append_header(header, value.encode())
  return write
 
- url = urlparse(http_req.uri_get(req, 2048))
+ url = urlparse(req.get_uri(2048))
  environ = {
- "REQUEST_METHOD": http_req.method_get(req, 12),
+ "REQUEST_METHOD": req.get_method(12),
  "PATH_INFO": url.path,
  "QUERY_STRING": url.query,
  "SERVER_NAME": url.hostname,
  "SERVER_PORT": str(url.port),
- "wsgi.errors": StdErr(),
+ "wsgi.errors": sys.stderr,
  }
  for body_chunk in app(environ, start_response):
  # TODO: this would be a good place to stream, but for now we just
  # write to the buffer and send once the handler is done.
  write(body_chunk)
- send_downstream(response, response_body, False)
-
-
-class Reactor(BaseReactor):
- def serve(self, req: int, body: int) -> None:
- init()
- try:
- serve_wsgi_request(req, body, app)
- except Exception as e:
- log_exception(e)
-
-
-def log_exception(e):
- """Pretty-print an exception to our logging endpoint.
-
- Do it without callling format_exc(), which calls stat() to determine whether
- we're in a tty and what its width is. stat() and other fd routines currently
- crash when they try to access stdout or stderr, probably because they are
- not in the preopens.
- """
- try:
- print(f"Exception {type(e).__name__} - {e}")
- print("--- Traceback Follows ---")
-
- current_tb = e.__traceback__
- while current_tb:
- frame = current_tb.tb_frame
- print(
- f" File: {frame.f_code.co_filename}, "
- f"Function: {frame.f_code.co_name}, "
- f"Line: {frame.f_lineno}"
- )
- current_tb = current_tb.tb_next
- except Exception as e2:
- print(f"print_exc failed {e2}")
+ send_downstream(response, response_body)
+
+
+class HttpIncoming(BaseHttpIncoming):
+ def handle(self, request, body):
+ serve_wsgi_request(request, body, app)

fastly_compute/__init__.py

@@ -0,0 +1,7 @@
+"""Fastly Compute SDK for Python.
+
+This package provides a Python SDK for building Fastly Compute services.
+"""
+
+# Testing utilities are available but not imported by default
+# Users can import them explicitly: from fastly_compute.testing import ViceroyTestBase

fastly_compute/pytest_plugin.py

@@ -0,0 +1,31 @@
+"""Pytest plugin for automatic viceroy output on test failures."""
+
+import sys
+
+import pytest
+
+
+@pytest.hookimpl(tryfirst=True, hookwrapper=True)
+def pytest_runtest_makereport(item, call):
+ """Hook to display viceroy output on test failure.
+
+ This hook automatically displays recent viceroy server output
+ when any test fails, making debugging easier.
+ """
+ outcome = yield
+ rep = outcome.get_result()
+
+ # Only show output on test failures during the call phase
+ if rep.when == "call" and rep.failed:
+ # Try to get the viceroy_server fixture from the test
+ if hasattr(item, "funcargs") and "viceroy_server" in item.funcargs:
+ server = item.funcargs["viceroy_server"]
+ if hasattr(server, "output_lines"):
+ print(
+ f"\n=== Viceroy output for failed test: {item.name} ===",
+ file=sys.stderr,
+ )
+ # Show last 15 lines of output
+ for line in server.output_lines[-15:]:
+ print(f" {line}", file=sys.stderr)
+ print("=== End viceroy output ===", file=sys.stderr)

.github/workflows/python-ci.yml

@@ -0,0 +1,39 @@
+name: Python CI
+
+on:
+ push:
+ branches:
+ - main
+ pull_request:
+ branches:
+ - main
+
+jobs:
+ build:
+ runs-on: ubuntu-latest
+ steps:
+ - uses: actions/checkout@v4
+ - name: Set Up Rust Toolchain
+ uses: actions-rust-lang/setup-rust-toolchain@v1
+ with:
+ toolchain: '1.86.0'
+ - name: Set up Python
+ uses: actions/setup-python@v5
+ with:
+ python-version: '3.12'
+ - name: Install uv
+ run: pip install uv
+ - name: Install dependencies
+ run: uv sync
+ - name: Install viceroy
+ run: cargo install --git https://github.com/fastly/Viceroy.git --branch sunfishcode/sync-wit viceroy
+ - name: Build WebAssembly component
+ run: make app.wasm
+ - name: Install dependencies
+ run: uv sync --extra dev --extra test
+ - name: Check formatting
+ run: make format-check
+ - name: Run linting
+ run: make lint
+ - name: Run tests
+ run: make test

.gitignore

@@ -3,6 +3,6 @@
 *.egg-info
 uv.lock
 
-/hello_compute/
+/stubs/
 __pycache__
 app.wasm

Makefile

@@ -1,11 +1,28 @@
 all: app.wasm
 
+STUBS_DIR := stubs
+
 app.wasm: wit/viceroy.wit wit/deps/fastly/compute.wit app.py
-	rm -rf hello_compute
-	uv run componentize-py -d wit -w compute bindings hello_compute
-	uv run componentize-py -d wit -w compute componentize --stub-wasi app -o app.wasm
+	rm -rf ${STUBS_DIR}
+	uv run componentize-py -d wit -w viceroy bindings ${STUBS_DIR}
+	uv run componentize-py -d wit -w viceroy componentize app -o app.wasm
 
 serve: app.wasm
-	viceroy --adapt app.wasm
+	viceroy serve app.wasm
+
+test: app.wasm
+	uv run --extra test pytest
+
+lint:
+	uv run --extra dev ruff check .
+
+lint-fix:
+	uv run --extra dev ruff check --fix .
+
+format:
+	uv run --extra dev ruff format .
+
+format-check:
+	uv run --extra dev ruff format --check .
 
-.PHONY: all serve
+.PHONY: all serve test lint format format-check

README.md

@@ -21,13 +21,6 @@ Currently, this demonstrates…
  native-code compression stdlibs which haven't been compiled against WASI yet.
  Moving componentize-py to a new Python may help, as [WASIp1 is now a Tier 2
  supported platform](https://peps.python.org/pep-0011/#tier-2).
-* It crashes every time something tries to write to stdout or stderr. It may be
- that those aren't in the preopens; adding those to the preopens should be
- possible with changes to Viceroy. We're also using `--stub-wasi` at the
- moment, which means things like `fd_write` are coded to immediately trap; that
- probably doesn't help. Finally, it may be possible to monkeypatch in Python
- and redirect them to a logging endpoint, but our initial attempts were
- unsuccessful.
 
 # Install Dependencies
 
@@ -40,7 +33,33 @@ Currently, this demonstrates…
 # Build and Run
 
 1. `make serve`
-2. Visit http://127.0.0.1:7676/hello/fred in a browser.
+2. Visit http://127.0.0.1:7676/hello/world or http://127.0.0.1:7676/info in a browser.
 
 You are seeing Bottle, a simple Python web framework, run on a Fastly Compute
 worker!
+
+# Testing
+
+```bash
+# Install dependencies and run tests
+uv sync --extra dev --extra test
+make test
+```
+
+The tests automatically build the WebAssembly component, start viceroy, and verify all endpoints work correctly with the WIT APIs.
+
+# Development
+
+```bash
+# Format code
+make format
+
+# Check formatting
+make format-check
+
+# Run linting
+make lint
+
+# Run linting and apply automatic fixes
+make lint-fix
+```

app.py

@@ -1,52 +1,49 @@
+import sys
 from urllib.parse import urlparse
 
-import art
-import bottle
-from bottle import template, Bottle
-
-from wit_world.exports import Reactor as BaseReactor
-from wit_world.imports import log, http_req, http_resp, http_body
+from bottle import Bottle
+from wit_world.exports import HttpIncoming as BaseHttpIncoming
+from wit_world.imports import compute_runtime, http_body, http_resp
 from wit_world.imports.http_resp import send_downstream
 
-
 # Enable a bit more debug logging from the framework.
-bottle.debug(True)
-
 app = Bottle()
-app.catchall = False # bottle backtrace causes issues; use our own.
 
 
 @app.route("/hello/<name>")
-def index(name):
- return template("Hello <pre>{{name}}</pre>", name=art.text2art(name))
+def hello(name):
+ return f"Hello {name}!"
 
 
-def print(*args):
- # hack to allow print locally; so far, monkeypatching
- # sys.stdout/sys.stderr hasn't panned out, so more
- # research required.
- log.write(log_ep, " ".join(args).encode())
+@app.route("/info")
+def info():
+ """Return JSON with request information we can test against"""
+ from bottle import request
 
+ # Get some runtime info we can test
+ vcpu_time = compute_runtime.get_vcpu_ms()
 
-def init():
- global log_ep
- log_ep = log.endpoint_get("")
+ return {
+ "service": "fastly-compute-python",
+ "status": "ok",
+ "message": "Hello from Fastly Compute!",
+ "vcpu_time_ms": vcpu_time,
+ "request_method": request.environ.get("REQUEST_METHOD"),
+ "path_info": request.environ.get("PATH_INFO"),
+ }
 
-class StdErr:
- """File-like object to receive errors and direct them to our logging endpoint"""
-
- def write(self, data: str):
- print(f"wsgi-error: {data}")
 
- def flush(self):
- pass
+@app.route("/error")
+def error():
+ """Endpoint that intentionally raises an exception to test error handling."""
+ raise RuntimeError("This is an intentional error for testing purposes")
 
 
 def serve_wsgi_request(req, body, app):
  """Pass a WSGI application a single request, and adapt its behavior back
  to the Fastly API."""
 
- response = http_resp.new()
+ response = http_resp.Response.new()
  response_body = http_body.new()
 
  def write(body_data: bytes):
@@ -56,56 +53,27 @@ def write(body_data: bytes):
 
  def start_response(status: str, headers: list[tuple], exc_info=None):
  code, _description = status.split(" ", 1)
-http_resp.status_set(response, int(code))
+response.set_status(int(code))
  for header, value in headers:
-http_resp.header_append(response, header.encode(), value.encode())
+ response.append_header(header, value.encode())
  return write
 
- url = urlparse(http_req.uri_get(req, 2048))
+ url = urlparse(req.get_uri(2048))
  environ = {
- "REQUEST_METHOD": http_req.method_get(req, 12),
+ "REQUEST_METHOD": req.get_method(12),
  "PATH_INFO": url.path,
  "QUERY_STRING": url.query,
  "SERVER_NAME": url.hostname,
  "SERVER_PORT": str(url.port),
- "wsgi.errors": StdErr(),
+ "wsgi.errors": sys.stderr,
  }
  for body_chunk in app(environ, start_response):
  # TODO: this would be a good place to stream, but for now we just
  # write to the buffer and send once the handler is done.
  write(body_chunk)
- send_downstream(response, response_body, False)
-
-
-class Reactor(BaseReactor):
- def serve(self, req: int, body: int) -> None:
- init()
- try:
- serve_wsgi_request(req, body, app)
- except Exception as e:
- log_exception(e)
-
-
-def log_exception(e):
- """Pretty-print an exception to our logging endpoint.
-
- Do it without callling format_exc(), which calls stat() to determine whether
- we're in a tty and what its width is. stat() and other fd routines currently
- crash when they try to access stdout or stderr, probably because they are
- not in the preopens.
- """
- try:
- print(f"Exception {type(e).__name__} - {e}")
- print("--- Traceback Follows ---")
-
- current_tb = e.__traceback__
- while current_tb:
- frame = current_tb.tb_frame
- print(
- f" File: {frame.f_code.co_filename}, "
- f"Function: {frame.f_code.co_name}, "
- f"Line: {frame.f_lineno}"
- )
- current_tb = current_tb.tb_next
- except Exception as e2:
- print(f"print_exc failed {e2}")
+ send_downstream(response, response_body)
+
+
+class HttpIncoming(BaseHttpIncoming):
+ def handle(self, request, body):
+ serve_wsgi_request(request, body, app)

fastly_compute/__init__.py

@@ -0,0 +1,7 @@
+"""Fastly Compute SDK for Python.
+
+This package provides a Python SDK for building Fastly Compute services.
+"""
+
+# Testing utilities are available but not imported by default
+# Users can import them explicitly: from fastly_compute.testing import ViceroyTestBase

fastly_compute/pytest_plugin.py

@@ -0,0 +1,31 @@
+"""Pytest plugin for automatic viceroy output on test failures."""
+
+import sys
+
+import pytest
+
+
+@pytest.hookimpl(tryfirst=True, hookwrapper=True)
+def pytest_runtest_makereport(item, call):
+ """Hook to display viceroy output on test failure.
+
+ This hook automatically displays recent viceroy server output
+ when any test fails, making debugging easier.
+ """
+ outcome = yield
+ rep = outcome.get_result()
+
+ # Only show output on test failures during the call phase
+ if rep.when == "call" and rep.failed:
+ # Try to get the viceroy_server fixture from the test
+ if hasattr(item, "funcargs") and "viceroy_server" in item.funcargs:
+ server = item.funcargs["viceroy_server"]
+ if hasattr(server, "output_lines"):
+ print(
+ f"\n=== Viceroy output for failed test: {item.name} ===",
+ file=sys.stderr,
+ )
+ # Show last 15 lines of output
+ for line in server.output_lines[-15:]:
+ print(f" {line}", file=sys.stderr)
+ print("=== End viceroy output ===", file=sys.stderr)

.github/workflows/python-ci.yml

@@ -0,0 +1,39 @@
+name: Python CI
+
+on:
+ push:
+ branches:
+ - main
+ pull_request:
+ branches:
+ - main
+
+jobs:
+ build:
+ runs-on: ubuntu-latest
+ steps:
+ - uses: actions/checkout@v4
+ - name: Set Up Rust Toolchain
+ uses: actions-rust-lang/setup-rust-toolchain@v1
+ with:
+ toolchain: '1.86.0'
+ - name: Set up Python
+ uses: actions/setup-python@v5
+ with:
+ python-version: '3.12'
+ - name: Install uv
+ run: pip install uv
+ - name: Install dependencies
+ run: uv sync
+ - name: Install viceroy
+ run: cargo install --git https://github.com/fastly/Viceroy.git --branch sunfishcode/sync-wit viceroy
+ - name: Build WebAssembly component
+ run: make app.wasm
+ - name: Install dependencies
+ run: uv sync --extra dev --extra test
+ - name: Check formatting
+ run: make format-check
+ - name: Run linting
+ run: make lint
+ - name: Run tests
+ run: make test

.gitignore

@@ -3,6 +3,6 @@
 *.egg-info
 uv.lock
 
-/hello_compute/
+/stubs/
 __pycache__
 app.wasm

Makefile

@@ -1,11 +1,28 @@
 all: app.wasm
 
+STUBS_DIR := stubs
+
 app.wasm: wit/viceroy.wit wit/deps/fastly/compute.wit app.py
-	rm -rf hello_compute
-	uv run componentize-py -d wit -w compute bindings hello_compute
-	uv run componentize-py -d wit -w compute componentize --stub-wasi app -o app.wasm
+	rm -rf ${STUBS_DIR}
+	uv run componentize-py -d wit -w viceroy bindings ${STUBS_DIR}
+	uv run componentize-py -d wit -w viceroy componentize app -o app.wasm
 
 serve: app.wasm
-	viceroy --adapt app.wasm
+	viceroy serve app.wasm
+
+test: app.wasm
+	uv run --extra test pytest
+
+lint:
+	uv run --extra dev ruff check .
+
+lint-fix:
+	uv run --extra dev ruff check --fix .
+
+format:
+	uv run --extra dev ruff format .
+
+format-check:
+	uv run --extra dev ruff format --check .
 
-.PHONY: all serve
+.PHONY: all serve test lint format format-check

README.md

@@ -21,13 +21,6 @@ Currently, this demonstrates…
  native-code compression stdlibs which haven't been compiled against WASI yet.
  Moving componentize-py to a new Python may help, as [WASIp1 is now a Tier 2
  supported platform](https://peps.python.org/pep-0011/#tier-2).
-* It crashes every time something tries to write to stdout or stderr. It may be
- that those aren't in the preopens; adding those to the preopens should be
- possible with changes to Viceroy. We're also using `--stub-wasi` at the
- moment, which means things like `fd_write` are coded to immediately trap; that
- probably doesn't help. Finally, it may be possible to monkeypatch in Python
- and redirect them to a logging endpoint, but our initial attempts were
- unsuccessful.
 
 # Install Dependencies
 
@@ -40,7 +33,33 @@ Currently, this demonstrates…
 # Build and Run
 
 1. `make serve`
-2. Visit http://127.0.0.1:7676/hello/fred in a browser.
+2. Visit http://127.0.0.1:7676/hello/world or http://127.0.0.1:7676/info in a browser.
 
 You are seeing Bottle, a simple Python web framework, run on a Fastly Compute
 worker!
+
+# Testing
+
+```bash
+# Install dependencies and run tests
+uv sync --extra dev --extra test
+make test
+```
+
+The tests automatically build the WebAssembly component, start viceroy, and verify all endpoints work correctly with the WIT APIs.
+
+# Development
+
+```bash
+# Format code
+make format
+
+# Check formatting
+make format-check
+
+# Run linting
+make lint
+
+# Run linting and apply automatic fixes
+make lint-fix
+```

app.py

@@ -1,52 +1,49 @@
+import sys
 from urllib.parse import urlparse
 
-import art
-import bottle
-from bottle import template, Bottle
-
-from wit_world.exports import Reactor as BaseReactor
-from wit_world.imports import log, http_req, http_resp, http_body
+from bottle import Bottle
+from wit_world.exports import HttpIncoming as BaseHttpIncoming
+from wit_world.imports import compute_runtime, http_body, http_resp
 from wit_world.imports.http_resp import send_downstream
 
-
 # Enable a bit more debug logging from the framework.
-bottle.debug(True)
-
 app = Bottle()
-app.catchall = False # bottle backtrace causes issues; use our own.
 
 
 @app.route("/hello/<name>")
-def index(name):
- return template("Hello <pre>{{name}}</pre>", name=art.text2art(name))
+def hello(name):
+ return f"Hello {name}!"
 
 
-def print(*args):
- # hack to allow print locally; so far, monkeypatching
- # sys.stdout/sys.stderr hasn't panned out, so more
- # research required.
- log.write(log_ep, " ".join(args).encode())
+@app.route("/info")
+def info():
+ """Return JSON with request information we can test against"""
+ from bottle import request
 
+ # Get some runtime info we can test
+ vcpu_time = compute_runtime.get_vcpu_ms()
 
-def init():
- global log_ep
- log_ep = log.endpoint_get("")
+ return {
+ "service": "fastly-compute-python",
+ "status": "ok",
+ "message": "Hello from Fastly Compute!",
+ "vcpu_time_ms": vcpu_time,
+ "request_method": request.environ.get("REQUEST_METHOD"),
+ "path_info": request.environ.get("PATH_INFO"),
+ }
 
-class StdErr:
- """File-like object to receive errors and direct them to our logging endpoint"""
-
- def write(self, data: str):
- print(f"wsgi-error: {data}")
 
- def flush(self):
- pass
+@app.route("/error")
+def error():
+ """Endpoint that intentionally raises an exception to test error handling."""
+ raise RuntimeError("This is an intentional error for testing purposes")
 
 
 def serve_wsgi_request(req, body, app):
  """Pass a WSGI application a single request, and adapt its behavior back
  to the Fastly API."""
 
- response = http_resp.new()
+ response = http_resp.Response.new()
  response_body = http_body.new()
 
  def write(body_data: bytes):
@@ -56,56 +53,27 @@ def write(body_data: bytes):
 
  def start_response(status: str, headers: list[tuple], exc_info=None):
  code, _description = status.split(" ", 1)
-http_resp.status_set(response, int(code))
+response.set_status(int(code))
  for header, value in headers:
-http_resp.header_append(response, header.encode(), value.encode())
+ response.append_header(header, value.encode())
  return write
 
- url = urlparse(http_req.uri_get(req, 2048))
+ url = urlparse(req.get_uri(2048))
  environ = {
- "REQUEST_METHOD": http_req.method_get(req, 12),
+ "REQUEST_METHOD": req.get_method(12),
  "PATH_INFO": url.path,
  "QUERY_STRING": url.query,
  "SERVER_NAME": url.hostname,
  "SERVER_PORT": str(url.port),
- "wsgi.errors": StdErr(),
+ "wsgi.errors": sys.stderr,
  }
  for body_chunk in app(environ, start_response):
  # TODO: this would be a good place to stream, but for now we just
  # write to the buffer and send once the handler is done.
  write(body_chunk)
- send_downstream(response, response_body, False)
-
-
-class Reactor(BaseReactor):
- def serve(self, req: int, body: int) -> None:
- init()
- try:
- serve_wsgi_request(req, body, app)
- except Exception as e:
- log_exception(e)
-
-
-def log_exception(e):
- """Pretty-print an exception to our logging endpoint.
-
- Do it without callling format_exc(), which calls stat() to determine whether
- we're in a tty and what its width is. stat() and other fd routines currently
- crash when they try to access stdout or stderr, probably because they are
- not in the preopens.
- """
- try:
- print(f"Exception {type(e).__name__} - {e}")
- print("--- Traceback Follows ---")
-
- current_tb = e.__traceback__
- while current_tb:
- frame = current_tb.tb_frame
- print(
- f" File: {frame.f_code.co_filename}, "
- f"Function: {frame.f_code.co_name}, "
- f"Line: {frame.f_lineno}"
- )
- current_tb = current_tb.tb_next
- except Exception as e2:
- print(f"print_exc failed {e2}")
+ send_downstream(response, response_body)
+
+
+class HttpIncoming(BaseHttpIncoming):
+ def handle(self, request, body):
+ serve_wsgi_request(request, body, app)

fastly_compute/__init__.py

@@ -0,0 +1,7 @@
+"""Fastly Compute SDK for Python.
+
+This package provides a Python SDK for building Fastly Compute services.
+"""
+
+# Testing utilities are available but not imported by default
+# Users can import them explicitly: from fastly_compute.testing import ViceroyTestBase

fastly_compute/pytest_plugin.py

@@ -0,0 +1,31 @@
+"""Pytest plugin for automatic viceroy output on test failures."""
+
+import sys
+
+import pytest
+
+
+@pytest.hookimpl(tryfirst=True, hookwrapper=True)
+def pytest_runtest_makereport(item, call):
+ """Hook to display viceroy output on test failure.
+
+ This hook automatically displays recent viceroy server output
+ when any test fails, making debugging easier.
+ """
+ outcome = yield
+ rep = outcome.get_result()
+
+ # Only show output on test failures during the call phase
+ if rep.when == "call" and rep.failed:
+ # Try to get the viceroy_server fixture from the test
+ if hasattr(item, "funcargs") and "viceroy_server" in item.funcargs:
+ server = item.funcargs["viceroy_server"]
+ if hasattr(server, "output_lines"):
+ print(
+ f"\n=== Viceroy output for failed test: {item.name} ===",
+ file=sys.stderr,
+ )
+ # Show last 15 lines of output
+ for line in server.output_lines[-15:]:
+ print(f" {line}", file=sys.stderr)
+ print("=== End viceroy output ===", file=sys.stderr)

.github/workflows/python-ci.yml

@@ -0,0 +1,39 @@
+name: Python CI
+
+on:
+ push:
+ branches:
+ - main
+ pull_request:
+ branches:
+ - main
+
+jobs:
+ build:
+ runs-on: ubuntu-latest
+ steps:
+ - uses: actions/checkout@v4
+ - name: Set Up Rust Toolchain
+ uses: actions-rust-lang/setup-rust-toolchain@v1
+ with:
+ toolchain: '1.86.0'
+ - name: Set up Python
+ uses: actions/setup-python@v5
+ with:
+ python-version: '3.12'
+ - name: Install uv
+ run: pip install uv
+ - name: Install dependencies
+ run: uv sync
+ - name: Install viceroy
+ run: cargo install --git https://github.com/fastly/Viceroy.git --branch sunfishcode/sync-wit viceroy
+ - name: Build WebAssembly component
+ run: make app.wasm
+ - name: Install dependencies
+ run: uv sync --extra dev --extra test
+ - name: Check formatting
+ run: make format-check
+ - name: Run linting
+ run: make lint
+ - name: Run tests
+ run: make test

.gitignore

@@ -3,6 +3,6 @@
 *.egg-info
 uv.lock
 
-/hello_compute/
+/stubs/
 __pycache__
 app.wasm

Makefile

@@ -1,11 +1,28 @@
 all: app.wasm
 
+STUBS_DIR := stubs
+
 app.wasm: wit/viceroy.wit wit/deps/fastly/compute.wit app.py
-	rm -rf hello_compute
-	uv run componentize-py -d wit -w compute bindings hello_compute
-	uv run componentize-py -d wit -w compute componentize --stub-wasi app -o app.wasm
+	rm -rf ${STUBS_DIR}
+	uv run componentize-py -d wit -w viceroy bindings ${STUBS_DIR}
+	uv run componentize-py -d wit -w viceroy componentize app -o app.wasm
 
 serve: app.wasm
-	viceroy --adapt app.wasm
+	viceroy serve app.wasm
+
+test: app.wasm
+	uv run --extra test pytest
+
+lint:
+	uv run --extra dev ruff check .
+
+lint-fix:
+	uv run --extra dev ruff check --fix .
+
+format:
+	uv run --extra dev ruff format .
+
+format-check:
+	uv run --extra dev ruff format --check .
 
-.PHONY: all serve
+.PHONY: all serve test lint format format-check

README.md

@@ -21,13 +21,6 @@ Currently, this demonstrates…
  native-code compression stdlibs which haven't been compiled against WASI yet.
  Moving componentize-py to a new Python may help, as [WASIp1 is now a Tier 2
  supported platform](https://peps.python.org/pep-0011/#tier-2).
-* It crashes every time something tries to write to stdout or stderr. It may be
- that those aren't in the preopens; adding those to the preopens should be
- possible with changes to Viceroy. We're also using `--stub-wasi` at the
- moment, which means things like `fd_write` are coded to immediately trap; that
- probably doesn't help. Finally, it may be possible to monkeypatch in Python
- and redirect them to a logging endpoint, but our initial attempts were
- unsuccessful.
 
 # Install Dependencies
 
@@ -40,7 +33,33 @@ Currently, this demonstrates…
 # Build and Run
 
 1. `make serve`
-2. Visit http://127.0.0.1:7676/hello/fred in a browser.
+2. Visit http://127.0.0.1:7676/hello/world or http://127.0.0.1:7676/info in a browser.
 
 You are seeing Bottle, a simple Python web framework, run on a Fastly Compute
 worker!
+
+# Testing
+
+```bash
+# Install dependencies and run tests
+uv sync --extra dev --extra test
+make test
+```
+
+The tests automatically build the WebAssembly component, start viceroy, and verify all endpoints work correctly with the WIT APIs.
+
+# Development
+
+```bash
+# Format code
+make format
+
+# Check formatting
+make format-check
+
+# Run linting
+make lint
+
+# Run linting and apply automatic fixes
+make lint-fix
+```

app.py

@@ -1,52 +1,49 @@
+import sys
 from urllib.parse import urlparse
 
-import art
-import bottle
-from bottle import template, Bottle
-
-from wit_world.exports import Reactor as BaseReactor
-from wit_world.imports import log, http_req, http_resp, http_body
+from bottle import Bottle
+from wit_world.exports import HttpIncoming as BaseHttpIncoming
+from wit_world.imports import compute_runtime, http_body, http_resp
 from wit_world.imports.http_resp import send_downstream
 
-
 # Enable a bit more debug logging from the framework.
-bottle.debug(True)
-
 app = Bottle()
-app.catchall = False # bottle backtrace causes issues; use our own.
 
 
 @app.route("/hello/<name>")
-def index(name):
- return template("Hello <pre>{{name}}</pre>", name=art.text2art(name))
+def hello(name):
+ return f"Hello {name}!"
 
 
-def print(*args):
- # hack to allow print locally; so far, monkeypatching
- # sys.stdout/sys.stderr hasn't panned out, so more
- # research required.
- log.write(log_ep, " ".join(args).encode())
+@app.route("/info")
+def info():
+ """Return JSON with request information we can test against"""
+ from bottle import request
 
+ # Get some runtime info we can test
+ vcpu_time = compute_runtime.get_vcpu_ms()
 
-def init():
- global log_ep
- log_ep = log.endpoint_get("")
+ return {
+ "service": "fastly-compute-python",
+ "status": "ok",
+ "message": "Hello from Fastly Compute!",
+ "vcpu_time_ms": vcpu_time,
+ "request_method": request.environ.get("REQUEST_METHOD"),
+ "path_info": request.environ.get("PATH_INFO"),
+ }
 
-class StdErr:
- """File-like object to receive errors and direct them to our logging endpoint"""
-
- def write(self, data: str):
- print(f"wsgi-error: {data}")
 
- def flush(self):
- pass
+@app.route("/error")
+def error():
+ """Endpoint that intentionally raises an exception to test error handling."""
+ raise RuntimeError("This is an intentional error for testing purposes")
 
 
 def serve_wsgi_request(req, body, app):
  """Pass a WSGI application a single request, and adapt its behavior back
  to the Fastly API."""
 
- response = http_resp.new()
+ response = http_resp.Response.new()
  response_body = http_body.new()
 
  def write(body_data: bytes):
@@ -56,56 +53,27 @@ def write(body_data: bytes):
 
  def start_response(status: str, headers: list[tuple], exc_info=None):
  code, _description = status.split(" ", 1)
-http_resp.status_set(response, int(code))
+response.set_status(int(code))
  for header, value in headers:
-http_resp.header_append(response, header.encode(), value.encode())
+ response.append_header(header, value.encode())
  return write
 
- url = urlparse(http_req.uri_get(req, 2048))
+ url = urlparse(req.get_uri(2048))
  environ = {
- "REQUEST_METHOD": http_req.method_get(req, 12),
+ "REQUEST_METHOD": req.get_method(12),
  "PATH_INFO": url.path,
  "QUERY_STRING": url.query,
  "SERVER_NAME": url.hostname,
  "SERVER_PORT": str(url.port),
- "wsgi.errors": StdErr(),
+ "wsgi.errors": sys.stderr,
  }
  for body_chunk in app(environ, start_response):
  # TODO: this would be a good place to stream, but for now we just
  # write to the buffer and send once the handler is done.
  write(body_chunk)
- send_downstream(response, response_body, False)
-
-
-class Reactor(BaseReactor):
- def serve(self, req: int, body: int) -> None:
- init()
- try:
- serve_wsgi_request(req, body, app)
- except Exception as e:
- log_exception(e)
-
-
-def log_exception(e):
- """Pretty-print an exception to our logging endpoint.
-
- Do it without callling format_exc(), which calls stat() to determine whether
- we're in a tty and what its width is. stat() and other fd routines currently
- crash when they try to access stdout or stderr, probably because they are
- not in the preopens.
- """
- try:
- print(f"Exception {type(e).__name__} - {e}")
- print("--- Traceback Follows ---")
-
- current_tb = e.__traceback__
- while current_tb:
- frame = current_tb.tb_frame
- print(
- f" File: {frame.f_code.co_filename}, "
- f"Function: {frame.f_code.co_name}, "
- f"Line: {frame.f_lineno}"
- )
- current_tb = current_tb.tb_next
- except Exception as e2:
- print(f"print_exc failed {e2}")
+ send_downstream(response, response_body)
+
+
+class HttpIncoming(BaseHttpIncoming):
+ def handle(self, request, body):
+ serve_wsgi_request(request, body, app)

fastly_compute/__init__.py

@@ -0,0 +1,7 @@
+"""Fastly Compute SDK for Python.
+
+This package provides a Python SDK for building Fastly Compute services.
+"""
+
+# Testing utilities are available but not imported by default
+# Users can import them explicitly: from fastly_compute.testing import ViceroyTestBase

fastly_compute/pytest_plugin.py

@@ -0,0 +1,31 @@
+"""Pytest plugin for automatic viceroy output on test failures."""
+
+import sys
+
+import pytest
+
+
+@pytest.hookimpl(tryfirst=True, hookwrapper=True)
+def pytest_runtest_makereport(item, call):
+ """Hook to display viceroy output on test failure.
+
+ This hook automatically displays recent viceroy server output
+ when any test fails, making debugging easier.
+ """
+ outcome = yield
+ rep = outcome.get_result()
+
+ # Only show output on test failures during the call phase
+ if rep.when == "call" and rep.failed:
+ # Try to get the viceroy_server fixture from the test
+ if hasattr(item, "funcargs") and "viceroy_server" in item.funcargs:
+ server = item.funcargs["viceroy_server"]
+ if hasattr(server, "output_lines"):
+ print(
+ f"\n=== Viceroy output for failed test: {item.name} ===",
+ file=sys.stderr,
+ )
+ # Show last 15 lines of output
+ for line in server.output_lines[-15:]:
+ print(f" {line}", file=sys.stderr)
+ print("=== End viceroy output ===", file=sys.stderr)

.github/workflows/python-ci.yml

@@ -0,0 +1,39 @@
+name: Python CI
+
+on:
+ push:
+ branches:
+ - main
+ pull_request:
+ branches:
+ - main
+
+jobs:
+ build:
+ runs-on: ubuntu-latest
+ steps:
+ - uses: actions/checkout@v4
+ - name: Set Up Rust Toolchain
+ uses: actions-rust-lang/setup-rust-toolchain@v1
+ with:
+ toolchain: '1.86.0'
+ - name: Set up Python
+ uses: actions/setup-python@v5
+ with:
+ python-version: '3.12'
+ - name: Install uv
+ run: pip install uv
+ - name: Install dependencies
+ run: uv sync
+ - name: Install viceroy
+ run: cargo install --git https://github.com/fastly/Viceroy.git --branch sunfishcode/sync-wit viceroy
+ - name: Build WebAssembly component
+ run: make app.wasm
+ - name: Install dependencies
+ run: uv sync --extra dev --extra test
+ - name: Check formatting
+ run: make format-check
+ - name: Run linting
+ run: make lint
+ - name: Run tests
+ run: make test

.gitignore

@@ -3,6 +3,6 @@
 *.egg-info
 uv.lock
 
-/hello_compute/
+/stubs/
 __pycache__
 app.wasm

Makefile

@@ -1,11 +1,28 @@
 all: app.wasm
 
+STUBS_DIR := stubs
+
 app.wasm: wit/viceroy.wit wit/deps/fastly/compute.wit app.py
-	rm -rf hello_compute
-	uv run componentize-py -d wit -w compute bindings hello_compute
-	uv run componentize-py -d wit -w compute componentize --stub-wasi app -o app.wasm
+	rm -rf ${STUBS_DIR}
+	uv run componentize-py -d wit -w viceroy bindings ${STUBS_DIR}
+	uv run componentize-py -d wit -w viceroy componentize app -o app.wasm
 
 serve: app.wasm
-	viceroy --adapt app.wasm
+	viceroy serve app.wasm
+
+test: app.wasm
+	uv run --extra test pytest
+
+lint:
+	uv run --extra dev ruff check .
+
+lint-fix:
+	uv run --extra dev ruff check --fix .
+
+format:
+	uv run --extra dev ruff format .
+
+format-check:
+	uv run --extra dev ruff format --check .
 
-.PHONY: all serve
+.PHONY: all serve test lint format format-check

README.md

@@ -21,13 +21,6 @@ Currently, this demonstrates…
  native-code compression stdlibs which haven't been compiled against WASI yet.
  Moving componentize-py to a new Python may help, as [WASIp1 is now a Tier 2
  supported platform](https://peps.python.org/pep-0011/#tier-2).
-* It crashes every time something tries to write to stdout or stderr. It may be
- that those aren't in the preopens; adding those to the preopens should be
- possible with changes to Viceroy. We're also using `--stub-wasi` at the
- moment, which means things like `fd_write` are coded to immediately trap; that
- probably doesn't help. Finally, it may be possible to monkeypatch in Python
- and redirect them to a logging endpoint, but our initial attempts were
- unsuccessful.
 
 # Install Dependencies
 
@@ -40,7 +33,33 @@ Currently, this demonstrates…
 # Build and Run
 
 1. `make serve`
-2. Visit http://127.0.0.1:7676/hello/fred in a browser.
+2. Visit http://127.0.0.1:7676/hello/world or http://127.0.0.1:7676/info in a browser.
 
 You are seeing Bottle, a simple Python web framework, run on a Fastly Compute
 worker!
+
+# Testing
+
+```bash
+# Install dependencies and run tests
+uv sync --extra dev --extra test
+make test
+```
+
+The tests automatically build the WebAssembly component, start viceroy, and verify all endpoints work correctly with the WIT APIs.
+
+# Development
+
+```bash
+# Format code
+make format
+
+# Check formatting
+make format-check
+
+# Run linting
+make lint
+
+# Run linting and apply automatic fixes
+make lint-fix
+```

app.py

@@ -1,52 +1,49 @@
+import sys
 from urllib.parse import urlparse
 
-import art
-import bottle
-from bottle import template, Bottle
-
-from wit_world.exports import Reactor as BaseReactor
-from wit_world.imports import log, http_req, http_resp, http_body
+from bottle import Bottle
+from wit_world.exports import HttpIncoming as BaseHttpIncoming
+from wit_world.imports import compute_runtime, http_body, http_resp
 from wit_world.imports.http_resp import send_downstream
 
-
 # Enable a bit more debug logging from the framework.
-bottle.debug(True)
-
 app = Bottle()
-app.catchall = False # bottle backtrace causes issues; use our own.
 
 
 @app.route("/hello/<name>")
-def index(name):
- return template("Hello <pre>{{name}}</pre>", name=art.text2art(name))
+def hello(name):
+ return f"Hello {name}!"
 
 
-def print(*args):
- # hack to allow print locally; so far, monkeypatching
- # sys.stdout/sys.stderr hasn't panned out, so more
- # research required.
- log.write(log_ep, " ".join(args).encode())
+@app.route("/info")
+def info():
+ """Return JSON with request information we can test against"""
+ from bottle import request
 
+ # Get some runtime info we can test
+ vcpu_time = compute_runtime.get_vcpu_ms()
 
-def init():
- global log_ep
- log_ep = log.endpoint_get("")
+ return {
+ "service": "fastly-compute-python",
+ "status": "ok",
+ "message": "Hello from Fastly Compute!",
+ "vcpu_time_ms": vcpu_time,
+ "request_method": request.environ.get("REQUEST_METHOD"),
+ "path_info": request.environ.get("PATH_INFO"),
+ }
 
-class StdErr:
- """File-like object to receive errors and direct them to our logging endpoint"""
-
- def write(self, data: str):
- print(f"wsgi-error: {data}")
 
- def flush(self):
- pass
+@app.route("/error")
+def error():
+ """Endpoint that intentionally raises an exception to test error handling."""
+ raise RuntimeError("This is an intentional error for testing purposes")
 
 
 def serve_wsgi_request(req, body, app):
  """Pass a WSGI application a single request, and adapt its behavior back
  to the Fastly API."""
 
- response = http_resp.new()
+ response = http_resp.Response.new()
  response_body = http_body.new()
 
  def write(body_data: bytes):
@@ -56,56 +53,27 @@ def write(body_data: bytes):
 
  def start_response(status: str, headers: list[tuple], exc_info=None):
  code, _description = status.split(" ", 1)
-http_resp.status_set(response, int(code))
+response.set_status(int(code))
  for header, value in headers:
-http_resp.header_append(response, header.encode(), value.encode())
+ response.append_header(header, value.encode())
  return write
 
- url = urlparse(http_req.uri_get(req, 2048))
+ url = urlparse(req.get_uri(2048))
  environ = {
- "REQUEST_METHOD": http_req.method_get(req, 12),
+ "REQUEST_METHOD": req.get_method(12),
  "PATH_INFO": url.path,
  "QUERY_STRING": url.query,
  "SERVER_NAME": url.hostname,
  "SERVER_PORT": str(url.port),
- "wsgi.errors": StdErr(),
+ "wsgi.errors": sys.stderr,
  }
  for body_chunk in app(environ, start_response):
  # TODO: this would be a good place to stream, but for now we just
  # write to the buffer and send once the handler is done.
  write(body_chunk)
- send_downstream(response, response_body, False)
-
-
-class Reactor(BaseReactor):
- def serve(self, req: int, body: int) -> None:
- init()
- try:
- serve_wsgi_request(req, body, app)
- except Exception as e:
- log_exception(e)
-
-
-def log_exception(e):
- """Pretty-print an exception to our logging endpoint.
-
- Do it without callling format_exc(), which calls stat() to determine whether
- we're in a tty and what its width is. stat() and other fd routines currently
- crash when they try to access stdout or stderr, probably because they are
- not in the preopens.
- """
- try:
- print(f"Exception {type(e).__name__} - {e}")
- print("--- Traceback Follows ---")
-
- current_tb = e.__traceback__
- while current_tb:
- frame = current_tb.tb_frame
- print(
- f" File: {frame.f_code.co_filename}, "
- f"Function: {frame.f_code.co_name}, "
- f"Line: {frame.f_lineno}"
- )
- current_tb = current_tb.tb_next
- except Exception as e2:
- print(f"print_exc failed {e2}")
+ send_downstream(response, response_body)
+
+
+class HttpIncoming(BaseHttpIncoming):
+ def handle(self, request, body):
+ serve_wsgi_request(request, body, app)

fastly_compute/__init__.py

@@ -0,0 +1,7 @@
+"""Fastly Compute SDK for Python.
+
+This package provides a Python SDK for building Fastly Compute services.
+"""
+
+# Testing utilities are available but not imported by default
+# Users can import them explicitly: from fastly_compute.testing import ViceroyTestBase

fastly_compute/pytest_plugin.py

@@ -0,0 +1,31 @@
+"""Pytest plugin for automatic viceroy output on test failures."""
+
+import sys
+
+import pytest
+
+
+@pytest.hookimpl(tryfirst=True, hookwrapper=True)
+def pytest_runtest_makereport(item, call):
+ """Hook to display viceroy output on test failure.
+
+ This hook automatically displays recent viceroy server output
+ when any test fails, making debugging easier.
+ """
+ outcome = yield
+ rep = outcome.get_result()
+
+ # Only show output on test failures during the call phase
+ if rep.when == "call" and rep.failed:
+ # Try to get the viceroy_server fixture from the test
+ if hasattr(item, "funcargs") and "viceroy_server" in item.funcargs:
+ server = item.funcargs["viceroy_server"]
+ if hasattr(server, "output_lines"):
+ print(
+ f"\n=== Viceroy output for failed test: {item.name} ===",
+ file=sys.stderr,
+ )
+ # Show last 15 lines of output
+ for line in server.output_lines[-15:]:
+ print(f" {line}", file=sys.stderr)
+ print("=== End viceroy output ===", file=sys.stderr)

.github/workflows/python-ci.yml

@@ -0,0 +1,39 @@
+name: Python CI
+
+on:
+ push:
+ branches:
+ - main
+ pull_request:
+ branches:
+ - main
+
+jobs:
+ build:
+ runs-on: ubuntu-latest
+ steps:
+ - uses: actions/checkout@v4
+ - name: Set Up Rust Toolchain
+ uses: actions-rust-lang/setup-rust-toolchain@v1
+ with:
+ toolchain: '1.86.0'
+ - name: Set up Python
+ uses: actions/setup-python@v5
+ with:
+ python-version: '3.12'
+ - name: Install uv
+ run: pip install uv
+ - name: Install dependencies
+ run: uv sync
+ - name: Install viceroy
+ run: cargo install --git https://github.com/fastly/Viceroy.git --branch sunfishcode/sync-wit viceroy
+ - name: Build WebAssembly component
+ run: make app.wasm
+ - name: Install dependencies
+ run: uv sync --extra dev --extra test
+ - name: Check formatting
+ run: make format-check
+ - name: Run linting
+ run: make lint
+ - name: Run tests
+ run: make test

.gitignore

@@ -3,6 +3,6 @@
 *.egg-info
 uv.lock
 
-/hello_compute/
+/stubs/
 __pycache__
 app.wasm

Makefile

@@ -1,11 +1,28 @@
 all: app.wasm
 
+STUBS_DIR := stubs
+
 app.wasm: wit/viceroy.wit wit/deps/fastly/compute.wit app.py
-	rm -rf hello_compute
-	uv run componentize-py -d wit -w compute bindings hello_compute
-	uv run componentize-py -d wit -w compute componentize --stub-wasi app -o app.wasm
+	rm -rf ${STUBS_DIR}
+	uv run componentize-py -d wit -w viceroy bindings ${STUBS_DIR}
+	uv run componentize-py -d wit -w viceroy componentize app -o app.wasm
 
 serve: app.wasm
-	viceroy --adapt app.wasm
+	viceroy serve app.wasm
+
+test: app.wasm
+	uv run --extra test pytest
+
+lint:
+	uv run --extra dev ruff check .
+
+lint-fix:
+	uv run --extra dev ruff check --fix .
+
+format:
+	uv run --extra dev ruff format .
+
+format-check:
+	uv run --extra dev ruff format --check .
 
-.PHONY: all serve
+.PHONY: all serve test lint format format-check

README.md

@@ -21,13 +21,6 @@ Currently, this demonstrates…
  native-code compression stdlibs which haven't been compiled against WASI yet.
  Moving componentize-py to a new Python may help, as [WASIp1 is now a Tier 2
  supported platform](https://peps.python.org/pep-0011/#tier-2).
-* It crashes every time something tries to write to stdout or stderr. It may be
- that those aren't in the preopens; adding those to the preopens should be
- possible with changes to Viceroy. We're also using `--stub-wasi` at the
- moment, which means things like `fd_write` are coded to immediately trap; that
- probably doesn't help. Finally, it may be possible to monkeypatch in Python
- and redirect them to a logging endpoint, but our initial attempts were
- unsuccessful.
 
 # Install Dependencies
 
@@ -40,7 +33,33 @@ Currently, this demonstrates…
 # Build and Run
 
 1. `make serve`
-2. Visit http://127.0.0.1:7676/hello/fred in a browser.
+2. Visit http://127.0.0.1:7676/hello/world or http://127.0.0.1:7676/info in a browser.
 
 You are seeing Bottle, a simple Python web framework, run on a Fastly Compute
 worker!
+
+# Testing
+
+```bash
+# Install dependencies and run tests
+uv sync --extra dev --extra test
+make test
+```
+
+The tests automatically build the WebAssembly component, start viceroy, and verify all endpoints work correctly with the WIT APIs.
+
+# Development
+
+```bash
+# Format code
+make format
+
+# Check formatting
+make format-check
+
+# Run linting
+make lint
+
+# Run linting and apply automatic fixes
+make lint-fix
+```

app.py

@@ -1,52 +1,49 @@
+import sys
 from urllib.parse import urlparse
 
-import art
-import bottle
-from bottle import template, Bottle
-
-from wit_world.exports import Reactor as BaseReactor
-from wit_world.imports import log, http_req, http_resp, http_body
+from bottle import Bottle
+from wit_world.exports import HttpIncoming as BaseHttpIncoming
+from wit_world.imports import compute_runtime, http_body, http_resp
 from wit_world.imports.http_resp import send_downstream
 
-
 # Enable a bit more debug logging from the framework.
-bottle.debug(True)
-
 app = Bottle()
-app.catchall = False # bottle backtrace causes issues; use our own.
 
 
 @app.route("/hello/<name>")
-def index(name):
- return template("Hello <pre>{{name}}</pre>", name=art.text2art(name))
+def hello(name):
+ return f"Hello {name}!"
 
 
-def print(*args):
- # hack to allow print locally; so far, monkeypatching
- # sys.stdout/sys.stderr hasn't panned out, so more
- # research required.
- log.write(log_ep, " ".join(args).encode())
+@app.route("/info")
+def info():
+ """Return JSON with request information we can test against"""
+ from bottle import request
 
+ # Get some runtime info we can test
+ vcpu_time = compute_runtime.get_vcpu_ms()
 
-def init():
- global log_ep
- log_ep = log.endpoint_get("")
+ return {
+ "service": "fastly-compute-python",
+ "status": "ok",
+ "message": "Hello from Fastly Compute!",
+ "vcpu_time_ms": vcpu_time,
+ "request_method": request.environ.get("REQUEST_METHOD"),
+ "path_info": request.environ.get("PATH_INFO"),
+ }
 
-class StdErr:
- """File-like object to receive errors and direct them to our logging endpoint"""
-
- def write(self, data: str):
- print(f"wsgi-error: {data}")
 
- def flush(self):
- pass
+@app.route("/error")
+def error():
+ """Endpoint that intentionally raises an exception to test error handling."""
+ raise RuntimeError("This is an intentional error for testing purposes")
 
 
 def serve_wsgi_request(req, body, app):
  """Pass a WSGI application a single request, and adapt its behavior back
  to the Fastly API."""
 
- response = http_resp.new()
+ response = http_resp.Response.new()
  response_body = http_body.new()
 
  def write(body_data: bytes):
@@ -56,56 +53,27 @@ def write(body_data: bytes):
 
  def start_response(status: str, headers: list[tuple], exc_info=None):
  code, _description = status.split(" ", 1)
-http_resp.status_set(response, int(code))
+response.set_status(int(code))
  for header, value in headers:
-http_resp.header_append(response, header.encode(), value.encode())
+ response.append_header(header, value.encode())
  return write
 
- url = urlparse(http_req.uri_get(req, 2048))
+ url = urlparse(req.get_uri(2048))
  environ = {
- "REQUEST_METHOD": http_req.method_get(req, 12),
+ "REQUEST_METHOD": req.get_method(12),
  "PATH_INFO": url.path,
  "QUERY_STRING": url.query,
  "SERVER_NAME": url.hostname,
  "SERVER_PORT": str(url.port),
- "wsgi.errors": StdErr(),
+ "wsgi.errors": sys.stderr,
  }
  for body_chunk in app(environ, start_response):
  # TODO: this would be a good place to stream, but for now we just
  # write to the buffer and send once the handler is done.
  write(body_chunk)
- send_downstream(response, response_body, False)
-
-
-class Reactor(BaseReactor):
- def serve(self, req: int, body: int) -> None:
- init()
- try:
- serve_wsgi_request(req, body, app)
- except Exception as e:
- log_exception(e)
-
-
-def log_exception(e):
- """Pretty-print an exception to our logging endpoint.
-
- Do it without callling format_exc(), which calls stat() to determine whether
- we're in a tty and what its width is. stat() and other fd routines currently
- crash when they try to access stdout or stderr, probably because they are
- not in the preopens.
- """
- try:
- print(f"Exception {type(e).__name__} - {e}")
- print("--- Traceback Follows ---")
-
- current_tb = e.__traceback__
- while current_tb:
- frame = current_tb.tb_frame
- print(
- f" File: {frame.f_code.co_filename}, "
- f"Function: {frame.f_code.co_name}, "
- f"Line: {frame.f_lineno}"
- )
- current_tb = current_tb.tb_next
- except Exception as e2:
- print(f"print_exc failed {e2}")
+ send_downstream(response, response_body)
+
+
+class HttpIncoming(BaseHttpIncoming):
+ def handle(self, request, body):
+ serve_wsgi_request(request, body, app)

fastly_compute/__init__.py

@@ -0,0 +1,7 @@
+"""Fastly Compute SDK for Python.
+
+This package provides a Python SDK for building Fastly Compute services.
+"""
+
+# Testing utilities are available but not imported by default
+# Users can import them explicitly: from fastly_compute.testing import ViceroyTestBase

fastly_compute/pytest_plugin.py

@@ -0,0 +1,31 @@
+"""Pytest plugin for automatic viceroy output on test failures."""
+
+import sys
+
+import pytest
+
+
+@pytest.hookimpl(tryfirst=True, hookwrapper=True)
+def pytest_runtest_makereport(item, call):
+ """Hook to display viceroy output on test failure.
+
+ This hook automatically displays recent viceroy server output
+ when any test fails, making debugging easier.
+ """
+ outcome = yield
+ rep = outcome.get_result()
+
+ # Only show output on test failures during the call phase
+ if rep.when == "call" and rep.failed:
+ # Try to get the viceroy_server fixture from the test
+ if hasattr(item, "funcargs") and "viceroy_server" in item.funcargs:
+ server = item.funcargs["viceroy_server"]
+ if hasattr(server, "output_lines"):
+ print(
+ f"\n=== Viceroy output for failed test: {item.name} ===",
+ file=sys.stderr,
+ )
+ # Show last 15 lines of output
+ for line in server.output_lines[-15:]:
+ print(f" {line}", file=sys.stderr)
+ print("=== End viceroy output ===", file=sys.stderr)