refactor(config): remove unused BigDataTestConfig and related classes

- Deleted `BigDataTestConfig` and its associated components to eliminate unused code.
- Updated `spring-bigdata-test.toml` to include a new container environment variable for `localstackS3`.
- Adjusted `BigDataTestExtension` to use simplified configurations directly.

Author: CoderYellow

…bigdata/test/junit5/BigDataTestConfig.kt …ta/test/core/config/BigDataTestConfig.ktjunit5/src/main/kotlin/org/openprojectx/bigdata/test/junit5/BigDataTestConfig.kt renamed to core/src/main/kotlin/org/openprojectx/bigdata/test/core/config/BigDataTestConfig.kt junit5/src/main/kotlin/org/openprojectx/bigdata/test/junit5/BigDataTestConfig.kt renamed to core/src/main/kotlin/org/openprojectx/bigdata/test/core/config/BigDataTestConfig.kt

@@ -3,11 +3,23 @@ plugins {
     kotlin("plugin.spring") version "2.2.21"
     id("org.springframework.boot") version "4.0.5"
     id("io.spring.dependency-management") version "1.1.7"
-    id("org.openprojectx.bigdata-test") version "0.1.17-SNAPSHOT"
+    id("org.openprojectx.bigdata-test") version "0.1.20-SNAPSHOT"
 }
 
 group = "org.openprojectx.bigdata.test.example"
-version = "0.1.17-SNAPSHOT"
+version = providers.gradleProperty("bigdataTestPluginVersion")
+    .orElse(providers.environmentVariable("BIGDATA_TEST_PLUGIN_VERSION"))
+    .orElse(
+        providers.provider {
+            file("../../gradle.properties")
+                .readLines()
+                .map(String::trim)
+                .firstOrNull { it.startsWith("version") && it.contains("=") }
+                ?.substringAfter("=")
+                ?.trim()
+        },
+    )
+    .get()
 
 kotlin {
     jvmToolchain(17)

example/spring-gradle-plugin/build.gradle.kts

@@ -5,9 +5,21 @@ pluginManagement {
         mavenCentral()
     }
 
+    fun rootBuildVersion(): String? {
+        val propertiesFile = settingsDir.resolve("../../gradle.properties").normalize()
+        if (!propertiesFile.isFile) return null
+        return propertiesFile.readLines()
+            .map(String::trim)
+            .firstOrNull { it.startsWith("version") && it.contains("=") }
+            ?.substringAfter("=")
+            ?.trim()
+            ?.takeIf(String::isNotBlank)
+    }
+
     val bigDataTestPluginVersion =
         providers.gradleProperty("bigdataTestPluginVersion")
             .orElse(providers.environmentVariable("BIGDATA_TEST_PLUGIN_VERSION"))
+            .orElse(providers.provider { rootBuildVersion() })
 
     resolutionStrategy {
         eachPlugin {

example/spring-gradle-plugin/settings.gradle.kts

@@ -26,3 +26,6 @@ mode = "STDOUT"
 [containerLogLevels]
 kerberos = "DEBUG"
 hdfs = "DEBUG"
+
+[containers.localstackS3.env]
+DISABLE_CORS_CHECKS = "1"

example/spring-gradle-plugin/src/main/resources/spring-bigdata-test.toml

@@ -19,6 +19,8 @@ abstract class BigDataTestGradleExtension @Inject constructor(objects: ObjectFac
     val extensionConfig: ListProperty<String> = objects.listProperty(String::class.java).convention(emptyList())
     val containerLogLevels: MapProperty<String, String> =
         objects.mapProperty(String::class.java, String::class.java).convention(emptyMap())
+    internal val containerCustomizations: ListProperty<String> =
+        objects.listProperty(String::class.java).convention(emptyList())
     val extensionRuntime: BigDataTestGradleExtensionRuntime =
         objects.newInstance(BigDataTestGradleExtensionRuntime::class.java)
 

gradle-plugin/src/main/kotlin/org/openprojectx/bigdata/test/gradle/BigDataTestGradleConfig.kt

@@ -4,6 +4,7 @@ import org.gradle.api.Plugin
 import org.gradle.api.Project
 import org.gradle.api.artifacts.Configuration
 import org.gradle.api.artifacts.ExternalModuleDependency
+import org.gradle.api.provider.ListProperty
 import org.gradle.api.provider.MapProperty
 import org.gradle.api.provider.Property
 import org.gradle.api.tasks.SourceSetContainer
@@ -43,6 +44,7 @@ class BigDataTestGradlePlugin : Plugin<Project> {
             )
             spec.parameters.extensionRuntimeClasspath.from(extensionRuntimeClasspath)
             spec.parameters.containerLogLevels.set(extension.containerLogLevels)
+            spec.parameters.containerCustomizations.set(extension.containerCustomizations)
 
             spec.parameters.kerberos.set(extension.services.kerberos)
             spec.parameters.hdfs.set(extension.services.hdfs)
@@ -325,7 +327,12 @@ class BigDataTestGradlePlugin : Plugin<Project> {
         extension.containerLogs.mode.tomlConvention(config.containerLogs.mode)
         extension.containerLogs.directory.tomlConvention(config.containerLogs.directory)
         extension.containerLogs.append.tomlConvention(config.containerLogs.append)
-        extension.containerLogLevels.tomlConvention(config.containerLogLevels.takeIf { it.isNotEmpty() })
+        extension.containerLogLevels.tomlConvention(
+            config.containerLogLevels.mapKeys { (service, _) -> service.name }.takeIf { it.isNotEmpty() },
+        )
+        extension.containerCustomizations.tomlConvention(
+            config.encodedContainerCustomizations().takeIf { it.isNotEmpty() },
+        )
     }
 
     private fun Project.resolveExtensionConfigLocation(location: String): String {
@@ -350,6 +357,10 @@ class BigDataTestGradlePlugin : Plugin<Project> {
         if (value != null) convention(value)
     }
 
+    private fun <T : Any> ListProperty<T>.tomlConvention(value: List<T>?) {
+        if (value != null) convention(value)
+    }
+
     private data class ExtensionRuntimeNeeds(
         val hadoop: Boolean = false,
         val kafkaAvro: Boolean = false,

gradle-plugin/src/main/kotlin/org/openprojectx/bigdata/test/gradle/BigDataTestGradleExtension.kt

@@ -9,8 +9,11 @@ import org.gradle.api.services.BuildServiceParameters
 import java.net.URLClassLoader
 import org.openprojectx.bigdata.test.core.BigDataService
 import org.openprojectx.bigdata.test.core.BigDataTestKit
+import org.openprojectx.bigdata.test.core.ContainerCustomizationOptions
+import org.openprojectx.bigdata.test.core.ContainerFileTransferOptions
 import org.openprojectx.bigdata.test.core.ContainerLogMode
 import org.openprojectx.bigdata.test.core.ContainerLogOptions
+import org.openprojectx.bigdata.test.core.ContainerMountOptions
 import org.openprojectx.bigdata.test.core.ContainerPortOptions
 import org.openprojectx.bigdata.test.core.HdfsOptions
 import org.openprojectx.bigdata.test.core.HiveMetastoreDistribution
@@ -32,6 +35,7 @@ abstract class BigDataTestGradleService : BuildService<BigDataTestGradleService.
         val extensionConfig: ListProperty<String>
         val extensionRuntimeClasspath: ConfigurableFileCollection
         val containerLogLevels: MapProperty<String, String>
+        val containerCustomizations: ListProperty<String>
 
         val kerberos: Property<Boolean>
         val hdfs: Property<Boolean>
@@ -272,6 +276,9 @@ abstract class BigDataTestGradleService : BuildService<BigDataTestGradleService.
         parameters.containerLogLevels.get().forEach { (service, level) ->
             builder.withContainerLogLevel(service.toBigDataService(), level)
         }
+        decodeContainerCustomizations(parameters.containerCustomizations.get()).forEach { (service, customization) ->
+            builder.withContainerCustomization(service, customization)
+        }
         return builder.build()
     }
 
@@ -324,6 +331,61 @@ abstract class BigDataTestGradleService : BuildService<BigDataTestGradleService.
                 service.name.replace("_", "").equals(this, ignoreCase = true)
         } ?: error("Unknown bigdata-test service '$this'")
 
+    private fun decodeContainerCustomizations(encoded: List<String>): Map<BigDataService, ContainerCustomizationOptions> {
+        val customizations = linkedMapOf<BigDataService, ContainerCustomizationOptions>()
+        encoded.forEach { item ->
+            val parts = decode(item)
+            require(parts.size >= 3) { "Invalid encoded container customization" }
+            val kind = parts[0]
+            val service = parts[1].toBigDataService()
+            val options = when (kind) {
+                "network" -> {
+                    require(parts.size == 3) { "Invalid encoded network container customization" }
+                    ContainerCustomizationOptions(networkMode = parts[2])
+                }
+                "env" -> {
+                    require(parts.size == 4) { "Invalid encoded env container customization" }
+                    ContainerCustomizationOptions(environment = mapOf(parts[2] to parts[3]))
+                }
+                "file" -> {
+                    require(parts.size == 6) { "Invalid encoded file container customization" }
+                    val fileMode = parts[5].takeIf { it.isNotBlank() }?.toInt()
+                    val file = if (parts[3].isNotBlank()) {
+                        ContainerFileTransferOptions.hostPath(parts[3], parts[2], fileMode)
+                    } else {
+                        ContainerFileTransferOptions.content(
+                            java.util.Base64.getDecoder().decode(parts[4]),
+                            parts[2],
+                            fileMode,
+                        )
+                    }
+                    ContainerCustomizationOptions(files = listOf(file))
+                }
+                "mount" -> {
+                    require(parts.size == 5) { "Invalid encoded mount container customization" }
+                    ContainerCustomizationOptions(
+                        mounts = listOf(
+                            ContainerMountOptions(
+                                hostPath = parts[2],
+                                containerPath = parts[3],
+                                readOnly = parts[4].toBooleanStrict(),
+                            ),
+                        ),
+                    )
+                }
+                "port" -> {
+                    require(parts.size == 4) { "Invalid encoded port container customization" }
+                    ContainerCustomizationOptions(
+                        ports = listOf(ContainerPortOptions(containerPort = parts[2].toInt(), hostPort = parts[3].toInt())),
+                    )
+                }
+                else -> error("Unknown encoded container customization kind '$kind'")
+            }
+            customizations[service] = customizations[service]?.merge(options) ?: options
+        }
+        return customizations
+    }
+
     private fun BigDataService.propertyName(): String =
         name.lowercase().replace('_', '-')
 

gradle-plugin/src/main/kotlin/org/openprojectx/bigdata/test/gradle/BigDataTestGradlePlugin.kt

@@ -23,6 +23,8 @@ import org.openprojectx.bigdata.test.core.KerberosOptions
 import org.openprojectx.bigdata.test.core.ObjectStoreOptions
 import org.openprojectx.bigdata.test.core.PortBindingOptions
 import org.openprojectx.bigdata.test.core.TlsOptions
+import org.openprojectx.bigdata.test.core.config.BigDataTestConfigLoader
+import org.openprojectx.bigdata.test.core.config.BigDataTestHttpTlsConfig
 
 class BigDataTestExtension : BeforeAllCallback, AfterAllCallback, ParameterResolver {
     override fun beforeAll(context: ExtensionContext) {
@@ -95,13 +97,13 @@ class BigDataTestExtension : BeforeAllCallback, AfterAllCallback, ParameterResol
                 ),
             )
         }
-        config.containerLogLevels.levels.forEach { (service, level) ->
+        config.containerLogLevels.forEach { (service, level) ->
             builder.withContainerLogLevel(service, level)
         }
-        config.containerCustomizations.customizations.forEach { (service, customization) ->
+        config.containerCustomizations.forEach { (service, customization) ->
             builder.withContainerCustomization(service, customization)
         }
-        config.healthChecks.healthChecks.forEach { (service, healthCheck) ->
+        config.healthChecks.forEach { (service, healthCheck) ->
             builder.withHealthCheck(service, healthCheck)
         }
         val kerberos = annotation.kerberos || services.kerberos == true