x402/python/legacy/tests/flask_tests/test_middleware.py
Carson Roscoe 30a847d7d1
feat: New Python SDK with v2 support (#841)
* chore: renamed python/x402 to python/legacy

* feat: initial Python core SDK

* feat: added core HTTP wrappers

* feat: added core types

* feat: added evm mechanism for exact v1/v2

* feat: added httpx client

* feat: added requests client

* feat: added fastapi middleware

* feat: added flask middleware

* feat: added integration tests

* feat: added Python SDK to e2e tests

* python-v2: fix workflow checks (#863)

* fix format

* fix lint

* fix build

* fix pytest

* Fix syntax errors and missing imports in manual integration example (#902)

- Add missing imports (base64, json, Response, JSONResponse, PaymentPayload, FacilitatorClient)
- Fix function signature syntax error
- Fix dict initialization syntax (colon to equals)
- Add missing return statement after successful payment
- Remove trailing whitespace

* feat: add Python SDK v2 server examples (FastAPI, Flask)  (#879)

* feat: add fastapi example project configuration

* feat: add fastapi example with x402 payment middleware

* docs: add comprehensive README for fastapi example

* feat: add flask example project configuration

* feat: add flask example with x402 payment middleware

* docs: add comprehensive README for flask example

* feat: add test clients for fastapi and flask examples

* docs: add test client usage to READMEs

* chore - remove python-version and test-client.py

* docs - remove test client guide from README.md

* chore - remove license and classifier

* feat - add description and mime type

* feat - update .env-local

* feat: add Python v2 client examples (httpx & requests) (#857)

* feat: add Python v2 client examples (httpx & requests)

Add simple client examples demonstrating httpx (async) and requests (sync) usage with the x402 Python v2 SDK.

- examples/python/clients/example.py - Simple example showing both httpx and requests
- Uses EthAccountSigner with register_exact_evm_client helper
- Minimal configuration required

* refactor: split Python client examples into separate directories

Address PR review feedback:
- Separate httpx/ and requests/ directories
- Add pyproject.toml for uv sync support
- Add environment variable validation
- Add payment response header extraction
- Use context manager for requests session cleanup

Tested on Base Sepolia testnet:
- httpx: tx 0xce49f668aba01c4b0b1af2eb0d9a381f4c62295506a91f20af479e0e834ef350
- requests: tx 0xb83b6feefa5a744b7779ba5b37df33f9c7241f58119454d66102acd97a92f024

* Update examples/python/clients/httpx/main.py

Co-authored-by: phdargen <pdargent@icloud.com>

* Update examples/python/clients/requests/main.py

Co-authored-by: phdargen <pdargent@icloud.com>

---------

Co-authored-by: phdargen <pdargent@icloud.com>

* feat(python): Make v2 framework and client dependencies optional extras (#901)

* python-v2: add svm mechanism (#904)

* add svm mechanism

* add unit tests

* add integration tests

* update server examples

* add e2e tests

* update clients

* make EVM/SVM dependencies optional extras

* fix legacy uv paths

* V2 python bazaar (#929)

* add bazaar extension

* strip query params for discovery

* fix 862

* updated e2e tests

* Add advanced Python client examples (#947)

* Add advanced Python client examples

Implements 5 advanced patterns demonstrating x402 SDK v2 features:
- hooks.py: Payment lifecycle hooks (before, after, failure)
- preferred_network.py: Custom network preference selector
- builder_pattern.py: Network-specific registration with wildcards
- error_recovery.py: Error classification and recovery strategies
- custom_transport.py: Custom httpx transport with retry/timing

Includes:
- CLI entry point (index.py) for running examples
- Comprehensive test suite (40 unit tests)
- E2E integration tests
- README documentation

All tests passing.

* Remove tests and examples beyond TypeScript SDK parity

Address PR review feedback:
- Remove tests directory (tests belong in SDK, not examples)
- Remove custom_transport.py (runtime error, beyond TS parity)
- Remove error_recovery.py (duplicate of hooks.py, beyond TS parity)
- Update index.py, README.md, pyproject.toml accordingly

* Address PR feedback: add SVM support and use optional deps

- Update pyproject.toml to use x402[evm,svm,httpx] instead of
  listing dependencies separately
- Add Solana/SVM network examples to preferred_network.py
- Support both EVM and SVM signers for cross-chain flexibility
- Update .env-local with SOLANA_PRIVATE_KEY option

* Python-v2: facilitator example + e2e (#950)

* add facilitator example

* improve svm signer

* add description to DiscoveredResource

* add facilitator e2e

* add paywall builder (#953)

* Add Python custom client example (#954)

Demonstrates manual x402 v2 payment flow without convenience wrappers.

Shows the 6-step process:
1. Initialize client and register payment schemes
2. Make initial request, receive 402
3. Decode PAYMENT-REQUIRED header
4. Create signed payment payload
5. Retry with PAYMENT-SIGNATURE header
6. Handle success/failure response

Useful for integrating with non-standard HTTP libraries or implementing
custom retry logic.

* feat(v2-sdk): support async dynamic hooks for price and metadata (#900)

* feat(http): implement dual class design for sync/async support

- Add x402HTTPResourceServer (async) for FastAPI/Starlette
- Add x402HTTPResourceServerSync (sync) for Flask/Django
- Share common logic via _x402HTTPServerBase
- Remove dynamic description/resource (keep only dynamic price/payTo)
- Update Flask middleware to use sync server directly
- Integrate with enrich_extensions for bazaar support
- Add per-route hook_timeout_seconds configuration

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

* fix(types): add missing Awaitable import and fix test import sorting

- Add Awaitable import to types.py for DynamicPayTo/DynamicPrice type hints
- Fix import block sorting in test_async_hooks.py and test_core.py

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

* refactor: simplify API by removing unused types and making timeout opt-in

Address reviewer feedback from @phdargen:
- Remove SyncDynamicPayTo/SyncDynamicPrice (unused types that would require SyncPaymentOption to be useful)
- Change hook_timeout_seconds default to None (opt-in, matching TS/Go parity)
- Export x402HTTPResourceServerSync from http/__init__.py

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>

* python-v2: make create_facilitator_config work with both V1 and V2 (#968)

* make create_facilitator_config work with both V1 and V2

* fix lint

* feat: add Python SDK v2 server advanced example (FastAPI) (#952)

* feat - add pyproject.toml, uv.lock for advanced example

* feat - add bazaar extension

* feat - add hooks

* feat - add x402 extensions to pyproject.toml

* feat - add dynamic pricing feature

* feat - add dynamic pay-to and custom money parser features

* docs - add README for advanced server example

* style - apply lint

* chore - add comments for bazaar extension code

* fix: python v2 x402HTTPAdapter retry logic (#978)

* fix: fix consecutive payment bug in x402HTTPAdapter

- Replace instance-level _is_retry flag with per-request header
  to prevent state leakage between consecutive 402 requests.

* tests - add test case for consecutive payment with x402HTTPAdapter

* style - apply lint

* Python-v2: async lifecycle hooks (#975)

* add dual sync/async classes for server/client/facilitator

* update integration/e2e tests

* add unit tests for core, http and implement wrapHttpxWithPaymentFromConfig/wrapRequestsWithPayment

* refactor core server/client/facilitator

* refactor x402_http_server/facilitator_client/x402_http_client

* update exmamples

* add utility function that takes care of html-safe escaping

* add sdk readmes

* add retry unit tests to httpx client

* Update Python SDK Docs for v2 (#976)

* Porting docs and updating for v2 changes (#813)

* porting docs and updating for v2 changes

* update quickstart for sellers

* update quickstarts, miniapps, and mcp docs

* update doc links

* update FAQs

* fix getting started docs

* update core concepts

* remove miniapps guide

* update extensions

* fix bazaar code examples

* fix broken links and yaml file

* remove unnecessary protocol layer doc

* add migration guide

* update documentation for python v2 sdk

* testing pr preview

* docs(python): remove unused os imports and align with TS tab patterns

- Remove unused 'import os' from FastAPI and Flask examples in quickstart-for-sellers
- Update bazaar-discovery-layer Python example to use hardcoded '0xYourPrivateKey' to match TypeScript tab consistency

* update migration doc

* cleanup comments

* cleanup readme

* fix: Python facilitator e2e code

* fix: lint

---------

Co-authored-by: phdargen <p.dargent@cern.ch>
Co-authored-by: somesome <57699892+sohw400@users.noreply.github.com>
Co-authored-by: Logan Kang <kcs93023@gmail.com>
Co-authored-by: 1bcMax <viewitter@gmail.com>
Co-authored-by: phdargen <pdargent@icloud.com>
Co-authored-by: Vladimir Sotnikov <bubert9@gmail.com>
Co-authored-by: Shuhei <shuhei0866@gmail.com>
Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>
Co-authored-by: Faris Habib <faris.habib@coinbase.com>
2026-01-21 16:32:07 -08:00

358 lines
9.9 KiB
Python

from flask import Flask, g
from x402.flask.middleware import PaymentMiddleware
def create_app_with_middleware(configs):
app = Flask(__name__)
@app.route("/protected")
def protected():
return {"message": "protected"}
@app.route("/unprotected")
def unprotected():
return {"message": "unprotected"}
middleware = PaymentMiddleware(app)
for cfg in configs:
middleware.add(**cfg)
return app
def test_payment_required_for_protected_route():
app = create_app_with_middleware(
[
{
"price": "$1.00",
"pay_to_address": "0x1",
"path": "/protected",
"network": "base-sepolia",
}
]
)
with app.test_client() as client:
resp = client.get("/protected")
assert resp.status_code == 402
assert resp.json is not None
assert "accepts" in resp.json
assert resp.json["error"].startswith("No X-PAYMENT header provided")
def test_unprotected_route():
app = create_app_with_middleware(
[
{
"price": "$1.00",
"pay_to_address": "0x1",
"path": "/protected",
"network": "base-sepolia",
}
]
)
with app.test_client() as client:
resp = client.get("/unprotected")
assert resp.status_code == 200
assert resp.json == {"message": "unprotected"}
def test_invalid_payment_header():
app = create_app_with_middleware(
[
{
"price": "$1.00",
"pay_to_address": "0x1",
"path": "/protected",
"network": "base-sepolia",
}
]
)
with app.test_client() as client:
resp = client.get("/protected", headers={"X-PAYMENT": "not_base64"})
assert resp.status_code == 402
assert resp.json is not None
assert "Invalid payment header format" in resp.json["error"]
def test_path_pattern_matching():
app = Flask(__name__)
@app.route("/foo")
def foo():
return {"foo": True}
@app.route("/bar/123")
def bar():
return {"bar": True}
middleware = PaymentMiddleware(app)
middleware.add(
price="$1.00",
pay_to_address="0x1",
path=["/foo", "/bar/*", "regex:^/baz/\\d+$"],
network="base-sepolia",
)
with app.test_client() as client:
assert client.get("/foo").status_code == 402
assert client.get("/bar/123").status_code == 402
# Not protected
@app.route("/baz/abc")
def baz():
return {"baz": True}
assert client.get("/baz/abc").status_code == 200
def test_multiple_middleware_configs():
app = Flask(__name__)
@app.route("/a")
def a():
return {"a": True}
@app.route("/b")
def b():
return {"b": True}
middleware = PaymentMiddleware(app)
middleware.add(
price="$1.00", pay_to_address="0x1", path="/a", network="base-sepolia"
)
middleware.add(
price="$2.00", pay_to_address="0x2", path="/b", network="base-sepolia"
)
with app.test_client() as client:
assert client.get("/a").status_code == 402
assert client.get("/b").status_code == 402
# Not protected
@app.route("/c")
def c():
return {"c": True}
assert client.get("/c").status_code == 200
def test_payment_details_in_g():
app = Flask(__name__)
@app.route("/protected")
def protected():
return {
"has_payment_details": hasattr(g, "payment_details"),
"has_verify_response": hasattr(g, "verify_response"),
}
middleware = PaymentMiddleware(app)
middleware.add(
price="$1.00", pay_to_address="0x1", path="/protected", network="base-sepolia"
)
with app.test_client() as client:
resp = client.get("/protected")
assert resp.status_code == 402
def test_browser_request_returns_html():
"""Test that browser requests return HTML paywall instead of JSON."""
app = create_app_with_middleware(
[
{
"price": "$1.00",
"pay_to_address": "0x1",
"path": "/protected",
"network": "base-sepolia",
}
]
)
# Simulate browser request headers
browser_headers = {
"Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
"User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36",
}
with app.test_client() as client:
resp = client.get("/protected", headers=browser_headers)
assert resp.status_code == 402
assert resp.content_type == "text/html; charset=utf-8"
# Check that HTML is returned
html_content = resp.get_data(as_text=True)
assert "<!DOCTYPE html>" in html_content or "<html>" in html_content
assert "window.x402" in html_content
def test_api_client_request_returns_json():
"""Test that API client requests return JSON response."""
app = create_app_with_middleware(
[
{
"price": "$1.00",
"pay_to_address": "0x1",
"path": "/protected",
"network": "base-sepolia",
}
]
)
# Simulate API client request headers
api_headers = {
"Accept": "application/json",
"User-Agent": "curl/7.68.0",
}
with app.test_client() as client:
resp = client.get("/protected", headers=api_headers)
assert resp.status_code == 402
assert resp.content_type == "application/json"
assert resp.json is not None
assert "accepts" in resp.json
assert "error" in resp.json
def test_paywall_config_injection():
"""Test that paywall configuration is properly injected into HTML."""
paywall_config = {
"app_name": "Test Application",
"app_logo": "https://example.com/logo.png",
}
app = create_app_with_middleware(
[
{
"price": "$2.50",
"pay_to_address": "0x123",
"path": "/protected",
"network": "base-sepolia",
"paywall_config": paywall_config,
}
]
)
browser_headers = {
"Accept": "text/html",
"User-Agent": "Mozilla/5.0 (compatible browser)",
}
with app.test_client() as client:
resp = client.get("/protected", headers=browser_headers)
assert resp.status_code == 402
html_content = resp.get_data(as_text=True)
assert "window.x402" in html_content
assert '"appName": "Test Application"' in html_content
assert '"appLogo": "https://example.com/logo.png"' in html_content
assert '"amount": 2.5' in html_content
def test_custom_paywall_html():
"""Test that custom paywall HTML is used when provided."""
custom_html = """
<!DOCTYPE html>
<html>
<head>
<title>Custom Paywall</title>
</head>
<body>
<h1>Custom Payment Required</h1>
<div id="custom-payment">Please pay to continue</div>
</body>
</html>
"""
app = create_app_with_middleware(
[
{
"price": "$1.00",
"pay_to_address": "0x1",
"path": "/protected",
"network": "base-sepolia",
"custom_paywall_html": custom_html,
}
]
)
browser_headers = {
"Accept": "text/html",
"User-Agent": "Mozilla/5.0",
}
with app.test_client() as client:
resp = client.get("/protected", headers=browser_headers)
assert resp.status_code == 402
html_content = resp.get_data(as_text=True)
assert "Custom Payment Required" in html_content
assert "custom-payment" in html_content
assert "Custom Paywall" in html_content
def test_mainnet_vs_testnet_config():
"""Test that mainnet vs testnet is properly configured."""
# Test testnet (base-sepolia)
app_testnet = create_app_with_middleware(
[
{
"price": "$1.00",
"pay_to_address": "0x1",
"path": "/protected",
"network": "base-sepolia",
}
]
)
# Test mainnet (base)
app_mainnet = create_app_with_middleware(
[
{
"price": "$1.00",
"pay_to_address": "0x1",
"path": "/protected",
"network": "base",
}
]
)
browser_headers = {
"Accept": "text/html",
"User-Agent": "Mozilla/5.0",
}
with app_testnet.test_client() as client:
resp = client.get("/protected", headers=browser_headers)
html_content = resp.get_data(as_text=True)
assert '"testnet": true' in html_content
assert "console.log('Payment requirements initialized" in html_content
with app_mainnet.test_client() as client:
resp = client.get("/protected", headers=browser_headers)
html_content = resp.get_data(as_text=True)
assert '"testnet": false' in html_content
# Should not have console.log for mainnet
assert "console.log('Payment requirements initialized" not in html_content
def test_payment_amount_conversion():
"""Test that payment amounts are properly converted to display values."""
app = create_app_with_middleware(
[
{
"price": "$0.001", # Small amount
"pay_to_address": "0x1",
"path": "/protected",
"network": "base-sepolia",
}
]
)
browser_headers = {
"Accept": "text/html",
"User-Agent": "Mozilla/5.0",
}
with app.test_client() as client:
resp = client.get("/protected", headers=browser_headers)
html_content = resp.get_data(as_text=True)
# $0.001 should be converted to 0.001 in the display
assert '"amount": 0.001' in html_content