Light, fluffy, and always free - The AWS Local Emulator alternative
feat(lambda): manage code signing configurations (#4286)
lex0041ceed4dba4d
diff --git a/docs/services/lambda.md b/docs/services/lambda.mdindex acfee960a9..8b22263bf2 100644--- a/docs/services/lambda.md+++ b/docs/services/lambda.md@@ -33,7 +33,12 @@ Floci Lambda runs your function code locally inside real Docker containers - clo| `GetPolicy` | Get the function resource policy || `RemovePermission` | Remove a resource-policy statement || `GetFunctionCodeSigningConfig` | Return code-signing config (always empty) |-| `ListFunctionsByCodeSigningConfig` | Validates the ARN; no code-signing config can exist, so every well-formed ARN returns `ResourceNotFoundException` |+| `ListFunctionsByCodeSigningConfig` | List functions carrying a config. Always empty, since nothing can attach one |+| `CreateCodeSigningConfig` | Create a code signing configuration |+| `GetCodeSigningConfig` | Read a code signing configuration |+| `UpdateCodeSigningConfig` | Update the members the request names |+| `DeleteCodeSigningConfig` | Delete a code signing configuration |+| `ListCodeSigningConfigs` | List the configurations in the region || `CreateFunctionUrlConfig` | Provision a function URL || `GetFunctionUrlConfig` | Read function URL config || `UpdateFunctionUrlConfig` | Update function URL config |@@ -305,7 +310,13 @@ These AWS Lambda operations have no handler in Floci. Calls will return `404` or- Layer permissions (`AddLayerVersionPermission`, `RemoveLayerVersionPermission`, `GetLayerVersionPolicy`)- Provisioned concurrency (`PutProvisionedConcurrencyConfig`, `GetProvisionedConcurrencyConfig`, `ListProvisionedConcurrencyConfigs`, `DeleteProvisionedConcurrencyConfig`)- `InvokeWithResponseStream`-- Code signing management (only `GetFunctionCodeSigningConfig` and `ListFunctionsByCodeSigningConfig` are wired; there is no `PutFunctionCodeSigningConfig` or `CreateCodeSigningConfig`, so no code-signing config can exist and `ListFunctionsByCodeSigningConfig` reports every well-formed ARN as `ResourceNotFoundException` — a malformed ARN or an out-of-range `MaxItems` is rejected with `InvalidParameterValueException` first)+- Code signing enforcement. A configuration is created, read, updated, deleted and listed, and+ nothing verifies a signature against it, so it never gates a deployment. Attaching one to a+ function is not wired either: there is no `PutFunctionCodeSigningConfig`, so+ `GetFunctionCodeSigningConfig` still reports an empty ARN and `ListFunctionsByCodeSigningConfig`+ always reports no functions. An unknown configuration is `ResourceNotFoundException`, and a+ malformed ARN or an out-of-range `MaxItems` is rejected with `InvalidParameterValueException`+ first## Configurationdiff --git a/src/main/java/io/github/hectorvent/floci/services/lambda/LambdaCodeSigningConfigFunctionsController.java b/src/main/java/io/github/hectorvent/floci/services/lambda/LambdaCodeSigningConfigFunctionsController.javaindex 2d2697e54c..2140856640 100644--- a/src/main/java/io/github/hectorvent/floci/services/lambda/LambdaCodeSigningConfigFunctionsController.java+++ b/src/main/java/io/github/hectorvent/floci/services/lambda/LambdaCodeSigningConfigFunctionsController.java@@ -1,19 +1,30 @@package io.github.hectorvent.floci.services.lambda;+import com.fasterxml.jackson.databind.ObjectMapper;+import com.fasterxml.jackson.databind.node.ObjectNode;import io.github.hectorvent.floci.core.common.AwsException;+import io.github.hectorvent.floci.core.common.RegionResolver;+import io.github.hectorvent.floci.services.lambda.model.CodeSigningConfig;+import jakarta.inject.Inject;import jakarta.ws.rs.Consumes;+import jakarta.ws.rs.DELETE;import jakarta.ws.rs.GET;+import jakarta.ws.rs.POST;+import jakarta.ws.rs.PUT;import jakarta.ws.rs.Path;import jakarta.ws.rs.PathParam;import jakarta.ws.rs.Produces;import jakarta.ws.rs.QueryParam;+import jakarta.ws.rs.core.Context;+import jakarta.ws.rs.core.HttpHeaders;import jakarta.ws.rs.core.MediaType;import jakarta.ws.rs.core.Response;+import java.util.List;import java.util.regex.Pattern;/**- * ListFunctionsByCodeSigningConfig: GET /2020-04-22/code-signing-configs/{CodeSigningConfigArn}/functions.+ * The code signing configuration resource, all under /2020-04-22/code-signing-configs.** <p>A separate class from {@link LambdaCodeSigningController} because it lives* under a different API version prefix (/2020-04-22 vs /2020-06-30) — JAX-RS@@ -21,16 +32,15 @@ import java.util.regex.Pattern;* one falls through to a more general catch-all route (S3's bucket-path matcher)* instead of matching here.</p>*- * <p>Floci does not implement code signing config management — there is no- * CreateCodeSigningConfig / PutFunctionCodeSigningConfig, so no code signing- * config can ever exist. That does <em>not</em> make an unconditional empty list- * the right answer: botocore models both {@code InvalidParameterValueException}- * and {@code ResourceNotFoundException} for this operation, and the only resource- * the path parameter can name is a code signing config. A malformed ARN is- * therefore a 400 and a well-formed ARN is a 404, because every well-formed ARN- * necessarily names a config that does not exist here. Returning 200 with an- * empty list would tell a caller that the config exists and simply has no- * functions attached, which is a different — and false — statement.</p>+ * <p>Create, Get, Update, Delete and List manage the configuration itself.+ * ListFunctionsByCodeSigningConfig reports which functions carry one, and always reports none:+ * attaching a configuration to a function is PutFunctionCodeSigningConfig, which is not+ * implemented, so nothing can be attached. It answers a configuration that does not exist with a+ * 404 rather than an empty list, because an empty list would say the configuration exists and+ * simply has no functions.</p>+ *+ * <p>Nothing here verifies a signature. Lambda's own code signing checks are not emulated, so a+ * configuration never gates a deployment.</p>*/@Path("/2020-04-22")@Produces(MediaType.APPLICATION_JSON)@@ -51,6 +61,19 @@ public class LambdaCodeSigningConfigFunctionsController {private static final int MAX_ITEMS_MIN = 1;private static final int MAX_ITEMS_MAX = 10000;+ private final LambdaCodeSigningConfigService service;+ private final RegionResolver regionResolver;+ private final ObjectMapper objectMapper;++ @Inject+ public LambdaCodeSigningConfigFunctionsController(LambdaCodeSigningConfigService service,+ RegionResolver regionResolver,+ ObjectMapper objectMapper) {+ this.service = service;+ this.regionResolver = regionResolver;+ this.objectMapper = objectMapper;+ }+/*** Validation order matches AWS: request parameters are rejected before the* resource is resolved, so a bad {@code MaxItems} is reported as such rather@@ -59,16 +82,95 @@ public class LambdaCodeSigningConfigFunctionsController {@GET@Path("/code-signing-configs/{codeSigningConfigArn}/functions")public Response listFunctionsByCodeSigningConfig(+ @Context HttpHeaders headers,@PathParam("codeSigningConfigArn") String codeSigningConfigArn,@QueryParam("Marker") String marker,@QueryParam("MaxItems") String maxItems) {requireValidArn(codeSigningConfigArn);parseMaxItems(maxItems);- // Marker is accepted and carries no state: the result set is always empty,- // so any marker addresses a page past the end and NextMarker is never emitted.+ // Resolving the config is what turns an unknown ARN into the 404. A known one has no+ // functions, since PutFunctionCodeSigningConfig is not implemented, so Marker addresses a+ // page past the end and NextMarker is never emitted.+ service.get(regionResolver.resolveRegion(headers), codeSigningConfigArn);++ ObjectNode root = objectMapper.createObjectNode();+ root.putArray("FunctionArns");+ return Response.ok(root).build();+ }++ @POST+ @Path("/code-signing-configs")+ public Response createCodeSigningConfig(@Context HttpHeaders headers, ObjectNode body) {+ String region = regionResolver.resolveRegion(headers);+ CodeSigningConfig config = service.create(region, regionResolver.getAccountId(),+ text(body, "Description"), allowedPublishers(body), policies(body));+ return Response.status(Response.Status.CREATED).entity(wrap(config)).build();+ }++ @GET+ @Path("/code-signing-configs/{codeSigningConfigArn}")+ public Response getCodeSigningConfig(@Context HttpHeaders headers,+ @PathParam("codeSigningConfigArn") String codeSigningConfigArn) {+ requireValidArn(codeSigningConfigArn);+ return Response.ok(wrap(service.get(regionResolver.resolveRegion(headers), codeSigningConfigArn))).build();+ }++ @PUT+ @Path("/code-signing-configs/{codeSigningConfigArn}")+ public Response updateCodeSigningConfig(@Context HttpHeaders headers,+ @PathParam("codeSigningConfigArn") String codeSigningConfigArn,+ ObjectNode body) {+ requireValidArn(codeSigningConfigArn);+ CodeSigningConfig config = service.update(regionResolver.resolveRegion(headers), codeSigningConfigArn,+ text(body, "Description"), allowedPublishers(body), policies(body));+ return Response.ok(wrap(config)).build();+ }++ @DELETE+ @Path("/code-signing-configs/{codeSigningConfigArn}")+ public Response deleteCodeSigningConfig(@Context HttpHeaders headers,+ @PathParam("codeSigningConfigArn") String codeSigningConfigArn) {+ requireValidArn(codeSigningConfigArn);+ service.delete(regionResolver.resolveRegion(headers), codeSigningConfigArn);+ return Response.noContent().build();+ }++ @GET+ @Path("/code-signing-configs")+ public Response listCodeSigningConfigs(@Context HttpHeaders headers,+ @QueryParam("Marker") String marker,+ @QueryParam("MaxItems") String maxItems) {+ parseMaxItems(maxItems);+ List<CodeSigningConfig> configs = service.list(regionResolver.resolveRegion(headers));+ ObjectNode root = objectMapper.createObjectNode();+ root.set("CodeSigningConfigs", objectMapper.valueToTree(configs));+ return Response.ok(root).build();+ }- throw new AwsException("ResourceNotFoundException",- "The code signing configuration " + codeSigningConfigArn + " does not exist.", 404);+ private ObjectNode wrap(CodeSigningConfig config) {+ ObjectNode root = objectMapper.createObjectNode();+ root.set("CodeSigningConfig", objectMapper.valueToTree(config));+ return root;+ }++ private static String text(ObjectNode body, String field) {+ return body == null || !body.hasNonNull(field) ? null : body.get(field).asText();+ }++ private CodeSigningConfig.AllowedPublishers allowedPublishers(ObjectNode body) {+ if (body == null || !body.hasNonNull("AllowedPublishers")) {+ return null;+ }+ return objectMapper.convertValue(body.get("AllowedPublishers"),+ CodeSigningConfig.AllowedPublishers.class);+ }++ private CodeSigningConfig.CodeSigningPolicies policies(ObjectNode body) {+ if (body == null || !body.hasNonNull("CodeSigningPolicies")) {+ return null;+ }+ return objectMapper.convertValue(body.get("CodeSigningPolicies"),+ CodeSigningConfig.CodeSigningPolicies.class);}private void requireValidArn(String arn) {diff --git a/src/main/java/io/github/hectorvent/floci/services/lambda/LambdaCodeSigningConfigService.java b/src/main/java/io/github/hectorvent/floci/services/lambda/LambdaCodeSigningConfigService.javanew file mode 100644index 0000000000..0e2d4400b8--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/lambda/LambdaCodeSigningConfigService.java@@ -0,0 +1,205 @@+package io.github.hectorvent.floci.services.lambda;++import com.fasterxml.jackson.core.type.TypeReference;+import io.github.hectorvent.floci.core.common.AwsArnUtils;+import io.github.hectorvent.floci.core.common.AwsException;+import io.github.hectorvent.floci.core.storage.StorageBackend;+import io.github.hectorvent.floci.core.storage.StorageFactory;+import io.github.hectorvent.floci.services.lambda.model.CodeSigningConfig;+import jakarta.enterprise.context.ApplicationScoped;+import jakarta.inject.Inject;++import java.security.SecureRandom;+import java.time.Instant;+import java.time.ZoneOffset;+import java.time.format.DateTimeFormatter;+import java.util.Comparator;+import java.util.List;+import java.util.Map;++/**+ * Code signing configurations, the resource CreateCodeSigningConfig manages.+ *+ * <p>Nothing is verified against these. Lambda's own signature checking is not emulated, so a+ * configuration is stored and reported back and never gates a deployment.+ */+@ApplicationScoped+public class LambdaCodeSigningConfigService {++ /**+ * Lowercase alphanumerics because the ARN is the stricter of the two patterns, not the id.+ * CodeSigningConfigId allows {@code csc-[a-zA-Z0-9-_\.]{17}}, while CodeSigningConfigArn ends+ * in {@code csc-[a-z0-9]{17}}. Widening this alphabet to match the id pattern would still mint+ * a conforming id and an ARN that no longer conforms.+ */+ private static final String ID_ALPHABET = "abcdefghijklmnopqrstuvwxyz0123456789";+ private static final int ID_LENGTH = 17;+ private static final int MAX_DESCRIPTION = 256;+ private static final int MAX_SIGNING_PROFILE_ARNS = 20;++ /** The model documents Warn as the default when the request names no policy. */+ static final String DEFAULT_UNTRUSTED_ARTIFACT_POLICY = "Warn";+ private static final List<String> POLICIES = List.of("Warn", "Enforce");++ private static final DateTimeFormatter LAST_MODIFIED =+ DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss.SSSXXX").withZone(ZoneOffset.UTC);++ private final StorageBackend<String, CodeSigningConfig> store;+ private final SecureRandom random = new SecureRandom();++ @Inject+ public LambdaCodeSigningConfigService(StorageFactory storageFactory) {+ this.store = storageFactory.create("lambda", "lambda-code-signing-configs.json",+ new TypeReference<Map<String, CodeSigningConfig>>() {});+ }++ public CodeSigningConfig create(String region, String accountId, String description,+ CodeSigningConfig.AllowedPublishers allowedPublishers,+ CodeSigningConfig.CodeSigningPolicies policies) {+ validateDescription(description);+ validateAllowedPublishers(allowedPublishers);+ validatePolicies(policies);++ String id = "csc-" + randomId();+ CodeSigningConfig config = new CodeSigningConfig();+ config.setCodeSigningConfigId(id);+ config.setCodeSigningConfigArn(+ AwsArnUtils.Arn.of("lambda", region, accountId, "code-signing-config:" + id).toString());+ config.setDescription(description);+ config.setAllowedPublishers(allowedPublishers);+ config.setCodeSigningPolicies(policies != null ? policies : defaultPolicies());+ config.setLastModified(now());+ store.put(key(region, id), config);+ return config;+ }++ public CodeSigningConfig get(String region, String arn) {+ return store.get(key(region, idFromArn(arn)))+ .orElseThrow(() -> notFound(arn));+ }++ /**+ * Applies only the members the request names. A member the request omits keeps its stored+ * value, which is what UpdateCodeSigningConfig does: every one of its inputs is optional.+ */+ public CodeSigningConfig update(String region, String arn, String description,+ CodeSigningConfig.AllowedPublishers allowedPublishers,+ CodeSigningConfig.CodeSigningPolicies policies) {+ CodeSigningConfig config = get(region, arn);+ // Every member is validated before any is applied. The store hands back the live instance,+ // so validating and setting in turn would leave an earlier member written when a later one+ // is rejected, and the request would have changed the configuration while answering 400.+ if (description != null) {+ validateDescription(description);+ }+ if (allowedPublishers != null) {+ validateAllowedPublishers(allowedPublishers);+ }+ if (policies != null) {+ validatePolicies(policies);+ }+ if (description != null) {+ config.setDescription(description);+ }+ if (allowedPublishers != null) {+ config.setAllowedPublishers(allowedPublishers);+ }+ if (policies != null) {+ config.setCodeSigningPolicies(policies);+ }+ config.setLastModified(now());+ store.put(key(region, config.getCodeSigningConfigId()), config);+ return config;+ }++ public void delete(String region, String arn) {+ String id = idFromArn(arn);+ if (store.get(key(region, id)).isEmpty()) {+ throw notFound(arn);+ }+ store.delete(key(region, id));+ }++ public List<CodeSigningConfig> list(String region) {+ String prefix = "csc::" + region + "::";+ return store.scan(k -> k.startsWith(prefix)).stream()+ .sorted(Comparator.comparing(CodeSigningConfig::getCodeSigningConfigId))+ .toList();+ }++ private static AwsException notFound(String arn) {+ return new AwsException("ResourceNotFoundException",+ "The code signing configuration " + arn + " does not exist.", 404);+ }++ private static void validateDescription(String description) {+ if (description != null && description.length() > MAX_DESCRIPTION) {+ throw new AwsException("InvalidParameterValueException",+ "Description must be at most " + MAX_DESCRIPTION + " characters.", 400);+ }+ }++ /**+ * AllowedPublishers is required and carries between one and twenty signing profile ARNs. An+ * empty list is refused rather than stored: a configuration that allows no publisher at all is+ * not a shape the API accepts.+ */+ private static void validateAllowedPublishers(CodeSigningConfig.AllowedPublishers publishers) {+ List<String> arns = publishers == null ? null : publishers.getSigningProfileVersionArns();+ if (arns == null || arns.isEmpty()) {+ throw new AwsException("InvalidParameterValueException",+ "AllowedPublishers must name at least one signing profile version ARN.", 400);+ }+ if (arns.size() > MAX_SIGNING_PROFILE_ARNS) {+ throw new AwsException("InvalidParameterValueException",+ "AllowedPublishers accepts at most " + MAX_SIGNING_PROFILE_ARNS+ + " signing profile version ARNs.", 400);+ }+ }++ private static void validatePolicies(CodeSigningConfig.CodeSigningPolicies policies) {+ if (policies == null) {+ return;+ }+ String policy = policies.getUntrustedArtifactOnDeployment();+ if (policy != null && !POLICIES.contains(policy)) {+ throw new AwsException("InvalidParameterValueException",+ "UntrustedArtifactOnDeployment must be one of " + POLICIES + ".", 400);+ }+ if (policy == null) {+ policies.setUntrustedArtifactOnDeployment(DEFAULT_UNTRUSTED_ARTIFACT_POLICY);+ }+ }++ private static CodeSigningConfig.CodeSigningPolicies defaultPolicies() {+ CodeSigningConfig.CodeSigningPolicies policies = new CodeSigningConfig.CodeSigningPolicies();+ policies.setUntrustedArtifactOnDeployment(DEFAULT_UNTRUSTED_ARTIFACT_POLICY);+ return policies;+ }++ /** The trailing segment of a code-signing-config ARN, or the value itself when it is an id. */+ static String idFromArn(String arn) {+ if (arn == null || arn.isBlank()) {+ throw new AwsException("InvalidParameterValueException",+ "CodeSigningConfigArn is required.", 400);+ }+ int colon = arn.lastIndexOf(':');+ return colon < 0 ? arn : arn.substring(colon + 1);+ }++ private static String key(String region, String id) {+ return "csc::" + region + "::" + id;+ }++ private static String now() {+ return LAST_MODIFIED.format(Instant.now());+ }++ private String randomId() {+ StringBuilder id = new StringBuilder(ID_LENGTH);+ for (int i = 0; i < ID_LENGTH; i++) {+ id.append(ID_ALPHABET.charAt(random.nextInt(ID_ALPHABET.length())));+ }+ return id.toString();+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/lambda/model/CodeSigningConfig.java b/src/main/java/io/github/hectorvent/floci/services/lambda/model/CodeSigningConfig.javanew file mode 100644index 0000000000..fad399fca0--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/lambda/model/CodeSigningConfig.java@@ -0,0 +1,69 @@+package io.github.hectorvent.floci.services.lambda.model;++import com.fasterxml.jackson.annotation.JsonInclude;+import com.fasterxml.jackson.annotation.JsonProperty;+import io.quarkus.runtime.annotations.RegisterForReflection;++import java.util.ArrayList;+import java.util.List;++/** A Lambda code signing configuration, as CreateCodeSigningConfig returns it. */+@RegisterForReflection+@JsonInclude(JsonInclude.Include.NON_NULL)+public class CodeSigningConfig {++ @JsonProperty("CodeSigningConfigId")+ private String codeSigningConfigId;++ @JsonProperty("CodeSigningConfigArn")+ private String codeSigningConfigArn;++ @JsonProperty("Description")+ private String description;++ @JsonProperty("AllowedPublishers")+ private AllowedPublishers allowedPublishers;++ @JsonProperty("CodeSigningPolicies")+ private CodeSigningPolicies codeSigningPolicies;++ @JsonProperty("LastModified")+ private String lastModified;++ public String getCodeSigningConfigId() { return codeSigningConfigId; }+ public void setCodeSigningConfigId(String codeSigningConfigId) { this.codeSigningConfigId = codeSigningConfigId; }+ public String getCodeSigningConfigArn() { return codeSigningConfigArn; }+ public void setCodeSigningConfigArn(String codeSigningConfigArn) { this.codeSigningConfigArn = codeSigningConfigArn; }+ public String getDescription() { return description; }+ public void setDescription(String description) { this.description = description; }+ public AllowedPublishers getAllowedPublishers() { return allowedPublishers; }+ public void setAllowedPublishers(AllowedPublishers allowedPublishers) { this.allowedPublishers = allowedPublishers; }+ public CodeSigningPolicies getCodeSigningPolicies() { return codeSigningPolicies; }+ public void setCodeSigningPolicies(CodeSigningPolicies codeSigningPolicies) { this.codeSigningPolicies = codeSigningPolicies; }+ public String getLastModified() { return lastModified; }+ public void setLastModified(String lastModified) { this.lastModified = lastModified; }++ @RegisterForReflection+ @JsonInclude(JsonInclude.Include.NON_NULL)+ public static class AllowedPublishers {+ @JsonProperty("SigningProfileVersionArns")+ private List<String> signingProfileVersionArns = new ArrayList<>();++ public List<String> getSigningProfileVersionArns() { return signingProfileVersionArns; }+ public void setSigningProfileVersionArns(List<String> signingProfileVersionArns) {+ this.signingProfileVersionArns = signingProfileVersionArns;+ }+ }++ @RegisterForReflection+ @JsonInclude(JsonInclude.Include.NON_NULL)+ public static class CodeSigningPolicies {+ @JsonProperty("UntrustedArtifactOnDeployment")+ private String untrustedArtifactOnDeployment;++ public String getUntrustedArtifactOnDeployment() { return untrustedArtifactOnDeployment; }+ public void setUntrustedArtifactOnDeployment(String untrustedArtifactOnDeployment) {+ this.untrustedArtifactOnDeployment = untrustedArtifactOnDeployment;+ }+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/lambda/LambdaCodeSigningConfigLifecycleIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/lambda/LambdaCodeSigningConfigLifecycleIntegrationTest.javanew file mode 100644index 0000000000..c34cef124c--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/lambda/LambdaCodeSigningConfigLifecycleIntegrationTest.java@@ -0,0 +1,158 @@+package io.github.hectorvent.floci.services.lambda;++import io.quarkus.test.junit.QuarkusTest;+import org.junit.jupiter.api.Test;++import java.util.List;++import static io.restassured.RestAssured.given;+import static org.hamcrest.Matchers.contains;+import static org.hamcrest.Matchers.hasItem;+import static org.hamcrest.Matchers.is;+import static org.hamcrest.Matchers.matchesRegex;+import static org.hamcrest.Matchers.nullValue;++/** Create, Get, Update, Delete and List for a code signing configuration. */+@QuarkusTest+class LambdaCodeSigningConfigLifecycleIntegrationTest {++ private static final String BASE = "/2020-04-22/code-signing-configs";+ private static final String PROFILE =+ "arn:aws:signer:us-east-1:000000000000:/signing-profiles/prof/AbCdEfGhIj";++ private static String create(String body) {+ return given().contentType("application/json").body(body)+ .when().post(BASE)+ .then().statusCode(201)+ .extract().path("CodeSigningConfig.CodeSigningConfigArn");+ }++ @Test+ void createReportsTheModelsIdAndArnShapeAndDefaultsThePolicy() {+ given()+ .contentType("application/json")+ .body("{\"AllowedPublishers\":{\"SigningProfileVersionArns\":[\"" + PROFILE + "\"]},"+ + "\"Description\":\"release artifacts\"}")+ .when()+ .post(BASE)+ .then()+ .statusCode(201)+ .body("CodeSigningConfig.CodeSigningConfigId", matchesRegex("csc-[a-z0-9]{17}"))+ .body("CodeSigningConfig.CodeSigningConfigArn",+ matchesRegex("arn:aws:lambda:us-east-1:\\d{12}:code-signing-config:csc-[a-z0-9]{17}"))+ .body("CodeSigningConfig.Description", is("release artifacts"))+ .body("CodeSigningConfig.AllowedPublishers.SigningProfileVersionArns", contains(PROFILE))+ // The model documents Warn as the default when the request names no policy.+ .body("CodeSigningConfig.CodeSigningPolicies.UntrustedArtifactOnDeployment", is("Warn"))+ .body("CodeSigningConfig.LastModified",+ matchesRegex("\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}\\.\\d{3}Z"));+ }++ @Test+ void getReadsBackWhatCreateStored() {+ String arn = create("{\"AllowedPublishers\":{\"SigningProfileVersionArns\":[\"" + PROFILE + "\"]},"+ + "\"CodeSigningPolicies\":{\"UntrustedArtifactOnDeployment\":\"Enforce\"}}");++ given().when().get(BASE + "/" + arn).then()+ .statusCode(200)+ .body("CodeSigningConfig.CodeSigningConfigArn", is(arn))+ .body("CodeSigningConfig.CodeSigningPolicies.UntrustedArtifactOnDeployment", is("Enforce"));+ }++ @Test+ void updateAppliesOnlyTheMembersTheRequestNames() {+ String arn = create("{\"AllowedPublishers\":{\"SigningProfileVersionArns\":[\"" + PROFILE + "\"]},"+ + "\"Description\":\"first\"}");++ // Description alone. AllowedPublishers is omitted and must survive.+ given().contentType("application/json").body("{\"Description\":\"second\"}")+ .when().put(BASE + "/" + arn)+ .then().statusCode(200)+ .body("CodeSigningConfig.Description", is("second"))+ .body("CodeSigningConfig.AllowedPublishers.SigningProfileVersionArns", contains(PROFILE));+ }++ @Test+ void aRejectedUpdateChangesNothing() {+ String arn = create("{\"AllowedPublishers\":{\"SigningProfileVersionArns\":[\"" + PROFILE + "\"]},"+ + "\"Description\":\"before\"}");++ // Valid Description, invalid AllowedPublishers. The description must not survive the 400.+ given().contentType("application/json")+ .body("{\"Description\":\"after\",\"AllowedPublishers\":{\"SigningProfileVersionArns\":[]}}")+ .when().put(BASE + "/" + arn)+ .then().statusCode(400)+ .body("__type", is("InvalidParameterValueException"));++ given().when().get(BASE + "/" + arn).then()+ .statusCode(200)+ .body("CodeSigningConfig.Description", is("before"));++ // The same shape with the policy as the rejected member.+ given().contentType("application/json")+ .body("{\"Description\":\"after\","+ + "\"CodeSigningPolicies\":{\"UntrustedArtifactOnDeployment\":\"Ignore\"}}")+ .when().put(BASE + "/" + arn)+ .then().statusCode(400);++ given().when().get(BASE + "/" + arn).then()+ .statusCode(200)+ .body("CodeSigningConfig.Description", is("before"));+ }++ @Test+ void listReturnsTheConfigsAndDeleteRemovesOne() {+ String arn = create("{\"AllowedPublishers\":{\"SigningProfileVersionArns\":[\"" + PROFILE + "\"]}}");++ given().when().get(BASE).then().statusCode(200)+ .body("CodeSigningConfigs.CodeSigningConfigArn", hasItem(arn));++ given().when().delete(BASE + "/" + arn).then().statusCode(204);+ given().when().get(BASE + "/" + arn).then().statusCode(404)+ .body("__type", is("ResourceNotFoundException"));+ given().when().delete(BASE + "/" + arn).then().statusCode(404);+ }++ @Test+ void anUnknownConfigIsNotFoundAndAKnownOneListsNoFunctions() {+ String arn = create("{\"AllowedPublishers\":{\"SigningProfileVersionArns\":[\"" + PROFILE + "\"]}}");++ // A config now exists, so the functions route reports an empty attachment list rather than+ // the 404 it had to give when no config could exist at all.+ given().when().get(BASE + "/" + arn + "/functions").then()+ .statusCode(200)+ .body("FunctionArns", is(List.of()))+ .body("NextMarker", nullValue());++ String missing = "arn:aws:lambda:us-east-1:000000000000:code-signing-config:csc-abcdefghij1234567";+ given().when().get(BASE + "/" + missing + "/functions").then().statusCode(404);+ }++ @Test+ void allowedPublishersIsRequiredAndBounded() {+ given().contentType("application/json").body("{\"Description\":\"no publishers\"}")+ .when().post(BASE).then().statusCode(400)+ .body("__type", is("InvalidParameterValueException"));++ given().contentType("application/json")+ .body("{\"AllowedPublishers\":{\"SigningProfileVersionArns\":[]}}")+ .when().post(BASE).then().statusCode(400);++ StringBuilder many = new StringBuilder();+ for (int i = 0; i < 21; i++) {+ many.append(i > 0 ? "," : "").append('"').append(PROFILE).append('"');+ }+ given().contentType("application/json")+ .body("{\"AllowedPublishers\":{\"SigningProfileVersionArns\":[" + many + "]}}")+ .when().post(BASE).then().statusCode(400);+ }++ @Test+ void anUnmodelledPolicyValueIsRejected() {+ given().contentType("application/json")+ .body("{\"AllowedPublishers\":{\"SigningProfileVersionArns\":[\"" + PROFILE + "\"]},"+ + "\"CodeSigningPolicies\":{\"UntrustedArtifactOnDeployment\":\"Ignore\"}}")+ .when().post(BASE).then().statusCode(400)+ .body("__type", is("InvalidParameterValueException"));+ }+}