Scala 使用ciris kubernetes从kubernetes secret加载配置的单元测试或集成测试

你好，scala社区

我正在使用注入来自kubernetes secrets的凭据和证书。虽然它工作起来很有魅力，但我想知道什么是对该功能进行单元测试或编写集成测试的最佳方法

更具体地说，如果配置为代码的主要目标之一是为其编写测试，那么这方面不应该给予更大的重视吗

这是我用来保存配置的case类

import java.io.File 
import ciris.Secret 

final case class SAMLCertificateConfiguration(publicKey: Secret[File], privateKey: Secret[File], password: Secret[String])

和配置加载程序

object ConfigurationLoader {

  private[this] val log = LoggerFactory getLogger this.getClass

  private def createConfigurationUsingSecret(namespace: NonEmptyString, secretName: NonEmptyString): IO[SAMLCertificateConfiguration] = {

    def getKubernetesSecret: IO[SecretInNamespace[IO]] =
      for {
        apiClient <- defaultApiClient[IO]
      } yield secretInNamespace[IO](namespace, apiClient)

    def createCertificateConfigurationWith(secret: SecretInNamespace[IO]): IO[SAMLCertificateConfiguration] =
      loadConfig(secret[Secret[File]](secretName.value, "public.crt"), secret[Secret[File]](secretName.value, "private.pfx"), secret[Secret[String]](secretName.value, "password")) {
        (publicKey, privateKey, privateKeyPassword) =>
          SAMLCertificateConfiguration(publicKey, privateKey, privateKeyPassword)
      }.orRaiseThrowable

    for {
      secret <- getKubernetesSecret
      samlCertificateConfiguration <- createCertificateConfigurationWith(secret)
    } yield samlCertificateConfiguration

  }

  def loadSAMLCertificateConfiguration: IO[SAMLCertificateConfiguration] =
    loadConfig(
      envF[IO, ApplicationEnvironment]("APPLICATION_ENVIRONMENT")
        .orElse(propF[IO, ApplicationEnvironment]("application.environment"))
        .orNone,
      envF[IO, NonEmptyString]("KUBERNETES_NAMESPACE")
        .orElse(propF[IO, NonEmptyString]("kubernetes.namespace"))
        .orValue("default"),
      envF[IO, NonEmptyString]("KUBERNETES_SECRET_NAME")
        .orElse(propF[IO, NonEmptyString]("kubernetes.secret.name"))
        .orValue("saml-pfx")
    ) { (environment, namespace, secret) =>
      import pp.util.configuration.ApplicationEnvironment._
      log.info(s"Environment: $environment, Kubernetes namespace: $namespace, Kubernetes secret's name: $secret")
      environment match {
        case Some(Test) | Some(Production) =>
          createConfigurationUsingSecret(namespace, secret).unsafeRunSync()
        case _ =>
          createSAMLCertificateConfigurationUsingHOCON
      }
    }.orRaiseThrowable

}

import enumeratum.{Enum, EnumEntry}
import scala.collection.immutable

sealed abstract class ApplicationEnvironment extends EnumEntry

object ApplicationEnvironment extends Enum[ApplicationEnvironment] {
  case object Development extends ApplicationEnvironment
  case object Test extends ApplicationEnvironment
  case object Production extends ApplicationEnvironment
  def values: immutable.IndexedSeq[ApplicationEnvironment] = findValues
}

import ciris._
import lt.dvim.ciris.Hocon._
import com.typesafe.config.ConfigFactory

object DefaultConfigurationLoader {

  def createSAMLCertificateConfigurationUsingHOCON: SAMLCertificateConfiguration = {

    def defaultConfiguration = {
      val fallbackConfiguration = ConfigFactory.parseString("""
                    |saml.certificate {
                    |  privateKey = "/tmp/certificates/private.pfx"
                    |  publicKey = "/tmp/certificates/public.crt"
                    |  password = ""
                    |}
                """.stripMargin)
      ConfigFactory.load().withFallback(fallbackConfiguration)
    }

    def hocon = hoconAt(defaultConfiguration)("saml.certificate")

    loadConfig(hocon[String]("publicKey"), hocon[String]("privateKey"), hocon[String]("password"))((publicKeyPath, privateKeyPath, privateKeyPassword) => {
      import java.nio.file.Paths
      import ciris.Secret
      SAMLCertificateConfiguration(Secret(Paths.get(publicKeyPath).toFile), Secret(Paths.get(privateKeyPath).toFile), Secret(privateKeyPassword))
    }).orThrow()
  }

}

对象配置加载程序{
private[this]val log=LoggerFactory getLogger this.getClass
private def createConfigurationUsingSecret（命名空间：NonEmptyString，secretName:NonEmptyString）：IO[SAMLCertificateConfiguration]={
def getkubernetesscret:IO[secretnnamespace[IO]]=
为了{
apiClient
SAMLCertificateConfiguration（公钥、私钥、私钥密码）
}.奥赖斯可擦洗
为了{
秘密
createConfigurationUsingSecret（名称空间，secret）.unsafeRunSync（）
案例=>
使用HOCON创建SamlCertificateConfiguration
}
}.奥赖斯可擦洗
}
导入枚举。{Enum，EnumEntry}
导入scala.collection.immutable
密封抽象类ApplicationEnvironment扩展了EnumEntry
对象ApplicationEnvironment扩展枚举[ApplicationEnvironment]{
案例对象开发扩展了ApplicationEnvironment
案例对象测试扩展了ApplicationEnvironment
案例对象生产扩展了ApplicationEnvironment
def值：不可变。IndexedSeq[ApplicationEnvironment]=FindValue
}
进口茜草_
导入lt.dvim.ciris.Hocon_
导入com.typesafe.config.ConfigFactory
对象DefaultConfigurationLoader{
def createSAMLCertificateConfigurationUsingHOCON:SAMLCertificateConfiguration={
def defaultConfiguration={
val fallbackConfiguration=ConfigFactory.parseString（“”）
|saml证书{
|privateKey=“/tmp/certificates/private.pfx”
|publicKey=“/tmp/certificates/public.crt”
|password=“”
|}
“.stripMargin）
ConfigFactory.load（）.带回退（回退配置）
}
def hocon=hoconAt（默认配置）（“saml.certificate”）
loadConfig（hocon[String]（“publicKey”）、hocon[String]（“privateKey”）、hocon[String]（“密码”）（（publicKeyPath、privateKeyPath、privateKeyPassword）=>{
导入java.nio.file.path
西里斯，秘密
SAMLCertificateConfiguration（Secret（path.get（publicKeyPath）.toFile）、Secret（path.get（privateKeyPath.toFile）、Secret（privateKeyPassword））
})奥思罗先生（）
}
}

是否应该使用io.fabric8.kubernetes.client.server.mock.KubernetesServer并将kubernetes java客户端隐式注入配置加载程序，以便在测试中对其进行模拟