feat(core): replace hardcoded S3 and GCS emulator images with constants

- Introduced `DEFAULT_LOCALSTACK_S3_IMAGE` and `DEFAULT_FAKE_GCS_IMAGE` constants for centralizing default image configuration.
- Updated `BigDataTestKit`, `BigDataContainerFactory`, Gradle plugin, and related test configurations to reference constants instead of hardcoded image strings.
- Enhanced support for Floci S3 and GCS emulators with dynamic health endpoint selection and conditional configuration.
- Updated documentation and examples to reflect emulator-specific changes and default configurations.

Author: CoderYellow

autoconfigure/src/main/kotlin/org/openprojectx/bigdata/test/autoconfigure/BigDataTestProperties.kt

@@ -5,6 +5,8 @@ import org.openprojectx.bigdata.test.core.HiveMetastoreOptions
 import org.openprojectx.bigdata.test.core.ClouderaHmsDatabaseType
 
 import org.openprojectx.bigdata.test.core.ContainerLogMode
+import org.openprojectx.bigdata.test.core.DEFAULT_FAKE_GCS_IMAGE
+import org.openprojectx.bigdata.test.core.DEFAULT_LOCALSTACK_S3_IMAGE
 import org.springframework.boot.context.properties.ConfigurationProperties
 
 @ConfigurationProperties("bigdata.test")
@@ -17,8 +19,8 @@ data class BigDataTestProperties(
     var hiveMetastore: HiveMetastore = HiveMetastore(),
     var clouderaHms: ClouderaHms = ClouderaHms(),
     var kafka: Kafka = Kafka(),
-    var localstackS3: ObjectStore = ObjectStore(image = "localstack/localstack:4.14.0"),
-    var fakeGcs: ObjectStore = ObjectStore(image = "fsouza/fake-gcs-server:1.54"),
+    var localstackS3: ObjectStore = ObjectStore(image = DEFAULT_LOCALSTACK_S3_IMAGE),
+    var fakeGcs: ObjectStore = ObjectStore(image = DEFAULT_FAKE_GCS_IMAGE),
     var containerLogs: ContainerLogs = ContainerLogs(),
     var containerLogLevels: Map<String, String> = emptyMap(),
 ) {

core/src/main/kotlin/org/openprojectx/bigdata/test/core/BigDataService.kt

@@ -59,7 +59,7 @@ enum class BigDataService(
         ),
     ),
     FAKE_GCS(
-        defaultPorts = mapOf("http" to 4443, "https" to 443),
+        defaultPorts = mapOf("http" to 4588, "https" to 443),
         endpointProperties = setOf("bigdata.test.gcs.endpoint", "google.cloud.storage.host"),
     ),
 }

core/src/main/kotlin/org/openprojectx/bigdata/test/core/BigDataTestKit.kt

@@ -58,7 +58,7 @@ class BigDataTestKit private constructor(
         private var hiveMetastore = HiveMetastoreOptions()
         private var kafka = KafkaOptions()
         private var localStackS3 = ObjectStoreOptions()
-        private var fakeGcs = ObjectStoreOptions(image = "fsouza/fake-gcs-server:1.54")
+        private var fakeGcs = ObjectStoreOptions(image = DEFAULT_FAKE_GCS_IMAGE)
         private var portBindings = PortBindingOptions()
         private var containerLogs = ContainerLogOptions()
         private var containerCustomizations = emptyMap<BigDataService, ContainerCustomizationOptions>()
@@ -92,7 +92,7 @@ class BigDataTestKit private constructor(
         fun withLocalStackS3(options: ObjectStoreOptions = ObjectStoreOptions(enabled = true)): Builder =
             apply { localStackS3 = options.copy(enabled = true) }
 
-        fun withFakeGcs(options: ObjectStoreOptions = ObjectStoreOptions(enabled = true, image = "fsouza/fake-gcs-server:1.54")): Builder =
+        fun withFakeGcs(options: ObjectStoreOptions = ObjectStoreOptions(enabled = true, image = DEFAULT_FAKE_GCS_IMAGE)): Builder =
             apply { fakeGcs = options.copy(enabled = true) }
 
         fun withPortBindings(options: PortBindingOptions): Builder =

core/src/main/kotlin/org/openprojectx/bigdata/test/core/BigDataTestKitOptions.kt

@@ -2,14 +2,17 @@ package org.openprojectx.bigdata.test.core
 
 import org.testcontainers.containers.GenericContainer
 
+const val DEFAULT_LOCALSTACK_S3_IMAGE = "floci/floci:latest"
+const val DEFAULT_FAKE_GCS_IMAGE = "floci/floci-gcp:latest"
+
 data class BigDataTestKitOptions(
     val kerberos: KerberosOptions = KerberosOptions(),
     val tls: TlsOptions = TlsOptions(),
     val hdfs: HdfsOptions = HdfsOptions(),
     val hiveMetastore: HiveMetastoreOptions = HiveMetastoreOptions(),
     val kafka: KafkaOptions = KafkaOptions(),
     val localStackS3: ObjectStoreOptions = ObjectStoreOptions(),
-    val fakeGcs: ObjectStoreOptions = ObjectStoreOptions(image = "fsouza/fake-gcs-server:1.54"),
+    val fakeGcs: ObjectStoreOptions = ObjectStoreOptions(image = DEFAULT_FAKE_GCS_IMAGE),
     val portBindings: PortBindingOptions = PortBindingOptions(),
     val containerLogs: ContainerLogOptions = ContainerLogOptions(),
     val containerCustomizations: Map<BigDataService, ContainerCustomizationOptions> = emptyMap(),
@@ -148,7 +151,7 @@ data class KafkaOptions(
 
 data class ObjectStoreOptions(
     val enabled: Boolean = false,
-    val image: String = "localstack/localstack:4.14.0",
+    val image: String = DEFAULT_LOCALSTACK_S3_IMAGE,
     val tls: HttpTlsOptions = HttpTlsOptions(),
 )
 

core/src/main/kotlin/org/openprojectx/bigdata/test/core/container/BigDataContainerFactory.kt

@@ -710,12 +710,19 @@ internal class BigDataContainerFactory(
 
     private fun localStackS3(): BigDataServiceContainer {
         val objectStore = options.localStackS3
+        val isFloci = objectStore.image.substringBefore(":") == "floci/floci"
         val container = GenericBigDataContainer(objectStore.image)
             .withNetwork(network)
             .withNetworkAliases("localstack")
             .withServicePort(4566, options.portBindings.hostPort(4566, options.portBindings.localStackS3))
-            .withEnv("SERVICES", "s3")
-            .waitingFor(Wait.forHttp("/_localstack/health").forStatusCode(200).withStartupTimeout(Duration.ofMinutes(3)))
+            .waitingFor(
+                Wait.forHttp(if (isFloci) "/_floci/health" else "/_localstack/health")
+                    .forStatusCode(200)
+                    .withStartupTimeout(Duration.ofMinutes(3)),
+            )
+        if (!isFloci) {
+            container.withEnv("SERVICES", "s3")
+        }
 
         return BigDataServiceContainer(
             BigDataService.LOCALSTACK_S3,
@@ -746,12 +753,20 @@ internal class BigDataContainerFactory(
 
     private fun fakeGcs(): BigDataServiceContainer {
         val objectStore = options.fakeGcs
+        val servicePort = fakeGcsServicePort()
+        val isFlociGcp = isFlociGcp()
         val container = GenericBigDataContainer(objectStore.image)
             .withNetwork(network)
             .withNetworkAliases("fake-gcs")
-            .withServicePort(4443, options.portBindings.hostPort(4443, options.portBindings.fakeGcs))
-            .withCommand("-scheme", "http", "-port", "4443")
-            .waitingFor(Wait.forHttp("/storage/v1/b").forStatusCode(200).withStartupTimeout(Duration.ofMinutes(2)))
+            .withServicePort(servicePort, options.portBindings.hostPort(servicePort, options.portBindings.fakeGcs))
+            .waitingFor(
+                Wait.forHttp(if (isFlociGcp) "/_floci-gcp/health" else "/storage/v1/b")
+                    .forStatusCode(200)
+                    .withStartupTimeout(Duration.ofMinutes(2)),
+            )
+        if (!isFlociGcp) {
+            container.withCommand("-scheme", "http", "-port", servicePort.toString())
+        }
 
         return BigDataServiceContainer(
             BigDataService.FAKE_GCS,
@@ -761,14 +776,14 @@ internal class BigDataContainerFactory(
                 name = "fake-gcs",
                 tls = objectStore.tls,
                 backendHost = "fake-gcs",
-                backendPort = 4443,
+                backendPort = servicePort,
                 hostPort = tlsHostPort(options.portBindings.fakeGcsTls),
             )
-            val endpoint = tlsEndpoint.url ?: "http://${container.host}:${container.getMappedPort(4443)}"
+            val endpoint = tlsEndpoint.url ?: "http://${container.host}:${container.getMappedPort(servicePort)}"
             BigDataEndpoint(
                 service = BigDataService.FAKE_GCS,
                 host = tlsEndpoint.host ?: container.host,
-                ports = mapOf("http" to container.getMappedPort(4443)) + tlsEndpoint.port("https"),
+                ports = mapOf("http" to container.getMappedPort(servicePort)) + tlsEndpoint.port("https"),
                 properties = mapOf(
                     "bigdata.test.gcs.endpoint" to endpoint,
                     "google.cloud.storage.host" to endpoint,
@@ -777,6 +792,12 @@ internal class BigDataContainerFactory(
         }
     }
 
+    private fun isFlociGcp(): Boolean =
+        options.fakeGcs.image.substringBefore(":") == "floci/floci-gcp"
+
+    private fun fakeGcsServicePort(): Int =
+        if (isFlociGcp()) 4588 else 4443
+
 
     private fun hiveMetastoreObjectStoreConfiguration(): Map<String, String> =
         buildMap {
@@ -796,10 +817,11 @@ internal class BigDataContainerFactory(
                 put("fs.s3a.change.detection.mode", "none")
             }
             if (options.fakeGcs.enabled) {
+                val fakeGcsEndpoint = "http://fake-gcs:${fakeGcsServicePort()}"
                 put("fs.gs.impl", "com.google.cloud.hadoop.fs.gcs.GoogleHadoopFileSystem")
                 put("fs.AbstractFileSystem.gs.impl", "com.google.cloud.hadoop.fs.gcs.GoogleHadoopFS")
                 put("fs.gs.project.id", "bigdata-test")
-                put("fs.gs.storage.root.url", "http://fake-gcs:4443/")
+                put("fs.gs.storage.root.url", "$fakeGcsEndpoint/")
                 put("fs.gs.storage.service.path", "storage/v1/")
                 put("fs.gs.client.type", "HTTP_API_CLIENT")
                 put("fs.gs.auth.type", "UNAUTHENTICATED")
@@ -842,12 +864,13 @@ internal class BigDataContainerFactory(
                 .withEnv("S3_SSL_ENABLED", "false")
         }
         if (options.fakeGcs.enabled) {
+            val fakeGcsEndpoint = "http://fake-gcs:${fakeGcsServicePort()}"
             container
                 .withEnv("GCS_FILE_SYSTEM_IMPL", "com.google.cloud.hadoop.fs.gcs.GoogleHadoopFileSystem")
                 .withEnv("GCS_ABSTRACT_FILE_SYSTEM_IMPL", "com.google.cloud.hadoop.fs.gcs.GoogleHadoopFS")
                 .withEnv("GCS_AUTH_TYPE", "UNAUTHENTICATED")
                 .withEnv("GCS_PROJECT_ID", "bigdata-test")
-                .withEnv("GCS_STORAGE_ROOT_URL", "http://fake-gcs:4443")
+                .withEnv("GCS_STORAGE_ROOT_URL", fakeGcsEndpoint)
                 .withEnv("GCS_STORAGE_SERVICE_PATH", "/storage/v1/")
                 .withEnv("GCS_CREATE_ITEMS_CONFLICT_CHECK_ENABLED", "false")
                 .withEnv("GCS_CLIENT_UPLOAD_TYPE", "WRITE_TO_DISK_THEN_UPLOAD")
@@ -1204,11 +1227,11 @@ internal class BigDataContainerFactory(
                 elif command -v aws >/dev/null 2>&1; then
                   AWS_ACCESS_KEY_ID=test AWS_SECRET_ACCESS_KEY=test aws --endpoint-url=http://localhost:4566 s3 ls >/dev/null
                 else
-                  ${httpContainerProbe("http://localhost:4566/_localstack/health")}
+                  ${httpContainerProbe("http://localhost:4566/_floci/health")} || ${httpContainerProbe("http://localhost:4566/_localstack/health")}
                 fi
                 """.trimIndent()
             BigDataService.FAKE_GCS ->
-                httpContainerProbe("http://localhost:4443/storage/v1/b")
+                "${httpContainerProbe("http://localhost:4588/_floci-gcp/health")} || ${httpContainerProbe("http://localhost:4443/storage/v1/b")}"
         }
 
     private fun httpContainerProbe(url: String): String =

doc/user-guide.adoc

@@ -16,8 +16,8 @@ The project currently provides containers and test integration for:
 * Kafka
 * Schema Registry
 * Kafka UI
-* LocalStack S3
-* fake-gcs-server
+* Floci S3-compatible AWS emulator
+* Floci GCP-compatible GCS emulator
 * Kerberos KDC and service principals
 
 The project is split so lightweight users can depend on `core` or `junit5` without pulling Spark, Hadoop client utilities, or storage SDKs. Heavier setup such as JCEKS creation, Kafka Avro seeding, and Spark SQL preparation lives in the `extensions` module.
@@ -213,10 +213,10 @@ The JUnit extension starts the kit before all tests in the class and closes it a
 |Configures Kafka UI for Kerberos/SASL Kafka access.
 
 |`localStackS3`
-|Starts LocalStack with S3 enabled.
+|Starts Floci S3-compatible AWS emulation.
 
 |`fakeGcs`
-|Starts fake-gcs-server.
+|Starts Floci GCP-compatible GCS emulation.
 |===
 
 === Service Image Configuration
@@ -236,8 +236,8 @@ clouderaHmsMariadb = "ghcr.io/openprojectx/cloudera-hms:0.1.74-mariadb"
 kafka = "apache/kafka:4.1.2"
 schemaRegistry = "confluentinc/cp-schema-registry:7.8.0"
 kafkaUi = "ghcr.io/kafbat/kafka-ui:latest"
-localStackS3 = "localstack/localstack:4.14.0"
-fakeGcs = "fsouza/fake-gcs-server:1.54"
+localStackS3 = "floci/floci:latest"
+fakeGcs = "floci/floci-gcp:latest"
 ----
 
 Kafka and the open-source HMS database sidecar use typed Testcontainers classes instead of plain generic containers. When you override those images, `bigdata-test` marks the configured Kafka image as a compatible substitute for `apache/kafka`, PostgreSQL as a compatible substitute for `postgres`, and MySQL as a compatible substitute for `mysql`, so private mirrors or rebuilt images can still pass Testcontainers image checks.
@@ -521,11 +521,11 @@ Current CLI probes:
 |Kafka UI
 |Uses `wget` or `curl` against `/`.
 
-|LocalStack S3
+|Floci S3-compatible AWS emulator
 |Uses `awslocal s3 ls` when available, then falls back to `aws --endpoint-url`, then HTTP health.
 
-|fake-gcs-server
-|Uses `wget` or `curl` against `/storage/v1/b`.
+|Floci GCP-compatible GCS emulator
+|Uses `wget` or `curl` against the configured HTTP health endpoint.
 |===
 
 CLI probes validate the container's own environment. For host-side behavior, such as Windows HDFS clients connecting through mapped ports, use a host/JVM smoke test as well because an in-container `hdfs dfs` command cannot prove host network reachability.
@@ -834,7 +834,7 @@ To bind each enabled service to the same localhost port it uses inside the conta
 class MySameHostPortTest
 ----
 
-This maps common service ports directly, for example HDFS `8020`, `9866`, and `9870`, Hive Metastore `9083`, Kafka `9092`, Schema Registry `8085`, LocalStack `4566`, and fake GCS `4443`. Explicit per-service port fields still take priority over `sameHostPorts`.
+This maps common service ports directly, for example HDFS `8020`, `9866`, and `9870`, Hive Metastore `9083`, Kafka `9092`, Schema Registry `8085`, Floci S3 `4566`, and Floci GCS `4588`. Explicit per-service port fields still take priority over `sameHostPorts`.
 
 TLS gateway ports are not affected by `sameHostPorts`, because every gateway listens on container port `443`. Configure the per-service TLS port fields explicitly if a stable HTTPS host port is needed.
 
@@ -913,22 +913,22 @@ Available fixed host-port config:
 |`kafkaUiTls`
 |`443` on the HAProxy gateway
 
-|LocalStack S3 HTTP
+|Floci S3 HTTP
 |`localStackS3`
 |`localStackS3Port`
 |`4566`
 
-|LocalStack S3 TLS gateway
+|Floci S3 TLS gateway
 |`localStackS3Tls`
 |`localStackS3Tls`
 |`443` on the HAProxy gateway
 
-|fake-gcs-server HTTP
+|Floci GCS HTTP
 |`fakeGcs`
 |`fakeGcsPort`
-|`4443`
+|`4588` by default, or `4443` when overriding the image to `fsouza/fake-gcs-server`
 
-|fake-gcs-server TLS gateway
+|Floci GCS TLS gateway
 |`fakeGcsTls`
 |`fakeGcsTls`
 |`443` on the HAProxy gateway
@@ -1003,7 +1003,7 @@ Each started service exposes a `BigDataEndpoint` with named ports and connection
 
 |`BigDataService.FAKE_GCS`
 |`http`, `https`
-|`4443`, `443`
+|`4588`, `443`
 |`bigdata.test.gcs.endpoint`, `google.cloud.storage.host`
 |===
 
@@ -1348,7 +1348,7 @@ Outputs:
 
 === S3 JCEKS Extension
 
-The `s3Jceks` extension creates a Hadoop credential provider file in HDFS and stores LocalStack S3 credentials in it.
+The `s3Jceks` extension creates a Hadoop credential provider file in HDFS and stores the S3 emulator credentials in it.
 It builds its Hadoop client configuration from the active HDFS endpoint properties, including `fs.defaultFS`, `dfs.client.use.datanode.hostname`, `dfs.datanode.hostname`, and any HDFS TLS properties exposed by the test kit.
 
 [source,toml]
@@ -1421,8 +1421,8 @@ When `useKitEndpoints = true`, the default, the extension wires known endpoint p
 
 * Hive Metastore URI and HMS TLS properties
 * HDFS default filesystem and DataNode hostname setting
-* LocalStack S3 endpoint and test credentials
-* fake-gcs-server endpoint using unauthenticated GCS connector settings
+* S3 emulator endpoint and test credentials
+* GCS emulator endpoint using unauthenticated GCS connector settings
 * Kerberos client `krb5.conf`, principal, and keytab properties when Kerberos is enabled
 
 Explicit `configs` are applied after endpoint defaults and therefore override generated Spark config.
@@ -1572,7 +1572,7 @@ This asks HMS to validate table metadata and location using HMS server-side Hado
 
 === HMS Server-Side S3A
 
-When Hive Metastore starts with LocalStack S3 enabled, `bigdata-test` injects HMS-side S3A configuration:
+When Hive Metastore starts with the S3 emulator enabled, `bigdata-test` injects HMS-side S3A configuration:
 
 * `fs.s3a.endpoint=http://localstack:4566`
 * `fs.s3a.endpoint.region=us-east-1`
@@ -1583,7 +1583,7 @@ When Hive Metastore starts with LocalStack S3 enabled, `bigdata-test` injects HM
 * `fs.s3a.connection.ssl.enabled=false`
 * `fs.s3a.change.detection.mode=none`
 
-This allows Hive external table DDL with `s3a://` locations to validate against the internal LocalStack endpoint. The Spark example includes this path and verifies the HMS table location through `HiveMetaStoreClient`.
+This allows Hive external table DDL with `s3a://` locations to validate against the internal S3 emulator endpoint. The Spark example includes this path and verifies the HMS table location through `HiveMetaStoreClient`.
 
 === HMS Server-Side HDFS
 
@@ -1597,12 +1597,12 @@ This lets HMS resolve `hdfs://` warehouse and table locations from inside the Do
 
 === HMS Server-Side GCS
 
-When Hive Metastore starts with fake GCS enabled, `bigdata-test` injects HMS-side GCS configuration based on the Google Cloud Storage connector configuration model:
+When Hive Metastore starts with the GCS emulator enabled, `bigdata-test` injects HMS-side GCS configuration based on the Google Cloud Storage connector configuration model:
 
 * `fs.gs.impl=com.google.cloud.hadoop.fs.gcs.GoogleHadoopFileSystem`
 * `fs.AbstractFileSystem.gs.impl=com.google.cloud.hadoop.fs.gcs.GoogleHadoopFS`
 * `fs.gs.project.id=bigdata-test`
-* `fs.gs.storage.root.url=http://fake-gcs:4443/`
+* `fs.gs.storage.root.url=http://fake-gcs:4588/`
 * `fs.gs.storage.service.path=storage/v1/`
 * `fs.gs.client.type=HTTP_API_CLIENT`
 * `fs.gs.auth.type=UNAUTHENTICATED`
@@ -2078,7 +2078,7 @@ The Spring example is a normal Spring Boot web application. Its default configur
 GRADLE_USER_HOME=/data/.gradle ./gradlew :example:spring:check
 ----
 
-The local developer profile is fully configuration driven. The app source does not call `BigDataTestKit`; `application-local.yaml` starts Kerberos, HDFS, and LocalStack S3 and enables the REST API.
+The local developer profile is fully configuration driven. The app source does not call `BigDataTestKit`; `application-local.yaml` starts Kerberos, HDFS, and the S3 emulator and enables the REST API.
 
 The local profile also enables HDFS and Kerberos container logs on stdout:
 
@@ -2137,7 +2137,7 @@ curl -sS -X DELETE http://localhost:8080/api/s3/objects/demo.txt
 
 === Spark Example
 
-The Spark example lives under `example/spark`. It starts HDFS, Hive Metastore, Kafka, Schema Registry, LocalStack S3, and fake GCS.
+The Spark example lives under `example/spark`. It starts HDFS, Hive Metastore, Kafka, Schema Registry, Floci S3, and Floci GCS.
 
 The example uses `hiveMetastore = true` with the Hive 3 open-source HMS image. This keeps Spark 3.x on a compatible HMS protocol while still exercising server-side S3A and GCS configuration. Use `clouderaHms = true` when the embedded-Postgres Cloudera HMS image is the target under test.
 
@@ -2284,7 +2284,7 @@ This Hadoop message can appear in test output when Hadoop checks for native util
 
 === S3 Hive External Table Fails with Credential Errors
 
-If a Hive external table on `s3a://` fails with an AWS credential error, check whether HMS was started with LocalStack S3 enabled and whether custom `HiveMetastoreOptions.extraConfiguration` overrides the S3A settings.
+If a Hive external table on `s3a://` fails with an AWS credential error, check whether HMS was started with the S3 emulator enabled and whether custom `HiveMetastoreOptions.extraConfiguration` overrides the S3A settings.
 
 The important distinction is where the path is resolved:
 

example/junit/src/test/kotlin/org/openprojectx/bigdata/test/example/junit/LocalStackS3TlsExampleTest.kt

@@ -20,7 +20,7 @@ class LocalStackS3TlsExampleTest {
         val client = HttpClient.newHttpClient()
 
         val response = client.send(
-            HttpRequest.newBuilder(URI.create("$url/_localstack/health")).GET().build(),
+            HttpRequest.newBuilder(URI.create("$url/_floci/health")).GET().build(),
             HttpResponse.BodyHandlers.ofString(),
         )