Skip to content

Ministack: Free, open-source local AWS emulator - 60+ services, Terraform compatible, real databases. Free forever. MIT licensed.

fix nested functions (#410)

Nahuel Nuceraa56da154d143
diff --git a/ministack/services/apigateway.py b/ministack/services/apigateway.py
index 9c1f6020..5462c5f6 100644
--- a/ministack/services/apigateway.py
+++ b/ministack/services/apigateway.py
@@ -92,6 +92,30 @@ def _api_arn(api_id: str) -> str:
return f"arn:aws:apigateway:{get_region()}::/apis/{api_id}"
+def _extract_lambda_ref_from_integration_uri(uri: str) -> str:
+ """Return the inner Lambda ARN / name from an APIGW integrationUri.
+
+ Terraform and real AWS store Lambda proxy URIs as the wrapper form
+ ``arn:aws:apigateway:<region>:lambda:path/2015-03-31/functions/<lambda-arn>/invocations``.
+ Splitting the whole wrapper on ``:`` would mis-parse the nested ARN
+ (taking the wrapper's ``aws``/``lambda`` segments as function name +
+ qualifier, issue #409).
+
+ Also accepts already-unwrapped Lambda ARNs and plain function names so
+ fixtures that pass the bare ARN continue to work.
+ """
+ if not uri:
+ return ""
+ if "/functions/" in uri:
+ inner = uri.split("/functions/", 1)[1]
+ if "/invocations" in inner:
+ inner = inner.split("/invocations", 1)[0]
+ return inner
+ if uri.endswith("/invocations"):
+ return uri[: -len("/invocations")]
+ return uri
+
+
# ---- Persistence hooks ----
def get_state() -> dict:
@@ -451,12 +475,12 @@ async def _invoke_lambda_proxy(integration, api_id, stage, path, method, headers
from ministack.core.lambda_runtime import get_or_create_worker
from ministack.services import lambda_svc
- # integrationUri is typically a Lambda ARN; strip the trailing /invocations
- # that the apigateway:lambda:path form appends, then parse name + qualifier.
- # Qualified aliases (arn:...:function:<name>:<alias>) must resolve to the
- # alias's target version, not be treated as the function name itself (#407).
- uri = integration.get("integrationUri", "").replace("/invocations", "")
- func_name, qualifier = lambda_svc._resolve_name_and_qualifier(uri)
+ # integrationUri from Terraform / real AWS is wrapped:
+ # arn:aws:apigateway:<region>:lambda:path/2015-03-31/functions/<lambda-arn>/invocations
+ # Unwrap to the inner Lambda ARN before parsing name + qualifier (#409).
+ # Bare Lambda ARNs and plain function names keep working via the fallback.
+ lambda_ref = _extract_lambda_ref_from_integration_uri(integration.get("integrationUri", ""))
+ func_name, qualifier = lambda_svc._resolve_name_and_qualifier(lambda_ref)
func_data, func_config = lambda_svc._get_func_record_for_qualifier(func_name, qualifier)
if func_data is None:
return 502, {"Content-Type": "application/json"}, json.dumps({
@@ -1123,9 +1147,10 @@ async def _invoke_ws_lambda(api_id: str, account_id: str, route: dict, stage: st
)
return None
- # Parse name + qualifier so alias ARNs resolve to their target version (#407).
- uri = integration.get("integrationUri", "").replace("/invocations", "")
- func_name, qualifier = lambda_svc._resolve_name_and_qualifier(uri)
+ # Same unwrap path as HTTP (#409): APIGW integrationUri is the wrapper form
+ # that nests the Lambda ARN between /functions/ and /invocations.
+ lambda_ref = _extract_lambda_ref_from_integration_uri(integration.get("integrationUri", ""))
+ func_name, qualifier = lambda_svc._resolve_name_and_qualifier(lambda_ref)
func_data, func_config = lambda_svc._get_func_record_for_qualifier(func_name, qualifier)
if func_data is None:
return None
diff --git a/tests/test_apigatewayv2.py b/tests/test_apigatewayv2.py
index b4391eb0..61c8d5bb 100644
--- a/tests/test_apigatewayv2.py
+++ b/tests/test_apigatewayv2.py
@@ -1659,3 +1659,110 @@ def test_apigwv2_named_stage_still_requires_prefix(apigw, lam):
req.add_header("Host", f"{api_id}.execute-api.localhost:{_EXECUTE_PORT}")
r = urllib.request.urlopen(req, timeout=5)
assert r.status == 200
+
+
+# ========== APIGW wrapper URI unwrap (issue #409) ==========
+
+def _wrapped_uri(fn_arn: str) -> str:
+ """Build the APIGW integration URI Terraform/AWS actually send."""
+ return f"arn:aws:apigateway:us-east-1:lambda:path/2015-03-31/functions/{fn_arn}/invocations"
+
+
+def test_apigwv2_integration_wrapped_function_arn(apigw, lam):
+ """Wrapped integrationUri pointing at an unqualified Lambda ARN must invoke
+ the function — regression test for 1.3.6's wrapper mis-parse (#409)."""
+ import urllib.request
+
+ code = "def handler(e,c): return {'statusCode': 200, 'body': 'wrapped-plain'}\n"
+ fn_name = f"wrapped-plain-{uuid.uuid4().hex[:6]}"
+ arn = _make_fn(lam, fn_name, code)
+
+ api_id = apigw.create_api(Name="wrapped-plain-api", ProtocolType="HTTP")["ApiId"]
+ integ = apigw.create_integration(
+ ApiId=api_id, IntegrationType="AWS_PROXY",
+ IntegrationUri=_wrapped_uri(arn), IntegrationMethod="POST",
+ )
+ apigw.create_route(ApiId=api_id, RouteKey="GET /hello",
+ Target=f"integrations/{integ['IntegrationId']}")
+ apigw.create_stage(ApiId=api_id, StageName="$default", AutoDeploy=True)
+
+ req = urllib.request.Request(f"http://{api_id}.execute-api.localhost:{_EXECUTE_PORT}/hello")
+ req.add_header("Host", f"{api_id}.execute-api.localhost:{_EXECUTE_PORT}")
+ r = urllib.request.urlopen(req, timeout=5)
+ assert r.status == 200
+ assert r.read() == b"wrapped-plain"
+
+
+def test_apigwv2_integration_wrapped_alias_arn(apigw, lam):
+ """Wrapped integrationUri pointing at an alias ARN must resolve to the
+ alias target (combines #407 + #409)."""
+ import urllib.request
+
+ code = "def handler(e,c): return {'statusCode': 200, 'body': 'wrapped-alias'}\n"
+ fn_name = f"wrapped-alias-{uuid.uuid4().hex[:6]}"
+ lam.create_function(
+ FunctionName=fn_name, Runtime="python3.12", Role=_LAMBDA_ROLE,
+ Handler="index.handler", Code={"ZipFile": _make_zip(code)}, Publish=True,
+ )
+ lam.create_alias(FunctionName=fn_name, Name="live", FunctionVersion="1")
+ alias_arn = f"arn:aws:lambda:us-east-1:000000000000:function:{fn_name}:live"
+
+ api_id = apigw.create_api(Name="wrapped-alias-api", ProtocolType="HTTP")["ApiId"]
+ integ = apigw.create_integration(
+ ApiId=api_id, IntegrationType="AWS_PROXY",
+ IntegrationUri=_wrapped_uri(alias_arn), IntegrationMethod="POST",
+ )
+ apigw.create_route(ApiId=api_id, RouteKey="GET /hello",
+ Target=f"integrations/{integ['IntegrationId']}")
+ apigw.create_stage(ApiId=api_id, StageName="$default", AutoDeploy=True)
+
+ req = urllib.request.Request(f"http://{api_id}.execute-api.localhost:{_EXECUTE_PORT}/hello")
+ req.add_header("Host", f"{api_id}.execute-api.localhost:{_EXECUTE_PORT}")
+ r = urllib.request.urlopen(req, timeout=5)
+ assert r.status == 200
+ assert r.read() == b"wrapped-alias"
+
+
+def test_apigwv2_extract_lambda_ref_matrix():
+ """Unit-level table test for every integrationUri shape we've seen in the
+ wild. Lock the parser so #409-class bugs can't recur silently (#407, #409)."""
+ from ministack.services.apigateway import _extract_lambda_ref_from_integration_uri as unwrap
+ from ministack.services.lambda_svc import _resolve_name_and_qualifier as parse
+
+ cases = [
+ # wrapped (Terraform invoke_arn)
+ ("arn:aws:apigateway:us-east-1:lambda:path/2015-03-31/functions/arn:aws:lambda:us-east-1:000000000000:function:my-function/invocations",
+ "my-function", None),
+ # wrapped + alias
+ ("arn:aws:apigateway:us-east-1:lambda:path/2015-03-31/functions/arn:aws:lambda:us-east-1:000000000000:function:my-function:live/invocations",
+ "my-function", "live"),
+ # wrapped + version number
+ ("arn:aws:apigateway:us-east-1:lambda:path/2015-03-31/functions/arn:aws:lambda:us-east-1:000000000000:function:my-function:3/invocations",
+ "my-function", "3"),
+ # wrapped + $LATEST explicit
+ ("arn:aws:apigateway:us-east-1:lambda:path/2015-03-31/functions/arn:aws:lambda:us-east-1:000000000000:function:my-function:$LATEST/invocations",
+ "my-function", "$LATEST"),
+ # bare lambda ARN (direct CreateIntegration without wrapper)
+ ("arn:aws:lambda:us-east-1:000000000000:function:my-function", "my-function", None),
+ # bare alias ARN
+ ("arn:aws:lambda:us-east-1:000000000000:function:my-function:live", "my-function", "live"),
+ # plain function name
+ ("my-function", "my-function", None),
+ # plain name + qualifier
+ ("my-function:live", "my-function", "live"),
+ # empty string (degenerate — should not crash)
+ ("", "", None),
+ # future API version path — unwrap still works
+ ("arn:aws:apigateway:us-east-1:lambda:path/2020-04-16/functions/arn:aws:lambda:us-east-1:000000000000:function:my-function/invocations",
+ "my-function", None),
+ # cross-account wrapper (parse OK; downstream per-account lookup handles existence)
+ ("arn:aws:apigateway:us-east-1:lambda:path/2015-03-31/functions/arn:aws:lambda:us-east-1:999999999999:function:cross-acct/invocations",
+ "cross-acct", None),
+ # malformed: /invocations suffix without a wrapper
+ ("my-function/invocations", "my-function", None),
+ ]
+ for uri, expected_name, expected_q in cases:
+ ref = unwrap(uri)
+ name, qualifier = parse(ref)
+ assert name == expected_name, f"{uri!r} → name={name!r}, expected {expected_name!r}"
+ assert qualifier == expected_q, f"{uri!r} → qualifier={qualifier!r}, expected {expected_q!r}"