Merge pull request #183 from shift7-ch/feature-minio-hybrid

Add hybrid integration tests for deployed MinIO.

Author: chenkins

README.md

@@ -21,7 +21,7 @@ Features:
 ## One-Stop Shop Demo with Docker Compose
 
 ```bash
-docker compose -f hub/src/test/resources/docker-compose-minio-localhost-hub.yml --profile local up -d
+docker compose -f hub/src/test/resources/docker-compose-minio-localhost-hub.yml --profile local up --wait
 docker compose -f hub/src/test/resources/docker-compose-minio-localhost-hub.yml --profile local down
 ```
 

hub/src/test/java/cloud/katta/client/model/ObjectMapperTest.java

@@ -24,7 +24,7 @@ public void testAWSStatic() throws IOException {
         final ObjectMapper mapper = new ObjectMapper();
         mapper.registerModule(new JsonNullableModule());
 
-        final StorageProfileS3Dto awsStaticProfile = mapper.readValue(this.getClass().getResourceAsStream("/setup/aws_static/aws_static_profile.json"), StorageProfileS3Dto.class);
+        final StorageProfileS3Dto awsStaticProfile = mapper.readValue(this.getClass().getResourceAsStream("/setup/hybrid/aws_static/aws_static_profile.json"), StorageProfileS3Dto.class);
         assertEquals(Protocol.S3, awsStaticProfile.getProtocol());
         assertEquals("https", awsStaticProfile.getScheme());
         assertNull(awsStaticProfile.getHostname());
@@ -41,7 +41,7 @@ public void testAWSSTS() throws IOException {
         mapper.registerModule(new JsonNullableModule());
 
 
-        final StorageProfileS3STSDto awsSTSProfile = mapper.readValue(this.getClass().getResourceAsStream("/setup/aws_sts/aws_sts_profile.json"), StorageProfileS3STSDto.class);
+        final StorageProfileS3STSDto awsSTSProfile = mapper.readValue(this.getClass().getResourceAsStream("/setup/hybrid/aws_sts/aws_sts_profile.json"), StorageProfileS3STSDto.class);
         assertEquals("katta-test-", awsSTSProfile.getBucketPrefix());
         assertEquals("eu-west-1", awsSTSProfile.getRegion());
         assertEquals(Arrays.asList("eu-west-1", "eu-west-2", "eu-west-3"), awsSTSProfile.getRegions());
@@ -64,7 +64,7 @@ public void testMinioStatic() throws IOException {
         final ObjectMapper mapper = new ObjectMapper();
         mapper.registerModule(new JsonNullableModule());
 
-        final StorageProfileS3Dto minioStaticProfile = mapper.readValue(this.getClass().getResourceAsStream("/setup/minio_static/minio_static_profile.json"), StorageProfileS3Dto.class);
+        final StorageProfileS3Dto minioStaticProfile = mapper.readValue(this.getClass().getResourceAsStream("/setup/local/minio_static/minio_static_profile.json"), StorageProfileS3Dto.class);
         assertEquals(Protocol.S3, minioStaticProfile.getProtocol());
         assertEquals("http", minioStaticProfile.getScheme());
         assertEquals("minio", minioStaticProfile.getHostname());
@@ -79,7 +79,7 @@ public void testMinioStatic() throws IOException {
     public void testMinioSTS() throws IOException {
         final ObjectMapper mapper = new ObjectMapper();
         mapper.registerModule(new JsonNullableModule());
-        final StorageProfileS3STSDto minioSTSProfile = mapper.readValue(this.getClass().getResourceAsStream("/setup/minio_sts/minio_sts_profile.json"), StorageProfileS3STSDto.class);
+        final StorageProfileS3STSDto minioSTSProfile = mapper.readValue(this.getClass().getResourceAsStream("/setup/local/minio_sts/minio_sts_profile.json"), StorageProfileS3STSDto.class);
         assertEquals("katta-test-", minioSTSProfile.getBucketPrefix());
         assertEquals("eu-central-1", minioSTSProfile.getRegion());
         assertEquals(Arrays.asList("eu-west-1", "eu-west-2", "eu-west-3", "eu-north-1", "eu-south-1", "eu-south-2", "eu-central-1", "eu-central-2"), minioSTSProfile.getRegions());

hub/src/test/java/cloud/katta/core/AbstractHubSynchronizeTest.java

@@ -53,8 +53,11 @@
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.EnumSet;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Properties;
 import java.util.UUID;
+import java.util.stream.Collectors;
 
 import cloud.katta.client.ApiClient;
 import cloud.katta.client.ApiException;
@@ -94,6 +97,15 @@ public abstract class AbstractHubSynchronizeTest extends AbstractHubTest {
     @MethodIgnorableSource(value = "arguments")
     public void test01Bootstrapping(final HubTestConfig hubTestConfig) throws Exception {
         log.info("M01 {}", hubTestConfig);
+        final String profile = hubTestConfig.setup.dockerConfig.profile;
+        final Properties props = new Properties();
+        props.load(this.getClass().getResourceAsStream(hubTestConfig.setup.dockerConfig.envFile));
+        final HashMap<String, String> env = props.entrySet().stream().collect(
+                Collectors.toMap(
+                        e -> String.valueOf(e.getKey()),
+                        e -> String.valueOf(e.getValue()),
+                        (prev, next) -> next, HashMap::new
+                ));
 
         final HubSession hubSession = setupConnection(hubTestConfig.setup);
         try {
@@ -105,7 +117,9 @@ public void test01Bootstrapping(final HubTestConfig hubTestConfig) throws Except
             mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
             mapper.registerModule(new JsonNullableModule());
             try {
-                adminStorageProfileApi.apiStorageprofileS3Put(mapper.readValue(AbstractHubSynchronizeTest.class.getResourceAsStream("/setup/aws_static/aws_static_profile.json"), StorageProfileS3Dto.class).storageClass(S3STORAGECLASSES.STANDARD));
+                adminStorageProfileApi.apiStorageprofileS3Put(mapper.readValue(AbstractHubSynchronizeTest.class.getResourceAsStream(String.format("/setup/%s/aws_static/aws_static_profile.json", profile)), StorageProfileS3Dto.class)
+                        .storageClass(S3STORAGECLASSES.STANDARD)
+                );
             }
             catch(ApiException e) {
                 if(e.getCode() == 409) {
@@ -116,7 +130,7 @@ public void test01Bootstrapping(final HubTestConfig hubTestConfig) throws Except
                 }
             }
             try {
-                adminStorageProfileApi.apiStorageprofileS3stsPut(mapper.readValue(AbstractHubSynchronizeTest.class.getResourceAsStream("/setup/aws_sts/aws_sts_profile.json"), StorageProfileS3STSDto.class)
+                adminStorageProfileApi.apiStorageprofileS3stsPut(mapper.readValue(AbstractHubSynchronizeTest.class.getResourceAsStream(String.format("/setup/%s/aws_sts/aws_sts_profile.json", profile)), StorageProfileS3STSDto.class)
                         .storageClass(S3STORAGECLASSES.STANDARD).bucketEncryption(S3SERVERSIDEENCRYPTION.NONE));
             }
             catch(ApiException e) {
@@ -128,7 +142,17 @@ public void test01Bootstrapping(final HubTestConfig hubTestConfig) throws Except
                 }
             }
             try {
-                adminStorageProfileApi.apiStorageprofileS3Put(mapper.readValue(AbstractHubSynchronizeTest.class.getResourceAsStream("/setup/minio_static/minio_static_profile.json"), StorageProfileS3Dto.class).storageClass(S3STORAGECLASSES.STANDARD));
+                final StorageProfileS3Dto storageProfile = mapper.readValue(AbstractHubSynchronizeTest.class.getResourceAsStream(String.format("/setup/%s/minio_static/minio_static_profile.json", profile)), StorageProfileS3Dto.class)
+                        .storageClass(S3STORAGECLASSES.STANDARD);
+                final String minioPort = props.getProperty("MINIO_PORT");
+                if(minioPort != null) {
+                    storageProfile.setPort(Integer.valueOf(minioPort));
+                }
+                final String minioHostname = props.getProperty("MINIO_HOSTNAME");
+                if(minioHostname != null) {
+                    storageProfile.setHostname(minioHostname);
+                }
+                adminStorageProfileApi.apiStorageprofileS3Put(storageProfile);
             }
             catch(ApiException e) {
                 if(e.getCode() == 409) {
@@ -139,8 +163,19 @@ public void test01Bootstrapping(final HubTestConfig hubTestConfig) throws Except
                 }
             }
             try {
-                final StorageProfileS3STSDto storageProfile = mapper.readValue(AbstractHubSynchronizeTest.class.getResourceAsStream("/setup/minio_sts/minio_sts_profile.json"), StorageProfileS3STSDto.class)
-                        .storageClass(S3STORAGECLASSES.STANDARD).bucketEncryption(S3SERVERSIDEENCRYPTION.NONE);
+                final StorageProfileS3STSDto storageProfile = mapper.readValue(AbstractHubSynchronizeTest.class.getResourceAsStream(String.format("/setup/%s/minio_sts/minio_sts_profile.json", profile)), StorageProfileS3STSDto.class)
+                        .storageClass(S3STORAGECLASSES.STANDARD)
+                        .bucketEncryption(S3SERVERSIDEENCRYPTION.NONE);
+                final String minioPort = props.getProperty("MINIO_PORT");
+                if(minioPort != null) {
+                    storageProfile.setPort(Integer.valueOf(minioPort));
+                    storageProfile.setStsEndpoint(storageProfile.getStsEndpoint().replace("9000", minioPort));
+                }
+                final String minioHostname = props.getProperty("MINIO_HOSTNAME");
+                if(minioHostname != null) {
+                    storageProfile.setStsEndpoint(storageProfile.getStsEndpoint().replace("minio", minioHostname));
+                    storageProfile.setHostname(minioHostname);
+                }
                 adminStorageProfileApi.apiStorageprofileS3stsPut(storageProfile);
             }
             catch(ApiException e) {
@@ -155,16 +190,16 @@ public void test01Bootstrapping(final HubTestConfig hubTestConfig) throws Except
                     .apiStorageprofileGet(false);
             // aws static
             assertTrue(storageProfileDtos.stream().anyMatch(storageProfileDto -> StorageProfileDtoWrapper.coerce(storageProfileDto).getId().toString()
-                    .equals("72736c19-283c-49d3-80a5-ab74b5202543")));
+                    .startsWith("72736c19-283c-49d3-80a5-ab74b520254")));
             // aws sts
             assertTrue(storageProfileDtos.stream().anyMatch(storageProfileDto -> StorageProfileDtoWrapper.coerce(storageProfileDto).getId().toString()
-                    .equals("844bd517-96d4-4787-bcfa-238e103149f6")));
+                    .startsWith("844bd517-96d4-4787-bcfa-238e103149f")));
             // minio static
             assertTrue(storageProfileDtos.stream().anyMatch(storageProfileDto -> StorageProfileDtoWrapper.coerce(storageProfileDto).getId().toString()
-                    .equals("71b910e0-2ecc-46de-a871-8db28549677e")));
+                    .startsWith("71b910e0-2ecc-46de-a871-8db28549677")));
             // minio sts
             assertTrue(storageProfileDtos.stream().anyMatch(storageProfileDto -> StorageProfileDtoWrapper.coerce(storageProfileDto).getId().toString()
-                    .equals("732d43fa-3716-46c4-b931-66ea5405ef1c")));
+                    .startsWith("732d43fa-3716-46c4-b931-66ea5405ef1")));
         }
         catch(ApiException e) {
             log.error("{} {}", e.getCode(), e.getMessage(), e);

hub/src/test/java/cloud/katta/core/HubSynchronizeTest.java

@@ -27,9 +27,7 @@ class HubSynchronizeTest {
     @TestInstance(PER_CLASS)
     public class Local extends AbstractHubSynchronizeTest {
         private Stream<Arguments> arguments() {
-            return Stream.of(
-                    LOCAL_MINIO_STATIC,
-                    LOCAL_MINIO_STS);
+            return Stream.of(LOCAL_MINIO_STATIC, LOCAL_MINIO_STS);
         }
     }
 
@@ -58,12 +56,7 @@ private Stream<Arguments> arguments() {
     @TestInstance(PER_CLASS)
     public class Hybrid extends AbstractHubSynchronizeTest {
         private Stream<Arguments> arguments() {
-            return Stream.of(
-                    HYBRID_MINIO_STATIC,
-                    HYBRID_MINIO_STS ,
-                    HYBRID_AWS_STATIC,
-                    HYBRID_AWS_STS
-            );
+            return Stream.of(HYBRID_MINIO_STATIC, HYBRID_MINIO_STS, HYBRID_AWS_STATIC, HYBRID_AWS_STS);
         }
     }
 

hub/src/test/java/cloud/katta/testsetup/AbstractHubTest.java

@@ -44,18 +44,9 @@ public abstract class AbstractHubTest extends VaultTest {
         credentials();
     }
 
-    private static final HubTestConfig.VaultSpec minioSTSVaultConfig = new HubTestConfig.VaultSpec("MinIO STS", "732D43FA-3716-46C4-B931-66EA5405EF1C",
-            null, null, "eu-central-1");
-    private static final HubTestConfig.VaultSpec minioStaticVaultConfig = new HubTestConfig.VaultSpec("MinIO static", "71B910E0-2ECC-46DE-A871-8DB28549677E",
-            "minioadmin", "minioadmin", "us-east-1");
-    private static final HubTestConfig.VaultSpec awsSTSVaultConfig = new HubTestConfig.VaultSpec("AWS STS", "844BD517-96D4-4787-BCFA-238E103149F6",
-            null, null, "eu-west-1");
-    private static final HubTestConfig.VaultSpec awsStaticVaultConfig = new HubTestConfig.VaultSpec("AWS static", "72736C19-283C-49D3-80A5-AB74B5202543",
-            PROPERTIES.get("handmade2.s3.amazonaws.com.username"), PROPERTIES.get("handmade2.s3.amazonaws.com.password"), "us-east-1"
-    );
 
     /**
-     * Local: hub, Keycloak, MinIO started via testcontainers+docker-compose.
+     * LOCAL: hub, Keycloak, MinIO, localstack started via testcontainers+docker-compose.
      */
     public static final HubTestConfig.Setup LOCAL;
     public static final HubTestConfig.Setup.DockerConfig LOCAL_DOCKER_CONFIG;
@@ -69,27 +60,18 @@ public abstract class AbstractHubTest extends VaultTest {
                 .withDockerConfig(LOCAL_DOCKER_CONFIG);
     }
 
-    private static final Function<HubTestConfig.VaultSpec, Arguments> argumentUnattendedLocalOnly = vs -> Arguments.of(Named.of(
+    private static final Function<HubTestConfig.VaultSpec, Arguments> prepareArgumentLocal = vs -> Arguments.of(Named.of(
             String.format("%s %s", vs.storageProfileName, LOCAL.hubURL),
             new HubTestConfig(LOCAL, vs)));
 
+    public static final Arguments LOCAL_MINIO_STATIC = prepareArgumentLocal.apply(new HubTestConfig.VaultSpec(
+            "MinIO static", "71B910E0-2ECC-46DE-A871-8DB28549677E", "testuser", "top-secret", "us-east-1"));
+    public static final Arguments LOCAL_MINIO_STS = prepareArgumentLocal.apply(new HubTestConfig.VaultSpec(
+            "MinIO STS", "732D43FA-3716-46C4-B931-66EA5405EF1C", null, null, "eu-central-1"));
 
-    public static final Arguments LOCAL_MINIO_STATIC = argumentUnattendedLocalOnly.apply(minioStaticVaultConfig);
-    public static final Arguments LOCAL_MINIO_STS = argumentUnattendedLocalOnly.apply(minioSTSVaultConfig);
 
     /**
-     * Local attended: re-use running local stetup.
-     */
-    private static final HubTestConfig.Setup LOCAL_ATTENDED = new HubTestConfig.Setup()
-            .withHubURL("http://localhost:8080")
-            .withAdminConfig(new HubTestConfig.Setup.UserConfig("admin", "admin", staticSetupCode()))
-            .withUserConfig(new HubTestConfig.Setup.UserConfig("alice", "asd", staticSetupCode()));
-    private static final Function<HubTestConfig.VaultSpec, Arguments> argumentAttendedLocalOnly = vs -> Arguments.of(Named.of(
-            String.format("%s %s", vs.storageProfileName, LOCAL_ATTENDED.hubURL),
-            new HubTestConfig(LOCAL_ATTENDED, vs)));
-
-    /**
-     * Hybrid: local hub (testcontainers+docker-compose) against AWS/MinIO/Keycloak remote.
+     * HYBRID: local hub (testcontainers+docker-compose) against AWS/MinIO/Keycloak remote.
      */
     public static final HubTestConfig.Setup HYBRID;
     public static final HubTestConfig.Setup.DockerConfig HYBRID_DOCKER_CONFIG;
@@ -98,7 +80,7 @@ public abstract class AbstractHubTest extends VaultTest {
         HYBRID_DOCKER_CONFIG = new HubTestConfig.Setup.DockerConfig(
                 "/docker-compose-minio-localhost-hub.yml",
                 "/.hybrid.env",
-                null,
+                "hybrid",
                 PROPERTIES.get("testing.katta.cloud.chipotle.admin.name"),
                 PROPERTIES.get("testing.katta.cloud.chipotle.admin.password"),
                 PROPERTIES.get("testing.katta.cloud.chipotle.syncer.password")
@@ -120,15 +102,27 @@ public abstract class AbstractHubTest extends VaultTest {
                 .withDockerConfig(HYBRID_DOCKER_CONFIG);
     }
 
-    private static final Function<HubTestConfig.VaultSpec, Arguments> argumentUnattendedHybrid = vs -> Arguments.of(Named.of(
+    private static final Function<HubTestConfig.VaultSpec, Arguments> prepareArgumentsHybrid = vs -> Arguments.of(Named.of(
             String.format("%s %s", vs.storageProfileName, HYBRID.hubURL),
             new HubTestConfig(HYBRID, vs)));
 
 
-    public static final Arguments HYBRID_MINIO_STATIC = argumentUnattendedHybrid.apply(minioStaticVaultConfig);
-    public static final Arguments HYBRID_MINIO_STS = argumentUnattendedHybrid.apply(minioSTSVaultConfig);
-    public static final Arguments HYBRID_AWS_STATIC = argumentUnattendedHybrid.apply(awsStaticVaultConfig);
-    public static final Arguments HYBRID_AWS_STS = argumentUnattendedHybrid.apply(awsSTSVaultConfig);
+    public static final Arguments HYBRID_MINIO_STATIC = prepareArgumentsHybrid.apply(new HubTestConfig.VaultSpec(
+            "MinIO static", "71B910E0-2ECC-46DE-A871-8DB285496779", PROPERTIES.get("minio.testing.katta.cloud.handmade_access_user.name"), PROPERTIES.get("minio.testing.katta.cloud.handmade_access_user.password"), "us-east-1"
+    ));
+    public static final Arguments HYBRID_MINIO_STS = prepareArgumentsHybrid.apply(new HubTestConfig.VaultSpec(
+            "MinIO STS", "732D43FA-3716-46C4-B931-66EA5405EF19", null, null, "eu-central-1"
+    ));
+
+    public static final Arguments HYBRID_AWS_STATIC = prepareArgumentsHybrid.apply(new HubTestConfig.VaultSpec(
+            "AWS static", "72736C19-283C-49D3-80A5-AB74B5202549", PROPERTIES.get("handmade2.s3.amazonaws.com.username"), PROPERTIES.get("handmade2.s3.amazonaws.com.password"),
+            // TODO https://github.com/shift7-ch/katta-server/issues/87
+            // "eu-north-1"
+            "us-east-1"
+    ));
+    public static final Arguments HYBRID_AWS_STS = prepareArgumentsHybrid.apply(new HubTestConfig.VaultSpec(
+            "AWS STS", "844BD517-96D4-4787-BCFA-238E103149F9", null, null, "eu-west-1"
+    ));
 
     @BeforeEach
     public void preferences() throws IOException {

hub/src/test/java/cloud/katta/testsetup/HubTestSetupDockerExtension.java

@@ -61,9 +61,8 @@ protected void setupDocker(final HubTestConfig.Setup.DockerConfig configuration)
                 .withPull(true)
                 .withEnv(env)
                 .withOptions(configuration.profile == null ? "" : String.format("--profile=%s", configuration.profile))
-                .waitingFor("wait-1", new LogMessageWaitStrategy().withRegEx(".*exit 0.*").withStartupTimeout(Duration.ofMinutes(2)));
+                .waitingFor("minio_setup-1", new LogMessageWaitStrategy().withRegEx(".*Completed MinIO Setup.*").withStartupTimeout(Duration.ofMinutes(2)));
         compose.start();
-
         log.info("Done setup docker {}", configuration);
     }