Light, fluffy, and always free - The AWS Local Emulator alternative
fix(ec2): honor DryRun when creating VPCs, subnets and security groups (#6823)
Jackson Priced7763fff8ebf
diff --git a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/Ec2CreateDryRunTest.java b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/Ec2CreateDryRunTest.javanew file mode 100644index 0000000000..3029f8283b--- /dev/null+++ b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/Ec2CreateDryRunTest.java@@ -0,0 +1,124 @@+package com.floci.test;++import org.junit.jupiter.api.DisplayName;+import org.junit.jupiter.api.Test;+import org.junit.jupiter.api.function.Executable;+import software.amazon.awssdk.services.ec2.Ec2Client;+import software.amazon.awssdk.services.ec2.model.Ec2Exception;+import software.amazon.awssdk.services.ec2.model.Filter;+import software.amazon.awssdk.services.ec2.model.ResourceType;+import software.amazon.awssdk.services.ec2.model.SecurityGroup;+import software.amazon.awssdk.services.ec2.model.Tag;+import software.amazon.awssdk.services.ec2.model.TagSpecification;++import static org.assertj.core.api.Assertions.assertThat;+import static org.junit.jupiter.api.Assertions.assertThrows;++/**+ * A create with DryRun answers DryRunOperation (HTTP 412) and creates nothing, so the same create+ * without DryRun then succeeds. A subnet or group dry run naming a missing VPC keeps the real create's+ * error.+ */+class Ec2CreateDryRunTest {++ @Test+ @DisplayName("CreateVpc with DryRun creates no VPC")+ void createVpcWithDryRun() {+ String marker = TestFixtures.uniqueName("compat-dry-run");+ TagSpecification nameTag = TagSpecification.builder().resourceType(ResourceType.VPC)+ .tags(Tag.builder().key("Name").value(marker).build()).build();+ try (Ec2Client ec2 = TestFixtures.ec2Client()) {+ try {+ expectDryRunOperation(() -> ec2.createVpc(r -> r.cidrBlock("10.212.0.0/16")+ .tagSpecifications(nameTag).dryRun(true)));+ assertThat(ec2.describeVpcs(r -> r.filters(byName(marker))).vpcs()).isEmpty();++ ec2.createVpc(r -> r.cidrBlock("10.212.0.0/16").tagSpecifications(nameTag));+ assertThat(ec2.describeVpcs(r -> r.filters(byName(marker))).vpcs()).hasSize(1);+ } finally {+ ec2.describeVpcs(r -> r.filters(byName(marker))).vpcs()+ .forEach(vpc -> ec2.deleteVpc(r -> r.vpcId(vpc.vpcId())));+ }+ }+ }++ @Test+ @DisplayName("CreateSubnet with DryRun creates no subnet and leaves its CIDR block free")+ void createSubnetWithDryRun() {+ try (Ec2Client ec2 = TestFixtures.ec2Client()) {+ String vpcId = ec2.createVpc(r -> r.cidrBlock("10.213.0.0/16")).vpc().vpcId();+ try {+ expectDryRunOperation(() -> ec2.createSubnet(r -> r.vpcId(vpcId)+ .cidrBlock("10.213.8.0/24").dryRun(true)));+ assertThat(ec2.describeSubnets(r -> r.filters(byVpc(vpcId))).subnets()).isEmpty();++ assertThat(ec2.createSubnet(r -> r.vpcId(vpcId).cidrBlock("10.213.8.0/24")).subnet().cidrBlock())+ .isEqualTo("10.213.8.0/24");+ } finally {+ ec2.describeSubnets(r -> r.filters(byVpc(vpcId))).subnets()+ .forEach(subnet -> ec2.deleteSubnet(r -> r.subnetId(subnet.subnetId())));+ ec2.deleteVpc(r -> r.vpcId(vpcId));+ }+ }+ }++ @Test+ @DisplayName("CreateSecurityGroup with DryRun creates no group and leaves its name free")+ void createSecurityGroupWithDryRun() {+ try (Ec2Client ec2 = TestFixtures.ec2Client()) {+ String vpcId = ec2.createVpc(r -> r.cidrBlock("10.214.0.0/16")).vpc().vpcId();+ try {+ expectDryRunOperation(() -> ec2.createSecurityGroup(r -> r.vpcId(vpcId)+ .groupName("compat-dry-run-sg").description("compatibility dry run").dryRun(true)));+ assertThat(ec2.describeSecurityGroups(r -> r.filters(byVpc(vpcId))).securityGroups())+ .extracting(SecurityGroup::groupName).containsExactly("default");++ assertThat(ec2.createSecurityGroup(r -> r.vpcId(vpcId)+ .groupName("compat-dry-run-sg").description("compatibility dry run")).groupId())+ .isNotBlank();+ } finally {+ ec2.describeSecurityGroups(r -> r.filters(byVpc(vpcId))).securityGroups().stream()+ .filter(group -> !"default".equals(group.groupName()))+ .forEach(group -> ec2.deleteSecurityGroup(r -> r.groupId(group.groupId())));+ ec2.deleteVpc(r -> r.vpcId(vpcId));+ }+ }+ }++ @Test+ @DisplayName("CreateSubnet with DryRun in a missing VPC keeps InvalidVpcID.NotFound")+ void createSubnetWithDryRunInAMissingVpc() {+ try (Ec2Client ec2 = TestFixtures.ec2Client()) {+ Ec2Exception error = assertThrows(Ec2Exception.class, () -> ec2.createSubnet(r -> r+ .vpcId("vpc-0123456789abcdef0").cidrBlock("10.215.8.0/24").dryRun(true)));+ assertThat(error.statusCode()).isEqualTo(400);+ assertThat(error.awsErrorDetails().errorCode()).isEqualTo("InvalidVpcID.NotFound");+ }+ }++ @Test+ @DisplayName("CreateSecurityGroup with DryRun in a missing VPC keeps InvalidVpcID.NotFound")+ void createSecurityGroupWithDryRunInAMissingVpc() {+ try (Ec2Client ec2 = TestFixtures.ec2Client()) {+ Ec2Exception error = assertThrows(Ec2Exception.class, () -> ec2.createSecurityGroup(r -> r+ .vpcId("vpc-0123456789abcdef0").groupName("compat-dry-run-missing-vpc")+ .description("compatibility dry run").dryRun(true)));+ assertThat(error.statusCode()).isEqualTo(400);+ assertThat(error.awsErrorDetails().errorCode()).isEqualTo("InvalidVpcID.NotFound");+ }+ }++ private static Filter byName(String name) {+ return Filter.builder().name("tag:Name").values(name).build();+ }++ private static Filter byVpc(String vpcId) {+ return Filter.builder().name("vpc-id").values(vpcId).build();+ }++ private static void expectDryRunOperation(Executable call) {+ Ec2Exception error = assertThrows(Ec2Exception.class, call);+ assertThat(error.statusCode()).isEqualTo(412);+ assertThat(error.awsErrorDetails().errorCode()).isEqualTo("DryRunOperation");+ }+}diff --git a/docs/services/ec2.md b/docs/services/ec2.mdindex b154a1cad7..9cfa564502 100644--- a/docs/services/ec2.md+++ b/docs/services/ec2.md@@ -294,7 +294,7 @@ naming different VPCs find nothing.| Action | Description ||--------|-------------|-| CreateVpc | Creates a VPC with the requested CIDR block. `InstanceTenancy` accepts `default` or `dedicated`; `host` is rejected with `InvalidParameterValue`, as on AWS. |+| CreateVpc | Creates a VPC with the requested CIDR block. `InstanceTenancy` accepts `default` or `dedicated`; `host` is rejected with `InvalidParameterValue`, as on AWS. `DryRun=true` is answered with `DryRunOperation` and creates nothing. A tag specification error keeps its own error; the CIDR block and the tenancy are checked only without `DryRun`. || DescribeVpcs | Lists or returns stored VPCs. || DeleteVpc | Deletes a VPC from the local EC2 store, together with its default security group and rules, main route table and default network ACL. Fails with `DependencyViolation` while the VPC still has a subnet, a security group, route table or network ACL other than those defaults, a VPC endpoint, an attached internet gateway or egress-only internet gateway, a transit gateway attachment, an Elastic Load Balancing v2 load balancer, or anything still holding a network interface in one of its subnets: an instance that is not terminated, a NAT gateway that is not deleted or failed, a standalone network interface, or an interface endpoint. || ModifyVpcAttribute | Updates supported VPC attributes. |@@ -320,7 +320,7 @@ private gateway lifecycles are not modelled.| Action | Description ||--------|-------------|-| CreateSubnet | Creates a subnet in a VPC. |+| CreateSubnet | Creates a subnet in a VPC. `DryRun=true` is answered with `DryRunOperation` and creates nothing. A tag specification error or a missing `VpcId` or VPC keeps its own error; the CIDR block, zone, IPv6 block and overlap with other subnets are checked only without `DryRun`. || DescribeSubnets | Lists or returns stored subnets. The `default-for-az` filter and its `defaultForAz` alias select default or non-default subnets; values are ORed and separate filters are ANDed. || DeleteSubnet | Deletes a subnet from the local EC2 store. Fails with `DependencyViolation` while the subnet still has a transit gateway attachment, an Elastic Load Balancing v2 load balancer, or anything holding a network interface in it: an instance that is not terminated, a NAT gateway that is not deleted or failed, a standalone network interface, or an interface endpoint. || ModifySubnetAttribute | Updates supported subnet attributes. |@@ -329,7 +329,7 @@ private gateway lifecycles are not modelled.| Action | Description ||--------|-------------|-| CreateSecurityGroup | Creates a security group in a VPC. |+| CreateSecurityGroup | Creates a security group in a VPC, the default VPC when `VpcId` is absent or empty. `DryRun=true` is answered with `DryRunOperation` and creates nothing. A tag specification error or a missing `GroupName`, `GroupDescription` or VPC keeps its own error; a taken group name is checked only without `DryRun`. || DescribeSecurityGroups | Lists or returns stored security groups. || DeleteSecurityGroup | Deletes a security group from the local EC2 store. || AuthorizeSecurityGroupIngress | Adds inbound permissions. Sources may be IPv4 ranges, IPv6 ranges, or another security group (`UserIdGroupPairs`, sent on the wire as `Groups`); prefix list sources are not stored. One rule is stored per source, each carrying its own description. |diff --git a/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2QueryHandler.java b/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2QueryHandler.javaindex 19d21ccad1..29804f1179 100644--- a/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2QueryHandler.java+++ b/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2QueryHandler.java@@ -1699,6 +1699,8 @@ public class Ec2QueryHandler {String cidrBlock = p.getFirst("CidrBlock");boolean amazonProvidedIpv6 = "true".equalsIgnoreCase(p.getFirst("AmazonProvidedIpv6CidrBlock"));List<Tag> vpcTags = parseTagsForResource(p, "vpc");+ // Answered before Ec2Service checks the CIDR block and the tenancy, an order AWS does not document.+ checkDryRun(p);Vpc vpc = service.createVpc(region, cidrBlock, false, amazonProvidedIpv6, p.getFirst("InstanceTenancy"));applyResourceTags(vpcTags, region, vpc.getVpcId());XmlBuilder xml = new XmlBuilder()@@ -3324,6 +3326,10 @@ public class Ec2QueryHandler {String azId = p.getFirst("AvailabilityZoneId");String ipv6CidrBlock = p.getFirst("Ipv6CidrBlock");List<Tag> tags = parseTagsForResource(p, "subnet", Set.of("subnet"));+ // A dry run needs the VPC to exist and is answered before the CIDR, zone and overlap checks.+ requireParameter(p, "VpcId");+ service.requireVpc(region, vpcId);+ checkDryRun(p);Subnet subnet = service.createSubnet(region, vpcId, cidrBlock, az, azId, ipv6CidrBlock);try {if (!tags.isEmpty()) {@@ -3402,6 +3408,9 @@ public class Ec2QueryHandler {String groupName = requireParameter(p, "GroupName");String description = requireParameter(p, "GroupDescription");String vpcId = p.getFirst("VpcId");+ // A dry run needs the (default) VPC to exist and is answered before the taken-name check.+ service.requireSecurityGroupVpc(region, vpcId);+ checkDryRun(p);SecurityGroup sg = service.createSecurityGroup(region, groupName, description, vpcId);applyResourceTags(resourceTags, region, sg.getGroupId());XmlBuilder xml = new XmlBuilder()diff --git a/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2Service.java b/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2Service.javaindex bd002f4f20..1cadc7bb87 100644--- a/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2Service.java+++ b/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2Service.java@@ -7620,13 +7620,17 @@ public class Ec2Service implements ContainerTeardown, ResourceProvider, Resettab// ─── Security Groups ───────────────────────────────────────────────────────- public SecurityGroup createSecurityGroup(String region, String groupName, String description, String vpcId) {+ /**+ * The VPC a new security group goes into: the one {@code vpcId} names, or the region's default VPC+ * when {@code vpcId} is absent or empty. Fails with InvalidVpcID.NotFound when that VPC does not exist.+ */+ public Vpc requireSecurityGroupVpc(String region, String vpcId) {ensureDefaultResources(region);- if (vpcId != null && !vpcId.isEmpty()) {- getRequiredVpc(region, vpcId);- } else {- vpcId = resolveDefaultVpcId(region);- }+ return getRequiredVpc(region, vpcId != null && !vpcId.isEmpty() ? vpcId : resolveDefaultVpcId(region));+ }++ public SecurityGroup createSecurityGroup(String region, String groupName, String description, String vpcId) {+ vpcId = requireSecurityGroupVpc(region, vpcId).getVpcId();// Check duplicateString finalVpcId = vpcId;boolean exists = securityGroups.scan(k -> true).stream()diff --git a/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2CreateDryRunIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2CreateDryRunIntegrationTest.javanew file mode 100644index 0000000000..8a0f950bb0--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2CreateDryRunIntegrationTest.java@@ -0,0 +1,261 @@+package io.github.hectorvent.floci.services.ec2;++import io.quarkus.test.junit.QuarkusTest;+import io.restassured.path.xml.XmlPath;+import io.restassured.response.ValidatableResponse;+import io.restassured.specification.RequestSpecification;+import org.junit.jupiter.api.Test;+import org.junit.jupiter.params.ParameterizedTest;+import org.junit.jupiter.params.provider.CsvSource;+import org.junit.jupiter.params.provider.ValueSource;++import java.util.UUID;++import static io.github.hectorvent.floci.testing.Ec2Requests.ec2;+import static org.hamcrest.Matchers.emptyOrNullString;+import static org.hamcrest.Matchers.equalTo;++/**+ * DryRun on CreateVpc, CreateSubnet and CreateSecurityGroup is answered with DryRunOperation and HTTP 412,+ * and nothing is created, so the real create that follows can still take the same CIDR block or group+ * name. A subnet or group dry run first needs the VPC it names to exist; Floci then answers it before the+ * CIDR block, tenancy, overlap and group name are checked, an order AWS does not document.+ */+@QuarkusTest+class Ec2CreateDryRunIntegrationTest {++ private static final String MISSING_VPC = "vpc-0123456789abcdef0";++ @Test+ void aCreateVpcDryRunCreatesNoVpc() {+ String name = "dryrun-" + UUID.randomUUID();+ try {+ assertDryRun(tagged(createVpc("10.91.0.0/16"), "vpc", name).formParam("DryRun", "true"));++ ec2("DescribeVpcs", "test", "us-east-1")+ .formParam("Filter.1.Name", "tag:Name")+ .formParam("Filter.1.Value.1", name)+ .post("/").then().statusCode(200)+ .body("DescribeVpcsResponse.vpcSet", emptyOrNullString());++ tagged(createVpc("10.91.0.0/16"), "vpc", name).formParam("DryRun", "false")+ .post("/").then().statusCode(200)+ .body("CreateVpcResponse.vpc.cidrBlock", equalTo("10.91.0.0/16"));+ } finally {+ deleteVpcsNamed(name);+ }+ }++ @Test+ void aCreateSubnetDryRunCreatesNoSubnetAndLeavesItsRangeFree() {+ String vpcId = createVpcId("10.92.0.0/16");+ try {+ assertDryRun(createSubnet(vpcId, "10.92.1.0/24").formParam("DryRun", "true"));++ ec2("DescribeSubnets", "test", "us-east-1")+ .formParam("Filter.1.Name", "vpc-id")+ .formParam("Filter.1.Value.1", vpcId)+ .post("/").then().statusCode(200)+ .body("DescribeSubnetsResponse.subnetSet", emptyOrNullString());++ createSubnet(vpcId, "10.92.1.0/24")+ .post("/").then().statusCode(200)+ .body("CreateSubnetResponse.subnet.cidrBlock", equalTo("10.92.1.0/24"));+ } finally {+ deleteVpcAndItsContents(vpcId);+ }+ }++ @Test+ void aCreateSecurityGroupDryRunCreatesNoGroupAndLeavesItsNameFree() {+ String vpcId = createVpcId("10.93.0.0/16");+ try {+ assertDryRun(createSecurityGroup(vpcId, "dryrun-group").formParam("DryRun", "true"));++ ec2("DescribeSecurityGroups", "test", "us-east-1")+ .formParam("Filter.1.Name", "vpc-id")+ .formParam("Filter.1.Value.1", vpcId)+ .post("/").then().statusCode(200)+ .body("DescribeSecurityGroupsResponse.securityGroupInfo.item.groupName", equalTo("default"));++ createSecurityGroup(vpcId, "dryrun-group")+ .post("/").then().statusCode(200)+ .body("CreateSecurityGroupResponse.return", equalTo("true"));+ } finally {+ deleteVpcAndItsContents(vpcId);+ }+ }++ /** A group dry run with no VpcId, or an empty one, is answered for the region's default VPC. */+ @ParameterizedTest+ @ValueSource(strings = {"absent", "empty"})+ void aGroupDryRunWithoutAVpcIdIsAnsweredForTheDefaultVpc(String vpcId) {+ String name = "dryrun-default-" + UUID.randomUUID();+ try {+ RequestSpecification dryRun = ec2("CreateSecurityGroup", "test", "us-east-1")+ .formParam("GroupName", name)+ .formParam("GroupDescription", "dry run test group")+ .formParam("DryRun", "true");+ if ("empty".equals(vpcId)) {+ dryRun.formParam("VpcId", "");+ }+ assertDryRun(dryRun);++ groupsNamed(name).body("DescribeSecurityGroupsResponse.securityGroupInfo", emptyOrNullString());+ } finally {+ for (String groupId : groupsNamed(name).extract().xmlPath()+ .getList("DescribeSecurityGroupsResponse.securityGroupInfo.item.groupId", String.class)) {+ ec2("DeleteSecurityGroup", "test", "us-east-1").formParam("GroupId", groupId).post("/").then().statusCode(200);+ }+ }+ }++ /**+ * A dry run whose real create would fail one of those checks is answered with DryRunOperation too,+ * and the same request without DryRun still fails with its own error.+ */+ @ParameterizedTest+ @CsvSource({+ "vpc-prefix-out-of-range, InvalidVpc.Range",+ "vpc-reserved-range, InvalidVpc.Range",+ "vpc-host-tenancy, InvalidParameterValue",+ "subnet-range-in-use, InvalidSubnet.Conflict",+ "subnet-outside-the-vpc, InvalidSubnet.Range",+ "group-name-taken, InvalidGroup.Duplicate"+ })+ void aDryRunIsAnsweredBeforeTheChecksThatFailTheRealCreate(String request, String errorCode) {+ String name = "dryrun-" + UUID.randomUUID();+ String vpcId = createVpcId("10.94.0.0/16");+ try {+ createSubnet(vpcId, "10.94.1.0/24").post("/").then().statusCode(200);+ createSecurityGroup(vpcId, "taken-group").post("/").then().statusCode(200);++ assertDryRun(failingCreate(request, vpcId, name).formParam("DryRun", "true"));++ failingCreate(request, vpcId, name)+ .post("/").then().statusCode(400)+ .body("Response.Errors.Error.Code", equalTo(errorCode));+ } finally {+ try {+ deleteVpcAndItsContents(vpcId);+ } finally {+ deleteVpcsNamed(name);+ }+ }+ }++ /**+ * A subnet or group dry run naming a VPC that does not exist, or a subnet dry run naming none, keeps the+ * error the real create gives, as a RunInstances dry run keeps the error of a missing subnet.+ */+ @ParameterizedTest+ @CsvSource({+ "subnet-in-missing-vpc, InvalidVpcID.NotFound",+ "subnet-without-vpc-id, MissingParameter",+ "group-in-missing-vpc, InvalidVpcID.NotFound"+ })+ void aDryRunKeepsTheErrorOfAMissingVpc(String request, String errorCode) {+ missingVpcCreate(request).formParam("DryRun", "true")+ .post("/").then().statusCode(400)+ .body("Response.Errors.Error.Code", equalTo(errorCode));++ missingVpcCreate(request)+ .post("/").then().statusCode(400)+ .body("Response.Errors.Error.Code", equalTo(errorCode));+ }++ private static RequestSpecification missingVpcCreate(String request) {+ return switch (request) {+ case "subnet-in-missing-vpc" -> createSubnet(MISSING_VPC, "10.97.1.0/24");+ case "subnet-without-vpc-id" -> ec2("CreateSubnet", "test", "us-east-1").formParam("CidrBlock", "10.97.1.0/24");+ case "group-in-missing-vpc" -> createSecurityGroup(MISSING_VPC, "missing-vpc-group");+ default -> throw new IllegalArgumentException(request);+ };+ }++ /** The failing request named by {@code request}; a VPC it might create carries the tag {@code name}. */+ private static RequestSpecification failingCreate(String request, String vpcId, String name) {+ return switch (request) {+ case "vpc-prefix-out-of-range" -> tagged(createVpc("10.0.0.0/8"), "vpc", name);+ case "vpc-reserved-range" -> tagged(createVpc("127.0.0.0/16"), "vpc", name);+ case "vpc-host-tenancy" -> tagged(createVpc("10.95.0.0/16"), "vpc", name)+ .formParam("InstanceTenancy", "host");+ case "subnet-range-in-use" -> createSubnet(vpcId, "10.94.1.0/24");+ case "subnet-outside-the-vpc" -> createSubnet(vpcId, "10.96.1.0/24");+ case "group-name-taken" -> createSecurityGroup(vpcId, "taken-group");+ default -> throw new IllegalArgumentException(request);+ };+ }++ private static void assertDryRun(RequestSpecification request) {+ request.post("/").then()+ .statusCode(412)+ .body("Response.Errors.Error.Code", equalTo("DryRunOperation"))+ .body("Response.Errors.Error.Message",+ equalTo("Request would have succeeded, but DryRun flag is set."));+ }++ private static ValidatableResponse groupsNamed(String name) {+ return ec2("DescribeSecurityGroups", "test", "us-east-1")+ .formParam("Filter.1.Name", "group-name")+ .formParam("Filter.1.Value.1", name)+ .post("/").then().statusCode(200);+ }++ private static RequestSpecification tagged(RequestSpecification request, String resourceType, String name) {+ return request+ .formParam("TagSpecification.1.ResourceType", resourceType)+ .formParam("TagSpecification.1.Tag.1.Key", "Name")+ .formParam("TagSpecification.1.Tag.1.Value", name);+ }++ private static RequestSpecification createVpc(String cidrBlock) {+ return ec2("CreateVpc", "test", "us-east-1").formParam("CidrBlock", cidrBlock);+ }++ private static RequestSpecification createSubnet(String vpcId, String cidrBlock) {+ return ec2("CreateSubnet", "test", "us-east-1").formParam("VpcId", vpcId).formParam("CidrBlock", cidrBlock);+ }++ private static RequestSpecification createSecurityGroup(String vpcId, String groupName) {+ return ec2("CreateSecurityGroup", "test", "us-east-1")+ .formParam("VpcId", vpcId)+ .formParam("GroupName", groupName)+ .formParam("GroupDescription", "dry run test group");+ }++ private static String createVpcId(String cidrBlock) {+ return createVpc(cidrBlock).post("/").then().statusCode(200)+ .extract().path("CreateVpcResponse.vpc.vpcId");+ }++ private static void deleteVpcsNamed(String name) {+ XmlPath vpcs = ec2("DescribeVpcs", "test", "us-east-1")+ .formParam("Filter.1.Name", "tag:Name")+ .formParam("Filter.1.Value.1", name)+ .post("/").then().statusCode(200).extract().xmlPath();+ for (String vpcId : vpcs.getList("DescribeVpcsResponse.vpcSet.item.vpcId", String.class)) {+ deleteVpcAndItsContents(vpcId);+ }+ }++ /** Deletes the VPC with every subnet and non-default group in it, including any a dry run left. */+ private static void deleteVpcAndItsContents(String vpcId) {+ XmlPath subnets = ec2("DescribeSubnets", "test", "us-east-1")+ .formParam("Filter.1.Name", "vpc-id")+ .formParam("Filter.1.Value.1", vpcId)+ .post("/").then().statusCode(200).extract().xmlPath();+ for (String subnetId : subnets.getList("DescribeSubnetsResponse.subnetSet.item.subnetId", String.class)) {+ ec2("DeleteSubnet", "test", "us-east-1").formParam("SubnetId", subnetId).post("/").then().statusCode(200);+ }+ XmlPath groups = ec2("DescribeSecurityGroups", "test", "us-east-1")+ .formParam("Filter.1.Name", "vpc-id")+ .formParam("Filter.1.Value.1", vpcId)+ .post("/").then().statusCode(200).extract().xmlPath();+ for (String groupId : groups.getList("DescribeSecurityGroupsResponse.securityGroupInfo.item"+ + ".findAll { it.groupName != 'default' }.groupId", String.class)) {+ ec2("DeleteSecurityGroup", "test", "us-east-1").formParam("GroupId", groupId).post("/").then().statusCode(200);+ }+ ec2("DeleteVpc", "test", "us-east-1").formParam("VpcId", vpcId).post("/").then().statusCode(200);+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2QueryHandlerTest.java b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2QueryHandlerTest.javaindex f15fe1284d..359ce3b562 100644--- a/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2QueryHandlerTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2QueryHandlerTest.java@@ -1,6 +1,7 @@package io.github.hectorvent.floci.services.ec2;import io.github.hectorvent.floci.config.EmulatorConfig;+import io.github.hectorvent.floci.core.common.AwsException;import io.github.hectorvent.floci.core.common.AwsPartition;import io.github.hectorvent.floci.core.common.RegionResolver;import io.github.hectorvent.floci.services.ec2.model.BlockDeviceMapping;@@ -616,6 +617,44 @@ class Ec2QueryHandlerTest {return (String) response.getEntity();}+ /** A rejected tag specification keeps its error on a dry run: the tags are read before DryRun is answered. */+ @ParameterizedTest+ @CsvSource({"CreateVpc,vpc,InvalidParameter", "CreateSubnet,subnet,InvalidParameter",+ "CreateSecurityGroup,security-group,InvalidParameterValue"})+ void aDryRunKeepsTheErrorOfAReservedTagKey(String action, String resourceType, String code) {+ Ec2Service service = mock(Ec2Service.class);+ MultivaluedMap<String, String> params = createSubnetParams("10.38.1.0/24");+ params.putSingle("GroupName", "test");+ params.putSingle("GroupDescription", "test");+ params.putSingle("DryRun", "true");+ params.putSingle("TagSpecification.1.ResourceType", resourceType);+ params.putSingle("TagSpecification.1.Tag.1.Key", "aws:reserved");+ params.putSingle("TagSpecification.1.Tag.1.Value", "invalid");++ Response response = handler(service).handle(action, params, "us-east-1");++ assertEquals(400, response.getStatus());+ assertTrue(response.getEntity().toString().contains("<Code>" + code + "</Code>"));+ verifyNoInteractions(service);+ }++ @Test+ void aSecurityGroupDryRunWithoutAVpcIdNeedsTheDefaultVpcToExist() {+ Ec2Service service = mock(Ec2Service.class);+ when(service.requireSecurityGroupVpc("us-east-1", null)).thenThrow(new AwsException(+ "InvalidVpcID.NotFound", "The vpc ID 'vpc-default-us-east-1' does not exist", 400));+ MultivaluedMap<String, String> params = new MultivaluedHashMap<>();+ params.putSingle("GroupName", "test");+ params.putSingle("GroupDescription", "test");+ params.putSingle("DryRun", "true");++ Response response = handler(service).handle("CreateSecurityGroup", params, "us-east-1");++ assertEquals(400, response.getStatus());+ assertTrue(response.getEntity().toString().contains("<Code>InvalidVpcID.NotFound</Code>"));+ verify(service, never()).createSecurityGroup(any(), any(), any(), any());+ }+private Ec2QueryHandler handler(Ec2Service service) {return handler(service, new RegionResolver("us-east-1", "000000000000"));}