Light, fluffy, and always free - The AWS Local Emulator alternative
test: share two persistent-storage profiles across six test classes (#6079)
Priamo Germosen6be05b9cbe97
diff --git a/src/test/java/io/github/hectorvent/floci/core/storage/StorageFactoryDuplicateBackendTest.java b/src/test/java/io/github/hectorvent/floci/core/storage/StorageFactoryDuplicateBackendTest.javaindex ea55e886e0..a53cde729a 100644--- a/src/test/java/io/github/hectorvent/floci/core/storage/StorageFactoryDuplicateBackendTest.java+++ b/src/test/java/io/github/hectorvent/floci/core/storage/StorageFactoryDuplicateBackendTest.java@@ -1,10 +1,11 @@package io.github.hectorvent.floci.core.storage;import com.fasterxml.jackson.core.type.TypeReference;+import io.github.hectorvent.floci.testing.PerServicePersistentStorageProfile;import io.quarkus.test.junit.QuarkusTest;-import io.quarkus.test.junit.QuarkusTestProfile;import io.quarkus.test.junit.TestProfile;import jakarta.inject.Inject;+import org.junit.jupiter.api.AfterEach;import org.junit.jupiter.api.BeforeEach;import org.junit.jupiter.api.Test;@@ -13,18 +14,22 @@ import java.nio.file.Files;import java.nio.file.Path;import java.util.Map;+import static io.github.hectorvent.floci.testing.PerServicePersistentStorageProfile.STORAGE_DIR;import static org.junit.jupiter.api.Assertions.assertEquals;/*** Reproduces issue #1921: two components request the same storage file, the factory hands out* two independent backends, and on graceful shutdown the stale duplicate flushes last and* clobbers the persisted state written by the active instance.+ *+ * <p>DynamoDB on persistent storage comes from {@link PerServicePersistentStorageProfile}, which+ * this class shares with other classes that each call a different service. The placeholder+ * entries it writes go into DynamoDB's table store, so it clears them again after the test.*/@QuarkusTest-@TestProfile(StorageFactoryDuplicateBackendTest.PersistentProfile.class)+@TestProfile(PerServicePersistentStorageProfile.class)class StorageFactoryDuplicateBackendTest {- private static final String STORAGE_PATH = "/tmp/floci-dedupe-backend-test";private static final String FILE_NAME = "dynamodb-tables.json";@Inject@@ -36,7 +41,12 @@ class StorageFactoryDuplicateBackendTest {// exist and hold in-memory state from app startup. Clear all backends (wipes memory + disk),// then remove the file so both create() calls below start from an empty store.storageFactory.clearAll();- Files.deleteIfExists(Path.of(STORAGE_PATH, FILE_NAME));+ Files.deleteIfExists(Path.of(STORAGE_DIR, FILE_NAME));+ }++ @AfterEach+ void clearPlaceholders() throws IOException {+ reset();}@Test@@ -59,21 +69,10 @@ class StorageFactoryDuplicateBackendTest {// Read the persisted file back with an independent reader.PersistentStorage<String, String> reader =- new PersistentStorage<>(Path.of(STORAGE_PATH, FILE_NAME), typeRef);+ new PersistentStorage<>(Path.of(STORAGE_DIR, FILE_NAME), typeRef);reader.load();assertEquals(60, reader.keys().size(),"persisted table definitions should survive flushAll despite the duplicate backend");}-- public static final class PersistentProfile implements QuarkusTestProfile {- @Override- public Map<String, String> getConfigOverrides() {- return Map.of(- "floci.storage.mode", "memory",- "floci.storage.services.dynamodb.mode", "persistent",- "floci.storage.persistent-path", STORAGE_PATH- );- }- }}diff --git a/src/test/java/io/github/hectorvent/floci/core/storage/StorageFactoryServiceCatalogIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/core/storage/StorageFactoryServiceCatalogIntegrationTest.javaindex ee6d06406b..9c1c6ebcd6 100644--- a/src/test/java/io/github/hectorvent/floci/core/storage/StorageFactoryServiceCatalogIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/core/storage/StorageFactoryServiceCatalogIntegrationTest.java@@ -1,43 +1,61 @@package io.github.hectorvent.floci.core.storage;import com.fasterxml.jackson.core.type.TypeReference;+import io.github.hectorvent.floci.config.EmulatorConfig;+import io.github.hectorvent.floci.core.common.ServiceConfigAccess;+import io.github.hectorvent.floci.testing.PerServicePersistentStorageProfile;import io.quarkus.test.junit.QuarkusTest;-import io.quarkus.test.junit.QuarkusTestProfile;import io.quarkus.test.junit.TestProfile;import jakarta.inject.Inject;import org.junit.jupiter.api.Test;+import java.io.IOException;+import java.nio.file.Files;+import java.nio.file.Path;import java.util.Map;-import static org.junit.jupiter.api.Assertions.assertInstanceOf;+import static io.github.hectorvent.floci.testing.PerServicePersistentStorageProfile.STORAGE_DIR;import static org.junit.jupiter.api.Assertions.assertTrue;+/**+ * A per-service storage mode takes effect: with the test default, memory, for storage as a whole+ * and ACM's own mode set to persistent, an ACM store writes through to its file.+ *+ * <p>The ACM override comes from {@link PerServicePersistentStorageProfile}, which also puts+ * DynamoDB and S3 on disk for the other classes on it. This class creates only the ACM store, so+ * those two never reach it. It creates that store on a factory of its own, built from the+ * application's configuration, so the application never holds it and no later flush of the+ * application's stores writes the file back after the test deletes it.+ */@QuarkusTest-@TestProfile(StorageFactoryServiceCatalogIntegrationTest.AcmPersistentStorageProfile.class)+@TestProfile(PerServicePersistentStorageProfile.class)class StorageFactoryServiceCatalogIntegrationTest {+ private static final String FILE_NAME = "acm-test.json";++ @Inject+ EmulatorConfig config;+@Inject- StorageFactory storageFactory;+ ServiceConfigAccess serviceConfigAccess;@Test- void acmStorageOverrideIsApplied() {- StorageBackend<String, String> backend = storageFactory.create(+ void acmStorageOverrideIsApplied() throws IOException {+ Path file = Path.of(STORAGE_DIR, FILE_NAME);+ Files.deleteIfExists(file);+ StorageFactory factory = new StorageFactory(config, serviceConfigAccess);+ StorageBackend<String, String> backend = factory.create("acm",- "acm-test.json",+ FILE_NAME,new TypeReference<Map<String, String>>() {});+ try {+ backend.put("probe", "persisted");- assertInstanceOf(AccountAwareStorageBackend.class, backend);- }-- public static final class AcmPersistentStorageProfile implements QuarkusTestProfile {- @Override- public Map<String, String> getConfigOverrides() {- return Map.of(- "floci.storage.mode", "memory",- "floci.storage.services.acm.mode", "persistent",- "floci.storage.persistent-path", "/tmp/floci-service-registry-unification-tests"- );+ // A store in the test default mode, memory, never writes the file.+ assertTrue(Files.exists(file), "the ACM store should write through to " + file);+ } finally {+ Files.deleteIfExists(file);}}}diff --git a/src/test/java/io/github/hectorvent/floci/services/athena/AthenaCreateWorkGroupPersistenceIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/athena/AthenaCreateWorkGroupPersistenceIntegrationTest.javaindex ddcb9110b9..0771a4f9ac 100644--- a/src/test/java/io/github/hectorvent/floci/services/athena/AthenaCreateWorkGroupPersistenceIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/athena/AthenaCreateWorkGroupPersistenceIntegrationTest.java@@ -2,18 +2,21 @@ package io.github.hectorvent.floci.services.athena;import com.fasterxml.jackson.core.type.TypeReference;import io.github.hectorvent.floci.core.storage.PersistentStorage;+import io.github.hectorvent.floci.testing.PartitionCleanup;+import io.github.hectorvent.floci.testing.PersistentStorageProfile;import io.github.hectorvent.floci.testing.RestAssuredJsonUtils;import io.quarkus.test.junit.QuarkusTest;-import io.quarkus.test.junit.QuarkusTestProfile;import io.quarkus.test.junit.TestProfile;import org.junit.jupiter.api.BeforeAll;import org.junit.jupiter.api.Test;+import org.junit.jupiter.api.extension.RegisterExtension;import java.nio.file.Files;import java.nio.file.Path;import java.util.List;import java.util.Map;+import static io.github.hectorvent.floci.testing.PersistentStorageProfile.STORAGE_DIR;import static io.restassured.RestAssured.given;import static org.junit.jupiter.api.Assertions.assertEquals;import static org.junit.jupiter.api.Assertions.assertFalse;@@ -21,14 +24,24 @@ import static org.junit.jupiter.api.Assertions.assertNotNull;import static org.junit.jupiter.api.Assertions.assertNull;import static org.junit.jupiter.api.Assertions.assertTrue;+/**+ * CreateWorkGroup and UpdateWorkGroup write the workgroup, with its defaults filled in and its+ * engine version resolved, to {@code workgroups.json}, and CreateWorkGroup does not write the+ * primary workgroup there.+ *+ * <p>Persistent storage comes from {@link PersistentStorageProfile}, which this class shares with+ * other classes that each read their own service's file, so it deletes the workgroups it creates.+ */@QuarkusTest-@TestProfile(AthenaCreateWorkGroupPersistenceIntegrationTest.PersistentStorageProfile.class)+@TestProfile(PersistentStorageProfile.class)class AthenaCreateWorkGroupPersistenceIntegrationTest {- static final String STORAGE_DIR = "target/athena-workgroups-it";private static final Path WORKGROUPS_FILE = Path.of(STORAGE_DIR, "workgroups.json");private static final String CONTENT_TYPE = "application/x-amz-json-1.1";+ @RegisterExtension+ final PartitionCleanup cleanup = new PartitionCleanup();+@BeforeAllstatic void setup() throws Exception {RestAssuredJsonUtils.configureAwsContentTypes();@@ -67,6 +80,7 @@ class AthenaCreateWorkGroupPersistenceIntegrationTest {.post("/").then().statusCode(200);+ cleanup.register(() -> deleteWorkGroup("analytics"));assertTrue(Files.exists(WORKGROUPS_FILE), "CreateWorkGroup should create workgroups.json");@@ -120,6 +134,7 @@ class AthenaCreateWorkGroupPersistenceIntegrationTest {.post("/").then().statusCode(200);+ cleanup.register(() -> deleteWorkGroup("defaulted-workgroup"));PersistentStorage<String, Map<String, Object>> store = new PersistentStorage<>(WORKGROUPS_FILE,@@ -166,6 +181,7 @@ class AthenaCreateWorkGroupPersistenceIntegrationTest {.post("/").then().statusCode(200);+ cleanup.register(() -> deleteWorkGroup("engine-normalized"));PersistentStorage<String, Map<String, Object>> store = new PersistentStorage<>(WORKGROUPS_FILE,@@ -204,6 +220,7 @@ class AthenaCreateWorkGroupPersistenceIntegrationTest {.post("/").then().statusCode(200);+ cleanup.register(() -> deleteWorkGroup("engine-explicit"));PersistentStorage<String, Map<String, Object>> store = new PersistentStorage<>(WORKGROUPS_FILE,@@ -239,6 +256,7 @@ class AthenaCreateWorkGroupPersistenceIntegrationTest {.post("/").then().statusCode(200);+ cleanup.register(() -> deleteWorkGroup("engine-empty"));PersistentStorage<String, Map<String, Object>> store = new PersistentStorage<>(WORKGROUPS_FILE,@@ -276,6 +294,7 @@ class AthenaCreateWorkGroupPersistenceIntegrationTest {.post("/").then().statusCode(200);+ cleanup.register(() -> deleteWorkGroup("engine-blank-selected"));PersistentStorage<String, Map<String, Object>> store = new PersistentStorage<>(WORKGROUPS_FILE,@@ -312,6 +331,7 @@ class AthenaCreateWorkGroupPersistenceIntegrationTest {.post("/").then().statusCode(200);+ cleanup.register(() -> deleteWorkGroup("persistent-update"));given().header("X-Amz-Target", "AmazonAthena.UpdateWorkGroup")@@ -348,13 +368,14 @@ class AthenaCreateWorkGroupPersistenceIntegrationTest {assertNull(configuration.get("BytesScannedCutoffPerQuery"));}- public static final class PersistentStorageProfile implements QuarkusTestProfile {- @Override- public Map<String, String> getConfigOverrides() {- return Map.of(- "floci.storage.mode", "persistent",- "floci.storage.persistent-path", STORAGE_DIR- );- }+ private static void deleteWorkGroup(String name) {+ given()+ .header("X-Amz-Target", "AmazonAthena.DeleteWorkGroup")+ .contentType(CONTENT_TYPE)+ .body("{ \"WorkGroup\": \"" + name + "\", \"RecursiveDeleteOption\": true }")+ .when()+ .post("/")+ .then()+ .statusCode(200);}}diff --git a/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationPersistenceIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationPersistenceIntegrationTest.javaindex e634b76277..d64defb538 100644--- a/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationPersistenceIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationPersistenceIntegrationTest.java@@ -3,18 +3,21 @@ package io.github.hectorvent.floci.services.cloudformation;import com.fasterxml.jackson.core.type.TypeReference;import io.github.hectorvent.floci.core.storage.PersistentStorage;import io.github.hectorvent.floci.services.cloudformation.model.Stack;+import io.github.hectorvent.floci.testing.PartitionCleanup;+import io.github.hectorvent.floci.testing.PersistentStorageProfile;import io.github.hectorvent.floci.testing.RestAssuredJsonUtils;import io.quarkus.test.junit.QuarkusTest;-import io.quarkus.test.junit.QuarkusTestProfile;import io.quarkus.test.junit.TestProfile;import org.junit.jupiter.api.BeforeAll;import org.junit.jupiter.api.Test;+import org.junit.jupiter.api.extension.RegisterExtension;import java.nio.file.Files;import java.nio.file.Path;import java.util.Map;import java.util.Optional;+import static io.github.hectorvent.floci.testing.PersistentStorageProfile.STORAGE_DIR;import static io.restassured.RestAssured.given;import static org.hamcrest.Matchers.containsString;import static org.junit.jupiter.api.Assertions.assertEquals;@@ -24,14 +27,20 @@ import static org.junit.jupiter.api.Assertions.assertTrue;* End-to-end check that a created stack is written to persistent storage so it survives a restart* (criteria #10, #11). Runs with the {@code persistent} storage mode; verifies the on-disk file* directly with a fresh {@link PersistentStorage} (what the service would read on the next boot).+ *+ * <p>Persistent storage comes from {@link PersistentStorageProfile}, which this class shares with+ * other classes that each read their own service's file, so it deletes its stack, and with it the+ * bucket the stack created.*/@QuarkusTest-@TestProfile(CloudFormationPersistenceIntegrationTest.PersistentStorageProfile.class)+@TestProfile(PersistentStorageProfile.class)class CloudFormationPersistenceIntegrationTest {- static final String STORAGE_DIR = "target/cfn-persistence-it";private static final Path STACKS_FILE = Path.of(STORAGE_DIR, "cloudformation-stacks.json");+ @RegisterExtension+ final PartitionCleanup cleanup = new PartitionCleanup();+@BeforeAllstatic void setup() throws Exception {RestAssuredJsonUtils.configureAwsContentTypes();@@ -60,6 +69,19 @@ class CloudFormationPersistenceIntegrationTest {.post("/").then().statusCode(200);+ cleanup.register(() -> {+ given()+ .contentType("application/x-www-form-urlencoded")+ .formParam("Action", "DeleteStack")+ .formParam("StackName", "persist-it-stack")+ .when()+ .post("/")+ .then()+ .statusCode(200);+ // DeleteStack answers before the deletion runs, so wait for it, then for the bucket.+ CfnStackWaits.awaitStackDeleted("persist-it-stack");+ given().when().head("/cfn-persist-it-bucket").then().statusCode(404);+ });given().contentType("application/x-www-form-urlencoded")@@ -86,13 +108,4 @@ class CloudFormationPersistenceIntegrationTest {assertEquals("cfn-persist-it-bucket",loaded.get().getResources().get("PersistBucket").getPhysicalId());}-- public static final class PersistentStorageProfile implements QuarkusTestProfile {- @Override- public Map<String, String> getConfigOverrides() {- return Map.of(- "floci.storage.mode", "persistent",- "floci.storage.persistent-path", STORAGE_DIR);- }- }}diff --git a/src/test/java/io/github/hectorvent/floci/services/cloudfront/CloudFrontS3DiskOriginServingTest.java b/src/test/java/io/github/hectorvent/floci/services/cloudfront/CloudFrontS3DiskOriginServingTest.javaindex b1fb090d7e..ad7beff5f3 100644--- a/src/test/java/io/github/hectorvent/floci/services/cloudfront/CloudFrontS3DiskOriginServingTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/cloudfront/CloudFrontS3DiskOriginServingTest.java@@ -5,32 +5,42 @@ import io.github.hectorvent.floci.services.cloudfront.model.Distribution;import io.github.hectorvent.floci.services.cloudfront.model.DistributionConfig;import io.github.hectorvent.floci.services.cloudfront.model.Origin;import io.github.hectorvent.floci.services.s3.S3Service;+import io.github.hectorvent.floci.testing.PerServicePersistentStorageProfile;import io.quarkus.test.junit.QuarkusTest;-import io.quarkus.test.junit.QuarkusTestProfile;import io.quarkus.test.junit.TestProfile;import io.restassured.response.Response;import jakarta.inject.Inject;import org.junit.jupiter.api.Test;+import java.io.IOException;import java.nio.charset.StandardCharsets;+import java.nio.file.Files;+import java.nio.file.Path;import java.util.Arrays;import java.util.LinkedHashMap;import java.util.List;import java.util.Map;import java.util.Random;+import java.util.stream.Stream;+import static io.github.hectorvent.floci.testing.PerServicePersistentStorageProfile.STORAGE_DIR;import static io.restassured.RestAssured.given;import static org.hamcrest.Matchers.containsString;import static org.hamcrest.Matchers.equalTo;import static org.junit.jupiter.api.Assertions.assertArrayEquals;import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertTrue;/*** An S3 origin whose objects live on disk, where CloudFront streams the object file to the viewer* instead of reading it into memory first.+ *+ * <p>S3 on disk comes from {@link PerServicePersistentStorageProfile}, which this class shares+ * with other classes that each call a different service, so it deletes its distribution as well+ * as its bucket.*/@QuarkusTest-@TestProfile(CloudFrontS3DiskOriginServingTest.S3OnDiskProfile.class)+@TestProfile(PerServicePersistentStorageProfile.class)class CloudFrontS3DiskOriginServingTest {private static final String REGION = "us-east-1";@@ -42,18 +52,23 @@ class CloudFrontS3DiskOriginServingTest {CloudFrontService cloudFrontService;@Test- void streamsAnObjectFileWithItsLength() {+ void streamsAnObjectFileWithItsLength() throws IOException {String suffix = Long.toString(System.nanoTime(), 36);String bucket = "cf-disk-origin-" + suffix;// Larger than any one buffer on the way, so the body arrives over many writes.byte[] body = new byte[3 * 1024 * 1024 + 1];new Random(5080).nextBytes(body);s3Service.createBucket(bucket, REGION);+ Distribution dist = null;try {s3Service.putObject(bucket, "video.bin", body, "application/octet-stream", Map.of());+ // S3 in memory would serve the same bytes, so check the object really is a file first.+ assertTrue(hasObjectFile(Path.of(STORAGE_DIR, "s3"), bucket, "video.bin", body.length),+ "video.bin should be a file in " + bucket + "'s directory under "+ + STORAGE_DIR + "/s3");s3Service.putObject(bucket, "index.html", ("INDEX-ON-DISK-" + suffix).getBytes(StandardCharsets.UTF_8),"text/html", Map.of());- Distribution dist = distributionFor(bucket);+ dist = distributionFor(bucket);Response get = given().header("Host", dist.getDomainName()).when().get("/video.bin");@@ -75,6 +90,9 @@ class CloudFrontS3DiskOriginServingTest {.header("Content-Length", equalTo(Integer.toString(("INDEX-ON-DISK-" + suffix).length()))).body(containsString("INDEX-ON-DISK-" + suffix));} finally {+ if (dist != null) {+ cloudFrontService.removeDistribution(dist.getId());+ }// The bucket is on disk and outlives the test, so it is removed rather than left for the next run.s3Service.deleteObject(bucket, "video.bin");s3Service.deleteObject(bucket, "index.html");@@ -82,6 +100,24 @@ class CloudFrontS3DiskOriginServingTest {}}+ /**+ * Whether a file named for {@code key}, of {@code size} bytes, sits in a directory named for+ * {@code bucket}. The bucket name is new on every run, so a file an earlier run left behind+ * cannot match.+ */+ private static boolean hasObjectFile(Path dir, String bucket, String key, long size)+ throws IOException {+ if (!Files.isDirectory(dir)) {+ return false;+ }+ try (Stream<Path> files = Files.walk(dir)) {+ return files.anyMatch(f -> Files.isRegularFile(f)+ && f.getParent().getFileName().toString().equals(bucket)+ && f.getFileName().toString().startsWith(key)+ && f.toFile().length() == size);+ }+ }+private Distribution distributionFor(String bucket) {Origin origin = new Origin();origin.setId("disk-origin");@@ -103,13 +139,4 @@ class CloudFrontS3DiskOriginServingTest {distribution.setConfig(config);return cloudFrontService.createDistribution(distribution, Map.of());}-- public static final class S3OnDiskProfile implements QuarkusTestProfile {- @Override- public Map<String, String> getConfigOverrides() {- return Map.of(- "floci.storage.services.s3.mode", "persistent",- "floci.storage.persistent-path", "target/cloudfront-s3-disk-origin-it");- }- }}diff --git a/src/test/java/io/github/hectorvent/floci/services/glue/GlueSecurityConfigurationIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/glue/GlueSecurityConfigurationIntegrationTest.javaindex eae39ac90d..37c25614d8 100644--- a/src/test/java/io/github/hectorvent/floci/services/glue/GlueSecurityConfigurationIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/glue/GlueSecurityConfigurationIntegrationTest.java@@ -3,19 +3,23 @@ package io.github.hectorvent.floci.services.glue;import com.fasterxml.jackson.core.type.TypeReference;import io.github.hectorvent.floci.core.storage.PersistentStorage;import io.github.hectorvent.floci.services.glue.model.SecurityConfiguration;+import io.github.hectorvent.floci.testing.PartitionCleanup;+import io.github.hectorvent.floci.testing.PersistentStorageProfile;import io.github.hectorvent.floci.testing.RestAssuredJsonUtils;import io.quarkus.test.junit.QuarkusTest;-import io.quarkus.test.junit.QuarkusTestProfile;import io.quarkus.test.junit.TestProfile;import org.junit.jupiter.api.BeforeAll;import org.junit.jupiter.api.Test;+import org.junit.jupiter.api.extension.RegisterExtension;import java.nio.file.Files;import java.nio.file.Path;import java.util.Map;import java.util.UUID;+import static io.github.hectorvent.floci.testing.PersistentStorageProfile.STORAGE_DIR;import static io.restassured.RestAssured.given;+import static org.hamcrest.Matchers.anyOf;import static org.hamcrest.Matchers.containsString;import static org.hamcrest.Matchers.equalTo;import static org.hamcrest.Matchers.hasSize;@@ -23,12 +27,20 @@ import static org.hamcrest.Matchers.instanceOf;import static org.junit.jupiter.api.Assertions.assertEquals;import static org.junit.jupiter.api.Assertions.assertTrue;+/**+ * Glue security configurations: create, read, list and delete, the errors for a duplicate or a+ * missing one, isolation by account and region, and the copy written to+ * {@code security_configurations.json}.+ *+ * <p>Persistent storage comes from {@link PersistentStorageProfile}, which this class shares with+ * other classes that each read their own service's file, so it deletes the configurations it+ * creates.+ */@QuarkusTest-@TestProfile(GlueSecurityConfigurationIntegrationTest.PersistentStorageProfile.class)+@TestProfile(PersistentStorageProfile.class)class GlueSecurityConfigurationIntegrationTest {private static final String CONTENT_TYPE = "application/x-amz-json-1.1";- private static final String STORAGE_DIR = "target/glue-security-configuration-it";private static final Path STORAGE_FILE = Path.of(STORAGE_DIR, "security_configurations.json");private static final String NAME = "security-" + UUID.randomUUID().toString().substring(0, 8);private static final String ENCRYPTION = """@@ -36,6 +48,9 @@ class GlueSecurityConfigurationIntegrationTest {"JobBookmarksEncryption":{"JobBookmarksEncryptionMode":"CSE-KMS"}}""";+ @RegisterExtension+ final PartitionCleanup cleanup = new PartitionCleanup();+@BeforeAllstatic void setup() throws Exception {RestAssuredJsonUtils.configureAwsContentTypes();@@ -45,6 +60,7 @@ class GlueSecurityConfigurationIntegrationTest {@Testvoid securityConfigurationCrudAndEncryptionRoundTrip() {create(NAME, "us-east-1", "000000000000");+ cleanup.register(() -> deleteIfPresent(NAME, "us-east-1", "000000000000"));given().contentType(CONTENT_TYPE).header("X-Amz-Target", "AWSGlue.GetSecurityConfiguration")@@ -77,6 +93,7 @@ class GlueSecurityConfigurationIntegrationTest {@Testvoid duplicateAndMissingConfigurationsUseAwsErrors() {create(NAME, "us-east-1", "000000000000");+ cleanup.register(() -> deleteIfPresent(NAME, "us-east-1", "000000000000"));given().contentType(CONTENT_TYPE).header("X-Amz-Target", "AWSGlue.CreateSecurityConfiguration")@@ -98,6 +115,7 @@ class GlueSecurityConfigurationIntegrationTest {@Testvoid accountAndRegionAreIsolatedAndConfigurationIsPersisted() throws Exception {create(NAME, "us-east-1", "000000000001");+ cleanup.register(() -> delete(NAME, "us-east-1", "000000000001"));given().contentType(CONTENT_TYPE).header("X-Amz-Target", "AWSGlue.GetSecurityConfiguration")@@ -142,17 +160,18 @@ class GlueSecurityConfigurationIntegrationTest {.then().statusCode(200);}+ /** For cleanup: each test deletes its configuration itself, unless an assertion stops it. */+ private static void deleteIfPresent(String name, String region, String account) {+ given().contentType(CONTENT_TYPE)+ .header("X-Amz-Target", "AWSGlue.DeleteSecurityConfiguration")+ .header("Authorization", authorization(account, region))+ .body("{\"Name\":\"" + name + "\"}")+ .when().post("/")+ .then().statusCode(anyOf(equalTo(200), equalTo(400)));+ }+private static String authorization(String account, String region) {return "AWS4-HMAC-SHA256 Credential=" + account+ "/20260918/" + region + "/glue/aws4_request, SignedHeaders=host, Signature=abc";}-- public static final class PersistentStorageProfile implements QuarkusTestProfile {- @Override- public Map<String, String> getConfigOverrides() {- return Map.of(- "floci.storage.mode", "persistent",- "floci.storage.persistent-path", STORAGE_DIR);- }- }}diff --git a/src/test/java/io/github/hectorvent/floci/testing/PerServicePersistentStorageProfile.java b/src/test/java/io/github/hectorvent/floci/testing/PerServicePersistentStorageProfile.javanew file mode 100644index 0000000000..ee1f97191e--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/testing/PerServicePersistentStorageProfile.java@@ -0,0 +1,49 @@+package io.github.hectorvent.floci.testing;++import io.quarkus.test.junit.QuarkusTestProfile;++import java.util.Map;++/**+ * DynamoDB, ACM and S3 on persistent storage while every other service stays on the test default,+ * memory, for the classes that test a per-service storage mode. Quarkus builds the application+ * once per distinct profile class, so they share this one rather than each declaring their own.+ *+ * <p>The overrides, and who relies on them:+ * <ul>+ * <li>{@code floci.storage.services.dynamodb.mode=persistent} puts DynamoDB's table file on disk.+ * {@code StorageFactoryDuplicateBackendTest} relies on it: it writes that file through two+ * backends and reads it back.</li>+ * <li>{@code floci.storage.services.acm.mode=persistent} puts ACM's store on disk.+ * {@code StorageFactoryServiceCatalogIntegrationTest} relies on it: it checks that an ACM store+ * written to reaches disk.</li>+ * <li>{@code floci.storage.services.s3.mode=persistent} keeps S3 objects in files, which+ * CloudFront streams to the viewer. {@code CloudFrontS3DiskOriginServingTest} relies on it: it+ * checks that its object is a file before fetching it through a distribution.</li>+ * <li>{@code floci.storage.persistent-path=}{@value #STORAGE_DIR} is the directory those files go+ * in, where each class looks for its own. All three rely on it.</li>+ * </ul>+ *+ * <p>Each override is inert for the other classes, since each reaches a single service and each+ * class is the only one here that calls its service. {@code StorageFactoryDuplicateBackendTest}+ * clears every store before and after it runs, and writes placeholder strings into DynamoDB's+ * table store in between, so no other class here may call DynamoDB, and none may count on state+ * outliving its own class.+ *+ * <p>Each class also deletes what it creates, so a class that joins later finds nothing left+ * behind. A class joins only if no other class here calls its service, and it deletes what it+ * creates.+ */+public class PerServicePersistentStorageProfile implements QuarkusTestProfile {++ public static final String STORAGE_DIR = "target/per-service-persistent-storage-it";++ @Override+ public Map<String, String> getConfigOverrides() {+ return Map.of(+ "floci.storage.services.dynamodb.mode", "persistent",+ "floci.storage.services.acm.mode", "persistent",+ "floci.storage.services.s3.mode", "persistent",+ "floci.storage.persistent-path", STORAGE_DIR);+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/testing/PersistentStorageProfile.java b/src/test/java/io/github/hectorvent/floci/testing/PersistentStorageProfile.javanew file mode 100644index 0000000000..7c009e0a20--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/testing/PersistentStorageProfile.java@@ -0,0 +1,43 @@+package io.github.hectorvent.floci.testing;++import io.quarkus.test.junit.QuarkusTestProfile;++import java.util.Map;++/**+ * Persistent storage as every service's default, in one directory, for the classes that read back+ * the file a service writes. Quarkus builds the application once per distinct profile class, so+ * they share this one rather than each declaring their own.+ *+ * <p>The overrides, and who relies on them:+ * <ul>+ * <li>{@code floci.storage.mode=persistent} writes each service's state to a JSON file as it+ * changes. A service the test {@code application.yml} gives a mode of its own keeps that mode:+ * Resource Explorer stays in memory. {@code AthenaCreateWorkGroupPersistenceIntegrationTest},+ * {@code CloudFormationPersistenceIntegrationTest} and+ * {@code GlueSecurityConfigurationIntegrationTest} each read their service's file back, and rely+ * on it.</li>+ * <li>{@code floci.storage.persistent-path=}{@value #STORAGE_DIR} puts those files in the one+ * directory each class reads its own from. All three rely on it.</li>+ * </ul>+ *+ * <p>The classes can share the directory because each one deletes and reads only its own+ * service's file ({@code workgroups.json}, {@code cloudformation-stacks.json} and+ * {@code security_configurations.json}), and is the only class here that calls its service. The+ * CloudFormation stack also creates an S3 bucket, and no other class here calls S3.+ *+ * <p>Each class also deletes what it creates, so a class that joins later finds nothing left+ * behind, in memory or on disk. A class joins only if no other class here calls its service, and+ * it deletes what it creates.+ */+public class PersistentStorageProfile implements QuarkusTestProfile {++ public static final String STORAGE_DIR = "target/persistent-storage-it";++ @Override+ public Map<String, String> getConfigOverrides() {+ return Map.of(+ "floci.storage.mode", "persistent",+ "floci.storage.persistent-path", STORAGE_DIR);+ }+}