Aryan Mathur
5 months ago
10 changed files with 1443 additions and 64 deletions
@ -0,0 +1,96 @@ |
|||
"""Static dependency-graph introspection for the debug endpoint. |
|||
|
|||
Nothing in this module executes any user callable. It walks the already-built |
|||
Dependant trees that live on each APIRoute and serialises them to plain dicts. |
|||
""" |
|||
|
|||
from collections.abc import Sequence |
|||
from typing import Any |
|||
|
|||
from fastapi.dependencies.models import Dependant, _impartial, _unwrapped_call |
|||
|
|||
|
|||
def _resolve_callable_name(call: Any) -> str: |
|||
"""Return the display name of a callable, unwrapping partials and decorators.""" |
|||
if call is None: |
|||
return "<unknown>" |
|||
unwrapped = _unwrapped_call(call) |
|||
if unwrapped is None: # pragma: no cover |
|||
return "<unknown>" |
|||
# For classes the __name__ is the class name; for functions it is the |
|||
# function name. Both are what we want. |
|||
return getattr(unwrapped, "__name__", type(unwrapped).__name__) |
|||
|
|||
|
|||
def _resolve_callable_module(call: Any) -> str: |
|||
"""Return the module path of a callable, unwrapping partials and decorators.""" |
|||
if call is None: |
|||
return "<unknown>" |
|||
unwrapped = _unwrapped_call(call) |
|||
if unwrapped is None: # pragma: no cover |
|||
return "<unknown>" |
|||
return getattr(unwrapped, "__module__", "<unknown>") |
|||
|
|||
|
|||
def build_dependency_graph( |
|||
dependant: Dependant, |
|||
*, |
|||
_path_seen: frozenset[Any] | None = None, |
|||
) -> dict[str, Any]: |
|||
"""Serialise one Dependant node (and its entire sub-tree) to a plain dict. |
|||
|
|||
Cycle / repeat detection operates on the *current root-to-node path* only. |
|||
The same callable appearing in two sibling branches is NOT flagged — only |
|||
an actual ancestor repeat on the same path triggers ``cached_repeat: true``. |
|||
""" |
|||
if _path_seen is None: |
|||
_path_seen = frozenset() |
|||
|
|||
cache_key = dependant.cache_key |
|||
is_repeat = cache_key in _path_seen |
|||
|
|||
node: dict[str, Any] = { |
|||
"callable_name": _resolve_callable_name(dependant.call), |
|||
"callable_module": _resolve_callable_module(dependant.call), |
|||
"scope": dependant.computed_scope, |
|||
"is_yield": dependant.is_gen_callable or dependant.is_async_gen_callable, |
|||
"is_async": dependant.is_async_gen_callable or dependant.is_coroutine_callable, |
|||
"security_scopes": list(dependant.oauth_scopes) if dependant.oauth_scopes else [], |
|||
"is_security_scheme": dependant._is_security_scheme, |
|||
} |
|||
|
|||
if is_repeat: |
|||
# Ancestor repeat on this path — stop recursion here. |
|||
node["cached_repeat"] = True |
|||
node["sub_dependencies"] = [] |
|||
else: |
|||
# Extend the path with the current node before recursing into children. |
|||
extended_path = _path_seen | {cache_key} |
|||
node["sub_dependencies"] = [ |
|||
build_dependency_graph(sub, _path_seen=extended_path) |
|||
for sub in dependant.dependencies |
|||
] |
|||
|
|||
return node |
|||
|
|||
|
|||
def get_all_route_graphs(routes: Sequence[Any]) -> list[dict[str, Any]]: |
|||
"""Build the full debug payload from a list of registered routes. |
|||
|
|||
Non-APIRoute entries (e.g. Mount, plain Starlette Route) are skipped. |
|||
""" |
|||
# Import here to avoid circular imports at module load time. |
|||
from fastapi.routing import APIRoute |
|||
|
|||
result: list[dict[str, Any]] = [] |
|||
for route in routes: |
|||
if not isinstance(route, APIRoute): |
|||
continue |
|||
entry: dict[str, Any] = { |
|||
"path": route.path_format, |
|||
"methods": sorted(route.methods) if route.methods else [], |
|||
"operation_id": route.unique_id, |
|||
"dependency_graph": build_dependency_graph(route.dependant), |
|||
} |
|||
result.append(entry) |
|||
return result |
|||
@ -0,0 +1,800 @@ |
|||
"""Regression tests for deterministic dependency-cleanup ordering (Task 2). |
|||
|
|||
Testing technique: every yield dep appends its own name to a closure-local list |
|||
*after* its yield (i.e. during cleanup). BackgroundTasks do the same. After |
|||
the HTTP round-trip completes the test inspects the list to assert ordering. |
|||
|
|||
The expected ordering is derived from the invariant documented in |
|||
``fastapi/routing.py`` (request_response) and |
|||
``fastapi/dependencies/utils.py`` (solve_dependencies): |
|||
|
|||
• Deps are pushed onto AsyncExitStack in dependant.dependencies iteration |
|||
order (route-level deps first, then signature deps left-to-right). |
|||
• Sub-deps of a dep are recursed *before* the parent is pushed. |
|||
• AsyncExitStack is LIFO → last-pushed finaliser runs first. |
|||
• function_stack exits BEFORE ``await response(…)``. |
|||
• BackgroundTasks run *inside* ``response(…)``. |
|||
• request_stack (inner_astack) exits AFTER ``response(…)``. |
|||
""" |
|||
|
|||
import json |
|||
import logging |
|||
from typing import Annotated |
|||
|
|||
from fastapi import BackgroundTasks, Depends, FastAPI, Request |
|||
from fastapi.responses import StreamingResponse |
|||
from fastapi.testclient import TestClient |
|||
|
|||
|
|||
# --------------------------------------------------------------------------- |
|||
# test_sibling_cleanup_is_lifo |
|||
# --------------------------------------------------------------------------- |
|||
|
|||
|
|||
def test_sibling_cleanup_is_lifo() -> None: |
|||
"""Two yield deps declared as (dep_a, dep_b) in the signature. |
|||
dep_a is pushed first, dep_b second. LIFO → dep_b cleans up first.""" |
|||
cleanup_order: list[str] = [] |
|||
|
|||
def dep_a(): # type: ignore[no-untyped-def] |
|||
yield "a" |
|||
cleanup_order.append("dep_a") |
|||
|
|||
def dep_b(): # type: ignore[no-untyped-def] |
|||
yield "b" |
|||
cleanup_order.append("dep_b") |
|||
|
|||
app = FastAPI() |
|||
|
|||
@app.get("/") |
|||
def endpoint( |
|||
_a: Annotated[str, Depends(dep_a)], |
|||
_b: Annotated[str, Depends(dep_b)], |
|||
) -> dict: |
|||
return {"ok": True} |
|||
|
|||
with TestClient(app) as client: |
|||
resp = client.get("/") |
|||
assert resp.status_code == 200 |
|||
assert cleanup_order == ["dep_b", "dep_a"] |
|||
|
|||
|
|||
# --------------------------------------------------------------------------- |
|||
# test_route_level_dep_cleanup_after_signature_deps |
|||
# --------------------------------------------------------------------------- |
|||
|
|||
|
|||
def test_route_level_dep_cleanup_after_signature_deps() -> None: |
|||
"""Route-level dep is prepended (pushed first) → cleaned up last.""" |
|||
cleanup_order: list[str] = [] |
|||
|
|||
def route_dep(): # type: ignore[no-untyped-def] |
|||
yield |
|||
cleanup_order.append("route_dep") |
|||
|
|||
def sig_dep(): # type: ignore[no-untyped-def] |
|||
yield |
|||
cleanup_order.append("sig_dep") |
|||
|
|||
app = FastAPI() |
|||
|
|||
@app.get("/", dependencies=[Depends(route_dep)]) |
|||
def endpoint(_s: Annotated[None, Depends(sig_dep)]) -> dict: |
|||
return {"ok": True} |
|||
|
|||
with TestClient(app) as client: |
|||
resp = client.get("/") |
|||
assert resp.status_code == 200 |
|||
# sig_dep pushed after route_dep → exits first (LIFO) |
|||
assert cleanup_order == ["sig_dep", "route_dep"] |
|||
|
|||
|
|||
# --------------------------------------------------------------------------- |
|||
# test_nested_dep_cleanup_order |
|||
# --------------------------------------------------------------------------- |
|||
|
|||
|
|||
def test_nested_dep_cleanup_order() -> None: |
|||
"""endpoint → dep_a (yield) → dep_b (yield). |
|||
dep_b is recursed first (pushed first). dep_a is pushed second. |
|||
LIFO: dep_a cleans up first, then dep_b.""" |
|||
cleanup_order: list[str] = [] |
|||
|
|||
def dep_b(): # type: ignore[no-untyped-def] |
|||
yield "b" |
|||
cleanup_order.append("dep_b") |
|||
|
|||
def dep_a(b: Annotated[str, Depends(dep_b)]): # type: ignore[no-untyped-def] |
|||
yield "a" |
|||
cleanup_order.append("dep_a") |
|||
|
|||
app = FastAPI() |
|||
|
|||
@app.get("/") |
|||
def endpoint(_a: Annotated[str, Depends(dep_a)]) -> dict: |
|||
return {"ok": True} |
|||
|
|||
with TestClient(app) as client: |
|||
resp = client.get("/") |
|||
assert resp.status_code == 200 |
|||
assert cleanup_order == ["dep_a", "dep_b"] |
|||
|
|||
|
|||
# --------------------------------------------------------------------------- |
|||
# test_async_and_sync_generators_share_lifo |
|||
# --------------------------------------------------------------------------- |
|||
|
|||
|
|||
def test_async_and_sync_generators_share_lifo() -> None: |
|||
"""A sync yield dep and an async yield dep, in that signature order. |
|||
Both land on the same stack via enter_async_context; ordering is purely |
|||
push order → async one (pushed second) exits first.""" |
|||
cleanup_order: list[str] = [] |
|||
|
|||
def dep_sync(): # type: ignore[no-untyped-def] |
|||
yield "sync" |
|||
cleanup_order.append("dep_sync") |
|||
|
|||
async def dep_async(): # type: ignore[no-untyped-def] |
|||
yield "async" |
|||
cleanup_order.append("dep_async") |
|||
|
|||
app = FastAPI() |
|||
|
|||
@app.get("/") |
|||
def endpoint( |
|||
_s: Annotated[str, Depends(dep_sync)], |
|||
_a: Annotated[str, Depends(dep_async)], |
|||
) -> dict: |
|||
return {"ok": True} |
|||
|
|||
with TestClient(app) as client: |
|||
resp = client.get("/") |
|||
assert resp.status_code == 200 |
|||
assert cleanup_order == ["dep_async", "dep_sync"] |
|||
|
|||
|
|||
# --------------------------------------------------------------------------- |
|||
# test_cleanup_runs_on_endpoint_exception |
|||
# --------------------------------------------------------------------------- |
|||
|
|||
|
|||
def test_cleanup_runs_on_endpoint_exception() -> None: |
|||
"""All yield-dep finalisers still run even when the endpoint raises.""" |
|||
cleanup_order: list[str] = [] |
|||
|
|||
def dep_a(): # type: ignore[no-untyped-def] |
|||
try: |
|||
yield "a" |
|||
finally: |
|||
cleanup_order.append("dep_a") |
|||
|
|||
def dep_b(): # type: ignore[no-untyped-def] |
|||
try: |
|||
yield "b" |
|||
finally: |
|||
cleanup_order.append("dep_b") |
|||
|
|||
app = FastAPI() |
|||
|
|||
@app.get("/") |
|||
def endpoint( |
|||
_a: Annotated[str, Depends(dep_a)], |
|||
_b: Annotated[str, Depends(dep_b)], |
|||
) -> dict: |
|||
raise RuntimeError("endpoint boom") |
|||
|
|||
# raise_server_exceptions=False so the 500 doesn't propagate into the test |
|||
with TestClient(app, raise_server_exceptions=False) as client: |
|||
resp = client.get("/") |
|||
assert resp.status_code == 500 |
|||
# Both deps cleaned up, in LIFO order |
|||
assert cleanup_order == ["dep_b", "dep_a"] |
|||
|
|||
|
|||
# --------------------------------------------------------------------------- |
|||
# test_function_scope_cleans_before_response_streaming |
|||
# --------------------------------------------------------------------------- |
|||
|
|||
|
|||
def test_function_scope_cleans_before_response_streaming() -> None: |
|||
"""A function-scoped yield dep's finaliser runs *before* the response |
|||
body is streamed. The streaming iterator can observe the side-effect.""" |
|||
flag: dict[str, bool] = {"cleaned": False} |
|||
|
|||
def func_dep(): # type: ignore[no-untyped-def] |
|||
yield |
|||
flag["cleaned"] = True |
|||
|
|||
app = FastAPI() |
|||
|
|||
@app.get("/stream") |
|||
def stream_endpoint(_: Annotated[None, Depends(func_dep, scope="function")]) -> StreamingResponse: # type: ignore[no-untyped-def] |
|||
def body(): # type: ignore[no-untyped-def] |
|||
# By the time this runs, function_stack has already exited |
|||
yield json.dumps({"cleaned": flag["cleaned"]}) |
|||
|
|||
return StreamingResponse(body(), media_type="application/json") |
|||
|
|||
with TestClient(app) as client: |
|||
resp = client.get("/stream") |
|||
assert resp.status_code == 200 |
|||
assert resp.json()["cleaned"] is True |
|||
|
|||
|
|||
# --------------------------------------------------------------------------- |
|||
# test_request_scope_cleans_after_response_streaming |
|||
# --------------------------------------------------------------------------- |
|||
|
|||
|
|||
def test_request_scope_cleans_after_response_streaming() -> None: |
|||
"""A request-scoped (default) yield dep's finaliser runs *after* the |
|||
response body is streamed. The streaming iterator sees the flag as False.""" |
|||
flag: dict[str, bool] = {"cleaned": False} |
|||
|
|||
def req_dep(): # type: ignore[no-untyped-def] |
|||
yield |
|||
flag["cleaned"] = True |
|||
|
|||
app = FastAPI() |
|||
|
|||
@app.get("/stream") |
|||
def stream_endpoint(_: Annotated[None, Depends(req_dep)]) -> StreamingResponse: # type: ignore[no-untyped-def] |
|||
def body(): # type: ignore[no-untyped-def] |
|||
# request_stack has NOT exited yet while the stream runs |
|||
yield json.dumps({"cleaned": flag["cleaned"]}) |
|||
|
|||
return StreamingResponse(body(), media_type="application/json") |
|||
|
|||
with TestClient(app) as client: |
|||
resp = client.get("/stream") |
|||
assert resp.status_code == 200 |
|||
assert resp.json()["cleaned"] is False |
|||
|
|||
|
|||
# --------------------------------------------------------------------------- |
|||
# test_background_task_runs_between_scopes |
|||
# --------------------------------------------------------------------------- |
|||
|
|||
|
|||
def test_background_task_runs_between_scopes() -> None: |
|||
"""The three phases interleave in exactly this order: |
|||
1. function-scoped finalisers (function_stack exits) |
|||
2. BackgroundTasks (inside response.__call__) |
|||
3. request-scoped finalisers (request_stack exits) |
|||
""" |
|||
cleanup_order: list[str] = [] |
|||
|
|||
def func_dep(): # type: ignore[no-untyped-def] |
|||
yield |
|||
cleanup_order.append("func_cleanup") |
|||
|
|||
def req_dep(): # type: ignore[no-untyped-def] |
|||
yield |
|||
cleanup_order.append("req_cleanup") |
|||
|
|||
app = FastAPI() |
|||
|
|||
@app.get("/") |
|||
def endpoint( |
|||
_f: Annotated[None, Depends(func_dep, scope="function")], |
|||
_r: Annotated[None, Depends(req_dep, scope="request")], |
|||
bg: BackgroundTasks, |
|||
) -> dict: |
|||
bg.add_task(lambda: cleanup_order.append("bg_task")) |
|||
return {"ok": True} |
|||
|
|||
with TestClient(app) as client: |
|||
resp = client.get("/") |
|||
assert resp.status_code == 200 |
|||
assert cleanup_order == ["func_cleanup", "bg_task", "req_cleanup"] |
|||
|
|||
|
|||
# --------------------------------------------------------------------------- |
|||
# test_cleanup_order_metadata_populated |
|||
# --------------------------------------------------------------------------- |
|||
|
|||
|
|||
def test_cleanup_order_metadata_populated() -> None: |
|||
"""scope["fastapi_dependency_cleanup_order"] is populated with one entry |
|||
per generator dep that was successfully pushed onto a stack.""" |
|||
captured: list[list[dict]] = [] # type: ignore[type-arg] |
|||
|
|||
async def capture(request: Request): # type: ignore[no-untyped-def] |
|||
yield |
|||
# By the time this finaliser runs, all pushes have been recorded. |
|||
captured.append( |
|||
list(request.scope.get("fastapi_dependency_cleanup_order", [])) |
|||
) |
|||
|
|||
def dep_a(): # type: ignore[no-untyped-def] |
|||
yield "a" |
|||
|
|||
def dep_b(): # type: ignore[no-untyped-def] |
|||
yield "b" |
|||
|
|||
app = FastAPI(dependency_debug_url="/_debug/deps") |
|||
|
|||
@app.get("/") |
|||
def endpoint( |
|||
_cap: Annotated[None, Depends(capture)], |
|||
_a: Annotated[str, Depends(dep_a)], |
|||
_b: Annotated[str, Depends(dep_b)], |
|||
) -> dict: |
|||
return {"ok": True} |
|||
|
|||
with TestClient(app) as client: |
|||
resp = client.get("/") |
|||
assert resp.status_code == 200 |
|||
|
|||
assert len(captured) == 1 |
|||
metadata = captured[0] |
|||
|
|||
# Three generators were pushed: capture, dep_a, dep_b |
|||
assert len(metadata) == 3 |
|||
|
|||
# Order indices are monotonically increasing from 0 |
|||
assert [m["order"] for m in metadata] == [0, 1, 2] |
|||
|
|||
# Names match push order (signature order) |
|||
assert metadata[0]["callable_name"] == "capture" |
|||
assert metadata[1]["callable_name"] == "dep_a" |
|||
assert metadata[2]["callable_name"] == "dep_b" |
|||
|
|||
# All are request-scoped (no explicit scope on generators → default "request") |
|||
for m in metadata: |
|||
assert m["scope"] == "request" |
|||
|
|||
|
|||
# --------------------------------------------------------------------------- |
|||
# test_cleanup_order_metadata_survives_exception |
|||
# --------------------------------------------------------------------------- |
|||
|
|||
|
|||
def test_cleanup_order_metadata_survives_exception() -> None: |
|||
"""If a generator dep raises *before* its yield (setup failure), it is |
|||
never pushed onto the stack and therefore never recorded. Deps that were |
|||
successfully pushed before it still appear in the metadata.""" |
|||
captured: list[list[dict]] = [] # type: ignore[type-arg] |
|||
|
|||
async def capture(request: Request): # type: ignore[no-untyped-def] |
|||
try: |
|||
yield |
|||
finally: |
|||
captured.append( |
|||
list(request.scope.get("fastapi_dependency_cleanup_order", [])) |
|||
) |
|||
|
|||
def dep_ok(): # type: ignore[no-untyped-def] |
|||
yield "ok" |
|||
|
|||
def dep_raises(): # type: ignore[no-untyped-def] |
|||
raise ValueError("setup failure") |
|||
yield "never" # pragma: no cover # noqa: RET503 |
|||
|
|||
app = FastAPI(dependency_debug_url="/_debug/deps") |
|||
|
|||
@app.get("/") |
|||
def endpoint( |
|||
_cap: Annotated[None, Depends(capture)], |
|||
_ok: Annotated[str, Depends(dep_ok)], |
|||
_bad: Annotated[str, Depends(dep_raises)], |
|||
) -> dict: |
|||
return {"ok": True} # pragma: no cover |
|||
|
|||
with TestClient(app, raise_server_exceptions=False) as client: |
|||
resp = client.get("/") |
|||
# The ValueError propagates → 500 |
|||
assert resp.status_code == 500 |
|||
|
|||
# capture and dep_ok were pushed; dep_raises was not |
|||
assert len(captured) == 1 |
|||
metadata = captured[0] |
|||
assert len(metadata) == 2 |
|||
names = [m["callable_name"] for m in metadata] |
|||
assert "capture" in names |
|||
assert "dep_ok" in names |
|||
assert "dep_raises" not in names |
|||
|
|||
|
|||
# --------------------------------------------------------------------------- |
|||
# test_use_cache_false_shared_dep_cleanup_runs_per_encounter |
|||
# --------------------------------------------------------------------------- |
|||
|
|||
|
|||
def test_use_cache_false_shared_dep_cleanup_runs_per_encounter() -> None: |
|||
"""use_cache=False on a shared yield dep bypasses the cache check |
|||
(utils.py:674) on every encounter. Each encounter calls |
|||
enter_async_context independently → one push per encounter, one |
|||
finaliser per push. The two finalisers are NOT adjacent in the LIFO |
|||
sequence; they are interleaved with the branch deps that triggered them. |
|||
|
|||
Expected full event sequence (setup + cleanup): |
|||
shared:setup branch_a:setup shared:setup branch_b:setup |
|||
branch_b:cleanup shared:cleanup branch_a:cleanup shared:cleanup |
|||
|
|||
Failure mode guarded: an optimisation that deduplicates |
|||
enter_async_context calls regardless of use_cache would collapse the |
|||
two shared finalisers into one, silently dropping cleanup work.""" |
|||
order: list[str] = [] |
|||
|
|||
def shared(): # type: ignore[no-untyped-def] |
|||
order.append("shared:setup") |
|||
yield "s" |
|||
order.append("shared:cleanup") |
|||
|
|||
def branch_a(s: Annotated[str, Depends(shared, use_cache=False)]): # type: ignore[no-untyped-def] |
|||
order.append("branch_a:setup") |
|||
yield "a" |
|||
order.append("branch_a:cleanup") |
|||
|
|||
def branch_b(s: Annotated[str, Depends(shared, use_cache=False)]): # type: ignore[no-untyped-def] |
|||
order.append("branch_b:setup") |
|||
yield "b" |
|||
order.append("branch_b:cleanup") |
|||
|
|||
app = FastAPI() |
|||
|
|||
@app.get("/") |
|||
def endpoint( |
|||
_a: Annotated[str, Depends(branch_a)], |
|||
_b: Annotated[str, Depends(branch_b)], |
|||
) -> dict: |
|||
return {} |
|||
|
|||
with TestClient(app) as client: |
|||
resp = client.get("/") |
|||
assert resp.status_code == 200 |
|||
assert order == [ |
|||
"shared:setup", |
|||
"branch_a:setup", |
|||
"shared:setup", |
|||
"branch_b:setup", |
|||
"branch_b:cleanup", |
|||
"shared:cleanup", |
|||
"branch_a:cleanup", |
|||
"shared:cleanup", |
|||
] |
|||
|
|||
|
|||
# --------------------------------------------------------------------------- |
|||
# test_background_task_observes_function_scoped_resource_as_invalidated |
|||
# --------------------------------------------------------------------------- |
|||
|
|||
|
|||
def test_background_task_observes_function_scoped_resource_as_invalidated() -> None: |
|||
"""function_stack exits before response() is called. BackgroundTasks |
|||
execute inside response(). A function-scoped dep that invalidates a |
|||
shared mutable resource during its cleanup does so *before* any |
|||
BackgroundTask reads it. |
|||
|
|||
Expected state seen by BackgroundTask: 'closed' (not 'open'). |
|||
|
|||
Failure mode guarded: moving ``await response(…)`` inside the |
|||
function_stack async-with block would make function-scoped resources |
|||
still alive during BackgroundTask execution, masking use-after-close |
|||
bugs in production.""" |
|||
state: dict[str, str] = {} |
|||
bg_saw: list[str] = [] |
|||
|
|||
def func_dep(): # type: ignore[no-untyped-def] |
|||
state["status"] = "open" |
|||
yield state |
|||
state["status"] = "closed" |
|||
|
|||
app = FastAPI() |
|||
|
|||
@app.get("/") |
|||
def endpoint( |
|||
res: Annotated[dict, Depends(func_dep, scope="function")], |
|||
bg: BackgroundTasks, |
|||
) -> dict: |
|||
bg.add_task(lambda: bg_saw.append(state["status"])) |
|||
return {} |
|||
|
|||
with TestClient(app) as client: |
|||
resp = client.get("/") |
|||
assert resp.status_code == 200 |
|||
assert bg_saw == ["closed"] |
|||
|
|||
|
|||
# --------------------------------------------------------------------------- |
|||
# test_function_scope_cleanup_can_enqueue_background_task |
|||
# --------------------------------------------------------------------------- |
|||
|
|||
|
|||
def test_function_scope_cleanup_can_enqueue_background_task() -> None: |
|||
"""function_stack exits before BackgroundTasks.__call__ snapshots |
|||
self.tasks and sets _executed. A function-scoped dep's cleanup code |
|||
that calls bg.add_task() runs before the snapshot → the task is |
|||
captured and executed. |
|||
|
|||
Expected run order: endpoint, from_func_cleanup. |
|||
|
|||
Failure mode guarded: moving the _executed flag or the task snapshot |
|||
to before function_stack exit would silently drop tasks enqueued |
|||
during function-scoped cleanup.""" |
|||
ran: list[str] = [] |
|||
|
|||
def func_dep(bg: BackgroundTasks): # type: ignore[no-untyped-def] |
|||
yield |
|||
bg.add_task(lambda: ran.append("from_func_cleanup")) |
|||
|
|||
app = FastAPI() |
|||
|
|||
@app.get("/") |
|||
def endpoint(_f: Annotated[None, Depends(func_dep, scope="function")]) -> dict: |
|||
ran.append("endpoint") |
|||
return {} |
|||
|
|||
with TestClient(app) as client: |
|||
resp = client.get("/") |
|||
assert resp.status_code == 200 |
|||
assert ran == ["endpoint", "from_func_cleanup"] |
|||
|
|||
|
|||
# --------------------------------------------------------------------------- |
|||
# test_request_scope_cleanup_cannot_enqueue_background_task |
|||
# --------------------------------------------------------------------------- |
|||
|
|||
|
|||
def test_request_scope_cleanup_cannot_enqueue_background_task(caplog) -> None: |
|||
"""request_stack exits after BackgroundTasks.__call__ has already set |
|||
_executed=True. A request-scoped dep's cleanup call to add_task hits |
|||
the guard in background.py, logs a warning, and the task is never |
|||
added to the list. |
|||
|
|||
Expected: 'from_req_cleanup' does NOT appear in ran; a log warning |
|||
containing 'already been executed' is emitted. |
|||
|
|||
Failure mode guarded: removing or deferring the _executed guard would |
|||
allow request-scoped cleanup to silently enqueue tasks that execute |
|||
in an undefined order relative to the response lifecycle.""" |
|||
ran: list[str] = [] |
|||
|
|||
def req_dep(bg: BackgroundTasks): # type: ignore[no-untyped-def] |
|||
yield |
|||
bg.add_task(lambda: ran.append("from_req_cleanup")) |
|||
|
|||
app = FastAPI() |
|||
|
|||
@app.get("/") |
|||
def endpoint(_r: Annotated[None, Depends(req_dep)]) -> dict: |
|||
ran.append("endpoint") |
|||
return {} |
|||
|
|||
with TestClient(app) as client: |
|||
with caplog.at_level(logging.WARNING, logger="fastapi.background"): |
|||
resp = client.get("/") |
|||
assert resp.status_code == 200 |
|||
assert "from_req_cleanup" not in ran |
|||
assert any("already been executed" in r.message for r in caplog.records) |
|||
|
|||
|
|||
# --------------------------------------------------------------------------- |
|||
# test_transitive_scope_leak_through_plain_wrapper |
|||
# --------------------------------------------------------------------------- |
|||
|
|||
|
|||
def test_transitive_scope_leak_through_plain_wrapper() -> None: |
|||
"""The DependencyScopeError guard (utils.py:284-287) checks only the |
|||
direct child's scope field. A plain (non-generator) function inserted |
|||
between a request-scoped generator parent and a function-scoped |
|||
generator grandchild has scope=None; the guard does not fire. The |
|||
plain wrapper returns the same object the function-scoped dep yielded. |
|||
By the time the request-scoped parent's cleanup runs, the |
|||
function-scoped grandchild has already invalidated that object. |
|||
|
|||
Expected: route registers without DependencyScopeError; request_dep's |
|||
cleanup observes resource status == 'closed'. |
|||
|
|||
Failure mode guarded (documentation): this test documents a known |
|||
single-depth limitation. If transitive scope validation is added, |
|||
this test must be updated to reflect the new behaviour.""" |
|||
cleanup_saw: list[str] = [] |
|||
resource: dict[str, str] = {} |
|||
|
|||
def func_dep(): # type: ignore[no-untyped-def] |
|||
resource["status"] = "open" |
|||
yield resource |
|||
resource["status"] = "closed" |
|||
|
|||
def plain_wrapper( |
|||
res: Annotated[dict, Depends(func_dep, scope="function")], |
|||
) -> dict: |
|||
return res # pass-through; not a generator |
|||
|
|||
def request_dep(res: Annotated[dict, Depends(plain_wrapper)]): # type: ignore[no-untyped-def] |
|||
yield |
|||
cleanup_saw.append(res["status"]) |
|||
|
|||
app = FastAPI() |
|||
|
|||
@app.get("/") |
|||
def endpoint(_r: Annotated[None, Depends(request_dep)]) -> dict: |
|||
return {} |
|||
|
|||
with TestClient(app) as client: |
|||
resp = client.get("/") |
|||
assert resp.status_code == 200 |
|||
assert cleanup_saw == ["closed"] |
|||
|
|||
|
|||
# --------------------------------------------------------------------------- |
|||
# test_multiple_route_deps_exit_in_reverse_declaration_order |
|||
# --------------------------------------------------------------------------- |
|||
|
|||
|
|||
def test_multiple_route_deps_exit_in_reverse_declaration_order() -> None: |
|||
"""Route-level deps are prepended via ``dependencies[::-1]`` + |
|||
``insert(0, …)`` (routing.py:479-483), which preserves their original |
|||
declaration order at the front of dependant.dependencies. They are |
|||
therefore pushed first and exit last, in reverse declaration order |
|||
(LIFO). |
|||
|
|||
Declaration order: r1, r2, r3. |
|||
Push order: r1, r2, r3. |
|||
Cleanup order: r3, r2, r1. |
|||
|
|||
Failure mode guarded: changing the reversal + insert pattern (e.g., |
|||
a plain append loop) would reverse the declaration order of route |
|||
deps at the front of the list, producing cleanup order r1, r2, r3.""" |
|||
order: list[str] = [] |
|||
|
|||
def r1(): # type: ignore[no-untyped-def] |
|||
yield |
|||
order.append("r1") |
|||
|
|||
def r2(): # type: ignore[no-untyped-def] |
|||
yield |
|||
order.append("r2") |
|||
|
|||
def r3(): # type: ignore[no-untyped-def] |
|||
yield |
|||
order.append("r3") |
|||
|
|||
app = FastAPI() |
|||
|
|||
@app.get("/", dependencies=[Depends(r1), Depends(r2), Depends(r3)]) |
|||
def endpoint() -> dict: |
|||
return {} |
|||
|
|||
with TestClient(app) as client: |
|||
resp = client.get("/") |
|||
assert resp.status_code == 200 |
|||
assert order == ["r3", "r2", "r1"] |
|||
|
|||
|
|||
# --------------------------------------------------------------------------- |
|||
# test_shared_dep_cleanup_position_is_first_dfs_encounter |
|||
# --------------------------------------------------------------------------- |
|||
|
|||
|
|||
def test_shared_dep_cleanup_position_is_first_dfs_encounter() -> None: |
|||
"""With use_cache=True (the default) a shared dep is pushed exactly |
|||
once — during the first branch whose DFS recursion reaches it. |
|||
Subsequent encounters hit the cache (utils.py:674) and skip the push. |
|||
The shared dep's cleanup position in the LIFO sequence is therefore |
|||
anchored to whichever branch appears first in the signature, not to |
|||
where the shared dep is declared. |
|||
|
|||
Both sub-cases below put shared as the deepest node. Swapping which |
|||
branch is listed first swaps the two branches' cleanup positions but |
|||
shared always exits last (it was pushed first). |
|||
|
|||
Failure mode guarded: changing cache-store or cache-check semantics |
|||
(e.g., storing only when use_cache=True) would move the shared dep's |
|||
cleanup to a different position depending on encounter order.""" |
|||
|
|||
# ── sub-case: branch_a listed first ── |
|||
order_a: list[str] = [] |
|||
|
|||
def shared_a(): # type: ignore[no-untyped-def] |
|||
yield "s" |
|||
order_a.append("shared") |
|||
|
|||
def ba(s: Annotated[str, Depends(shared_a)]): # type: ignore[no-untyped-def] |
|||
yield "a" |
|||
order_a.append("branch_a") |
|||
|
|||
def bb_a(s: Annotated[str, Depends(shared_a)]): # type: ignore[no-untyped-def] |
|||
yield "b" |
|||
order_a.append("branch_b") |
|||
|
|||
app_a = FastAPI() |
|||
|
|||
@app_a.get("/") |
|||
def ep_a( |
|||
_a: Annotated[str, Depends(ba)], |
|||
_b: Annotated[str, Depends(bb_a)], |
|||
) -> dict: |
|||
return {} |
|||
|
|||
with TestClient(app_a) as client: |
|||
client.get("/") |
|||
# push: shared, branch_a, branch_b → LIFO: branch_b, branch_a, shared |
|||
assert order_a == ["branch_b", "branch_a", "shared"] |
|||
|
|||
# ── sub-case: branch_b listed first ── |
|||
order_b: list[str] = [] |
|||
|
|||
def shared_b(): # type: ignore[no-untyped-def] |
|||
yield "s" |
|||
order_b.append("shared") |
|||
|
|||
def ba_b(s: Annotated[str, Depends(shared_b)]): # type: ignore[no-untyped-def] |
|||
yield "a" |
|||
order_b.append("branch_a") |
|||
|
|||
def bb(s: Annotated[str, Depends(shared_b)]): # type: ignore[no-untyped-def] |
|||
yield "b" |
|||
order_b.append("branch_b") |
|||
|
|||
app_b = FastAPI() |
|||
|
|||
@app_b.get("/") |
|||
def ep_b( |
|||
_b: Annotated[str, Depends(bb)], |
|||
_a: Annotated[str, Depends(ba_b)], |
|||
) -> dict: |
|||
return {} |
|||
|
|||
with TestClient(app_b) as client: |
|||
client.get("/") |
|||
# push: shared, branch_b, branch_a → LIFO: branch_a, branch_b, shared |
|||
assert order_b == ["branch_a", "branch_b", "shared"] |
|||
|
|||
|
|||
# --------------------------------------------------------------------------- |
|||
# test_dep_setup_failure_partial_cleanup |
|||
# --------------------------------------------------------------------------- |
|||
|
|||
|
|||
def test_dep_setup_failure_partial_cleanup() -> None: |
|||
"""When a dep raises before its yield (setup failure) the exception |
|||
propagates out of solve_dependencies. Deps that were already pushed |
|||
onto the stack before the failing dep are unwound normally (LIFO). |
|||
Deps declared after the failing dep in the signature are never |
|||
reached and never pushed — their cleanup does not run. |
|||
|
|||
Signature order: dep_ok_1, dep_boom, dep_ok_2. |
|||
dep_ok_1 is pushed. dep_boom raises during setup — never pushed. |
|||
dep_ok_2 is never reached. |
|||
|
|||
Expected cleanup set: dep_ok_1 only. |
|||
|
|||
Failure mode guarded: an 'all or nothing' error handler that skips |
|||
stack unwinding on setup failure would prevent dep_ok_1 from |
|||
cleaning up, leaking its resource.""" |
|||
order: list[str] = [] |
|||
|
|||
def dep_ok_1(): # type: ignore[no-untyped-def] |
|||
try: |
|||
yield "ok1" |
|||
finally: |
|||
order.append("dep_ok_1:cleanup") |
|||
|
|||
def dep_boom(): # type: ignore[no-untyped-def] |
|||
raise RuntimeError("setup boom") |
|||
yield # pragma: no cover # noqa: RET503 |
|||
|
|||
def dep_ok_2(): # type: ignore[no-untyped-def] |
|||
try: |
|||
yield "ok2" |
|||
finally: |
|||
order.append("dep_ok_2:cleanup") |
|||
|
|||
app = FastAPI() |
|||
|
|||
@app.get("/") |
|||
def endpoint( |
|||
_a: Annotated[str, Depends(dep_ok_1)], |
|||
_b: Annotated[str, Depends(dep_boom)], |
|||
_c: Annotated[str, Depends(dep_ok_2)], |
|||
) -> dict: |
|||
return {} # pragma: no cover |
|||
|
|||
with TestClient(app, raise_server_exceptions=False) as client: |
|||
resp = client.get("/") |
|||
assert resp.status_code == 500 |
|||
assert order == ["dep_ok_1:cleanup"] |
|||
@ -0,0 +1,341 @@ |
|||
"""Tests for the dependency-graph debug endpoint (Task 1).""" |
|||
|
|||
import functools |
|||
from typing import Annotated |
|||
|
|||
from fastapi import Depends, FastAPI, Security |
|||
from fastapi.security import OAuth2PasswordBearer |
|||
from fastapi.testclient import TestClient |
|||
|
|||
|
|||
# --------------------------------------------------------------------------- |
|||
# Helpers reused across tests |
|||
# --------------------------------------------------------------------------- |
|||
|
|||
_DEBUG_PATH = "/_debug/deps" |
|||
|
|||
|
|||
def _app(**kwargs) -> FastAPI: # type: ignore[no-untyped-def] |
|||
return FastAPI(dependency_debug_url=_DEBUG_PATH, **kwargs) |
|||
|
|||
|
|||
def _find_route(payload: dict, path: str) -> dict: # type: ignore[no-untyped-def] |
|||
for r in payload["routes"]: |
|||
if r["path"] == path: |
|||
return r |
|||
raise AssertionError(f"Route {path!r} not found in debug payload") # pragma: no cover |
|||
|
|||
|
|||
# --------------------------------------------------------------------------- |
|||
# test_debug_disabled_by_default |
|||
# --------------------------------------------------------------------------- |
|||
|
|||
|
|||
def test_debug_disabled_by_default() -> None: |
|||
app = FastAPI() # dependency_debug_url not set → None |
|||
|
|||
@app.get("/hello") |
|||
def hello() -> dict: |
|||
return {"hi": True} |
|||
|
|||
client = TestClient(app) |
|||
# The default path and a few guesses must all 404 |
|||
assert client.get("/_debug/deps").status_code == 404 |
|||
assert client.get("/_debug/dependencies").status_code == 404 |
|||
assert client.get("/debug").status_code == 404 |
|||
|
|||
|
|||
# --------------------------------------------------------------------------- |
|||
# test_debug_enabled_returns_200 |
|||
# --------------------------------------------------------------------------- |
|||
|
|||
|
|||
def test_debug_enabled_returns_200() -> None: |
|||
app = _app() |
|||
|
|||
@app.get("/hello") |
|||
def hello() -> dict: |
|||
return {"hi": True} |
|||
|
|||
client = TestClient(app) |
|||
resp = client.get(_DEBUG_PATH) |
|||
assert resp.status_code == 200 |
|||
|
|||
payload = resp.json() |
|||
assert "routes" in payload |
|||
route = _find_route(payload, "/hello") |
|||
assert "GET" in route["methods"] |
|||
assert route["dependency_graph"]["callable_name"] == "hello" |
|||
|
|||
|
|||
# --------------------------------------------------------------------------- |
|||
# test_debug_nested_three_levels |
|||
# --------------------------------------------------------------------------- |
|||
|
|||
|
|||
def test_debug_nested_three_levels() -> None: |
|||
def dep_c() -> str: |
|||
return "c" |
|||
|
|||
def dep_b(c: Annotated[str, Depends(dep_c)]) -> str: |
|||
return "b" |
|||
|
|||
def dep_a(b: Annotated[str, Depends(dep_b)]) -> str: |
|||
return "a" |
|||
|
|||
app = _app() |
|||
|
|||
@app.get("/nested") |
|||
def nested(a: Annotated[str, Depends(dep_a)]) -> dict: |
|||
return {"a": a} |
|||
|
|||
client = TestClient(app) |
|||
route = _find_route(client.get(_DEBUG_PATH).json(), "/nested") |
|||
graph = route["dependency_graph"] |
|||
|
|||
# Root is the endpoint itself |
|||
assert graph["callable_name"] == "nested" |
|||
|
|||
# Level 1: dep_a |
|||
assert len(graph["sub_dependencies"]) == 1 |
|||
a_node = graph["sub_dependencies"][0] |
|||
assert a_node["callable_name"] == "dep_a" |
|||
|
|||
# Level 2: dep_b |
|||
assert len(a_node["sub_dependencies"]) == 1 |
|||
b_node = a_node["sub_dependencies"][0] |
|||
assert b_node["callable_name"] == "dep_b" |
|||
|
|||
# Level 3: dep_c — leaf |
|||
assert len(b_node["sub_dependencies"]) == 1 |
|||
c_node = b_node["sub_dependencies"][0] |
|||
assert c_node["callable_name"] == "dep_c" |
|||
assert c_node["sub_dependencies"] == [] |
|||
|
|||
|
|||
# --------------------------------------------------------------------------- |
|||
# test_debug_yield_dep_flagged |
|||
# --------------------------------------------------------------------------- |
|||
|
|||
|
|||
def test_debug_yield_dep_flagged() -> None: |
|||
def plain_dep() -> str: |
|||
return "plain" |
|||
|
|||
def yield_dep(): # type: ignore[no-untyped-def] |
|||
yield "yielded" |
|||
|
|||
app = _app() |
|||
|
|||
@app.get("/mix") |
|||
def mix( |
|||
p: Annotated[str, Depends(plain_dep)], |
|||
y: Annotated[str, Depends(yield_dep)], |
|||
) -> dict: |
|||
return {} |
|||
|
|||
route = _find_route(TestClient(app).get(_DEBUG_PATH).json(), "/mix") |
|||
subs = route["dependency_graph"]["sub_dependencies"] |
|||
|
|||
# Order matches signature order: plain first, yield second |
|||
plain_node = subs[0] |
|||
yield_node = subs[1] |
|||
|
|||
assert plain_node["callable_name"] == "plain_dep" |
|||
assert plain_node["is_yield"] is False |
|||
|
|||
assert yield_node["callable_name"] == "yield_dep" |
|||
assert yield_node["is_yield"] is True |
|||
|
|||
|
|||
# --------------------------------------------------------------------------- |
|||
# test_debug_async_generator_flagged |
|||
# --------------------------------------------------------------------------- |
|||
|
|||
|
|||
def test_debug_async_generator_flagged() -> None: |
|||
async def async_gen_dep(): # type: ignore[no-untyped-def] |
|||
yield "async" |
|||
|
|||
app = _app() |
|||
|
|||
@app.get("/agen") |
|||
def agen(v: Annotated[str, Depends(async_gen_dep)]) -> dict: |
|||
return {} |
|||
|
|||
node = _find_route(TestClient(app).get(_DEBUG_PATH).json(), "/agen")["dependency_graph"] |
|||
sub = node["sub_dependencies"][0] |
|||
|
|||
assert sub["callable_name"] == "async_gen_dep" |
|||
assert sub["is_yield"] is True |
|||
assert sub["is_async"] is True |
|||
|
|||
|
|||
# --------------------------------------------------------------------------- |
|||
# test_debug_security_scopes |
|||
# --------------------------------------------------------------------------- |
|||
|
|||
|
|||
def test_debug_security_scopes() -> None: |
|||
oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token") |
|||
|
|||
async def get_current_user(token: Annotated[str, Depends(oauth2_scheme)]) -> dict: |
|||
return {"user": "me"} |
|||
|
|||
app = _app() |
|||
|
|||
@app.get("/protected") |
|||
def protected( |
|||
user: Annotated[dict, Security(get_current_user, scopes=["read", "admin"])], |
|||
) -> dict: |
|||
return user |
|||
|
|||
route = _find_route(TestClient(app).get(_DEBUG_PATH).json(), "/protected") |
|||
# The Security node is a direct sub of the endpoint root |
|||
sec_node = route["dependency_graph"]["sub_dependencies"][0] |
|||
assert sec_node["callable_name"] == "get_current_user" |
|||
assert "read" in sec_node["security_scopes"] |
|||
assert "admin" in sec_node["security_scopes"] |
|||
|
|||
|
|||
# --------------------------------------------------------------------------- |
|||
# test_debug_security_and_depends_siblings |
|||
# --------------------------------------------------------------------------- |
|||
|
|||
|
|||
def test_debug_security_and_depends_siblings() -> None: |
|||
oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token") |
|||
|
|||
def plain_dep() -> str: |
|||
return "plain" |
|||
|
|||
app = _app() |
|||
|
|||
@app.get("/siblings") |
|||
def siblings( |
|||
token: Annotated[str, Security(oauth2_scheme, scopes=["x"])], |
|||
plain: Annotated[str, Depends(plain_dep)], |
|||
) -> dict: |
|||
return {} |
|||
|
|||
route = _find_route(TestClient(app).get(_DEBUG_PATH).json(), "/siblings") |
|||
subs = route["dependency_graph"]["sub_dependencies"] |
|||
|
|||
# First sub is the Security dep (oauth2_scheme instance) |
|||
sec_sub = subs[0] |
|||
assert sec_sub["is_security_scheme"] is True |
|||
|
|||
# Second sub is the plain Depends |
|||
plain_sub = subs[1] |
|||
assert plain_sub["callable_name"] == "plain_dep" |
|||
assert plain_sub["is_security_scheme"] is False |
|||
|
|||
|
|||
# --------------------------------------------------------------------------- |
|||
# test_debug_route_level_deps_appear |
|||
# --------------------------------------------------------------------------- |
|||
|
|||
|
|||
def test_debug_route_level_deps_appear() -> None: |
|||
def route_dep() -> None: |
|||
pass |
|||
|
|||
app = _app() |
|||
|
|||
@app.get("/with-route-dep", dependencies=[Depends(route_dep)]) |
|||
def with_route_dep() -> dict: |
|||
return {} |
|||
|
|||
route = _find_route(TestClient(app).get(_DEBUG_PATH).json(), "/with-route-dep") |
|||
subs = route["dependency_graph"]["sub_dependencies"] |
|||
|
|||
# route_dep is prepended, so it is the first child |
|||
assert subs[0]["callable_name"] == "route_dep" |
|||
|
|||
|
|||
# --------------------------------------------------------------------------- |
|||
# test_debug_partial_callable_unwrapped |
|||
# --------------------------------------------------------------------------- |
|||
|
|||
|
|||
def test_debug_partial_callable_unwrapped() -> None: |
|||
def real_function(x: int = 1) -> int: |
|||
return x |
|||
|
|||
partial_dep = functools.partial(real_function, x=42) |
|||
|
|||
app = _app() |
|||
|
|||
@app.get("/partial") |
|||
def partial_endpoint(v: Annotated[int, Depends(partial_dep)]) -> dict: |
|||
return {"v": v} |
|||
|
|||
route = _find_route(TestClient(app).get(_DEBUG_PATH).json(), "/partial") |
|||
sub = route["dependency_graph"]["sub_dependencies"][0] |
|||
|
|||
# Must resolve through the partial to the underlying function name |
|||
assert sub["callable_name"] == "real_function" |
|||
|
|||
|
|||
# --------------------------------------------------------------------------- |
|||
# test_debug_class_based_dep |
|||
# --------------------------------------------------------------------------- |
|||
|
|||
|
|||
def test_debug_class_based_dep() -> None: |
|||
class MyDep: |
|||
def __call__(self) -> str: |
|||
return "class-dep" |
|||
|
|||
app = _app() |
|||
|
|||
@app.get("/classdep") |
|||
def classdep(v: Annotated[str, Depends(MyDep)]) -> dict: |
|||
return {"v": v} |
|||
|
|||
route = _find_route(TestClient(app).get(_DEBUG_PATH).json(), "/classdep") |
|||
sub = route["dependency_graph"]["sub_dependencies"][0] |
|||
|
|||
assert sub["callable_name"] == "MyDep" |
|||
|
|||
|
|||
# --------------------------------------------------------------------------- |
|||
# test_debug_cached_repeat_detection |
|||
# --------------------------------------------------------------------------- |
|||
|
|||
|
|||
def test_debug_cached_repeat_detection() -> None: |
|||
"""A shared dep used by two sibling branches must appear fully in both |
|||
(it is NOT on the same root→leaf path). This test verifies no spurious |
|||
``cached_repeat`` flag is set in that scenario.""" |
|||
|
|||
def shared() -> str: |
|||
return "shared" |
|||
|
|||
def branch_a(s: Annotated[str, Depends(shared)]) -> str: |
|||
return "a" |
|||
|
|||
def branch_b(s: Annotated[str, Depends(shared)]) -> str: |
|||
return "b" |
|||
|
|||
app = _app() |
|||
|
|||
@app.get("/shared") |
|||
def endpoint( |
|||
a: Annotated[str, Depends(branch_a)], |
|||
b: Annotated[str, Depends(branch_b)], |
|||
) -> dict: |
|||
return {} |
|||
|
|||
route = _find_route(TestClient(app).get(_DEBUG_PATH).json(), "/shared") |
|||
subs = route["dependency_graph"]["sub_dependencies"] |
|||
|
|||
# branch_a's child "shared" should be fully expanded (no cached_repeat) |
|||
shared_under_a = subs[0]["sub_dependencies"][0] |
|||
assert shared_under_a["callable_name"] == "shared" |
|||
assert "cached_repeat" not in shared_under_a |
|||
|
|||
# branch_b's child "shared" should also be fully expanded |
|||
shared_under_b = subs[1]["sub_dependencies"][0] |
|||
assert shared_under_b["callable_name"] == "shared" |
|||
assert "cached_repeat" not in shared_under_b |
|||
Loading…
Reference in new issue