Ministack: Free, open-source local AWS emulator - 60+ services, Terraform compatible, real databases. Free forever. MIT licensed.
Python awsaws-emulatoraws-localaws-sdkdevtoolsdockerdynamodbec2emulatorlambdalocalstacklocalstack-alternativeministackmock-awsopen-sourcepythons3sqsterraform
fix nested functions (#410)
Nahuel Nuceraa56da154d143
diff --git a/ministack/services/apigateway.py b/ministack/services/apigateway.pyindex 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, headersfrom ministack.core.lambda_runtime import get_or_create_workerfrom 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 Nonediff --git a/tests/test_apigatewayv2.py b/tests/test_apigatewayv2.pyindex 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}"