Skip to content

armgit / floci

Public Imported from GitHub
0

Light, fluffy, and always free - The AWS Local Emulator alternative

test(cloudformation): wire fixture provisioners from the named services (#2760)

Hector Venturaadc4b3627d6c
diff --git a/src/test/java/io/github/hectorvent/floci/services/cloudformation/CfnProvisionerFixture.java b/src/test/java/io/github/hectorvent/floci/services/cloudformation/CfnProvisionerFixture.java
index 40ff2b54e7..d3e397f774 100644
--- a/src/test/java/io/github/hectorvent/floci/services/cloudformation/CfnProvisionerFixture.java
+++ b/src/test/java/io/github/hectorvent/floci/services/cloudformation/CfnProvisionerFixture.java
@@ -8,6 +8,41 @@ import io.github.hectorvent.floci.services.apigatewayv2.ApiGatewayV2Service;
import io.github.hectorvent.floci.services.autoscaling.AutoScalingService;
import io.github.hectorvent.floci.services.batch.BatchService;
import io.github.hectorvent.floci.services.cloudformation.provisioners.CfnDynamicReferences;
+import io.github.hectorvent.floci.services.cloudformation.provisioners.ConfigCfnProvisioner;
+import io.github.hectorvent.floci.services.cloudformation.provisioners.Ec2FlowLogCfnProvisioner;
+import io.github.hectorvent.floci.services.cloudformation.provisioners.LambdaMicrovmsCfnProvisioner;
+import io.github.hectorvent.floci.services.cloudformation.provisioners.OrganizationsCfnProvisioner;
+import io.github.hectorvent.floci.services.cloudformation.provisioners.SqsCfnProvisioner;
+import io.github.hectorvent.floci.services.cloudformation.provisioners.WafV2CfnProvisioner;
+import io.github.hectorvent.floci.services.configservice.AwsConfigService;
+import io.github.hectorvent.floci.services.ec2.FlowLogService;
+import io.github.hectorvent.floci.services.lambdamicrovms.LambdaMicrovmsService;
+import io.github.hectorvent.floci.services.organizations.OrganizationsService;
+import io.github.hectorvent.floci.services.sqs.SqsService;
+import io.github.hectorvent.floci.services.wafv2.WafV2Service;
+import io.github.hectorvent.floci.services.cloudformation.provisioners.ApiGatewayAccountCfnProvisioner;
+import io.github.hectorvent.floci.services.cloudformation.provisioners.AutoScalingLifecycleHookCfnProvisioner;
+import io.github.hectorvent.floci.services.cloudformation.provisioners.CdkMetadataCfnProvisioner;
+import io.github.hectorvent.floci.services.cloudformation.provisioners.CloudWatchCfnProvisioner;
+import io.github.hectorvent.floci.services.cloudformation.provisioners.Ec2LaunchTemplateCfnProvisioner;
+import io.github.hectorvent.floci.services.cloudformation.provisioners.Ec2NetworkAclCfnProvisioner;
+import io.github.hectorvent.floci.services.cloudformation.provisioners.Ec2SecurityGroupRuleCfnProvisioner;
+import io.github.hectorvent.floci.services.cloudformation.provisioners.Ec2VpcCfnProvisioner;
+import io.github.hectorvent.floci.services.cloudformation.provisioners.Ec2VpcEndpointCfnProvisioner;
+import io.github.hectorvent.floci.services.cloudformation.provisioners.Ec2VpcGatewayAttachmentCfnProvisioner;
+import io.github.hectorvent.floci.services.cloudformation.provisioners.EcrCfnProvisioner;
+import io.github.hectorvent.floci.services.cloudformation.provisioners.EcsCapacityCfnProvisioner;
+import io.github.hectorvent.floci.services.cloudformation.provisioners.FirehoseCfnProvisioner;
+import io.github.hectorvent.floci.services.cloudformation.provisioners.IamRoleCfnProvisioner;
+import io.github.hectorvent.floci.services.cloudformation.provisioners.KinesisCfnProvisioner;
+import io.github.hectorvent.floci.services.cloudformation.provisioners.KmsCfnProvisioner;
+import io.github.hectorvent.floci.services.cloudformation.provisioners.LambdaAddressingCfnProvisioner;
+import io.github.hectorvent.floci.services.cloudformation.provisioners.LambdaVersionAliasCfnProvisioner;
+import io.github.hectorvent.floci.services.cloudformation.provisioners.LogsCfnProvisioner;
+import io.github.hectorvent.floci.services.cloudformation.provisioners.PipesCfnProvisioner;
+import io.github.hectorvent.floci.services.cloudformation.provisioners.S3CfnProvisioner;
+import io.github.hectorvent.floci.services.cloudformation.provisioners.SnsCfnProvisioner;
+import io.github.hectorvent.floci.services.cloudformation.provisioners.SsmCfnProvisioner;
import io.github.hectorvent.floci.services.cloudformation.provisioners.CfnResourceProvisioner;
import io.github.hectorvent.floci.services.cloudformation.provisioners.CloudFormationResourceRegistry;
import io.github.hectorvent.floci.services.cloudfront.CloudFrontService;
@@ -36,6 +71,7 @@ import io.github.hectorvent.floci.services.sns.SnsService;
import io.github.hectorvent.floci.services.ssm.SsmService;
import io.github.hectorvent.floci.services.stepfunctions.StepFunctionsService;
+import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
@@ -96,19 +132,126 @@ final class CfnProvisionerFixture {
private FirehoseService firehoseService;
private DocDbService docDbService;
private CloudFrontService cloudFrontService;
+ // Services that back a provisioner without being a constructor argument of the
+ // dispatcher. They exist only so inferredProvisioners() can wire their provisioner.
+ private FlowLogService flowLogService;
+ private LambdaMicrovmsService lambdaMicrovmsService;
+ private AwsConfigService awsConfigService;
+ private OrganizationsService organizationsService;
+ private SqsService sqsService;
+ private WafV2Service wafV2Service;
private CloudFormationResourceRegistry resourceRegistry;
+ private boolean registryChosenByTest;
private CfnDynamicReferences dynamicReferences;
private EmulatorConfig config;
private Builder() {
this.objectMapper = new ObjectMapper();
- this.resourceRegistry = new CloudFormationResourceRegistry(List.of());
}
- /** Registers extracted provisioners, the way production CDI discovery would. */
+ /**
+ * Registers an explicit provisioner set, replacing the ones inferred from the named
+ * services. Needed only for a provisioner this fixture cannot build itself, such as one
+ * taking collaborators beyond a single service.
+ */
public Builder provisioners(CfnResourceProvisioner... provisioners) {
this.resourceRegistry = new CloudFormationResourceRegistry(Arrays.asList(provisioners));
- return this;
+ this.registryChosenByTest = true;
+ return this;
+ }
+
+ /**
+ * The provisioners inferred from the services this test named, not everything CDI would
+ * discover: a service the test did not name contributes nothing here.
+ *
+ * <p>Inferring these is what keeps a test honest across a migration. A test that names a
+ * service and provisions one of its types used to keep passing when that type moved to a
+ * provisioner: the empty registry sent it to the dispatcher's stub arm, which reports
+ * CREATE_COMPLETE with a synthetic id, so the assertions ran against nothing. Wiring the
+ * provisioner from the service means the test follows the type instead.
+ *
+ * <p>Covers every provisioner that takes a single service. The two that take more
+ * ({@code CodeBuildCfnProvisioner}, {@code CodePipelineCfnProvisioner}) must be passed to
+ * {@link Builder#provisioners} explicitly. {@code CfnProvisionerFixtureTest} fails if a new
+ * provisioner is neither wired here nor listed as an exemption there, so this cannot fall
+ * behind silently.
+ */
+ private List<CfnResourceProvisioner> inferredProvisioners() {
+ List<CfnResourceProvisioner> discovered = new ArrayList<>();
+ discovered.add(new CdkMetadataCfnProvisioner());
+ if (s3Service != null) {
+ discovered.add(new S3CfnProvisioner(s3Service));
+ }
+ if (snsService != null) {
+ discovered.add(new SnsCfnProvisioner(snsService));
+ }
+ if (ssmService != null) {
+ discovered.add(new SsmCfnProvisioner(ssmService));
+ }
+ if (kmsService != null) {
+ discovered.add(new KmsCfnProvisioner(kmsService));
+ }
+ if (ecrService != null) {
+ discovered.add(new EcrCfnProvisioner(ecrService));
+ }
+ if (pipesService != null) {
+ discovered.add(new PipesCfnProvisioner(pipesService));
+ }
+ if (firehoseService != null) {
+ discovered.add(new FirehoseCfnProvisioner(firehoseService));
+ }
+ if (logsService != null) {
+ discovered.add(new LogsCfnProvisioner(logsService));
+ }
+ if (kinesisService != null) {
+ discovered.add(new KinesisCfnProvisioner(kinesisService));
+ }
+ if (cloudWatchMetricsService != null) {
+ discovered.add(new CloudWatchCfnProvisioner(cloudWatchMetricsService));
+ }
+ if (iamService != null) {
+ discovered.add(new IamRoleCfnProvisioner(iamService));
+ }
+ if (ecsService != null) {
+ discovered.add(new EcsCapacityCfnProvisioner(ecsService));
+ }
+ if (apiGatewayService != null) {
+ discovered.add(new ApiGatewayAccountCfnProvisioner(apiGatewayService));
+ }
+ if (autoScalingService != null) {
+ discovered.add(new AutoScalingLifecycleHookCfnProvisioner(autoScalingService));
+ }
+ if (lambdaService != null) {
+ discovered.add(new LambdaAddressingCfnProvisioner(lambdaService));
+ discovered.add(new LambdaVersionAliasCfnProvisioner(lambdaService));
+ }
+ if (flowLogService != null) {
+ discovered.add(new Ec2FlowLogCfnProvisioner(flowLogService));
+ }
+ if (lambdaMicrovmsService != null) {
+ discovered.add(new LambdaMicrovmsCfnProvisioner(lambdaMicrovmsService));
+ }
+ if (awsConfigService != null) {
+ discovered.add(new ConfigCfnProvisioner(awsConfigService));
+ }
+ if (organizationsService != null) {
+ discovered.add(new OrganizationsCfnProvisioner(organizationsService));
+ }
+ if (sqsService != null) {
+ discovered.add(new SqsCfnProvisioner(sqsService));
+ }
+ if (wafV2Service != null) {
+ discovered.add(new WafV2CfnProvisioner(wafV2Service));
+ }
+ if (ec2Service != null) {
+ discovered.add(new Ec2VpcCfnProvisioner(ec2Service));
+ discovered.add(new Ec2VpcEndpointCfnProvisioner(ec2Service));
+ discovered.add(new Ec2VpcGatewayAttachmentCfnProvisioner(ec2Service));
+ discovered.add(new Ec2NetworkAclCfnProvisioner(ec2Service));
+ discovered.add(new Ec2SecurityGroupRuleCfnProvisioner(ec2Service));
+ discovered.add(new Ec2LaunchTemplateCfnProvisioner(ec2Service));
+ }
+ return discovered;
}
public Builder s3(S3Service v) {
@@ -271,8 +414,39 @@ final class CfnProvisionerFixture {
return this;
}
+ public Builder flowLog(FlowLogService v) {
+ this.flowLogService = v;
+ return this;
+ }
+
+ public Builder lambdaMicrovms(LambdaMicrovmsService v) {
+ this.lambdaMicrovmsService = v;
+ return this;
+ }
+
+ public Builder awsConfig(AwsConfigService v) {
+ this.awsConfigService = v;
+ return this;
+ }
+
+ public Builder organizations(OrganizationsService v) {
+ this.organizationsService = v;
+ return this;
+ }
+
+ public Builder sqs(SqsService v) {
+ this.sqsService = v;
+ return this;
+ }
+
+ public Builder wafV2(WafV2Service v) {
+ this.wafV2Service = v;
+ return this;
+ }
+
public Builder registry(CloudFormationResourceRegistry v) {
this.resourceRegistry = v;
+ this.registryChosenByTest = true;
return this;
}
@@ -286,7 +460,17 @@ final class CfnProvisionerFixture {
return this;
}
+ /** The registry {@link #build()} would use: explicit if the test chose one, else inferred. */
+ CloudFormationResourceRegistry buildRegistry() {
+ return registryChosenByTest
+ ? resourceRegistry
+ : new CloudFormationResourceRegistry(inferredProvisioners());
+ }
+
public CloudFormationResourceProvisioner build() {
+ if (!registryChosenByTest) {
+ resourceRegistry = buildRegistry();
+ }
if (dynamicReferences == null) {
// Wire it from the services already named, the way CDI does in production, so a
// test resolving {{resolve:ssm:...}} or {{resolve:secretsmanager:...}} does not
diff --git a/src/test/java/io/github/hectorvent/floci/services/cloudformation/CfnProvisionerFixtureTest.java b/src/test/java/io/github/hectorvent/floci/services/cloudformation/CfnProvisionerFixtureTest.java
new file mode 100644
index 0000000000..3b9698a056
--- /dev/null
+++ b/src/test/java/io/github/hectorvent/floci/services/cloudformation/CfnProvisionerFixtureTest.java
@@ -0,0 +1,170 @@
+package io.github.hectorvent.floci.services.cloudformation;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import io.github.hectorvent.floci.services.cloudformation.model.StackResource;
+import io.github.hectorvent.floci.services.cloudformation.provisioners.CfnResourceProvisioner;
+import io.github.hectorvent.floci.services.cloudformation.provisioners.CloudFormationResourceRegistry;
+import io.github.hectorvent.floci.services.cloudformation.provisioners.ProvisionContext;
+import io.github.hectorvent.floci.services.cloudwatch.logs.CloudWatchLogsService;
+import io.github.hectorvent.floci.services.ec2.Ec2Service;
+import io.github.hectorvent.floci.services.sns.SnsService;
+import org.junit.jupiter.api.Test;
+
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Set;
+import java.util.TreeSet;
+import java.util.stream.Collectors;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.Mockito.mock;
+
+/**
+ * The fixture wires provisioners from the services a test names.
+ *
+ * <p>This is what keeps a test honest across a migration. Before it, a test that named a service
+ * and provisioned one of its types silently kept passing when that type moved into a provisioner:
+ * the empty registry sent it to the dispatcher's stub arm, which reports CREATE_COMPLETE with a
+ * synthetic physical id, so every assertion ran against a resource nothing had provisioned.
+ */
+class CfnProvisionerFixtureTest {
+
+ /**
+ * Provisioners the fixture cannot build from a single service, so they must be passed to
+ * {@code provisioners(...)} explicitly. Both take collaborators beyond one service
+ * ({@code RegionResolver} and an {@code ObjectMapper}), which the Builder does not model.
+ */
+ private static final Set<String> NOT_INFERABLE =
+ Set.of("CodeBuildCfnProvisioner", "CodePipelineCfnProvisioner");
+
+ /**
+ * Builder setters that replace the inferred registry outright rather than naming a service.
+ * Driving them in the sweep below would discard everything inference produced.
+ */
+ private static final Set<String> REGISTRY_OVERRIDES = Set.of("registry", "provisioners");
+
+ /** Reaches the registry the same way the dispatcher does. */
+ private static boolean serves(CfnProvisionerFixture.Builder builder, String type) {
+ return builder.buildRegistry().forType(type).isPresent();
+ }
+
+ @Test
+ void namingAServiceWiresItsProvisioner() {
+ CfnProvisionerFixture.Builder fixture = CfnProvisionerFixture.builder()
+ .logs(mock(CloudWatchLogsService.class));
+
+ assertTrue(serves(fixture, "AWS::Logs::LogGroup"));
+ }
+
+ @Test
+ void anUnnamedServiceIsNotWired() {
+ CfnProvisionerFixture.Builder fixture = CfnProvisionerFixture.builder()
+ .logs(mock(CloudWatchLogsService.class));
+
+ assertFalse(serves(fixture, "AWS::SNS::Topic"),
+ "a test that never named SNS should not get its provisioner");
+ }
+
+ /** One service can back several provisioners, as it does under CDI. */
+ @Test
+ void oneServiceCanWireSeveralProvisioners() {
+ CfnProvisionerFixture.Builder fixture = CfnProvisionerFixture.builder()
+ .ec2(mock(Ec2Service.class));
+
+ for (String type : Set.of("AWS::EC2::VPC", "AWS::EC2::VPCEndpoint", "AWS::EC2::NetworkAcl",
+ "AWS::EC2::LaunchTemplate", "AWS::EC2::SecurityGroupIngress")) {
+ assertTrue(serves(fixture, type), type + " should be wired from Ec2Service");
+ }
+ }
+
+ /** CDK::Metadata backs no service, so it is always available. */
+ @Test
+ void theServicelessProvisionerIsAlwaysWired() {
+ assertTrue(serves(CfnProvisionerFixture.builder(), "AWS::CDK::Metadata"));
+ }
+
+ /**
+ * Every provisioner on disk is reachable by driving the Builder's own public setters, or is
+ * explicitly exempt.
+ *
+ * <p>Deliberately behavioural rather than textual. An earlier version of this gate matched
+ * {@code new XCfnProvisioner(} against the fixture's source, which scored a construction arm as
+ * wired even when its field had no setter and could never be non-null. That is the same silent
+ * gap this fixture exists to close, so the check has to run the wiring instead of reading it:
+ * everything below reaches the registry only through the public API a test has, which means a
+ * field no setter assigns cannot be satisfied and shows up here as unreachable.
+ *
+ * <p>Mirrors {@code CfnResourceInventoryTest}, which compares the CDI-resolved production
+ * registry for the same reason.
+ */
+ @Test
+ void everyProvisionerIsReachableThroughThePublicBuilderOrExplicitlyExempt() throws Exception {
+ Path provisioners = Path.of(
+ "src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners");
+ Set<String> onDisk;
+ try (var files = Files.list(provisioners)) {
+ onDisk = files.map(f -> f.getFileName().toString())
+ .filter(n -> n.endsWith("CfnProvisioner.java"))
+ .map(n -> n.replace(".java", ""))
+ .collect(Collectors.toCollection(TreeSet::new));
+ }
+
+ CfnProvisionerFixture.Builder builder = CfnProvisionerFixture.builder();
+ for (Method setter : CfnProvisionerFixture.Builder.class.getDeclaredMethods()) {
+ boolean namesOneCollaborator = Modifier.isPublic(setter.getModifiers())
+ && setter.getReturnType() == CfnProvisionerFixture.Builder.class
+ && setter.getParameterCount() == 1
+ && !setter.isVarArgs()
+ && !REGISTRY_OVERRIDES.contains(setter.getName());
+ if (namesOneCollaborator) {
+ setter.invoke(builder, mock(setter.getParameterTypes()[0]));
+ }
+ }
+
+ CloudFormationResourceRegistry registry = builder.buildRegistry();
+ Set<String> reachable = registry.registeredTypes().stream()
+ .map(registry::ownerOf)
+ .collect(Collectors.toCollection(TreeSet::new));
+
+ Set<String> unreachable = new TreeSet<>(onDisk);
+ unreachable.removeAll(reachable);
+ unreachable.removeAll(NOT_INFERABLE);
+
+ assertTrue(unreachable.isEmpty(),
+ "These provisioners cannot be reached through any public Builder setter, so a "
+ + "fixture test naming their service would silently hit the stub arm. Give "
+ + "them a service field AND a setter in CfnProvisionerFixture, or add them "
+ + "to NOT_INFERABLE with a reason: " + unreachable);
+
+ Set<String> staleExemptions = new TreeSet<>(NOT_INFERABLE);
+ staleExemptions.removeAll(onDisk);
+ assertTrue(staleExemptions.isEmpty(),
+ "NOT_INFERABLE names provisioners that no longer exist: " + staleExemptions);
+ }
+
+ @Test
+ void anExplicitProvisionerSetReplacesTheInferredOne() {
+ CfnResourceProvisioner only = new CfnResourceProvisioner() {
+ @Override
+ public Set<String> resourceTypes() {
+ return Set.of("AWS::Test::Only");
+ }
+
+ @Override
+ public void provision(StackResource r, JsonNode props, ProvisionContext ctx) {
+ }
+ };
+
+ CfnProvisionerFixture.Builder fixture = CfnProvisionerFixture.builder()
+ .sns(mock(SnsService.class))
+ .provisioners(only);
+
+ assertTrue(serves(fixture, "AWS::Test::Only"));
+ assertFalse(serves(fixture, "AWS::SNS::Topic"),
+ "an explicit set replaces inference rather than adding to it");
+ }
+}
diff --git a/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationLogGroupProvisionerTest.java b/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationLogGroupProvisionerTest.java
index 9e2c81cec8..504862439b 100644
--- a/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationLogGroupProvisionerTest.java
+++ b/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationLogGroupProvisionerTest.java
@@ -3,7 +3,6 @@ package io.github.hectorvent.floci.services.cloudformation;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import io.github.hectorvent.floci.services.cloudformation.model.StackResource;
-import io.github.hectorvent.floci.services.cloudformation.provisioners.LogsCfnProvisioner;
import io.github.hectorvent.floci.services.cloudwatch.logs.CloudWatchLogsService;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
@@ -40,14 +39,12 @@ class CloudFormationLogGroupProvisionerTest {
@BeforeEach
void setUp() {
logsService = mock(CloudWatchLogsService.class);
- // Registering the provisioner is load-bearing, not decoration: AWS::Logs::LogGroup now lives
- // in LogsCfnProvisioner, so with an empty registry these calls would fall through to the
- // dispatcher's stub arm and assert against a synthetic id instead of the real logic. Going
- // through the dispatcher rather than the provisioner directly also covers the plumbing this
- // migration changed, that existingPhysicalId and existingAttributes reach ProvisionContext.
+ // Naming the service is enough: the fixture wires LogsCfnProvisioner from it, the way CDI
+ // does. Testing through the dispatcher rather than the provisioner directly also covers the
+ // plumbing that carries existingPhysicalId and existingAttributes into ProvisionContext.
provisioner = CfnProvisionerFixture.builder()
.objectMapper(mapper)
- .provisioners(new LogsCfnProvisioner(logsService))
+ .logs(logsService)
.build();
}