实现 Spring 环境接口进行测试

Question

我想实现 Spring Environment 接口来测试我的类，但是我在任何地方都找不到接口实现，也不知道它们应该返回什么值，或者从哪里获取它们。

我正在使用 Scala 测试编写测试，并且遇到了必须实现在 Spring 中传递的 Environment 接口的问题。但是，我收到一条错误消息，说我为实现的方法返回的值无效

An exception or error caused a run to abort: Invalid name: conductor.ldap.baseDn; nested exception is javax.naming.InvalidNameException: Invalid name: conductor.ldap.baseDn 
org.springframework.ldap.InvalidNameException: Invalid name: conductor.ldap.baseDn; nested exception is javax.naming.InvalidNameException: Invalid name: conductor.ldap.baseDn
    at org.springframework.ldap.support.LdapUtils.convertLdapException(LdapUtils.java:136)
    at org.springframework.ldap.support.LdapUtils.newLdapName(LdapUtils.java:416)
    at org.springframework.ldap.support.LdapNameBuilder.add(LdapNameBuilder.java:121)
    at com.ojolabs.conductor.engine.services.GluuIdmIdentityService.<init>(GluuIdmIdentityService.scala:28)
    at GluuIdmIdentityServiceTest.<init>(GluuIdmIdentityServiceTest.scala:47)
    at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)
    at sun.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:62)
    at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:45)
    at java.lang.reflect.Constructor.newInstance(Constructor.java:423)
    at java.lang.Class.newInstance(Class.java:442)

我知道发生这种情况是因为我返回了不正确的值，但我无法找到显示预期返回什么值的文档。

这是我要测试的课程

@Component
class GluuIdmIdentityService @Autowired() (ldapTemplate: LdapTemplate, env: Environment) extends IdmIdentityServiceImpl with StrictLogging {

  private val baseDn = LdapNameBuilder.newInstance().add(env.getRequiredProperty("conductor.ldap.baseDn")).build()
  private val userBaseDn = LdapNameBuilder.newInstance(baseDn).add(env.getRequiredProperty("conductor.ldap.userBaseDn")).build()
  private val groupBaseDn = LdapNameBuilder.newInstance(baseDn).add(env.getRequiredProperty("conductor.ldap.groupBaseDn")).build()

  private val userByIdCache: LoadingCache[String, Option[LdapUser]] = {
    CacheBuilder.
      newBuilder().
      maximumSize(500).
      expireAfterWrite(5, TimeUnit.MINUTES).
      build(new CacheLoader[String, Option[LdapUser]] {
        override def load(key: String): Option[LdapUser] = getUser(key)
      })

  }

  private def getUser(id: String): Option[LdapUser] = {
    val query = LdapQueryBuilder.query().base(userBaseDn).where("uid").is(id)

    val users = try {
      ldapTemplate.search(query, new AbstractContextMapper[LdapUser] {
        override def doMapFromContext(ctx: DirContextOperations): LdapUser = {

          val fullUserDn = LdapNameBuilder.newInstance(userBaseDn).add("inum", ctx.getStringAttribute("inum")).build()
          val groupQuery = LdapQueryBuilder.query().base(groupBaseDn).where("member").is(fullUserDn.toString)

          val groups: Seq[LdapGroup] = try {
            ldapTemplate.search(groupQuery, new AbstractContextMapper[LdapGroup] {
              override def doMapFromContext(groupCtx: DirContextOperations): LdapGroup = {

                LdapGroup(
                  LdapNameBuilder.newInstance(ctx.getDn).build(),
                  Option(groupCtx.getStringAttribute("displayName")).getOrElse(""),
                  Option(groupCtx.getStringAttribute("description")).getOrElse(""),
                  Option(groupCtx.getStringAttribute("gluuGroupType"))
                )
              }
            }).asScala

          } catch {
            case e: NamingException =>
              throw new FlowableException(s"Could not find groups for user $id", e)
          }

          LdapUser(
            LdapNameBuilder.newInstance(ctx.getDn).build(),
            ctx.getStringAttribute("uid"),
            Option(ctx.getStringAttribute("givenName")),
            Option(ctx.getStringAttribute("sn")),
            Option(ctx.getStringAttribute("mail")),
            Option(ctx.getStringAttribute("displayName")),
            groups
          )
        }
      }).asScala
    } catch {
      case e: NamingException =>
        throw new FlowableException(s"Could not find user with id $id", e)
    }

    if(users.size > 1) {
      throw new RuntimeException(s"More than one user returned for UID $id")
    } else {
      users.headOption
    }
  }

  override def createUserQuery(): UserQuery = new CachedUserQuery(userByIdCache)

  override def createGroupQuery(): GroupQuery = new CachedGroupQuery(userByIdCache)

  override def checkPassword(userId: String, password: String): Boolean = {
    //TODO: Ldap actually does support auth, build this in at some point
    throw new FlowableException("Gluu identity provider does not currently support authentication.")
  }

  override def newUser(userId: String): User ={
    throw new FlowableException("LDAP identity service doesn't support creating a new user")
  }

  override def saveUser(user: User): Unit = {
    throw new FlowableException("LDAP identity service doesn't support saving an user")
  }

  override def createNativeUserQuery(): NativeUserQuery = {
    throw new FlowableException("LDAP identity service doesn't support native querying")
  }

  override def deleteUser(userId: String): Unit = {
    throw new FlowableException("LDAP identity service doesn't support deleting an user")
  }

  override def newGroup(groupId: String): Group = {
    throw new FlowableException("LDAP identity service doesn't support creating a new group")
  }

  override def createNativeGroupQuery(): NativeGroupQuery = {
    throw new FlowableException("LDAP identity service doesn't support native querying")
  }

  override def saveGroup(group: Group): Unit = {
    throw new FlowableException("LDAP identity service doesn't support saving a group")
  }

  override def deleteGroup(groupId: String): Unit = {
    throw new FlowableException("LDAP identity service doesn't support deleting a group")
  }

这是我的测试

class GluuIdmIdentityServiceTest extends FlatSpec with Matchers {


  val env: Environment = new Environment {
    override def getDefaultProfiles = Array("default")
    override def getActiveProfiles = Array("default")

    override def acceptsProfiles(profiles: String*): Boolean = true

    override def getRequiredProperty(key: String): String = key

    override def getRequiredProperty[T](key: String, targetType: Class[T]) = targetType.cast(AnyRef)

    override def getProperty(key: String) = key

    override def getProperty(key: String, defaultValue: String) = key

    override def getProperty[T](key: String, targetType: Class[T]) = targetType.cast(AnyRef)

    override def getProperty[T](key: String, targetType: Class[T], defaultValue: T) = targetType.cast(AnyRef)

    override def resolveRequiredPlaceholders(text: String): String = text

    override def resolvePlaceholders(text: String): String = text

    override def containsProperty(key: String) = true
  }

  val source = new LdapContextSource()

  source.setUrl(env.getRequiredProperty("conductor.ldap.serverUrl"))
  source.setUserDn(env.getRequiredProperty("conductor.ldap.bindDn"))
  source.setPassword(env.getRequiredProperty("conductor.ldap.bindPassword"))
  //source.setBase(env.getRequiredProperty("conductor.ldap.baseDn"))
  source.setPooled(true)

  val ldapTemplate: LdapTemplate = new LdapTemplate(source)

  val idm: GluuIdmIdentityService = new GluuIdmIdentityService(ldapTemplate, env)

  "Create Group Query" should "return group query" in {

    assert(idm.createGroupQuery().isInstanceOf[GroupQuery])

  }
}

Answer 1

您可以使用StandardEnvironment 类而不是重新实现接口。