Light, fluffy, and always free - The AWS Local Emulator alternative
feat(ec2): support transit gateway route tables, associations and routes (#2348)
Michal Schreiberbc0f88c9b1df
diff --git a/compatibility-tests/sdk-test-awscli/test/ec2.bats b/compatibility-tests/sdk-test-awscli/test/ec2.batsindex f56a6c65e9..1785574c05 100644--- a/compatibility-tests/sdk-test-awscli/test/ec2.bats+++ b/compatibility-tests/sdk-test-awscli/test/ec2.bats@@ -11,12 +11,17 @@ setup() {TRANSIT_GATEWAY_ID=""TGW_ATTACHMENT_ID=""TGW_VPC_ID=""+ TGW_ROUTE_TABLE_ID=""}teardown() {if [ -n "$PREFIX_LIST_ID" ]; thenaws_cmd ec2 delete-managed-prefix-list --prefix-list-id "$PREFIX_LIST_ID" >/dev/null 2>&1 || truefi+ if [ -n "$TGW_ROUTE_TABLE_ID" ]; then+ aws_cmd ec2 delete-transit-gateway-route-table \+ --transit-gateway-route-table-id "$TGW_ROUTE_TABLE_ID" >/dev/null 2>&1 || true+ fiif [ -n "$TGW_ATTACHMENT_ID" ]; thenaws_cmd ec2 delete-transit-gateway-vpc-attachment \--transit-gateway-attachment-id "$TGW_ATTACHMENT_ID" >/dev/null 2>&1 || true@@ -441,3 +446,163 @@ create_attachment_fixture() {assert_successTRANSIT_GATEWAY_ID=""}++# ─── transit gateway route tables, associations, propagations and routes ────++@test "EC2: route table associations move between tables" {+ create_attachment_fixture+ local out+ out=$(aws_cmd ec2 create-transit-gateway-vpc-attachment --transit-gateway-id "$TRANSIT_GATEWAY_ID" \+ --vpc-id "$TGW_VPC_ID" --subnet-ids "$TGW_SUBNET_ID")+ TGW_ATTACHMENT_ID=$(json_get "$out" '.TransitGatewayVpcAttachment.TransitGatewayAttachmentId')+ out=$(aws_cmd ec2 describe-transit-gateways --transit-gateway-ids "$TRANSIT_GATEWAY_ID")+ local default_rtb+ default_rtb=$(json_get "$out" '.TransitGateways[0].Options.AssociationDefaultRouteTableId')++ run aws_cmd ec2 create-transit-gateway-route-table --transit-gateway-id "$TRANSIT_GATEWAY_ID" \+ --tag-specifications 'ResourceType=transit-gateway-route-table,Tags=[{Key=Name,Value=bats-rtb}]'+ assert_success+ TGW_ROUTE_TABLE_ID=$(json_get "$output" '.TransitGatewayRouteTable.TransitGatewayRouteTableId')+ [ "$(json_get "$output" '.TransitGatewayRouteTable.State')" = "available" ]+ [ "$(json_get "$output" '.TransitGatewayRouteTable.DefaultAssociationRouteTable')" = "false" ]++ # The attachment starts on the gateway's default table, so a second association is refused.+ run aws_cmd ec2 associate-transit-gateway-route-table \+ --transit-gateway-route-table-id "$TGW_ROUTE_TABLE_ID" \+ --transit-gateway-attachment-id "$TGW_ATTACHMENT_ID"+ assert_failure+ assert_output --partial "Resource.AlreadyAssociated"++ run aws_cmd ec2 disassociate-transit-gateway-route-table \+ --transit-gateway-route-table-id "$default_rtb" \+ --transit-gateway-attachment-id "$TGW_ATTACHMENT_ID"+ assert_success+ [ "$(json_get "$output" '.Association.State')" = "disassociating" ]++ run aws_cmd ec2 associate-transit-gateway-route-table \+ --transit-gateway-route-table-id "$TGW_ROUTE_TABLE_ID" \+ --transit-gateway-attachment-id "$TGW_ATTACHMENT_ID"+ assert_success+ [ "$(json_get "$output" '.Association.State')" = "associating" ]++ run aws_cmd ec2 get-transit-gateway-route-table-associations \+ --transit-gateway-route-table-id "$TGW_ROUTE_TABLE_ID"+ assert_success+ [ "$(json_get "$output" '.Associations[0].TransitGatewayAttachmentId')" = "$TGW_ATTACHMENT_ID" ]+ [ "$(json_get "$output" '.Associations[0].ResourceType')" = "vpc" ]+}++@test "EC2: propagation produces a route for the attached VPC" {+ create_attachment_fixture+ local out+ out=$(aws_cmd ec2 create-transit-gateway-vpc-attachment --transit-gateway-id "$TRANSIT_GATEWAY_ID" \+ --vpc-id "$TGW_VPC_ID" --subnet-ids "$TGW_SUBNET_ID")+ TGW_ATTACHMENT_ID=$(json_get "$out" '.TransitGatewayVpcAttachment.TransitGatewayAttachmentId')+ out=$(aws_cmd ec2 create-transit-gateway-route-table --transit-gateway-id "$TRANSIT_GATEWAY_ID")+ TGW_ROUTE_TABLE_ID=$(json_get "$out" '.TransitGatewayRouteTable.TransitGatewayRouteTableId')++ run aws_cmd ec2 enable-transit-gateway-route-table-propagation \+ --transit-gateway-route-table-id "$TGW_ROUTE_TABLE_ID" \+ --transit-gateway-attachment-id "$TGW_ATTACHMENT_ID"+ assert_success+ [ "$(json_get "$output" '.Propagation.State')" = "enabled" ]++ run aws_cmd ec2 get-transit-gateway-route-table-propagations \+ --transit-gateway-route-table-id "$TGW_ROUTE_TABLE_ID"+ assert_success+ [ "$(json_get "$output" '.TransitGatewayRouteTablePropagations[0].State')" = "enabled" ]++ run aws_cmd ec2 search-transit-gateway-routes \+ --transit-gateway-route-table-id "$TGW_ROUTE_TABLE_ID" \+ --filters 'Name=type,Values=propagated'+ assert_success+ [ "$(json_get "$output" '.Routes[0].DestinationCidrBlock')" = "10.80.0.0/16" ]+ [ "$(json_get "$output" '.Routes[0].Type')" = "propagated" ]+ [ "$(json_get "$output" '.Routes[0].State')" = "active" ]++ run aws_cmd ec2 enable-transit-gateway-route-table-propagation \+ --transit-gateway-route-table-id "$TGW_ROUTE_TABLE_ID" \+ --transit-gateway-attachment-id "$TGW_ATTACHMENT_ID"+ assert_failure+ assert_output --partial "TransitGatewayRouteTablePropagation.Duplicate"+}++@test "EC2: static and blackhole transit gateway routes" {+ create_attachment_fixture+ local out+ out=$(aws_cmd ec2 create-transit-gateway-vpc-attachment --transit-gateway-id "$TRANSIT_GATEWAY_ID" \+ --vpc-id "$TGW_VPC_ID" --subnet-ids "$TGW_SUBNET_ID")+ TGW_ATTACHMENT_ID=$(json_get "$out" '.TransitGatewayVpcAttachment.TransitGatewayAttachmentId')+ out=$(aws_cmd ec2 create-transit-gateway-route-table --transit-gateway-id "$TRANSIT_GATEWAY_ID")+ TGW_ROUTE_TABLE_ID=$(json_get "$out" '.TransitGatewayRouteTable.TransitGatewayRouteTableId')++ run aws_cmd ec2 create-transit-gateway-route \+ --transit-gateway-route-table-id "$TGW_ROUTE_TABLE_ID" \+ --destination-cidr-block 10.60.0.0/16 \+ --transit-gateway-attachment-id "$TGW_ATTACHMENT_ID"+ assert_success+ [ "$(json_get "$output" '.Route.Type')" = "static" ]+ [ "$(json_get "$output" '.Route.State')" = "active" ]+ [ "$(json_get "$output" '.Route.TransitGatewayAttachments[0].TransitGatewayAttachmentId')" = "$TGW_ATTACHMENT_ID" ]++ run aws_cmd ec2 create-transit-gateway-route \+ --transit-gateway-route-table-id "$TGW_ROUTE_TABLE_ID" \+ --destination-cidr-block 10.61.0.0/16 --blackhole+ assert_success+ [ "$(json_get "$output" '.Route.State')" = "blackhole" ]+ # A blackhole carries no attachment, so the key is absent rather than empty.+ count=$(json_get "$output" '.Route.TransitGatewayAttachments // [] | length')+ [ "$count" = "0" ]++ run aws_cmd ec2 search-transit-gateway-routes \+ --transit-gateway-route-table-id "$TGW_ROUTE_TABLE_ID" \+ --filters 'Name=type,Values=static'+ assert_success+ count=$(json_get "$output" '.Routes | length')+ [ "$count" = "2" ]++ run aws_cmd ec2 delete-transit-gateway-route \+ --transit-gateway-route-table-id "$TGW_ROUTE_TABLE_ID" \+ --destination-cidr-block 10.61.0.0/16+ assert_success+ [ "$(json_get "$output" '.Route.State')" = "deleted" ]+}++@test "EC2: replacing a transit gateway route moves its target and upserts" {+ create_attachment_fixture+ local out+ out=$(aws_cmd ec2 create-transit-gateway-vpc-attachment --transit-gateway-id "$TRANSIT_GATEWAY_ID" \+ --vpc-id "$TGW_VPC_ID" --subnet-ids "$TGW_SUBNET_ID")+ TGW_ATTACHMENT_ID=$(json_get "$out" '.TransitGatewayVpcAttachment.TransitGatewayAttachmentId')+ out=$(aws_cmd ec2 create-transit-gateway-route-table --transit-gateway-id "$TRANSIT_GATEWAY_ID")+ TGW_ROUTE_TABLE_ID=$(json_get "$out" '.TransitGatewayRouteTable.TransitGatewayRouteTableId')+ aws_cmd ec2 create-transit-gateway-route --transit-gateway-route-table-id "$TGW_ROUTE_TABLE_ID" \+ --destination-cidr-block 10.88.0.0/16 --transit-gateway-attachment-id "$TGW_ATTACHMENT_ID" >/dev/null++ run aws_cmd ec2 replace-transit-gateway-route \+ --transit-gateway-route-table-id "$TGW_ROUTE_TABLE_ID" \+ --destination-cidr-block 10.88.0.0/16 --blackhole+ assert_success+ [ "$(json_get "$output" '.Route.State')" = "blackhole" ]+ count=$(json_get "$output" '.Route.TransitGatewayAttachments // [] | length')+ [ "$count" = "0" ]++ run aws_cmd ec2 replace-transit-gateway-route \+ --transit-gateway-route-table-id "$TGW_ROUTE_TABLE_ID" \+ --destination-cidr-block 10.88.0.0/16 \+ --transit-gateway-attachment-id "$TGW_ATTACHMENT_ID"+ assert_success+ [ "$(json_get "$output" '.Route.State')" = "active" ]++ # Replacing a destination the table never held writes it.+ run aws_cmd ec2 replace-transit-gateway-route \+ --transit-gateway-route-table-id "$TGW_ROUTE_TABLE_ID" \+ --destination-cidr-block 10.89.0.0/16 --blackhole+ assert_success+ run aws_cmd ec2 search-transit-gateway-routes \+ --transit-gateway-route-table-id "$TGW_ROUTE_TABLE_ID" \+ --filters 'Name=type,Values=static'+ assert_success+ count=$(json_get "$output" '.Routes | length')+ [ "$count" = "2" ]+}diff --git a/docs/services/ec2.md b/docs/services/ec2.mdindex 4d4b39e6d6..794622da27 100644--- a/docs/services/ec2.md+++ b/docs/services/ec2.md@@ -372,6 +372,54 @@ trimmed the way AWS trims them: modify omits the `tagSet`, and delete omits boththe subnets. `Ipv6Support` is accepted without checking that the subnets carry IPv6 CIDRs, whichreal AWS rejects; Floci does not model subnet IPv6 allocation.+### Transit Gateway Route Tables++| Action | Description |+|--------|-------------|+| CreateTransitGatewayRouteTable | Creates a route table on a transit gateway. |+| DescribeTransitGatewayRouteTables | Lists or returns stored transit gateway route tables. |+| DeleteTransitGatewayRouteTable | Deletes a route table, along with its propagations and static routes. |+| AssociateTransitGatewayRouteTable | Associates an attachment with a route table. |+| DisassociateTransitGatewayRouteTable | Removes an attachment's association. |+| GetTransitGatewayRouteTableAssociations | Lists the attachments associated with a route table. |+| EnableTransitGatewayRouteTablePropagation | Propagates an attachment's routes into a route table. |+| DisableTransitGatewayRouteTablePropagation | Stops an attachment propagating into a route table. |+| GetTransitGatewayRouteTablePropagations | Lists the propagations into a route table. |+| CreateTransitGatewayRoute | Adds a static or blackhole route to a route table. |+| DeleteTransitGatewayRoute | Removes a static route. |+| ReplaceTransitGatewayRoute | Points an existing route at a different target, or writes it if absent. |+| SearchTransitGatewayRoutes | Returns a route table's routes, static and propagated, filtered. |++A route table asked for by name is never a default one; only the table a gateway mints for itself+carries `defaultAssociationRouteTable` or `defaultPropagationRouteTable`. Deleting a route table is+refused with `IncorrectState` while it is a gateway's default association table, and again while+attachments are still associated with it; the two cases carry different messages. Once it does go,+its propagations and static routes go with it.++An attachment is associated with exactly one route table at a time, so associating a second time+returns `Resource.AlreadyAssociated` rather than moving it — disassociate first. Association is+recorded on the attachment itself, which is why `GetTransitGatewayRouteTableAssociations` reports+the attachment's VPC as the associated resource.++Propagation is separate: one attachment may propagate into several route tables. Enabling twice+returns `TransitGatewayRouteTablePropagation.Duplicate`. Unlike association, which reports+`associating` and `disassociating`, propagation reports the settled `enabled` or `disabled` at+once — that is what the live API does rather than a shortcut taken here.++`ReplaceTransitGatewayRoute` is an upsert rather than an update: replacing a destination the table+has never held writes it instead of reporting it missing, which is what the live API does. The+target moves as a unit, so a route turned into a blackhole keeps no attachment and one pointed back+at an attachment regains all of its fields.++`SearchTransitGatewayRoutes` serves both kinds of route. Static routes are stored as written; a+blackhole is a static route in the `blackhole` state rather than a type of its own, and carries no+attachment. Propagated routes are derived when searched, from each enabled propagation joined to+the attached VPC's CIDR blocks, so a VPC's CIDRs changing cannot leave a stale route behind. A+route table's own listings drop the route table id that the mutating calls include, matching AWS.++Route table ids follow the live API's own inconsistency: an id that does not exist is+`InvalidRouteTableID.NotFound`, while one of the wrong shape is `InvalidRouteTableId.Malformed`.+### NAT Gateways| Action | 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 f8582c4efd..fc16e6d584 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@@ -99,6 +99,27 @@ public class Ec2QueryHandler {handleModifyTransitGatewayVpcAttachment(params, region);case "DeleteTransitGatewayVpcAttachment" ->handleDeleteTransitGatewayVpcAttachment(params, region);+ // Transit Gateway route tables, associations, propagations and routes+ case "CreateTransitGatewayRouteTable" -> handleCreateTransitGatewayRouteTable(params, region);+ case "DescribeTransitGatewayRouteTables" ->+ handleDescribeTransitGatewayRouteTables(params, region);+ case "DeleteTransitGatewayRouteTable" -> handleDeleteTransitGatewayRouteTable(params, region);+ case "AssociateTransitGatewayRouteTable" ->+ handleAssociateTransitGatewayRouteTable(params, region);+ case "DisassociateTransitGatewayRouteTable" ->+ handleDisassociateTransitGatewayRouteTable(params, region);+ case "GetTransitGatewayRouteTableAssociations" ->+ handleGetTransitGatewayRouteTableAssociations(params, region);+ case "EnableTransitGatewayRouteTablePropagation" ->+ handleEnableTransitGatewayRouteTablePropagation(params, region);+ case "DisableTransitGatewayRouteTablePropagation" ->+ handleDisableTransitGatewayRouteTablePropagation(params, region);+ case "GetTransitGatewayRouteTablePropagations" ->+ handleGetTransitGatewayRouteTablePropagations(params, region);+ case "CreateTransitGatewayRoute" -> handleCreateTransitGatewayRoute(params, region);+ case "DeleteTransitGatewayRoute" -> handleDeleteTransitGatewayRoute(params, region);+ case "ReplaceTransitGatewayRoute" -> handleReplaceTransitGatewayRoute(params, region);+ case "SearchTransitGatewayRoutes" -> handleSearchTransitGatewayRoutes(params, region);case "CreateDefaultVpc" -> handleCreateDefaultVpc(params, region);case "AssociateVpcCidrBlock" -> handleAssociateVpcCidrBlock(params, region);case "DisassociateVpcCidrBlock" -> handleDisassociateVpcCidrBlock(params, region);@@ -1381,6 +1402,234 @@ public class Ec2QueryHandler {return options;}+ private Response handleCreateTransitGatewayRouteTable(MultivaluedMap<String, String> p, String region) {+ TransitGatewayRouteTable routeTable = service.createTransitGatewayRouteTable(+ region, p.getFirst("TransitGatewayId"),+ parseTagsForResource(p, "transit-gateway-route-table"));+ XmlBuilder xml = new XmlBuilder()+ .start("CreateTransitGatewayRouteTableResponse", AwsNamespaces.EC2)+ .elem("requestId", UUID.randomUUID().toString())+ .start("transitGatewayRouteTable").raw(routeTableXml(routeTable, true))+ .end("transitGatewayRouteTable")+ .end("CreateTransitGatewayRouteTableResponse");+ return xmlResponse(xml.build());+ }++ private Response handleDescribeTransitGatewayRouteTables(MultivaluedMap<String, String> p, String region) {+ List<TransitGatewayRouteTable> routeTables = service.describeTransitGatewayRouteTables(+ region, getList(p, "TransitGatewayRouteTableIds"), getFilters(p));+ XmlBuilder xml = new XmlBuilder()+ .start("DescribeTransitGatewayRouteTablesResponse", AwsNamespaces.EC2)+ .elem("requestId", UUID.randomUUID().toString())+ .start("transitGatewayRouteTables");+ for (TransitGatewayRouteTable routeTable : routeTables) {+ xml.start("item").raw(routeTableXml(routeTable, true)).end("item");+ }+ xml.end("transitGatewayRouteTables").end("DescribeTransitGatewayRouteTablesResponse");+ return xmlResponse(xml.build());+ }++ private Response handleDeleteTransitGatewayRouteTable(MultivaluedMap<String, String> p, String region) {+ TransitGatewayRouteTable routeTable = service.deleteTransitGatewayRouteTable(+ region, p.getFirst("TransitGatewayRouteTableId"));+ XmlBuilder xml = new XmlBuilder()+ .start("DeleteTransitGatewayRouteTableResponse", AwsNamespaces.EC2)+ .elem("requestId", UUID.randomUUID().toString())+ .start("transitGatewayRouteTable").raw(routeTableXml(routeTable, false))+ .end("transitGatewayRouteTable")+ .end("DeleteTransitGatewayRouteTableResponse");+ return xmlResponse(xml.build());+ }++ private Response handleAssociateTransitGatewayRouteTable(MultivaluedMap<String, String> p, String region) {+ TransitGatewayVpcAttachment attachment = service.associateTransitGatewayRouteTable(+ region, p.getFirst("TransitGatewayRouteTableId"), p.getFirst("TransitGatewayAttachmentId"));+ // Verified live: the call reports the transitional state even though the association is+ // already recorded.+ return xmlResponse(new XmlBuilder()+ .start("AssociateTransitGatewayRouteTableResponse", AwsNamespaces.EC2)+ .elem("requestId", UUID.randomUUID().toString())+ .start("association").raw(associationXml(attachment, p.getFirst("TransitGatewayRouteTableId"),+ "associating", true)).end("association")+ .end("AssociateTransitGatewayRouteTableResponse").build());+ }++ private Response handleDisassociateTransitGatewayRouteTable(MultivaluedMap<String, String> p, String region) {+ String routeTableId = p.getFirst("TransitGatewayRouteTableId");+ TransitGatewayVpcAttachment attachment = service.disassociateTransitGatewayRouteTable(+ region, routeTableId, p.getFirst("TransitGatewayAttachmentId"));+ return xmlResponse(new XmlBuilder()+ .start("DisassociateTransitGatewayRouteTableResponse", AwsNamespaces.EC2)+ .elem("requestId", UUID.randomUUID().toString())+ .start("association").raw(associationXml(attachment, routeTableId, "disassociating", true))+ .end("association")+ .end("DisassociateTransitGatewayRouteTableResponse").build());+ }++ private Response handleGetTransitGatewayRouteTableAssociations(+ MultivaluedMap<String, String> p, String region) {+ String routeTableId = p.getFirst("TransitGatewayRouteTableId");+ List<TransitGatewayVpcAttachment> associated = service.associationsOf(region, routeTableId);+ XmlBuilder xml = new XmlBuilder()+ .start("GetTransitGatewayRouteTableAssociationsResponse", AwsNamespaces.EC2)+ .elem("requestId", UUID.randomUUID().toString())+ .start("associations");+ for (TransitGatewayVpcAttachment attachment : associated) {+ // The listing form carries no route table id: the caller named it in the request.+ xml.start("item").raw(associationXml(attachment, routeTableId, attachment.getAssociationState(), false))+ .end("item");+ }+ xml.end("associations").end("GetTransitGatewayRouteTableAssociationsResponse");+ return xmlResponse(xml.build());+ }++ private Response handleEnableTransitGatewayRouteTablePropagation(+ MultivaluedMap<String, String> p, String region) {+ TransitGatewayRouteTablePropagation propagation = service.enableTransitGatewayRouteTablePropagation(+ region, p.getFirst("TransitGatewayRouteTableId"), p.getFirst("TransitGatewayAttachmentId"));+ return xmlResponse(new XmlBuilder()+ .start("EnableTransitGatewayRouteTablePropagationResponse", AwsNamespaces.EC2)+ .elem("requestId", UUID.randomUUID().toString())+ .start("propagation").raw(propagationXml(propagation, true)).end("propagation")+ .end("EnableTransitGatewayRouteTablePropagationResponse").build());+ }++ private Response handleDisableTransitGatewayRouteTablePropagation(+ MultivaluedMap<String, String> p, String region) {+ TransitGatewayRouteTablePropagation propagation = service.disableTransitGatewayRouteTablePropagation(+ region, p.getFirst("TransitGatewayRouteTableId"), p.getFirst("TransitGatewayAttachmentId"));+ return xmlResponse(new XmlBuilder()+ .start("DisableTransitGatewayRouteTablePropagationResponse", AwsNamespaces.EC2)+ .elem("requestId", UUID.randomUUID().toString())+ .start("propagation").raw(propagationXml(propagation, true)).end("propagation")+ .end("DisableTransitGatewayRouteTablePropagationResponse").build());+ }++ private Response handleGetTransitGatewayRouteTablePropagations(+ MultivaluedMap<String, String> p, String region) {+ List<TransitGatewayRouteTablePropagation> propagations =+ service.propagationsOf(region, p.getFirst("TransitGatewayRouteTableId"));+ XmlBuilder xml = new XmlBuilder()+ .start("GetTransitGatewayRouteTablePropagationsResponse", AwsNamespaces.EC2)+ .elem("requestId", UUID.randomUUID().toString())+ .start("transitGatewayRouteTablePropagations");+ for (TransitGatewayRouteTablePropagation propagation : propagations) {+ // The listing form drops the route table id that enable and disable both carry.+ xml.start("item").raw(propagationXml(propagation, false)).end("item");+ }+ xml.end("transitGatewayRouteTablePropagations")+ .end("GetTransitGatewayRouteTablePropagationsResponse");+ return xmlResponse(xml.build());+ }++ private Response handleCreateTransitGatewayRoute(MultivaluedMap<String, String> p, String region) {+ TransitGatewayRoute route = service.createTransitGatewayRoute(+ region,+ p.getFirst("TransitGatewayRouteTableId"),+ p.getFirst("DestinationCidrBlock"),+ p.getFirst("TransitGatewayAttachmentId"),+ Boolean.parseBoolean(p.getFirst("Blackhole")));+ return xmlResponse(new XmlBuilder()+ .start("CreateTransitGatewayRouteResponse", AwsNamespaces.EC2)+ .elem("requestId", UUID.randomUUID().toString())+ .start("route").raw(routeXml(route)).end("route")+ .end("CreateTransitGatewayRouteResponse").build());+ }++ private Response handleReplaceTransitGatewayRoute(MultivaluedMap<String, String> p, String region) {+ TransitGatewayRoute route = service.replaceTransitGatewayRoute(+ region,+ p.getFirst("TransitGatewayRouteTableId"),+ p.getFirst("DestinationCidrBlock"),+ p.getFirst("TransitGatewayAttachmentId"),+ Boolean.parseBoolean(p.getFirst("Blackhole")));+ return xmlResponse(new XmlBuilder()+ .start("ReplaceTransitGatewayRouteResponse", AwsNamespaces.EC2)+ .elem("requestId", UUID.randomUUID().toString())+ .start("route").raw(routeXml(route)).end("route")+ .end("ReplaceTransitGatewayRouteResponse").build());+ }++ private Response handleDeleteTransitGatewayRoute(MultivaluedMap<String, String> p, String region) {+ TransitGatewayRoute route = service.deleteTransitGatewayRoute(+ region, p.getFirst("TransitGatewayRouteTableId"), p.getFirst("DestinationCidrBlock"));+ return xmlResponse(new XmlBuilder()+ .start("DeleteTransitGatewayRouteResponse", AwsNamespaces.EC2)+ .elem("requestId", UUID.randomUUID().toString())+ .start("route").raw(routeXml(route)).end("route")+ .end("DeleteTransitGatewayRouteResponse").build());+ }++ private Response handleSearchTransitGatewayRoutes(MultivaluedMap<String, String> p, String region) {+ List<TransitGatewayRoute> routes = service.searchTransitGatewayRoutes(+ region, p.getFirst("TransitGatewayRouteTableId"), getFilters(p));+ XmlBuilder xml = new XmlBuilder()+ .start("SearchTransitGatewayRoutesResponse", AwsNamespaces.EC2)+ .elem("requestId", UUID.randomUUID().toString())+ .start("routeSet");+ for (TransitGatewayRoute route : routes) {+ xml.start("item").raw(routeXml(route)).end("item");+ }+ xml.end("routeSet")+ .elem("additionalRoutesAvailable", "false")+ .end("SearchTransitGatewayRoutesResponse");+ return xmlResponse(xml.build());+ }++ private String routeTableXml(TransitGatewayRouteTable routeTable, boolean includeTags) {+ XmlBuilder xml = new XmlBuilder()+ .elem("transitGatewayRouteTableId", routeTable.getTransitGatewayRouteTableId())+ .elem("transitGatewayId", routeTable.getTransitGatewayId())+ .elem("state", routeTable.getState())+ .elem("defaultAssociationRouteTable", String.valueOf(routeTable.isDefaultAssociationRouteTable()))+ .elem("defaultPropagationRouteTable", String.valueOf(routeTable.isDefaultPropagationRouteTable()))+ .elem("creationTime", routeTable.getCreationTime());+ if (includeTags) {+ xml.raw(tagSetXml(routeTable.getTags()));+ }+ return xml.build();+ }++ private String associationXml(TransitGatewayVpcAttachment attachment, String routeTableId,+ String state, boolean includeRouteTableId) {+ XmlBuilder xml = new XmlBuilder();+ if (includeRouteTableId) {+ xml.elem("transitGatewayRouteTableId", routeTableId);+ }+ return xml.elem("transitGatewayAttachmentId", attachment.getTransitGatewayAttachmentId())+ .elem("resourceId", attachment.getVpcId())+ .elem("resourceType", "vpc")+ .elem("state", state)+ .build();+ }++ private String propagationXml(TransitGatewayRouteTablePropagation propagation, boolean includeRouteTableId) {+ XmlBuilder xml = new XmlBuilder()+ .elem("transitGatewayAttachmentId", propagation.getTransitGatewayAttachmentId())+ .elem("resourceId", propagation.getResourceId())+ .elem("resourceType", propagation.getResourceType());+ if (includeRouteTableId) {+ xml.elem("transitGatewayRouteTableId", propagation.getTransitGatewayRouteTableId());+ }+ return xml.elem("state", propagation.getState()).build();+ }++ private String routeXml(TransitGatewayRoute route) {+ XmlBuilder xml = new XmlBuilder()+ .elem("destinationCidrBlock", route.getDestinationCidrBlock());+ // A blackhole route, and a deleted one, carry no attachment at all.+ if (route.getTransitGatewayAttachmentId() != null) {+ xml.start("transitGatewayAttachments").start("item")+ .elem("resourceId", route.getResourceId())+ .elem("transitGatewayAttachmentId", route.getTransitGatewayAttachmentId())+ .elem("resourceType", route.getResourceType())+ .end("item").end("transitGatewayAttachments");+ }+ return xml.elem("type", route.getType())+ .elem("state", route.getState())+ .build();+ }+private String vpcAttachmentXml(TransitGatewayVpcAttachment attachment, boolean includeSubnets,boolean includeTags) {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 9dcab763f9..6af64590da 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@@ -7,6 +7,7 @@ import java.time.format.DateTimeFormatter;import java.util.ArrayList;import java.util.Base64;import java.util.Collections;+import java.util.Comparator;import java.util.HashSet;import java.util.LinkedHashMap;import java.util.LinkedHashSet;@@ -75,7 +76,9 @@ import io.github.hectorvent.floci.services.ec2.model.Subnet;import io.github.hectorvent.floci.services.ec2.model.Tag;import io.github.hectorvent.floci.services.ec2.model.TransitGateway;import io.github.hectorvent.floci.services.ec2.model.TransitGatewayOptions;+import io.github.hectorvent.floci.services.ec2.model.TransitGatewayRoute;import io.github.hectorvent.floci.services.ec2.model.TransitGatewayRouteTable;+import io.github.hectorvent.floci.services.ec2.model.TransitGatewayRouteTablePropagation;import io.github.hectorvent.floci.services.ec2.model.TransitGatewayVpcAttachment;import io.github.hectorvent.floci.services.ec2.model.TransitGatewayVpcAttachmentOptions;import io.github.hectorvent.floci.services.ec2.model.UserIdGroupPair;@@ -104,6 +107,8 @@ public class Ec2Service implements ContainerTeardown {// The ASN AWS assigns when CreateTransitGateway omits Options.AmazonSideAsn.private static final long DEFAULT_AMAZON_SIDE_ASN = 64512L;private static final Pattern TRANSIT_GATEWAY_ID_PATTERN = Pattern.compile("^tgw-[0-9a-f]{8}([0-9a-f]{9})?$");+ private static final Pattern TRANSIT_GATEWAY_ROUTE_TABLE_ID_PATTERN =+ Pattern.compile("^tgw-rtb-[0-9a-f]{8}([0-9a-f]{9})?$");private static final Pattern TRANSIT_GATEWAY_ATTACHMENT_ID_PATTERN =Pattern.compile("^tgw-attach-[0-9a-f]{8}([0-9a-f]{9})?$");@@ -139,6 +144,8 @@ public class Ec2Service implements ContainerTeardown {private final StorageBackend<String, TransitGateway> transitGateways;private final StorageBackend<String, TransitGatewayRouteTable> transitGatewayRouteTables;private final StorageBackend<String, TransitGatewayVpcAttachment> transitGatewayVpcAttachments;+ private final StorageBackend<String, TransitGatewayRouteTablePropagation> transitGatewayPropagations;+ private final StorageBackend<String, TransitGatewayRoute> transitGatewayRoutes;// resourceId → List<Tag>private final StorageBackend<String, List<Tag>> tags;private final Set<String> seededRegions = ConcurrentHashMap.newKeySet();@@ -174,7 +181,11 @@ public class Ec2Service implements ContainerTeardown {storageFactory.create("ec2", "ec2-transit-gateway-route-tables.json",new TypeReference<Map<String, TransitGatewayRouteTable>>() {}),storageFactory.create("ec2", "ec2-transit-gateway-vpc-attachments.json",- new TypeReference<Map<String, TransitGatewayVpcAttachment>>() {}));+ new TypeReference<Map<String, TransitGatewayVpcAttachment>>() {}),+ storageFactory.create("ec2", "ec2-transit-gateway-propagations.json",+ new TypeReference<Map<String, TransitGatewayRouteTablePropagation>>() {}),+ storageFactory.create("ec2", "ec2-transit-gateway-routes.json",+ new TypeReference<Map<String, TransitGatewayRoute>>() {}));}// Package-private for hermetic tests (pass in-memory or temp-dir-backed StorageBackends directly).@@ -205,7 +216,8 @@ public class Ec2Service implements ContainerTeardown {vpcs, subnets, securityGroups, securityGroupRules, internetGateways, routeTables, keyPairs,addresses, instances, volumes, registeredImages, snapshots, launchTemplates, vpcEndpoints,natGateways, spotInstanceRequests, networkAcls, managedPrefixLists, tags,- new InMemoryStorage<>(), new InMemoryStorage<>(), new InMemoryStorage<>());+ new InMemoryStorage<>(), new InMemoryStorage<>(), new InMemoryStorage<>(),+ new InMemoryStorage<>(), new InMemoryStorage<>());}// Package-private for hermetic tests, transit-gateway-aware. The shorter overload above keeps its@@ -235,7 +247,9 @@ public class Ec2Service implements ContainerTeardown {StorageBackend<String, List<Tag>> tags,StorageBackend<String, TransitGateway> transitGateways,StorageBackend<String, TransitGatewayRouteTable> transitGatewayRouteTables,- StorageBackend<String, TransitGatewayVpcAttachment> transitGatewayVpcAttachments) {+ StorageBackend<String, TransitGatewayVpcAttachment> transitGatewayVpcAttachments,+ StorageBackend<String, TransitGatewayRouteTablePropagation> transitGatewayPropagations,+ StorageBackend<String, TransitGatewayRoute> transitGatewayRoutes) {this.accountId = config.defaultAccountId();this.config = config;this.containerManager = containerManager;@@ -265,6 +279,8 @@ public class Ec2Service implements ContainerTeardown {this.transitGateways = transitGateways;this.transitGatewayRouteTables = transitGatewayRouteTables;this.transitGatewayVpcAttachments = transitGatewayVpcAttachments;+ this.transitGatewayPropagations = transitGatewayPropagations;+ this.transitGatewayRoutes = transitGatewayRoutes;}@PostConstruct@@ -911,6 +927,9 @@ public class Ec2Service implements ContainerTeardown {*/public TransitGateway createTransitGateway(String region, String description,TransitGatewayOptions requested, List<Tag> gatewayTags) {+ // Held here too, so the rule needs no exceptions: every write to a gateway, route table,+ // attachment, propagation or route happens under this one lock.+ synchronized (attachmentTopologyLock(region)) {String transitGatewayId = "tgw-" + randomHex(17);TransitGateway gateway = new TransitGateway();gateway.setTransitGatewayId(transitGatewayId);@@ -941,6 +960,7 @@ public class Ec2Service implements ContainerTeardown {}transitGateways.put(key(region, transitGatewayId), gateway);return gateway;+ }}private TransitGatewayOptions resolveTransitGatewayOptions(TransitGatewayOptions requested) {@@ -1023,6 +1043,10 @@ public class Ec2Service implements ContainerTeardown {public TransitGateway modifyTransitGateway(String region, String transitGatewayId, String description,TransitGatewayOptions changes, List<String> addCidrBlocks,List<String> removeCidrBlocks) {+ // Outermost first, as the deletes take it: this writes route tables through+ // markDefaultRouteTable, and a delete running between the read and that write would be+ // undone by it.+ synchronized (attachmentTopologyLock(region)) {synchronized (lockFor(key(region, transitGatewayId))) {TransitGateway gateway = getRequiredTransitGateway(region, transitGatewayId);requireCoherentDefaultRouteTableChange(region, gateway, changes);@@ -1044,6 +1068,7 @@ public class Ec2Service implements ContainerTeardown {transitGateways.put(key(region, transitGatewayId), gateway);return gateway;}+ }}/**@@ -1239,8 +1264,18 @@ public class Ec2Service implements ContainerTeardown {.filter(routeTable -> region.equals(routeTable.getRegion())).filter(routeTable -> transitGatewayId.equals(routeTable.getTransitGatewayId())).toList()- .forEach(routeTable -> transitGatewayRouteTables- .delete(key(region, routeTable.getTransitGatewayRouteTableId())));+ .forEach(routeTable -> {+ // What the table owned goes with it, or the propagations and routes+ // outlive the table they belong to and nothing can reach them again.+ String routeTableId = routeTable.getTransitGatewayRouteTableId();+ propagationsOf(region, routeTableId).forEach(propagation -> transitGatewayPropagations+ .delete(propagationKey(region, routeTableId,+ propagation.getTransitGatewayAttachmentId())));+ routesOf(region, routeTableId).forEach(route -> transitGatewayRoutes+ .delete(routeKey(region, routeTableId, route.getDestinationCidrBlock())));+ transitGatewayRouteTables.delete(key(region, routeTableId));+ tags.delete(routeTableId);+ });transitGateways.delete(key(region, transitGatewayId));tags.delete(transitGatewayId);gateway.setState("deleted");@@ -1451,9 +1486,33 @@ public class Ec2Service implements ContainerTeardown {}}+ /**+ * Deletes a VPC attachment and settles what pointed at it. Verified on a live account: the+ * attachment's propagations disappear, while a static route that named it survives as a+ * blackhole rather than being removed — the destination is still configured, it simply has+ * nowhere to go now.+ */public TransitGatewayVpcAttachment deleteTransitGatewayVpcAttachment(String region, String attachmentId) {synchronized (attachmentTopologyLock(region)) {TransitGatewayVpcAttachment attachment = getRequiredVpcAttachment(region, attachmentId);+ transitGatewayPropagations.scan(k -> true).stream()+ .filter(propagation -> region.equals(propagation.getRegion()))+ .filter(propagation -> attachmentId.equals(propagation.getTransitGatewayAttachmentId()))+ .toList()+ .forEach(propagation -> transitGatewayPropagations.delete(propagationKey(region,+ propagation.getTransitGatewayRouteTableId(), attachmentId)));+ transitGatewayRoutes.scan(k -> true).stream()+ .filter(route -> region.equals(route.getRegion()))+ .filter(route -> attachmentId.equals(route.getTransitGatewayAttachmentId()))+ .toList()+ .forEach(route -> {+ route.setState("blackhole");+ route.setTransitGatewayAttachmentId(null);+ route.setResourceId(null);+ route.setResourceType(null);+ transitGatewayRoutes.put(routeKey(region, route.getTransitGatewayRouteTableId(),+ route.getDestinationCidrBlock()), route);+ });transitGatewayVpcAttachments.delete(key(region, attachmentId));tags.delete(attachmentId);attachment.setState("deleted");@@ -1472,6 +1531,496 @@ public class Ec2Service implements ContainerTeardown {}}+ // ─── Transit Gateway Route Tables, Associations, Propagations and Routes ───++ /**+ * An attachment reached through a route table has to hang off the same gateway. Verified on a+ * live account: associating, propagating or routing to an attachment of another gateway is+ * refused as though the attachment did not exist, rather than with a mismatch of its own.+ */+ private TransitGatewayVpcAttachment requireAttachmentOfSameGateway(+ String region, TransitGatewayRouteTable routeTable, String attachmentId) {+ TransitGatewayVpcAttachment attachment = getRequiredVpcAttachment(region, attachmentId);+ if (!routeTable.getTransitGatewayId().equals(attachment.getTransitGatewayId())) {+ throw new AwsException("InvalidTransitGatewayAttachmentID.NotFound",+ "Transit Gateway Attachment " + attachmentId + " was deleted or does not exist.", 400);+ }+ return attachment;+ }++ public TransitGatewayRouteTable createTransitGatewayRouteTable(+ String region, String transitGatewayId, List<Tag> routeTableTags) {+ synchronized (attachmentTopologyLock(region)) {+ TransitGateway gateway = getRequiredTransitGateway(region, transitGatewayId);+ TransitGatewayRouteTable routeTable = new TransitGatewayRouteTable();+ String routeTableId = "tgw-rtb-" + randomHex(17);+ routeTable.setTransitGatewayRouteTableId(routeTableId);+ routeTable.setTransitGatewayId(gateway.getTransitGatewayId());+ // AWS reports pending and settles on available; nothing is slow locally.+ routeTable.setState("available");+ // A table asked for by name is never either default; only the one the gateway mints is.+ routeTable.setDefaultAssociationRouteTable(false);+ routeTable.setDefaultPropagationRouteTable(false);+ routeTable.setCreationTime(ISO_FMT.format(Instant.now()));+ routeTable.setRegion(region);+ if (routeTableTags != null && !routeTableTags.isEmpty()) {+ routeTable.setTags(new ArrayList<>(routeTableTags));+ tags.put(routeTableId, new ArrayList<>(routeTableTags));+ }+ transitGatewayRouteTables.put(key(region, routeTableId), routeTable);+ return routeTable;+ }+ }++ public List<TransitGatewayRouteTable> describeTransitGatewayRouteTables(+ String region, List<String> routeTableIds, Map<String, List<String>> filters) {+ routeTableIds.forEach(Ec2Service::requireWellFormedRouteTableId);+ List<TransitGatewayRouteTable> all = transitGatewayRouteTables.scan(k -> true).stream()+ .filter(routeTable -> region.equals(routeTable.getRegion()))+ .collect(Collectors.toList());+ for (String routeTableId : routeTableIds) {+ if (all.stream().noneMatch(rt -> rt.getTransitGatewayRouteTableId().equals(routeTableId))) {+ throw new AwsException("InvalidRouteTableID.NotFound",+ "Transit Gateway Route Table " + routeTableId + " was deleted or does not exist.", 400);+ }+ }+ return all.stream()+ .filter(rt -> routeTableIds.isEmpty() || routeTableIds.contains(rt.getTransitGatewayRouteTableId()))+ .filter(rt -> matchesFilters(rt, filters, region))+ .collect(Collectors.toList());+ }++ /**+ * Verified live: a route table will not go while it is a gateway's default association table,+ * nor while attachments are associated with it, and the two refusals carry different messages+ * under one {@code IncorrectState} code.+ */+ public TransitGatewayRouteTable deleteTransitGatewayRouteTable(String region, String routeTableId) {+ synchronized (attachmentTopologyLock(region)) {+ TransitGatewayRouteTable routeTable = getRequiredTransitGatewayRouteTable(region, routeTableId);+ TransitGateway gateway = transitGatewayRouteTables.get(key(region, routeTableId))+ .map(TransitGatewayRouteTable::getTransitGatewayId)+ .flatMap(id -> transitGateways.get(key(region, id)))+ .orElse(null);+ if (gateway != null+ && (routeTableId.equals(gateway.getOptions().getAssociationDefaultRouteTableId())+ || routeTableId.equals(gateway.getOptions().getPropagationDefaultRouteTableId()))) {+ throw new AwsException("IncorrectState", routeTableId+ + " is set as default association route table for " + gateway.getTransitGatewayId(), 400);+ }+ if (!associationsOf(region, routeTableId).isEmpty()) {+ throw new AwsException("IncorrectState", routeTableId + " has associated attachments", 400);+ }+ propagationsOf(region, routeTableId).forEach(propagation -> transitGatewayPropagations+ .delete(propagationKey(region, routeTableId, propagation.getTransitGatewayAttachmentId())));+ routesOf(region, routeTableId).forEach(route -> transitGatewayRoutes+ .delete(routeKey(region, routeTableId, route.getDestinationCidrBlock())));+ transitGatewayRouteTables.delete(key(region, routeTableId));+ tags.delete(routeTableId);+ routeTable.setState("deleted");+ return routeTable;+ }+ }++ /** An attachment associates with exactly one route table, so a second attempt is refused. */+ public TransitGatewayVpcAttachment associateTransitGatewayRouteTable(+ String region, String routeTableId, String attachmentId) {+ synchronized (attachmentTopologyLock(region)) {+ TransitGatewayRouteTable routeTable = getRequiredTransitGatewayRouteTable(region, routeTableId);+ TransitGatewayVpcAttachment attachment =+ requireAttachmentOfSameGateway(region, routeTable, attachmentId);+ if (attachment.getAssociationRouteTableId() != null) {+ throw new AwsException("Resource.AlreadyAssociated", "Transit Gateway Attachment "+ + attachmentId + " is already associated to a route table.", 400);+ }+ attachment.setAssociationRouteTableId(routeTableId);+ attachment.setAssociationState("associated");+ transitGatewayVpcAttachments.put(key(region, attachmentId), attachment);+ return attachment;+ }+ }++ public TransitGatewayVpcAttachment disassociateTransitGatewayRouteTable(+ String region, String routeTableId, String attachmentId) {+ synchronized (attachmentTopologyLock(region)) {+ TransitGatewayRouteTable routeTable = getRequiredTransitGatewayRouteTable(region, routeTableId);+ TransitGatewayVpcAttachment attachment =+ requireAttachmentOfSameGateway(region, routeTable, attachmentId);+ if (!routeTableId.equals(attachment.getAssociationRouteTableId())) {+ throw new AwsException("InvalidparameterValue", "Transit Gateway Attachment "+ + attachmentId + " is not associated with route table " + routeTableId + ".", 400);+ }+ attachment.setAssociationRouteTableId(null);+ attachment.setAssociationState(null);+ transitGatewayVpcAttachments.put(key(region, attachmentId), attachment);+ return attachment;+ }+ }++ /** The attachments associated with a route table, which is where an association is recorded. */+ public List<TransitGatewayVpcAttachment> associationsOf(String region, String routeTableId) {+ return transitGatewayVpcAttachments.scan(k -> true).stream()+ .filter(attachment -> region.equals(attachment.getRegion()))+ .filter(attachment -> routeTableId.equals(attachment.getAssociationRouteTableId()))+ .collect(Collectors.toList());+ }++ public TransitGatewayRouteTablePropagation enableTransitGatewayRouteTablePropagation(+ String region, String routeTableId, String attachmentId) {+ synchronized (attachmentTopologyLock(region)) {+ TransitGatewayRouteTable routeTable = getRequiredTransitGatewayRouteTable(region, routeTableId);+ TransitGatewayVpcAttachment attachment =+ requireAttachmentOfSameGateway(region, routeTable, attachmentId);+ if (transitGatewayPropagations.get(propagationKey(region, routeTableId, attachmentId)).isPresent()) {+ throw new AwsException("TransitGatewayRouteTablePropagation.Duplicate", "Propagation "+ + attachmentId + " already exists in Transit Gateway Route Table " + routeTableId + ".", 400);+ }+ TransitGatewayRouteTablePropagation propagation = new TransitGatewayRouteTablePropagation();+ propagation.setTransitGatewayRouteTableId(routeTableId);+ propagation.setTransitGatewayAttachmentId(attachmentId);+ propagation.setResourceId(attachment.getVpcId());+ propagation.setResourceType("vpc");+ // Verified live: propagation reports the settled state at once, where association+ // reports associating first.+ propagation.setState("enabled");+ propagation.setRegion(region);+ transitGatewayPropagations.put(propagationKey(region, routeTableId, attachmentId), propagation);+ return propagation;+ }+ }++ public TransitGatewayRouteTablePropagation disableTransitGatewayRouteTablePropagation(+ String region, String routeTableId, String attachmentId) {+ synchronized (attachmentTopologyLock(region)) {+ TransitGatewayRouteTable routeTable = getRequiredTransitGatewayRouteTable(region, routeTableId);+ requireAttachmentOfSameGateway(region, routeTable, attachmentId);+ TransitGatewayRouteTablePropagation propagation = transitGatewayPropagations+ .get(propagationKey(region, routeTableId, attachmentId))+ .orElseThrow(() -> new AwsException("InvalidparameterValue", "Propagation "+ + attachmentId + " does not exist in Transit Gateway Route Table "+ + routeTableId + ".", 400));+ transitGatewayPropagations.delete(propagationKey(region, routeTableId, attachmentId));+ propagation.setState("disabled");+ return propagation;+ }+ }++ public List<TransitGatewayRouteTablePropagation> propagationsOf(String region, String routeTableId) {+ return transitGatewayPropagations.scan(k -> true).stream()+ .filter(propagation -> region.equals(propagation.getRegion()))+ .filter(propagation -> routeTableId.equals(propagation.getTransitGatewayRouteTableId()))+ .collect(Collectors.toList());+ }++ public TransitGatewayRoute createTransitGatewayRoute(String region, String routeTableId,+ String destinationCidrBlock, String attachmentId,+ boolean blackhole) {+ synchronized (attachmentTopologyLock(region)) {+ getRequiredTransitGatewayRouteTable(region, routeTableId);+ if (destinationCidrBlock == null || destinationCidrBlock.isBlank()) {+ throw new AwsException("MissingParameter",+ "The request must contain the parameter DestinationCidrBlock.", 400);+ }+ if (transitGatewayRoutes.get(routeKey(region, routeTableId, destinationCidrBlock)).isPresent()) {+ throw new AwsException("RouteAlreadyExists", "Route " + destinationCidrBlock+ + " already exists in Transit Gateway Route Table " + routeTableId + ".", 400);+ }+ TransitGatewayRoute route = new TransitGatewayRoute();+ route.setTransitGatewayRouteTableId(routeTableId);+ route.setDestinationCidrBlock(destinationCidrBlock);+ // A blackhole is a state of a static route rather than a type, and carries no+ // attachment even when one was named.+ route.setType("static");+ route.setState(blackhole ? "blackhole" : "active");+ route.setRegion(region);+ if (!blackhole) {+ TransitGatewayVpcAttachment attachment = requireAttachmentOfSameGateway(region,+ getRequiredTransitGatewayRouteTable(region, routeTableId), attachmentId);+ route.setTransitGatewayAttachmentId(attachmentId);+ route.setResourceId(attachment.getVpcId());+ route.setResourceType("vpc");+ }+ transitGatewayRoutes.put(routeKey(region, routeTableId, destinationCidrBlock), route);+ return route;+ }+ }++ /**+ * Replaces a route's target, and writes the route when it is not there. Verified on a live+ * account: replacing a destination the table has never held creates it rather than reporting+ * it missing, so this is an upsert and not an update.+ */+ public TransitGatewayRoute replaceTransitGatewayRoute(String region, String routeTableId,+ String destinationCidrBlock, String attachmentId,+ boolean blackhole) {+ synchronized (attachmentTopologyLock(region)) {+ TransitGatewayRouteTable routeTable = getRequiredTransitGatewayRouteTable(region, routeTableId);+ if (destinationCidrBlock == null || destinationCidrBlock.isBlank()) {+ throw new AwsException("MissingParameter",+ "The request must contain the parameter DestinationCidrBlock.", 400);+ }+ TransitGatewayRoute route = transitGatewayRoutes+ .get(routeKey(region, routeTableId, destinationCidrBlock))+ .orElseGet(TransitGatewayRoute::new);+ route.setTransitGatewayRouteTableId(routeTableId);+ route.setDestinationCidrBlock(destinationCidrBlock);+ route.setType("static");+ route.setRegion(region);+ // The target moves as one: a blackhole keeps no attachment, and pointing the route at+ // an attachment again restores all three fields together.+ if (blackhole) {+ route.setState("blackhole");+ route.setTransitGatewayAttachmentId(null);+ route.setResourceId(null);+ route.setResourceType(null);+ } else {+ TransitGatewayVpcAttachment attachment =+ requireAttachmentOfSameGateway(region, routeTable, attachmentId);+ route.setState("active");+ route.setTransitGatewayAttachmentId(attachmentId);+ route.setResourceId(attachment.getVpcId());+ route.setResourceType("vpc");+ }+ transitGatewayRoutes.put(routeKey(region, routeTableId, destinationCidrBlock), route);+ return route;+ }+ }++ public TransitGatewayRoute deleteTransitGatewayRoute(String region, String routeTableId,+ String destinationCidrBlock) {+ synchronized (attachmentTopologyLock(region)) {+ getRequiredTransitGatewayRouteTable(region, routeTableId);+ TransitGatewayRoute route = transitGatewayRoutes+ .get(routeKey(region, routeTableId, destinationCidrBlock))+ .orElseThrow(() -> new AwsException("InvalidRoute.NotFound", "The route "+ + destinationCidrBlock + " does not exist in Transit Gateway Route Table "+ + routeTableId + ".", 400));+ transitGatewayRoutes.delete(routeKey(region, routeTableId, destinationCidrBlock));+ route.setState("deleted");+ route.setTransitGatewayAttachmentId(null);+ route.setResourceId(null);+ route.setResourceType(null);+ return route;+ }+ }++ /**+ * The static routes written into a table, plus the propagated ones, which are a view of the+ * enabled propagations joined to the attached VPC's CIDRs rather than records of their own.+ * Deriving them keeps a VPC's CIDR changes from leaving a stale route behind.+ */+ public List<TransitGatewayRoute> searchTransitGatewayRoutes(String region, String routeTableId,+ Map<String, List<String>> filters) {+ getRequiredTransitGatewayRouteTable(region, routeTableId);+ List<TransitGatewayRoute> routes = new ArrayList<>(routesOf(region, routeTableId));+ for (TransitGatewayRouteTablePropagation propagation : propagationsOf(region, routeTableId)) {+ TransitGatewayVpcAttachment attachment = transitGatewayVpcAttachments+ .get(key(region, propagation.getTransitGatewayAttachmentId())).orElse(null);+ if (attachment == null) {+ continue;+ }+ Vpc vpc = vpcs.get(key(region, attachment.getVpcId())).orElse(null);+ if (vpc == null) {+ continue;+ }+ for (String cidr : vpcCidrBlocks(vpc)) {+ TransitGatewayRoute route = new TransitGatewayRoute();+ route.setTransitGatewayRouteTableId(routeTableId);+ route.setDestinationCidrBlock(cidr);+ route.setTransitGatewayAttachmentId(attachment.getTransitGatewayAttachmentId());+ route.setResourceId(attachment.getVpcId());+ route.setResourceType("vpc");+ route.setType("propagated");+ route.setState("active");+ route.setRegion(region);+ routes.add(route);+ }+ }+ return applyRouteFilters(routes, filters);+ }++ /**+ * The route search filters, as the live API applies them. The three CIDR relationship filters+ * differ in the value they take, which is not something the reference spells out:+ * {@code supernet-of-match} and {@code subnet-of-match} take a CIDR and match inclusively in+ * either direction, while {@code longest-prefix-match} takes a bare address and returns the one+ * most specific route covering it. Handing either the other's value form returns nothing on+ * AWS, so the same holds here.+ *+ * <p>A filter name the API does not know is rejected rather than ignored: accepting it would+ * answer a question that was never asked.+ */+ private List<TransitGatewayRoute> applyRouteFilters(List<TransitGatewayRoute> routes,+ Map<String, List<String>> filters) {+ if (filters == null || filters.isEmpty()) {+ return routes;+ }+ List<TransitGatewayRoute> matched = new ArrayList<>(routes);+ for (Map.Entry<String, List<String>> filter : filters.entrySet()) {+ String name = filter.getKey();+ List<String> values = filter.getValue();+ switch (name) {+ case "type" -> matched.removeIf(route -> !matchesValue(values, route.getType()));+ case "state" -> matched.removeIf(route -> !matchesValue(values, route.getState()));+ case "route-search.exact-match" ->+ matched.removeIf(route -> !matchesValue(values, route.getDestinationCidrBlock()));+ case "attachment.transit-gateway-attachment-id" ->+ matched.removeIf(route -> !matchesValue(values, route.getTransitGatewayAttachmentId()));+ case "attachment.resource-id" ->+ matched.removeIf(route -> !matchesValue(values, route.getResourceId()));+ case "attachment.resource-type" ->+ matched.removeIf(route -> !matchesValue(values, route.getResourceType()));+ case "route-search.supernet-of-match" -> matched.removeIf(route -> values.stream()+ .noneMatch(value -> cidrContains(route.getDestinationCidrBlock(), value)));+ case "route-search.subnet-of-match" -> matched.removeIf(route -> values.stream()+ .noneMatch(value -> cidrContains(value, route.getDestinationCidrBlock())));+ case "route-search.longest-prefix-match" -> {+ List<TransitGatewayRoute> longest = new ArrayList<>();+ for (String address : values) {+ matched.stream()+ .filter(route -> cidrContainsAddress(route.getDestinationCidrBlock(), address))+ .max(Comparator.comparingInt(route ->+ prefixLengthOf(route.getDestinationCidrBlock())))+ .ifPresent(longest::add);+ }+ matched.retainAll(longest);+ }+ default -> throw new AwsException("InvalidParameterValue",+ "Value (" + name + ") for parameter Filter is invalid. ", 400);+ }+ }+ return matched;+ }++ /** Whether {@code outer} covers {@code inner}, both CIDRs, an equal pair counting as covered. */+ private boolean cidrContains(String outer, String inner) {+ int[] outerRange = cidrRange(outer);+ int[] innerRange = cidrRange(inner);+ if (outerRange == null || innerRange == null) {+ return false;+ }+ return outerRange[1] <= innerRange[1]+ && (innerRange[0] & maskOf(outerRange[1])) == outerRange[0];+ }++ /** Whether a CIDR covers a bare address, which is the form longest-prefix-match takes. */+ private boolean cidrContainsAddress(String cidr, String address) {+ if (address == null || address.contains("/")) {+ return false;+ }+ int[] range = cidrRange(cidr);+ Integer packed = packIpv4(address);+ if (range == null || packed == null) {+ return false;+ }+ return (packed & maskOf(range[1])) == range[0];+ }++ private int prefixLengthOf(String cidr) {+ int[] range = cidrRange(cidr);+ return range == null ? -1 : range[1];+ }++ /** The network address and prefix length of an IPv4 CIDR, or null when it is neither. */+ private int[] cidrRange(String cidr) {+ if (cidr == null) {+ return null;+ }+ int slash = cidr.indexOf('/');+ if (slash < 0) {+ return null;+ }+ Integer packed = packIpv4(cidr.substring(0, slash));+ if (packed == null) {+ return null;+ }+ int prefix;+ try {+ prefix = Integer.parseInt(cidr.substring(slash + 1));+ } catch (NumberFormatException e) {+ return null;+ }+ if (prefix < 0 || prefix > 32) {+ return null;+ }+ return new int[] {packed & maskOf(prefix), prefix};+ }++ private int maskOf(int prefixLength) {+ return prefixLength == 0 ? 0 : (int) (-1L << (32 - prefixLength));+ }++ private Integer packIpv4(String address) {+ String[] octets = address.split("\\.");+ if (octets.length != 4) {+ return null;+ }+ int packed = 0;+ for (String octet : octets) {+ int value;+ try {+ value = Integer.parseInt(octet);+ } catch (NumberFormatException e) {+ return null;+ }+ if (value < 0 || value > 255) {+ return null;+ }+ packed = (packed << 8) | value;+ }+ return packed;+ }++ private List<String> vpcCidrBlocks(Vpc vpc) {+ List<String> blocks = new ArrayList<>();+ if (vpc.getCidrBlock() != null) {+ blocks.add(vpc.getCidrBlock());+ }+ vpc.getCidrBlockAssociationSet().stream()+ .map(VpcCidrBlockAssociation::getCidrBlock)+ .filter(cidr -> cidr != null && !blocks.contains(cidr))+ .forEach(blocks::add);+ return blocks;+ }++ private List<TransitGatewayRoute> routesOf(String region, String routeTableId) {+ return transitGatewayRoutes.scan(k -> true).stream()+ .filter(route -> region.equals(route.getRegion()))+ .filter(route -> routeTableId.equals(route.getTransitGatewayRouteTableId()))+ .collect(Collectors.toList());+ }++ private String propagationKey(String region, String routeTableId, String attachmentId) {+ return key(region, routeTableId + "::" + attachmentId);+ }++ private String routeKey(String region, String routeTableId, String destinationCidrBlock) {+ return key(region, routeTableId + "::" + destinationCidrBlock);+ }++ private TransitGatewayRouteTable getRequiredTransitGatewayRouteTable(String region, String routeTableId) {+ if (routeTableId == null || routeTableId.isBlank()) {+ throw new AwsException("MissingParameter",+ "The request must contain the parameter TransitGatewayRouteTableId.", 400);+ }+ requireWellFormedRouteTableId(routeTableId);+ return transitGatewayRouteTables.get(key(region, routeTableId))+ .filter(routeTable -> region.equals(routeTable.getRegion()))+ .orElseThrow(() -> new AwsException("InvalidRouteTableID.NotFound",+ "Transit Gateway Route Table " + routeTableId + " was deleted or does not exist.", 400));+ }++ /**+ * Verified live, including the casing: the not-found code spells it {@code InvalidRouteTableID}+ * and the malformed one {@code InvalidRouteTableId}.+ */+ private static void requireWellFormedRouteTableId(String routeTableId) {+ if (!TRANSIT_GATEWAY_ROUTE_TABLE_ID_PATTERN.matcher(routeTableId).matches()) {+ throw new AwsException("InvalidRouteTableId.Malformed",+ "Invalid Transit Gateway Route Table id " + routeTableId + ".", 400);+ }+ }+private TransitGatewayVpcAttachment getRequiredVpcAttachment(String region, String attachmentId) {if (attachmentId == null || attachmentId.isBlank()) {throw new AwsException("MissingParameter",diff --git a/src/main/java/io/github/hectorvent/floci/services/ec2/model/TransitGatewayRoute.java b/src/main/java/io/github/hectorvent/floci/services/ec2/model/TransitGatewayRoute.javanew file mode 100644index 0000000000..b3b7970c4a--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/ec2/model/TransitGatewayRoute.java@@ -0,0 +1,60 @@+package io.github.hectorvent.floci.services.ec2.model;++import com.fasterxml.jackson.annotation.JsonIgnoreProperties;+import io.quarkus.runtime.annotations.RegisterForReflection;++/**+ * A static route in a transit gateway route table.+ *+ * <p>Only static routes are stored. A propagated route is a view of an enabled propagation joined+ * to the attached VPC's CIDR, so it is derived when routes are searched rather than written down —+ * storing it would go stale the moment the VPC's CIDR associations change.+ *+ * <p>A blackhole route is a static route in the {@code blackhole} state rather than a type of its+ * own, and carries no attachment.+ */+@RegisterForReflection+@JsonIgnoreProperties(ignoreUnknown = true)+public class TransitGatewayRoute {++ private String transitGatewayRouteTableId;+ private String destinationCidrBlock;+ private String transitGatewayAttachmentId;+ private String resourceId;+ private String resourceType;+ private String type;+ private String state;+ private String region;++ public TransitGatewayRoute() {}++ public String getTransitGatewayRouteTableId() { return transitGatewayRouteTableId; }+ public void setTransitGatewayRouteTableId(String transitGatewayRouteTableId) {+ this.transitGatewayRouteTableId = transitGatewayRouteTableId;+ }++ public String getDestinationCidrBlock() { return destinationCidrBlock; }+ public void setDestinationCidrBlock(String destinationCidrBlock) {+ this.destinationCidrBlock = destinationCidrBlock;+ }++ public String getTransitGatewayAttachmentId() { return transitGatewayAttachmentId; }+ public void setTransitGatewayAttachmentId(String transitGatewayAttachmentId) {+ this.transitGatewayAttachmentId = transitGatewayAttachmentId;+ }++ public String getResourceId() { return resourceId; }+ public void setResourceId(String resourceId) { this.resourceId = resourceId; }++ public String getResourceType() { return resourceType; }+ public void setResourceType(String resourceType) { this.resourceType = resourceType; }++ public String getType() { return type; }+ public void setType(String type) { this.type = type; }++ public String getState() { return state; }+ public void setState(String state) { this.state = state; }++ public String getRegion() { return region; }+ public void setRegion(String region) { this.region = region; }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/ec2/model/TransitGatewayRouteTablePropagation.java b/src/main/java/io/github/hectorvent/floci/services/ec2/model/TransitGatewayRouteTablePropagation.javanew file mode 100644index 0000000000..5cfc32beb2--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/ec2/model/TransitGatewayRouteTablePropagation.java@@ -0,0 +1,46 @@+package io.github.hectorvent.floci.services.ec2.model;++import com.fasterxml.jackson.annotation.JsonIgnoreProperties;+import io.quarkus.runtime.annotations.RegisterForReflection;++/**+ * An attachment propagating its routes into a transit gateway route table.+ *+ * <p>Unlike an association, which lives on the attachment because an attachment has at most one,+ * a propagation is its own record: one attachment may propagate into several route tables.+ */+@RegisterForReflection+@JsonIgnoreProperties(ignoreUnknown = true)+public class TransitGatewayRouteTablePropagation {++ private String transitGatewayRouteTableId;+ private String transitGatewayAttachmentId;+ private String resourceId;+ private String resourceType;+ private String state;+ private String region;++ public TransitGatewayRouteTablePropagation() {}++ public String getTransitGatewayRouteTableId() { return transitGatewayRouteTableId; }+ public void setTransitGatewayRouteTableId(String transitGatewayRouteTableId) {+ this.transitGatewayRouteTableId = transitGatewayRouteTableId;+ }++ public String getTransitGatewayAttachmentId() { return transitGatewayAttachmentId; }+ public void setTransitGatewayAttachmentId(String transitGatewayAttachmentId) {+ this.transitGatewayAttachmentId = transitGatewayAttachmentId;+ }++ public String getResourceId() { return resourceId; }+ public void setResourceId(String resourceId) { this.resourceId = resourceId; }++ public String getResourceType() { return resourceType; }+ public void setResourceType(String resourceType) { this.resourceType = resourceType; }++ public String getState() { return state; }+ public void setState(String state) { this.state = state; }++ public String getRegion() { return region; }+ public void setRegion(String region) { this.region = region; }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2ServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2ServiceTest.javaindex 28cafc32b3..29550af048 100644--- a/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2ServiceTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2ServiceTest.java@@ -29,7 +29,9 @@ import io.github.hectorvent.floci.services.ec2.model.Snapshot;import io.github.hectorvent.floci.services.ec2.model.Tag;import io.github.hectorvent.floci.services.ec2.model.TransitGateway;import io.github.hectorvent.floci.services.ec2.model.TransitGatewayOptions;+import io.github.hectorvent.floci.services.ec2.model.TransitGatewayRoute;import io.github.hectorvent.floci.services.ec2.model.TransitGatewayRouteTable;+import io.github.hectorvent.floci.services.ec2.model.TransitGatewayRouteTablePropagation;import io.github.hectorvent.floci.services.ec2.model.TransitGatewayVpcAttachment;import io.github.hectorvent.floci.services.ec2.model.TransitGatewayVpcAttachmentOptions;import io.github.hectorvent.floci.services.ec2.model.UserIdGroupPair;@@ -2195,6 +2197,404 @@ class Ec2ServiceTest {"describe serves tags added after creation");}+ // =========================================================================+ // Transit gateway route tables, associations, propagations and routes+ // =========================================================================++ /** A gateway, an attachment, and a second route table to move things onto. */+ private static String[] routeTableFixture(Ec2Service service) {+ String[] fixture = attachmentFixture(service);+ String attachmentId = service.createTransitGatewayVpcAttachment("us-east-1", fixture[0],+ fixture[1], List.of(fixture[2]), null, List.of()).getTransitGatewayAttachmentId();+ String routeTableId = service.createTransitGatewayRouteTable("us-east-1", fixture[0], List.of())+ .getTransitGatewayRouteTableId();+ return new String[] {fixture[0], fixture[1], fixture[2], attachmentId, routeTableId};+ }++ @Test+ void aRequestedRouteTableIsNeitherDefault() {+ Ec2Service service = prefixListService();+ String[] fixture = attachmentFixture(service);++ TransitGatewayRouteTable routeTable = service.createTransitGatewayRouteTable("us-east-1",+ fixture[0], List.of(new Tag("Name", "spoke")));++ assertTrue(routeTable.getTransitGatewayRouteTableId().startsWith("tgw-rtb-"));+ assertEquals("available", routeTable.getState());+ assertFalse(routeTable.isDefaultAssociationRouteTable());+ assertFalse(routeTable.isDefaultPropagationRouteTable());+ assertEquals(2, service.describeTransitGatewayRouteTables("us-east-1", List.of(), Map.of()).size(),+ "the gateway's own default table is there too");+ }++ /** Verified live: an attachment associates with exactly one route table. */+ @Test+ void anAttachmentAssociatesWithOneRouteTableAtATime() {+ Ec2Service service = prefixListService();+ String[] fixture = routeTableFixture(service);++ AwsException already = assertThrows(AwsException.class, () -> service+ .associateTransitGatewayRouteTable("us-east-1", fixture[4], fixture[3]));+ assertEquals("Resource.AlreadyAssociated", already.getErrorCode());++ TransitGateway gateway = service.describeTransitGateways("us-east-1", List.of(fixture[0]), Map.of())+ .getFirst();+ String defaultTable = gateway.getOptions().getAssociationDefaultRouteTableId();+ assertEquals(1, service.associationsOf("us-east-1", defaultTable).size(),+ "the attachment starts on the gateway's default table");++ service.disassociateTransitGatewayRouteTable("us-east-1", defaultTable, fixture[3]);+ assertTrue(service.associationsOf("us-east-1", defaultTable).isEmpty());++ service.associateTransitGatewayRouteTable("us-east-1", fixture[4], fixture[3]);+ assertEquals(fixture[3], service.associationsOf("us-east-1", fixture[4]).getFirst()+ .getTransitGatewayAttachmentId());+ }++ /** Verified live: propagation reports the settled state at once, and refuses a duplicate. */+ @Test+ void propagationIsEnabledAtOnceAndOnlyOnce() {+ Ec2Service service = prefixListService();+ String[] fixture = routeTableFixture(service);++ TransitGatewayRouteTablePropagation propagation = service+ .enableTransitGatewayRouteTablePropagation("us-east-1", fixture[4], fixture[3]);+ assertEquals("enabled", propagation.getState());+ assertEquals(fixture[1], propagation.getResourceId());+ assertEquals("vpc", propagation.getResourceType());++ assertEquals("TransitGatewayRouteTablePropagation.Duplicate", assertThrows(AwsException.class,+ () -> service.enableTransitGatewayRouteTablePropagation("us-east-1", fixture[4], fixture[3]))+ .getErrorCode());++ assertEquals("disabled", service.disableTransitGatewayRouteTablePropagation(+ "us-east-1", fixture[4], fixture[3]).getState());+ assertTrue(service.propagationsOf("us-east-1", fixture[4]).isEmpty());+ }++ /**+ * Verified live: enabling propagation makes the attached VPC's CIDR show up as a propagated+ * route. It is derived from the VPC rather than stored, so a CIDR change cannot leave a stale+ * route behind.+ */+ @Test+ void propagationProducesRoutesForTheAttachedVpcsCidr() {+ Ec2Service service = prefixListService();+ String[] fixture = routeTableFixture(service);+ service.enableTransitGatewayRouteTablePropagation("us-east-1", fixture[4], fixture[3]);++ List<TransitGatewayRoute> propagated = service.searchTransitGatewayRoutes("us-east-1", fixture[4],+ Map.of("type", List.of("propagated")));++ assertEquals(1, propagated.size());+ assertEquals("10.90.0.0/16", propagated.getFirst().getDestinationCidrBlock());+ assertEquals("active", propagated.getFirst().getState());+ assertEquals(fixture[3], propagated.getFirst().getTransitGatewayAttachmentId());++ service.disableTransitGatewayRouteTablePropagation("us-east-1", fixture[4], fixture[3]);+ assertTrue(service.searchTransitGatewayRoutes("us-east-1", fixture[4],+ Map.of("type", List.of("propagated"))).isEmpty(), "the route goes with the propagation");+ }++ /** A blackhole is a state of a static route, not a type, and carries no attachment. */+ @Test+ void staticAndBlackholeRoutesDifferByStateNotType() {+ Ec2Service service = prefixListService();+ String[] fixture = routeTableFixture(service);++ TransitGatewayRoute viaAttachment = service.createTransitGatewayRoute("us-east-1", fixture[4],+ "10.60.0.0/16", fixture[3], false);+ assertEquals("static", viaAttachment.getType());+ assertEquals("active", viaAttachment.getState());+ assertEquals(fixture[3], viaAttachment.getTransitGatewayAttachmentId());++ TransitGatewayRoute blackhole = service.createTransitGatewayRoute("us-east-1", fixture[4],+ "10.61.0.0/16", null, true);+ assertEquals("static", blackhole.getType());+ assertEquals("blackhole", blackhole.getState());+ assertNull(blackhole.getTransitGatewayAttachmentId());++ assertEquals("RouteAlreadyExists", assertThrows(AwsException.class,+ () -> service.createTransitGatewayRoute("us-east-1", fixture[4], "10.60.0.0/16",+ fixture[3], false)).getErrorCode());++ assertEquals(2, service.searchTransitGatewayRoutes("us-east-1", fixture[4],+ Map.of("type", List.of("static"))).size(), "a blackhole is still a static route");++ TransitGatewayRoute deleted = service.deleteTransitGatewayRoute("us-east-1", fixture[4], "10.61.0.0/16");+ assertEquals("deleted", deleted.getState());+ assertNull(deleted.getTransitGatewayAttachmentId());+ assertEquals(1, service.searchTransitGatewayRoutes("us-east-1", fixture[4], Map.of()).size());+ }++ /**+ * Verified live: a route table will not go while it is the gateway's default association table+ * nor while attachments are associated with it, both under IncorrectState.+ */+ @Test+ void aRouteTableInUseCannotBeDeleted() {+ Ec2Service service = prefixListService();+ String[] fixture = routeTableFixture(service);+ TransitGateway gateway = service.describeTransitGateways("us-east-1", List.of(fixture[0]), Map.of())+ .getFirst();+ String defaultTable = gateway.getOptions().getAssociationDefaultRouteTableId();++ AwsException isDefault = assertThrows(AwsException.class,+ () -> service.deleteTransitGatewayRouteTable("us-east-1", defaultTable));+ assertEquals("IncorrectState", isDefault.getErrorCode());+ assertTrue(isDefault.getMessage().contains("default association route table"), isDefault.getMessage());++ service.disassociateTransitGatewayRouteTable("us-east-1", defaultTable, fixture[3]);+ service.associateTransitGatewayRouteTable("us-east-1", fixture[4], fixture[3]);++ AwsException associated = assertThrows(AwsException.class,+ () -> service.deleteTransitGatewayRouteTable("us-east-1", fixture[4]));+ assertEquals("IncorrectState", associated.getErrorCode());+ assertTrue(associated.getMessage().contains("has associated attachments"), associated.getMessage());++ service.disassociateTransitGatewayRouteTable("us-east-1", fixture[4], fixture[3]);+ service.createTransitGatewayRoute("us-east-1", fixture[4], "10.70.0.0/16", null, true);+ assertEquals("deleted", service.deleteTransitGatewayRouteTable("us-east-1", fixture[4]).getState());+ assertEquals("InvalidRouteTableID.NotFound", assertThrows(AwsException.class,+ () -> service.searchTransitGatewayRoutes("us-east-1", fixture[4], Map.of())).getErrorCode(),+ "its routes went with it");+ }++ /** Verified live, casing included: NotFound spells it ID, Malformed spells it Id. */+ @Test+ void routeTableIdErrorsMatchTheLiveApiIncludingCasing() {+ Ec2Service service = prefixListService();++ assertEquals("InvalidRouteTableID.NotFound", assertThrows(AwsException.class,+ () -> service.describeTransitGatewayRouteTables("us-east-1",+ List.of("tgw-rtb-0123456789abcdef0"), Map.of())).getErrorCode());+ assertEquals("InvalidRouteTableId.Malformed", assertThrows(AwsException.class,+ () -> service.describeTransitGatewayRouteTables("us-east-1",+ List.of("tgw-rtb-nope"), Map.of())).getErrorCode());+ }++ /**+ * Verified on a live account: deleting an attachment removes its propagations, and a static+ * route that named it survives as a blackhole rather than disappearing — the destination is+ * still configured, it just has nowhere to go.+ */+ @Test+ void deletingAnAttachmentClearsPropagationsAndBlackholesItsRoutes() {+ Ec2Service service = prefixListService();+ String[] fixture = routeTableFixture(service);+ service.enableTransitGatewayRouteTablePropagation("us-east-1", fixture[4], fixture[3]);+ service.createTransitGatewayRoute("us-east-1", fixture[4], "10.99.0.0/16", fixture[3], false);++ service.deleteTransitGatewayVpcAttachment("us-east-1", fixture[3]);++ assertTrue(service.propagationsOf("us-east-1", fixture[4]).isEmpty(), "propagations go");+ List<TransitGatewayRoute> routes = service.searchTransitGatewayRoutes("us-east-1", fixture[4], Map.of());+ assertEquals(1, routes.size(), "the static route stays");+ assertEquals("blackhole", routes.getFirst().getState());+ assertNull(routes.getFirst().getTransitGatewayAttachmentId());+ assertTrue(service.searchTransitGatewayRoutes("us-east-1", fixture[4],+ Map.of("type", List.of("propagated"))).isEmpty(), "and its propagated route with it");+ }++ /** A gateway's route tables take their propagations, routes and tags with them. */+ @Test+ void deletingAGatewayLeavesNothingBehindItsRouteTables() {+ Ec2Service service = prefixListService();+ String[] fixture = routeTableFixture(service);+ service.enableTransitGatewayRouteTablePropagation("us-east-1", fixture[4], fixture[3]);+ service.createTransitGatewayRoute("us-east-1", fixture[4], "10.99.0.0/16", null, true);+ service.createTags("us-east-1", List.of(fixture[4]), List.of(new Tag("env", "prod")));+ service.deleteTransitGatewayVpcAttachment("us-east-1", fixture[3]);++ service.deleteTransitGateway("us-east-1", fixture[0]);++ assertTrue(service.describeTransitGatewayRouteTables("us-east-1", List.of(), Map.of()).isEmpty(),+ "the tables go with the gateway");+ assertTrue(service.propagationsOf("us-east-1", fixture[4]).isEmpty());+ assertTrue(service.describeTags("us-east-1", Map.of("resource-id", List.of(fixture[4]))).isEmpty(),+ "and their tags");+ }++ /**+ * Modifying a gateway writes route tables through its default-table markers, so it races the+ * deletes the same way tagging does. Whoever wins, a deleted table must not come back.+ */+ @Test+ void modifyingAGatewayCannotResurrectADeletedRouteTable() throws Exception {+ for (int trial = 0; trial < 10; trial++) {+ Ec2Service service = prefixListService();+ String[] fixture = attachmentFixture(service);+ String spare = service.createTransitGatewayRouteTable("us-east-1", fixture[0], List.of())+ .getTransitGatewayRouteTableId();+ java.util.concurrent.CountDownLatch start = new java.util.concurrent.CountDownLatch(1);+ java.util.concurrent.ExecutorService pool =+ java.util.concurrent.Executors.newFixedThreadPool(2);++ pool.submit(() -> {+ try {+ start.await();+ TransitGatewayOptions changes = new TransitGatewayOptions();+ changes.setDefaultRouteTableAssociation("enable");+ changes.setAssociationDefaultRouteTableId(spare);+ service.modifyTransitGateway("us-east-1", fixture[0], null, changes, List.of(), List.of());+ } catch (AwsException | InterruptedException ignored) {+ // Losing the race is fine.+ }+ });+ pool.submit(() -> {+ try {+ start.await();+ service.deleteTransitGatewayRouteTable("us-east-1", spare);+ } catch (AwsException | InterruptedException ignored) {+ // Same.+ }+ });+ start.countDown();+ pool.shutdown();+ assertTrue(pool.awaitTermination(30, java.util.concurrent.TimeUnit.SECONDS));++ boolean tableExists = service.describeTransitGatewayRouteTables("us-east-1", List.of(), Map.of())+ .stream().anyMatch(rt -> rt.getTransitGatewayRouteTableId().equals(spare));+ TransitGateway gateway = service.describeTransitGateways("us-east-1", List.of(fixture[0]), Map.of())+ .getFirst();+ if (!tableExists) {+ assertNotEquals(spare, gateway.getOptions().getAssociationDefaultRouteTableId(),+ "trial " + trial + ": the gateway names a route table that is gone");+ }+ }+ }++ /**+ * Verified on a live account: a route table only reaches attachments of its own gateway.+ * Associating, propagating or routing to another gateway's attachment is refused as though the+ * attachment did not exist, which is the same shape as a subnet belonging to another VPC.+ */+ @Test+ void aRouteTableOnlyReachesItsOwnGatewaysAttachments() {+ Ec2Service service = prefixListService();+ String[] fixture = routeTableFixture(service);+ String otherGateway = service.createTransitGateway("us-east-1", "other", null, List.of())+ .getTransitGatewayId();+ String foreignTable = service.createTransitGatewayRouteTable("us-east-1", otherGateway, List.of())+ .getTransitGatewayRouteTableId();++ for (Runnable crossGateway : List.<Runnable>of(+ () -> service.associateTransitGatewayRouteTable("us-east-1", foreignTable, fixture[3]),+ () -> service.disassociateTransitGatewayRouteTable("us-east-1", foreignTable, fixture[3]),+ () -> service.enableTransitGatewayRouteTablePropagation("us-east-1", foreignTable, fixture[3]),+ () -> service.disableTransitGatewayRouteTablePropagation("us-east-1", foreignTable, fixture[3]),+ () -> service.createTransitGatewayRoute("us-east-1", foreignTable, "10.77.0.0/16",+ fixture[3], false))) {+ assertEquals("InvalidTransitGatewayAttachmentID.NotFound",+ assertThrows(AwsException.class, crossGateway::run).getErrorCode());+ }++ // Nothing was recorded against the other gateway's table on the way through.+ assertTrue(service.associationsOf("us-east-1", foreignTable).isEmpty());+ assertTrue(service.propagationsOf("us-east-1", foreignTable).isEmpty());+ assertTrue(service.searchTransitGatewayRoutes("us-east-1", foreignTable, Map.of()).isEmpty());+ }++ /**+ * Verified on a live account: replacing a route flips its target in place, and replacing a+ * destination the table has never held writes it rather than reporting it missing — an upsert+ * rather than an update.+ */+ @Test+ void replacingARouteMovesItsTargetAndUpsertsWhenAbsent() {+ Ec2Service service = prefixListService();+ String[] fixture = routeTableFixture(service);+ service.createTransitGatewayRoute("us-east-1", fixture[4], "10.88.0.0/16", fixture[3], false);++ TransitGatewayRoute blackholed = service.replaceTransitGatewayRoute("us-east-1", fixture[4],+ "10.88.0.0/16", null, true);+ assertEquals("blackhole", blackholed.getState());+ assertNull(blackholed.getTransitGatewayAttachmentId(), "the target moves as one");+ assertNull(blackholed.getResourceId());++ TransitGatewayRoute restored = service.replaceTransitGatewayRoute("us-east-1", fixture[4],+ "10.88.0.0/16", fixture[3], false);+ assertEquals("active", restored.getState());+ assertEquals(fixture[3], restored.getTransitGatewayAttachmentId());+ assertEquals(fixture[1], restored.getResourceId());++ TransitGatewayRoute created = service.replaceTransitGatewayRoute("us-east-1", fixture[4],+ "10.89.0.0/16", null, true);+ assertEquals("blackhole", created.getState());+ assertEquals(2, service.searchTransitGatewayRoutes("us-east-1", fixture[4],+ Map.of("type", List.of("static"))).size(), "replacing an absent route writes it");++ // The same ownership rule as the other route table operations.+ String otherGateway = service.createTransitGateway("us-east-1", "other", null, List.of())+ .getTransitGatewayId();+ String foreignTable = service.createTransitGatewayRouteTable("us-east-1", otherGateway, List.of())+ .getTransitGatewayRouteTableId();+ assertEquals("InvalidTransitGatewayAttachmentID.NotFound", assertThrows(AwsException.class,+ () -> service.replaceTransitGatewayRoute("us-east-1", foreignTable, "10.90.0.0/16",+ fixture[3], false)).getErrorCode());++ // A replaced route is still a route, so losing its attachment blackholes it.+ service.deleteTransitGatewayVpcAttachment("us-east-1", fixture[3]);+ TransitGatewayRoute afterDetach = service.searchTransitGatewayRoutes("us-east-1", fixture[4],+ Map.of("route-search.exact-match", List.of("10.88.0.0/16"))).getFirst();+ assertEquals("blackhole", afterDetach.getState());+ assertNull(afterDetach.getTransitGatewayAttachmentId());+ }++ /**+ * The route search filters, as observed on a live account. The three CIDR relationship filters+ * take different value forms: supernet-of-match and subnet-of-match take a CIDR and match+ * inclusively, longest-prefix-match takes a bare address and returns the one most specific+ * route covering it. Giving either the other's form returns nothing there, and here.+ */+ @Test+ void routeSearchFiltersMatchTheLiveApi() {+ Ec2Service service = prefixListService();+ String[] fixture = routeTableFixture(service);+ for (String cidr : List.of("10.0.0.0/8", "10.1.0.0/16", "10.1.1.0/24", "192.168.0.0/16")) {+ service.createTransitGatewayRoute("us-east-1", fixture[4], cidr, null, true);+ }++ assertEquals(List.of("10.0.0.0/8", "10.1.0.0/16", "10.1.1.0/24"),+ cidrsOf(service.searchTransitGatewayRoutes("us-east-1", fixture[4],+ Map.of("route-search.supernet-of-match", List.of("10.1.1.0/24")))),+ "everything containing it, the exact match included");++ assertEquals(List.of("10.1.0.0/16", "10.1.1.0/24"),+ cidrsOf(service.searchTransitGatewayRoutes("us-east-1", fixture[4],+ Map.of("route-search.subnet-of-match", List.of("10.1.0.0/16")))),+ "everything it contains, the exact match included");++ assertEquals(List.of("10.1.1.0/24"),+ cidrsOf(service.searchTransitGatewayRoutes("us-east-1", fixture[4],+ Map.of("route-search.longest-prefix-match", List.of("10.1.1.5")))),+ "the most specific route covering the address");+ assertEquals(List.of("10.1.0.0/16"),+ cidrsOf(service.searchTransitGatewayRoutes("us-east-1", fixture[4],+ Map.of("route-search.longest-prefix-match", List.of("10.1.9.9")))));+ assertTrue(service.searchTransitGatewayRoutes("us-east-1", fixture[4],+ Map.of("route-search.longest-prefix-match", List.of("8.8.8.8"))).isEmpty(),+ "nothing covers it");++ // Each filter ignores the other's value form, exactly as the live API does.+ assertTrue(service.searchTransitGatewayRoutes("us-east-1", fixture[4],+ Map.of("route-search.longest-prefix-match", List.of("10.1.1.5/32"))).isEmpty(),+ "longest-prefix-match takes an address, not a CIDR");+ assertTrue(service.searchTransitGatewayRoutes("us-east-1", fixture[4],+ Map.of("route-search.supernet-of-match", List.of("10.1.1.5"))).isEmpty(),+ "supernet-of-match takes a CIDR, not an address");++ AwsException unknown = assertThrows(AwsException.class,+ () -> service.searchTransitGatewayRoutes("us-east-1", fixture[4],+ Map.of("nonsense", List.of("x"))));+ assertEquals("InvalidParameterValue", unknown.getErrorCode());+ assertTrue(unknown.getMessage().contains("nonsense"), unknown.getMessage());+ }++ private static List<String> cidrsOf(List<TransitGatewayRoute> routes) {+ return routes.stream().map(TransitGatewayRoute::getDestinationCidrBlock).sorted().toList();+ }+private static EmulatorConfig mockConfig(boolean ec2Mock) {EmulatorConfig config = mock(EmulatorConfig.class);EmulatorConfig.ServicesConfig services = mock(EmulatorConfig.ServicesConfig.class);diff --git a/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2TransitGatewayRouteTableIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2TransitGatewayRouteTableIntegrationTest.javanew file mode 100644index 0000000000..9fe0897420--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2TransitGatewayRouteTableIntegrationTest.java@@ -0,0 +1,251 @@+package io.github.hectorvent.floci.services.ec2;++import io.quarkus.test.junit.QuarkusTest;+import org.junit.jupiter.api.MethodOrderer;+import org.junit.jupiter.api.Order;+import org.junit.jupiter.api.Test;+import org.junit.jupiter.api.TestMethodOrder;++import static io.restassured.RestAssured.given;+import static org.hamcrest.MatcherAssert.assertThat;+import static org.hamcrest.Matchers.containsString;+import static org.hamcrest.Matchers.equalTo;+import static org.hamcrest.Matchers.not;++/**+ * Route tables, associations, propagations and routes over the EC2 Query protocol.+ *+ * <p>The shapes were captured from a live account, including two asymmetries that are easy to get+ * wrong: the association and propagation listings drop the route table id that the mutating calls+ * carry, and a blackhole route omits the attachment block entirely.+ */+@QuarkusTest+@TestMethodOrder(MethodOrderer.OrderAnnotation.class)+class Ec2TransitGatewayRouteTableIntegrationTest {++ private static final String AUTH_HEADER =+ "AWS4-HMAC-SHA256 Credential=test/20260205/us-east-1/ec2/aws4_request";++ private static String transitGatewayId;+ private static String defaultRouteTableId;+ private static String routeTableId;+ private static String attachmentId;+ private static String vpcId;++ @Test+ @Order(1)+ void buildAGatewayAnAttachmentAndASecondRouteTable() {+ String created = given()+ .formParam("Action", "CreateTransitGateway")+ .header("Authorization", AUTH_HEADER)+ .when().post("/")+ .then().statusCode(200).extract().asString();+ transitGatewayId = extract(created, "transitGatewayId");+ defaultRouteTableId = extract(created, "associationDefaultRouteTableId");++ vpcId = given()+ .formParam("Action", "CreateVpc")+ .formParam("CidrBlock", "10.40.0.0/16")+ .header("Authorization", AUTH_HEADER)+ .when().post("/")+ .then().statusCode(200).extract().path("CreateVpcResponse.vpc.vpcId");++ String subnetId = given()+ .formParam("Action", "CreateSubnet")+ .formParam("VpcId", vpcId)+ .formParam("CidrBlock", "10.40.1.0/24")+ .formParam("AvailabilityZone", "us-east-1a")+ .header("Authorization", AUTH_HEADER)+ .when().post("/")+ .then().statusCode(200).extract().path("CreateSubnetResponse.subnet.subnetId");++ attachmentId = given()+ .formParam("Action", "CreateTransitGatewayVpcAttachment")+ .formParam("TransitGatewayId", transitGatewayId)+ .formParam("VpcId", vpcId)+ .formParam("SubnetIds.1", subnetId)+ .header("Authorization", AUTH_HEADER)+ .when().post("/")+ .then().statusCode(200)+ .extract().path("CreateTransitGatewayVpcAttachmentResponse.transitGatewayVpcAttachment"+ + ".transitGatewayAttachmentId");++ routeTableId = given()+ .formParam("Action", "CreateTransitGatewayRouteTable")+ .formParam("TransitGatewayId", transitGatewayId)+ .formParam("TagSpecification.1.ResourceType", "transit-gateway-route-table")+ .formParam("TagSpecification.1.Tag.1.Key", "Name")+ .formParam("TagSpecification.1.Tag.1.Value", "spoke")+ .header("Authorization", AUTH_HEADER)+ .when().post("/")+ .then().statusCode(200)+ .body("CreateTransitGatewayRouteTableResponse.transitGatewayRouteTable.state", equalTo("available"))+ .body("CreateTransitGatewayRouteTableResponse.transitGatewayRouteTable"+ + ".defaultAssociationRouteTable", equalTo("false"))+ .body("CreateTransitGatewayRouteTableResponse.transitGatewayRouteTable.tagSet.item.value",+ equalTo("spoke"))+ .extract().path("CreateTransitGatewayRouteTableResponse.transitGatewayRouteTable"+ + ".transitGatewayRouteTableId");+ }++ private String extract(String body, String element) {+ int start = body.indexOf("<" + element + ">") + element.length() + 2;+ return body.substring(start, body.indexOf("</" + element + ">", start));+ }++ @Test+ @Order(2)+ void associationsMoveBetweenTablesAndTheListingDropsTheTableId() {+ given()+ .formParam("Action", "AssociateTransitGatewayRouteTable")+ .formParam("TransitGatewayRouteTableId", routeTableId)+ .formParam("TransitGatewayAttachmentId", attachmentId)+ .header("Authorization", AUTH_HEADER)+ .when().post("/")+ .then().statusCode(400)+ .body("Response.Errors.Error.Code", equalTo("Resource.AlreadyAssociated"));++ given()+ .formParam("Action", "DisassociateTransitGatewayRouteTable")+ .formParam("TransitGatewayRouteTableId", defaultRouteTableId)+ .formParam("TransitGatewayAttachmentId", attachmentId)+ .header("Authorization", AUTH_HEADER)+ .when().post("/")+ .then().statusCode(200)+ .body("DisassociateTransitGatewayRouteTableResponse.association.state", equalTo("disassociating"))+ .body("DisassociateTransitGatewayRouteTableResponse.association.transitGatewayRouteTableId",+ equalTo(defaultRouteTableId));++ given()+ .formParam("Action", "AssociateTransitGatewayRouteTable")+ .formParam("TransitGatewayRouteTableId", routeTableId)+ .formParam("TransitGatewayAttachmentId", attachmentId)+ .header("Authorization", AUTH_HEADER)+ .when().post("/")+ .then().statusCode(200)+ .body("AssociateTransitGatewayRouteTableResponse.association.state", equalTo("associating"));++ String listing = given()+ .formParam("Action", "GetTransitGatewayRouteTableAssociations")+ .formParam("TransitGatewayRouteTableId", routeTableId)+ .header("Authorization", AUTH_HEADER)+ .when().post("/")+ .then().statusCode(200)+ .body("GetTransitGatewayRouteTableAssociationsResponse.associations.item.resourceType",+ equalTo("vpc"))+ .body("GetTransitGatewayRouteTableAssociationsResponse.associations.item.state",+ equalTo("associated"))+ .extract().asString();++ // The caller named the table in the request, so the listing does not repeat it.+ assertThat(listing, not(containsString("transitGatewayRouteTableId")));+ }++ @Test+ @Order(3)+ void propagationEnablesAtOnceAndShowsUpAsARoute() {+ given()+ .formParam("Action", "EnableTransitGatewayRouteTablePropagation")+ .formParam("TransitGatewayRouteTableId", routeTableId)+ .formParam("TransitGatewayAttachmentId", attachmentId)+ .header("Authorization", AUTH_HEADER)+ .when().post("/")+ .then().statusCode(200)+ .body("EnableTransitGatewayRouteTablePropagationResponse.propagation.state", equalTo("enabled"))+ .body("EnableTransitGatewayRouteTablePropagationResponse.propagation.transitGatewayRouteTableId",+ equalTo(routeTableId));++ String listing = given()+ .formParam("Action", "GetTransitGatewayRouteTablePropagations")+ .formParam("TransitGatewayRouteTableId", routeTableId)+ .header("Authorization", AUTH_HEADER)+ .when().post("/")+ .then().statusCode(200)+ .body("GetTransitGatewayRouteTablePropagationsResponse.transitGatewayRouteTablePropagations"+ + ".item.state", equalTo("enabled"))+ .extract().asString();+ assertThat(listing, not(containsString("transitGatewayRouteTableId")));++ // The attached VPC's CIDR appears as a propagated route.+ given()+ .formParam("Action", "SearchTransitGatewayRoutes")+ .formParam("TransitGatewayRouteTableId", routeTableId)+ .formParam("Filter.1.Name", "type")+ .formParam("Filter.1.Value.1", "propagated")+ .header("Authorization", AUTH_HEADER)+ .when().post("/")+ .then().statusCode(200)+ .body("SearchTransitGatewayRoutesResponse.routeSet.item.destinationCidrBlock",+ equalTo("10.40.0.0/16"))+ .body("SearchTransitGatewayRoutesResponse.routeSet.item.type", equalTo("propagated"))+ .body("SearchTransitGatewayRoutesResponse.routeSet.item.state", equalTo("active"));+ }++ @Test+ @Order(4)+ void aBlackholeRouteCarriesNoAttachment() {+ given()+ .formParam("Action", "CreateTransitGatewayRoute")+ .formParam("TransitGatewayRouteTableId", routeTableId)+ .formParam("DestinationCidrBlock", "10.60.0.0/16")+ .formParam("TransitGatewayAttachmentId", attachmentId)+ .header("Authorization", AUTH_HEADER)+ .when().post("/")+ .then().statusCode(200)+ .body("CreateTransitGatewayRouteResponse.route.type", equalTo("static"))+ .body("CreateTransitGatewayRouteResponse.route.state", equalTo("active"))+ .body("CreateTransitGatewayRouteResponse.route.transitGatewayAttachments.item"+ + ".transitGatewayAttachmentId", equalTo(attachmentId));++ String blackhole = given()+ .formParam("Action", "CreateTransitGatewayRoute")+ .formParam("TransitGatewayRouteTableId", routeTableId)+ .formParam("DestinationCidrBlock", "10.61.0.0/16")+ .formParam("Blackhole", "true")+ .header("Authorization", AUTH_HEADER)+ .when().post("/")+ .then().statusCode(200)+ .body("CreateTransitGatewayRouteResponse.route.type", equalTo("static"))+ .body("CreateTransitGatewayRouteResponse.route.state", equalTo("blackhole"))+ .extract().asString();+ assertThat(blackhole, not(containsString("transitGatewayAttachments")));++ given()+ .formParam("Action", "CreateTransitGatewayRoute")+ .formParam("TransitGatewayRouteTableId", routeTableId)+ .formParam("DestinationCidrBlock", "10.60.0.0/16")+ .formParam("TransitGatewayAttachmentId", attachmentId)+ .header("Authorization", AUTH_HEADER)+ .when().post("/")+ .then().statusCode(400)+ .body("Response.Errors.Error.Code", equalTo("RouteAlreadyExists"));+ }++ @Test+ @Order(5)+ void aTableInUseIsRefusedAndTheIdErrorsKeepTheirCasing() {+ given()+ .formParam("Action", "DeleteTransitGatewayRouteTable")+ .formParam("TransitGatewayRouteTableId", routeTableId)+ .header("Authorization", AUTH_HEADER)+ .when().post("/")+ .then().statusCode(400)+ .body("Response.Errors.Error.Code", equalTo("IncorrectState"));++ given()+ .formParam("Action", "DescribeTransitGatewayRouteTables")+ .formParam("TransitGatewayRouteTableIds.1", "tgw-rtb-0123456789abcdef0")+ .header("Authorization", AUTH_HEADER)+ .when().post("/")+ .then().statusCode(400)+ .body("Response.Errors.Error.Code", equalTo("InvalidRouteTableID.NotFound"));++ given()+ .formParam("Action", "DescribeTransitGatewayRouteTables")+ .formParam("TransitGatewayRouteTableIds.1", "tgw-rtb-nope")+ .header("Authorization", AUTH_HEADER)+ .when().post("/")+ .then().statusCode(400)+ .body("Response.Errors.Error.Code", equalTo("InvalidRouteTableId.Malformed"));+ }+}