@hoanghainh/komagu 1.8.0 → 2.0.0

package/remediate/identity/spring/src/main/kotlin/io/komagu/security/identity/LegacyKomainuPropertiesPostProcessor.kt

@@ -1,60 +0,0 @@
-package io.komagu.security.identity
-
-import org.springframework.boot.SpringApplication
-import org.springframework.boot.context.config.ConfigDataEnvironmentPostProcessor
-import org.springframework.boot.env.EnvironmentPostProcessor
-import org.springframework.boot.logging.DeferredLogFactory
-import org.springframework.core.Ordered
-import org.springframework.core.env.ConfigurableEnvironment
-import org.springframework.core.env.EnumerablePropertySource
-import org.springframework.core.env.MapPropertySource
-
-/**
- * Maps deprecated pre-rename `komainu.security.*` properties (and `KOMAINU_SECURITY_*` env vars)
- * onto `komagu.security.*` (#290). The mapped values are added last, so any `komagu.security.*`
- * value set explicitly still wins. Remove in the next major release.
- */
-class LegacyKomainuPropertiesPostProcessor(logFactory: DeferredLogFactory) : EnvironmentPostProcessor, Ordered {
-
-    private val log = logFactory.getLog(javaClass)
-
-    override fun postProcessEnvironment(environment: ConfigurableEnvironment, application: SpringApplication?) {
-        val mapped = linkedMapOf<String, Any>()
-        // Property sources iterate highest precedence first, so the first legacy value seen wins.
-        environment.propertySources
-            .filterIsInstance<EnumerablePropertySource<*>>()
-            .filter { it.name != SOURCE_NAME }
-            .forEach { collectLegacy(it, mapped) }
-        if (mapped.isEmpty()) return
-        log.warn(
-            "komainu.security.* properties are deprecated, rename them to komagu.security.* " +
-                "(mapped: ${mapped.keys.joinToString()})"
-        )
-        environment.propertySources.addLast(MapPropertySource(SOURCE_NAME, mapped))
-    }
-
-    private fun collectLegacy(source: EnumerablePropertySource<*>, mapped: MutableMap<String, Any>) {
-        for (name in source.propertyNames) {
-            val current = currentName(name)
-            if (current != null && current !in mapped) {
-                source.getProperty(name)?.let { mapped[current] = it }
-            }
-        }
-    }
-
-    override fun getOrder(): Int = ConfigDataEnvironmentPostProcessor.ORDER + 1
-
-    companion object {
-        const val SOURCE_NAME = "legacyKomainuProperties"
-        private const val LEGACY_PREFIX = "komainu.security."
-        private const val LEGACY_ENV_PREFIX = "KOMAINU_SECURITY_"
-        private const val PREFIX = "komagu.security."
-
-        fun currentName(name: String): String? = when {
-            name.startsWith(LEGACY_PREFIX) -> PREFIX + name.removePrefix(LEGACY_PREFIX)
-            name.startsWith(LEGACY_ENV_PREFIX) ->
-                PREFIX + name.removePrefix(LEGACY_ENV_PREFIX).lowercase().replace('_', '.')
-            else -> null
-        }
-    }
-}

package/remediate/identity/spring/src/main/resources/META-INF/spring.factories

@@ -1,2 +0,0 @@
-org.springframework.boot.env.EnvironmentPostProcessor=\
-io.komagu.security.identity.LegacyKomainuPropertiesPostProcessor

package/remediate/identity/spring/src/test/kotlin/io/komagu/security/identity/LegacyKomainuPropertiesPostProcessorTest.kt

@@ -1,86 +0,0 @@
-package io.komagu.security.identity
-
-import org.junit.jupiter.api.Assertions.assertEquals
-import org.junit.jupiter.api.Assertions.assertNull
-import org.junit.jupiter.api.Assertions.assertTrue
-import org.junit.jupiter.api.Test
-import org.springframework.boot.context.properties.bind.Binder
-import org.springframework.boot.logging.DeferredLogFactory
-import org.springframework.core.env.MapPropertySource
-import org.springframework.core.env.PropertySource
-import org.springframework.core.env.StandardEnvironment
-import org.springframework.core.env.SystemEnvironmentPropertySource
-
-class LegacyKomainuPropertiesPostProcessorTest {
-
-    private val processor = LegacyKomainuPropertiesPostProcessor(DeferredLogFactory { it.get() })
-
-    private fun bind(env: StandardEnvironment): KomaguOidcProperties =
-        Binder.get(env).bind("komagu.security.oidc", KomaguOidcProperties::class.java).orElseGet { KomaguOidcProperties() }
-
-    private fun envWith(vararg sources: PropertySource<*>): StandardEnvironment {
-        val env = StandardEnvironment()
-        env.propertySources.toList().forEach { env.propertySources.remove(it.name) }
-        sources.forEach { env.propertySources.addLast(it) }
-        return env
-    }
-
-    @Test
-    fun `legacy properties bind to the komagu prefix`() {
-        val env = envWith(
-            MapPropertySource(
-                "app",
-                mapOf(
-                    "komainu.security.oidc.issuer" to "https://auth.example.com",
-                    "komainu.security.oidc.jwk-set-uri" to "https://auth.example.com/certs",
-                    "komainu.security.oidc.clock-skew-seconds" to "30"
-                )
-            )
-        )
-        processor.postProcessEnvironment(env, null)
-
-        val props = bind(env)
-        assertEquals("https://auth.example.com", props.issuer)
-        assertEquals("https://auth.example.com/certs", props.jwkSetUri)
-        assertEquals(30L, props.clockSkewSeconds)
-    }
-
-    @Test
-    fun `explicit komagu properties win over legacy ones`() {
-        val env = envWith(
-            MapPropertySource("low", mapOf("komagu.security.oidc.audience" to "new-api")),
-            MapPropertySource("high", mapOf("komainu.security.oidc.audience" to "old-api"))
-        )
-        processor.postProcessEnvironment(env, null)
-
-        assertEquals("new-api", bind(env).audience)
-    }
-
-    @Test
-    fun `legacy environment variables are mapped`() {
-        val env = envWith(
-            SystemEnvironmentPropertySource(
-                "systemEnvironment",
-                mapOf<String, Any>("KOMAINU_SECURITY_OIDC_ALLOWINSECUREHTTPJWKS" to "true")
-            )
-        )
-        processor.postProcessEnvironment(env, null)
-
-        assertEquals(true, bind(env).allowInsecureHttpJwks)
-    }
-
-    @Test
-    fun `nothing is added without legacy properties`() {
-        val env = envWith(MapPropertySource("app", mapOf("komagu.security.oidc.audience" to "x")))
-        processor.postProcessEnvironment(env, null)
-
-        assertNull(env.propertySources.get(LegacyKomainuPropertiesPostProcessor.SOURCE_NAME))
-    }
-
-    @Test
-    fun `post processor is registered in spring factories`() {
-        val factories = javaClass.classLoader.getResource("META-INF/spring.factories")!!.readText()
-        assertTrue("org.springframework.boot.env.EnvironmentPostProcessor" in factories)
-        assertTrue(LegacyKomainuPropertiesPostProcessor::class.java.name in factories)
-    }
-}

package/remediate/resilience/tests/test_legacy_env.py

@@ -1,33 +0,0 @@
-#!/usr/bin/env python3
-"""KOMAGU_* environment variables with the deprecated KOMAINU_* fallback (#290)."""
-
-from __future__ import annotations
-
-import os
-import unittest
-import warnings
-from unittest.mock import patch
-
-from remediate.resilience.dr import dr_manager
-
-MODULES = (dr_manager,)
-
-
-class TestLegacyEnvFallback(unittest.TestCase):
-    def test_new_name_wins_without_warning(self) -> None:
-        env = {"KOMAGU_DR_METADATA_PATH": "new", "KOMAINU_DR_METADATA_PATH": "old"}
-        for mod in MODULES:
-            with self.subTest(module=mod.__name__), patch.dict(os.environ, env), warnings.catch_warnings(record=True) as caught:
-                warnings.simplefilter("always")
-                self.assertEqual(mod._env("DR_METADATA_PATH"), "new")
-                self.assertEqual(caught, [])
-
-    def test_legacy_name_is_read_with_deprecation_warning(self) -> None:
-        for mod in MODULES:
-            with self.subTest(module=mod.__name__), patch.dict(os.environ, {"KOMAINU_DR_METADATA_PATH": "old"}, clear=True):
-                with self.assertWarnsRegex(DeprecationWarning, "KOMAINU_DR_METADATA_PATH is deprecated"):
-                    self.assertEqual(mod._env("DR_METADATA_PATH"), "old")
-
-
-if __name__ == "__main__":
-    unittest.main()

package/remediate/tenancy/tests/test_legacy_env.py

@@ -1,49 +0,0 @@
-#!/usr/bin/env python3
-"""KOMAGU_* environment variables with the deprecated KOMAINU_* fallback (#290)."""
-
-from __future__ import annotations
-
-import os
-import unittest
-import warnings
-from unittest.mock import patch
-
-from remediate.tenancy.audit import audit_trail
-from remediate.tenancy.crypto import byok_manager
-from remediate.tenancy.middleware import tenant_context
-
-# Each drop-in module carries its own copy of _env; other suites test theirs.
-MODULES = (audit_trail, byok_manager, tenant_context)
-
-
-class TestLegacyEnvFallback(unittest.TestCase):
-    def test_new_name_wins_without_warning(self) -> None:
-        env = {"KOMAGU_AUDIT_HMAC_KEY": "new", "KOMAINU_AUDIT_HMAC_KEY": "old"}
-        for mod in MODULES:
-            with self.subTest(module=mod.__name__), patch.dict(os.environ, env), warnings.catch_warnings(record=True) as caught:
-                warnings.simplefilter("always")
-                self.assertEqual(mod._env("AUDIT_HMAC_KEY"), "new")
-                self.assertEqual(caught, [])
-
-    def test_legacy_name_is_read_with_deprecation_warning(self) -> None:
-        for mod in MODULES:
-            with self.subTest(module=mod.__name__), patch.dict(os.environ, {"KOMAINU_INTERNAL_SERVICE_SECRET": "old"}, clear=True):
-                with self.assertWarnsRegex(DeprecationWarning, "KOMAINU_INTERNAL_SERVICE_SECRET is deprecated"):
-                    self.assertEqual(mod._env("INTERNAL_SERVICE_SECRET"), "old")
-
-    def test_default_when_unset(self) -> None:
-        for mod in MODULES:
-            with self.subTest(module=mod.__name__), patch.dict(os.environ, {}, clear=True):
-                self.assertEqual(mod._env("ENV", ""), "")
-                self.assertIsNone(mod._env("ENV"))
-
-    def test_legacy_audit_key_still_configures_audit_trail(self) -> None:
-        key = "k" * 32
-        with patch.dict(os.environ, {"KOMAINU_AUDIT_HMAC_KEY": key}, clear=True), warnings.catch_warnings():
-            warnings.simplefilter("ignore", DeprecationWarning)
-            trail = audit_trail.TenantAuditTrail()
-        self.assertEqual(trail.hmac_key, key.encode("utf-8"))
-
-
-if __name__ == "__main__":
-    unittest.main()