测试 OAuth 2.0

本站(springdoc.cn)中的内容来源于 spring.io ，原始版权归属于 spring.io。由 springdoc.cn 进行翻译，整理。可供个人学习、研究，未经许可，不得进行任何转载、商用或与之相关的行为。 商标声明：Spring 是 Pivotal Software, Inc. 在美国以及其他国家的商标。

当涉及到OAuth 2.0时，前面所涉及的相同原则仍然适用。归根结底，这取决于你的测试方法在 SecurityContextHolder 中的期望值是什么。

例如，对于一个看起来像这样的 controller：

  • Java

  • Kotlin

@GetMapping("/endpoint")
public String foo(Principal user) {
    return user.getName();
}
@GetMapping("/endpoint")
fun foo(user: Principal): String {
    return user.name
}

这与OAuth2无关，所以你可以简单地 使用 @WithMockUser，就可以了。

但是，在你的 controller 被绑定到Spring Security的OAuth 2.0支持的某些方面的情况下，比如下面。

  • Java

  • Kotlin

@GetMapping("/endpoint")
public String foo(@AuthenticationPrincipal OidcUser user) {
    return user.getIdToken().getSubject();
}
@GetMapping("/endpoint")
fun foo(@AuthenticationPrincipal user: OidcUser): String {
    return user.idToken.subject
}

那么 Spring Security 的测试支持就会派上用场。

测试 OIDC 登录

用Spring MVC Test来测试上述方法，需要用授权服务器来模拟某种授权流程。当然，这将是一项艰巨的任务，这就是为什么Spring Security支持删除这些模板的原因。

例如，我们可以告诉Spring Security使用 oidcLogin RequestPostProcessor, 包含一个默认的 OidcUser，像这样。

  • Java

  • Kotlin

mvc
    .perform(get("/endpoint").with(oidcLogin()));
mvc.get("/endpoint") {
    with(oidcLogin())
}

这将做的是用一个 OidcUser 配置相关的 MockHttpServletRequest，其中包括一个简单的 OidcIdToken、OidcUserInfo 和授予权限集合。

具体来说，它将包括一个 OidcIdToken，其 sub claim 设置为 user。

  • Java

  • Kotlin

assertThat(user.getIdToken().getClaim("sub")).isEqualTo("user");
assertThat(user.idToken.getClaim<String>("sub")).isEqualTo("user")

一个没有 claim 的 OidcUserInfo。

  • Java

  • Kotlin

assertThat(user.getUserInfo().getClaims()).isEmpty();
assertThat(user.userInfo.claims).isEmpty()

和一个只有一个权限的权限集合，即 SCOPE_read。

  • Java

  • Kotlin

assertThat(user.getAuthorities()).hasSize(1);
assertThat(user.getAuthorities()).containsExactly(new SimpleGrantedAuthority("SCOPE_read"));
assertThat(user.authorities).hasSize(1)
assertThat(user.authorities).containsExactly(SimpleGrantedAuthority("SCOPE_read"))

Spring Security做了必要的工作，以确保 OidcUser 实例对 @AuthenticationPrincipal 注解 可用。

此外，它还将 OidcUser 链接到一个简单的 OAuth2AuthorizedClient 实例，并将其存入一个模拟的 OAuth2AuthorizedClientRepository。如果你的测试 使用 @RegisteredOAuth2AuthorizedClient 注解，这就很方便了。

配置授权

在许多情况下，你的方法受到过滤器或方法安全的保护，需要你的 Authentication 有一定的授予权限来允许请求。

在这种情况下，你可以使用 authorities() 方法提供你所需要的授予权限。

  • Java

  • Kotlin

mvc
    .perform(get("/endpoint")
        .with(oidcLogin()
            .authorities(new SimpleGrantedAuthority("SCOPE_message:read"))
        )
    );
mvc.get("/endpoint") {
    with(oidcLogin()
        .authorities(SimpleGrantedAuthority("SCOPE_message:read"))
    )
}

配置 Claim

虽然授予权限在所有Spring Security中都很常见，但在OAuth 2.0中我们也有 claim。

比方说，你有一个 user_id 请求，表示用户在系统中的id。你可以在一个控制器中这样访问它。

  • Java

  • Kotlin

@GetMapping("/endpoint")
public String foo(@AuthenticationPrincipal OidcUser oidcUser) {
    String userId = oidcUser.getIdToken().getClaim("user_id");
    // ...
}
@GetMapping("/endpoint")
fun foo(@AuthenticationPrincipal oidcUser: OidcUser): String {
    val userId = oidcUser.idToken.getClaim<String>("user_id")
    // ...
}

在这种情况下，你会想用 idToken() 方法来指定这个 claim。

  • Java

  • Kotlin

mvc
    .perform(get("/endpoint")
        .with(oidcLogin()
                .idToken(token -> token.claim("user_id", "1234"))
        )
    );
mvc.get("/endpoint") {
    with(oidcLogin()
        .idToken {
            it.claim("user_id", "1234")
        }
    )
}

因为 OidcUser 从 OidcIdToken 中收集其 claim。

其他配置

也有其他的方法来进一步配置认证；这只是取决于你的 controller 期望得到什么数据。

  • userInfo(OidcUserInfo.Builder) - 用于配置 OidcUserInfo 实例。

  • clientRegistration(ClientRegistration) - 用于配置相关的 OAuth2AuthorizedClient 与给定的 ClientRegistration。

  • oidcUser(OidcUser) - 用于配置完整的 OidcUser 实例

最后一个是很方便的，如果你：

  1. 拥有你自己的 OidcUser 实现，或

  2. 需要改变名称属性(name attribute)

例如，假设你的授权服务器在 user_name claim 中发送了 principal name，而不是 sub claim。在这种情况下，你可以手工配置一个 OidcUser。

  • Java

  • Kotlin

OidcUser oidcUser = new DefaultOidcUser(
        AuthorityUtils.createAuthorityList("SCOPE_message:read"),
        OidcIdToken.withTokenValue("id-token").claim("user_name", "foo_user").build(),
        "user_name");

mvc
    .perform(get("/endpoint")
        .with(oidcLogin().oidcUser(oidcUser))
    );
val oidcUser: OidcUser = DefaultOidcUser(
    AuthorityUtils.createAuthorityList("SCOPE_message:read"),
    OidcIdToken.withTokenValue("id-token").claim("user_name", "foo_user").build(),
    "user_name"
)

mvc.get("/endpoint") {
    with(oidcLogin().oidcUser(oidcUser))
}

测试 OAuth 2.0 登录

与 测试OIDC登录 一样，测试OAuth 2.0登录也面临着模拟授予流程的类似挑战。正因为如此，Spring Security也有对非OIDC用例的测试支持。

比方说，我们有一个 controller，以 OAuth2User 的形式获取登录的用户。

  • Java

  • Kotlin

@GetMapping("/endpoint")
public String foo(@AuthenticationPrincipal OAuth2User oauth2User) {
    return oauth2User.getAttribute("sub");
}
@GetMapping("/endpoint")
fun foo(@AuthenticationPrincipal oauth2User: OAuth2User): String? {
    return oauth2User.getAttribute("sub")
}

在这种情况下，我们可以告诉 Spring Security 使用 oauth2Login RequestPostProcessor 包含一个默认的 OAuth2User，像这样。

  • Java

  • Kotlin

mvc
    .perform(get("/endpoint").with(oauth2Login()));
mvc.get("/endpoint") {
    with(oauth2Login())
}

这将做的是配置相关的 MockHttpServletRequest 与一个 OAuth2User，其中包括一个简单的 attribute Map 和授予权限的集合。

具体来说，它将包括一个带有 sub/user key/value 对的 Map。

  • Java

  • Kotlin

assertThat((String) user.getAttribute("sub")).isEqualTo("user");
assertThat(user.getAttribute<String>("sub")).isEqualTo("user")

和一个只有一个权限的权限集合，即 SCOPE_read。

  • Java

  • Kotlin

assertThat(user.getAuthorities()).hasSize(1);
assertThat(user.getAuthorities()).containsExactly(new SimpleGrantedAuthority("SCOPE_read"));
assertThat(user.authorities).hasSize(1)
assertThat(user.authorities).containsExactly(SimpleGrantedAuthority("SCOPE_read"))

Spring Security做了必要的工作，以确保 OAuth2User 实例对 @AuthenticationPrincipal 注解 可用。

此外，它还将 OAuth2User 链接到一个简单的 OAuth2AuthorizedClient 实例，并将其存入一个模拟的 OAuth2AuthorizedClientRepository 中。如果你的测试 使用 @RegisteredOAuth2AuthorizedClient 注解 ，这就很方便了。

配置授权

在许多情况下，你的方法受到过滤器或方法安全的保护，需要你的 Authentication 有一定的授予权限来允许请求。

在这种情况下，你可以使用 authorities() 方法提供你所需要的授予权限。

  • Java

  • Kotlin

mvc
    .perform(get("/endpoint")
        .with(oauth2Login()
            .authorities(new SimpleGrantedAuthority("SCOPE_message:read"))
        )
    );
mvc.get("/endpoint") {
    with(oauth2Login()
        .authorities(SimpleGrantedAuthority("SCOPE_message:read"))
    )
}

配置 Claim

虽然授予权限在所有Spring Security中都很常见，但在OAuth 2.0中我们也有 claim。

比方说，你有一个 user_id 属性，表示用户在系统中的id。你可以在一个 controller 中这样访问它。

  • Java

  • Kotlin

@GetMapping("/endpoint")
public String foo(@AuthenticationPrincipal OAuth2User oauth2User) {
    String userId = oauth2User.getAttribute("user_id");
    // ...
}
@GetMapping("/endpoint")
fun foo(@AuthenticationPrincipal oauth2User: OAuth2User): String {
    val userId = oauth2User.getAttribute<String>("user_id")
    // ...
}

在这种情况下，你会想用 attributes() 方法来指定该属性。

  • Java

  • Kotlin

mvc
    .perform(get("/endpoint")
        .with(oauth2Login()
                .attributes(attrs -> attrs.put("user_id", "1234"))
        )
    );
mvc.get("/endpoint") {
    with(oauth2Login()
        .attributes { attrs -> attrs["user_id"] = "1234" }
    )
}

其他配置

也有其他的方法来进一步配置认证；这只是取决于你的控制器期望得到什么数据。

  • clientRegistration(ClientRegistration) - 用于配置相关的 OAuth2AuthorizedClient 与给定的 ClientRegistration。

  • oauth2User(OAuth2User) - 用于配置完整的 OAuth2User 实例。

最后一个是很方便的，如果你：

  1. 有自己的 OAuth2User 的实现，或

  2. 需要改变名称属性(name attribute)

例如，假设你的授权服务器在 user_name 请求中发送了 principal name，而不是 sub claim。在这种情况下，你可以手工配置一个 OAuth2User。

  • Java

  • Kotlin

OAuth2User oauth2User = new DefaultOAuth2User(
        AuthorityUtils.createAuthorityList("SCOPE_message:read"),
        Collections.singletonMap("user_name", "foo_user"),
        "user_name");

mvc
    .perform(get("/endpoint")
        .with(oauth2Login().oauth2User(oauth2User))
    );
val oauth2User: OAuth2User = DefaultOAuth2User(
    AuthorityUtils.createAuthorityList("SCOPE_message:read"),
    mapOf(Pair("user_name", "foo_user")),
    "user_name"
)

mvc.get("/endpoint") {
    with(oauth2Login().oauth2User(oauth2User))
}

测试 OAuth 2.0 客户端

与你的用户认证方式无关，你可能有其他的token和客户端注册（client registration）在你正在测试的请求中发挥作用。例如，你的控制器可能依靠客户端凭证授予来获得一个与用户完全不相关的token。

  • Java

  • Kotlin

@GetMapping("/endpoint")
public String foo(@RegisteredOAuth2AuthorizedClient("my-app") OAuth2AuthorizedClient authorizedClient) {
    return this.webClient.get()
        .attributes(oauth2AuthorizedClient(authorizedClient))
        .retrieve()
        .bodyToMono(String.class)
        .block();
}
@GetMapping("/endpoint")
fun foo(@RegisteredOAuth2AuthorizedClient("my-app") authorizedClient: OAuth2AuthorizedClient?): String? {
    return this.webClient.get()
        .attributes(oauth2AuthorizedClient(authorizedClient))
        .retrieve()
        .bodyToMono(String::class.java)
        .block()
}

模拟这种与授权服务器的握手可能是很麻烦的。相反，你可以使用 oauth2Client RequestPostProcessor 将一个 OAuth2AuthorizedClient 添加到一个模拟的 OAuth2AuthorizedClientRepository。

  • Java

  • Kotlin

mvc
    .perform(get("/endpoint").with(oauth2Client("my-app")));
mvc.get("/endpoint") {
    with(
        oauth2Client("my-app")
    )
}

这将做的是创建一个 OAuth2AuthorizedClient，它有一个简单的 ClientRegistration、OAuth2AccessToken 和资源所有者名称。

Specifically, it will include a ClientRegistration with a client id of "test-client" and client secret of "test-secret":

具体来说，它将包括一个 ClientRegistration，客户端ID为 "test-client"，客户端 secret 为 "test-secret"。

  • Java

  • Kotlin

assertThat(authorizedClient.getClientRegistration().getClientId()).isEqualTo("test-client");
assertThat(authorizedClient.getClientRegistration().getClientSecret()).isEqualTo("test-secret");
assertThat(authorizedClient.clientRegistration.clientId).isEqualTo("test-client")
assertThat(authorizedClient.clientRegistration.clientSecret).isEqualTo("test-secret")

一个名为 "user" 的资源所有者。

  • Java

  • Kotlin

assertThat(authorizedClient.getPrincipalName()).isEqualTo("user");
assertThat(authorizedClient.principalName).isEqualTo("user")

和一个 OAuth2AccessToken，只有一个范围，read。

  • Java

  • Kotlin

assertThat(authorizedClient.getAccessToken().getScopes()).hasSize(1);
assertThat(authorizedClient.getAccessToken().getScopes()).containsExactly("read");
assertThat(authorizedClient.accessToken.scopes).hasSize(1)
assertThat(authorizedClient.accessToken.scopes).containsExactly("read")

然后可以在控制器方法中使用 @RegisteredOAuth2AuthorizedClient 来正常检索该客户端。

配置 Scope

在很多情况下，OAuth 2.0的访问令牌会附带一组scope。如果你的controller检查这些，就像这样说。

  • Java

  • Kotlin

@GetMapping("/endpoint")
public String foo(@RegisteredOAuth2AuthorizedClient("my-app") OAuth2AuthorizedClient authorizedClient) {
    Set<String> scopes = authorizedClient.getAccessToken().getScopes();
    if (scopes.contains("message:read")) {
        return this.webClient.get()
            .attributes(oauth2AuthorizedClient(authorizedClient))
            .retrieve()
            .bodyToMono(String.class)
            .block();
    }
    // ...
}
@GetMapping("/endpoint")
fun foo(@RegisteredOAuth2AuthorizedClient("my-app") authorizedClient: OAuth2AuthorizedClient): String? {
    val scopes = authorizedClient.accessToken.scopes
    if (scopes.contains("message:read")) {
        return webClient.get()
            .attributes(oauth2AuthorizedClient(authorizedClient))
            .retrieve()
            .bodyToMono(String::class.java)
            .block()
    }
    // ...
}

那么你可以使用 accessToken() 方法来配置 scope。

  • Java

  • Kotlin

mvc
    .perform(get("/endpoint")
        .with(oauth2Client("my-app")
            .accessToken(new OAuth2AccessToken(BEARER, "token", null, null, Collections.singleton("message:read"))))
        )
    );
mvc.get("/endpoint") {
    with(oauth2Client("my-app")
            .accessToken(OAuth2AccessToken(BEARER, "token", null, null, Collections.singleton("message:read")))
    )
}

其他配置

There are additional methods, too, for further configuring the authentication; it simply depends on what data your controller expects:

也有其他的方法来进一步配置 authentication；这只是取决于你的 controller 期望得到什么数据。

  • principalName(String) - 用于配置资源所有者名称

  • clientRegistration(Consumer<ClientRegistration.Builder>) - 用于配置相关的 ClientRegistration

  • clientRegistration(ClientRegistration) - 用于配置完整的 ClientRegistration

如果你想使用一个真正的 ClientRegistration，最后一个是很方便的。

例如，假设你想使用你的应用程序的一个 ClientRegistration 定义，如你的 application.yml 中指定的那样。

在这种情况下，你的测试可以 autowire（注入） ClientRegistrationRepository，并查找你的测试需要的那个。

  • Java

  • Kotlin

@Autowired
ClientRegistrationRepository clientRegistrationRepository;

// ...

mvc
    .perform(get("/endpoint")
        .with(oauth2Client()
            .clientRegistration(this.clientRegistrationRepository.findByRegistrationId("facebook"))));
@Autowired
lateinit var clientRegistrationRepository: ClientRegistrationRepository

// ...

mvc.get("/endpoint") {
    with(oauth2Client("my-app")
        .clientRegistration(clientRegistrationRepository.findByRegistrationId("facebook"))
    )
}

测试 JWT 认证

为了在资源服务器上进行授权请求，你需要一个 bearer token。

如果你的资源服务器是为JWT配置的，那么这就意味着需要对 bearer token 进行签名，然后根据JWT规范进行编码。所有这些都可能相当令人生畏，特别是当这不是你测试的重点时。

幸运的是，有一些简单的方法可以克服这个困难，让你的测试专注于授权而不是代表bearer token。我们现在就来看看其中的两个。

jwt() RequestPostProcessor

第一种方式是通过 jwt RequestPostProcessor。最简单的是这样的。

  • Java

  • Kotlin

mvc
    .perform(get("/endpoint").with(jwt()));
mvc.get("/endpoint") {
    with(jwt())
}

这将做的是创建一个模拟的 Jwt，通过任何 authentication API 正确传递它，这样它就可以供你的授权机制验证。

默认情况下，它所创建的 JWT 具有以下特征。

{
  "headers" : { "alg" : "none" },
  "claims" : {
    "sub" : "user",
    "scope" : "read"
  }
}

而由此产生的 Jwt，如果进行测试，将以如下方式通过。

  • Java

  • Kotlin

assertThat(jwt.getTokenValue()).isEqualTo("token");
assertThat(jwt.getHeaders().get("alg")).isEqualTo("none");
assertThat(jwt.getSubject()).isEqualTo("sub");
assertThat(jwt.tokenValue).isEqualTo("token")
assertThat(jwt.headers["alg"]).isEqualTo("none")
assertThat(jwt.subject).isEqualTo("sub")

当然，这些值是可以配置的。

任何 header 或 claim 都可以用其相应的方法来配置。

  • Java

  • Kotlin

mvc
    .perform(get("/endpoint")
        .with(jwt().jwt(jwt -> jwt.header("kid", "one").claim("iss", "https://idp.example.org"))));
mvc.get("/endpoint") {
    with(
        jwt().jwt { jwt -> jwt.header("kid", "one").claim("iss", "https://idp.example.org") }
    )
}

  • Java

  • Kotlin

mvc
    .perform(get("/endpoint")
        .with(jwt().jwt(jwt -> jwt.claims(claims -> claims.remove("scope")))));
mvc.get("/endpoint") {
    with(
        jwt().jwt { jwt -> jwt.claims { claims -> claims.remove("scope") } }
    )
}

在这里，scope 和 scp 请求的处理方式与普通 bearer token 请求中的处理方式相同。然而，这可以通过提供你的测试所需的 GrantedAuthority 实例列表来覆盖。

  • Java

  • Kotlin

mvc
    .perform(get("/endpoint")
        .with(jwt().authorities(new SimpleGrantedAuthority("SCOPE_messages"))));
mvc.get("/endpoint") {
    with(
        jwt().authorities(SimpleGrantedAuthority("SCOPE_messages"))
    )
}

或者，如果你有一个自定义的 Jwt 到 Collection<GrantedAuthority> 转换器，你也可以用它来推导授权（authority）。

  • Java

  • Kotlin

mvc
    .perform(get("/endpoint")
        .with(jwt().authorities(new MyConverter())));
mvc.get("/endpoint") {
    with(
        jwt().authorities(MyConverter())
    )
}

你也可以指定一个完整的 Jwt，为此 Jwt.Builder 就相当方便了。

  • Java

  • Kotlin

Jwt jwt = Jwt.withTokenValue("token")
    .header("alg", "none")
    .claim("sub", "user")
    .claim("scope", "read")
    .build();

mvc
    .perform(get("/endpoint")
        .with(jwt().jwt(jwt)));
val jwt: Jwt = Jwt.withTokenValue("token")
    .header("alg", "none")
    .claim("sub", "user")
    .claim("scope", "read")
    .build()

mvc.get("/endpoint") {
    with(
        jwt().jwt(jwt)
    )
}

authentication() RequestPostProcessor

第二种方式是通过使用 authentication() RequestPostProcessor。基本上，你可以实例化你自己的 JwtAuthenticationToken 并在你的测试中提供它，像这样。

  • Java

  • Kotlin

Jwt jwt = Jwt.withTokenValue("token")
    .header("alg", "none")
    .claim("sub", "user")
    .build();
Collection<GrantedAuthority> authorities = AuthorityUtils.createAuthorityList("SCOPE_read");
JwtAuthenticationToken token = new JwtAuthenticationToken(jwt, authorities);

mvc
    .perform(get("/endpoint")
        .with(authentication(token)));
val jwt = Jwt.withTokenValue("token")
    .header("alg", "none")
    .claim("sub", "user")
    .build()
val authorities: Collection<GrantedAuthority> = AuthorityUtils.createAuthorityList("SCOPE_read")
val token = JwtAuthenticationToken(jwt, authorities)

mvc.get("/endpoint") {
    with(
        authentication(token)
    )
}

注意，作为这些的替代，你也可以用 @MockBean 注解来模拟 JwtDecoder Bean 本身。

测试 Opaque Token 认证

与 JWT 类似，opaque token 需要授权服务器来验证其有效性，这可能会使测试更加困难。为了帮助解决这个问题，Spring Security 对 opaque token 提供了测试支持。

比方说，我们有一个controller，以 BearerTokenAuthentication 的形式检索认证。

  • Java

  • Kotlin

@GetMapping("/endpoint")
public String foo(BearerTokenAuthentication authentication) {
    return (String) authentication.getTokenAttributes().get("sub");
}
@GetMapping("/endpoint")
fun foo(authentication: BearerTokenAuthentication): String {
    return authentication.tokenAttributes["sub"] as String
}

在这种情况下，我们可以告诉Spring Security使用 opaqueToken RequestPostProcessor 方法包含一个默认的 BearerTokenAuthentication，像这样。

  • Java

  • Kotlin

mvc
    .perform(get("/endpoint").with(opaqueToken()));
mvc.get("/endpoint") {
    with(opaqueToken())
}

这将做的是用一个 BearerTokenAuthentication 配置相关的 MockHttpServletRequest，其中包括一个简单的 OAuth2AuthenticatedPrincipal、attribute Map 和授予权限集合。

具体来说，它将包括一个带有 sub/user key/value对 的 Map。

  • Java

  • Kotlin

assertThat((String) token.getTokenAttributes().get("sub")).isEqualTo("user");
assertThat(token.tokenAttributes["sub"] as String).isEqualTo("user")

和一个只有一个权限的权限集合，即 SCOPE_read。

  • Java

  • Kotlin

assertThat(token.getAuthorities()).hasSize(1);
assertThat(token.getAuthorities()).containsExactly(new SimpleGrantedAuthority("SCOPE_read"));
assertThat(token.authorities).hasSize(1)
assertThat(token.authorities).containsExactly(SimpleGrantedAuthority("SCOPE_read"))

Spring Security做了必要的工作，确保 BearerTokenAuthentication 实例对你的 controller 方法可用。

配置授权

在许多情况下，你的方法受到过滤器或方法安全的保护，并且需要你的 Authentication 拥有某些授予的权限来允许该请求。

在这种情况下，你可以使用 authorities() 方法提供你需要的授权。

  • Java

  • Kotlin

mvc
    .perform(get("/endpoint")
        .with(opaqueToken()
            .authorities(new SimpleGrantedAuthority("SCOPE_message:read"))
        )
    );
mvc.get("/endpoint") {
    with(opaqueToken()
        .authorities(SimpleGrantedAuthority("SCOPE_message:read"))
    )
}

配置 Claim

虽然授予权限在所有Spring Security中都很常见，但在OAuth 2.0中我们也有 Claim 属性。

比方说，你有一个 user_id 属性，表示用户在系统中的id。你可以在一个 controller 中这样访问它。

  • Java

  • Kotlin

@GetMapping("/endpoint")
public String foo(BearerTokenAuthentication authentication) {
    String userId = (String) authentication.getTokenAttributes().get("user_id");
    // ...
}
@GetMapping("/endpoint")
fun foo(authentication: BearerTokenAuthentication): String {
    val userId = authentication.tokenAttributes["user_id"] as String
    // ...
}

在这种情况下，你会想用 attributes() 方法来指定该属性。

  • Java

  • Kotlin

mvc
    .perform(get("/endpoint")
        .with(opaqueToken()
                .attributes(attrs -> attrs.put("user_id", "1234"))
        )
    );
mvc.get("/endpoint") {
    with(opaqueToken()
        .attributes { attrs -> attrs["user_id"] = "1234" }
    )
}

其他配置

也有其他的方法来进一步配置认证；这只是取决于你的 controller 期望得到什么数据。

其中一个是 principal(OAuth2AuthenticatedPrincipal)，你可以用它来配置完整的 OAuth2AuthenticatedPrincipal 实例，它是 BearerTokenAuthentication 的基础。

它很方便，如果你

  1. 有自己的 OAuth2AuthenticatedPrincipal 的实现，或

  2. 想指定一个不同的 principal name

例如，假设你的授权服务器在 user_name 属性中发送 principal name ，而不是在 sub 属性中发送。在这种情况下，你可以手工配置一个 OAuth2AuthenticatedPrincipal。

  • Java

  • Kotlin

Map<String, Object> attributes = Collections.singletonMap("user_name", "foo_user");
OAuth2AuthenticatedPrincipal principal = new DefaultOAuth2AuthenticatedPrincipal(
        (String) attributes.get("user_name"),
        attributes,
        AuthorityUtils.createAuthorityList("SCOPE_message:read"));

mvc
    .perform(get("/endpoint")
        .with(opaqueToken().principal(principal))
    );
val attributes: Map<String, Any> = Collections.singletonMap("user_name", "foo_user")
val principal: OAuth2AuthenticatedPrincipal = DefaultOAuth2AuthenticatedPrincipal(
    attributes["user_name"] as String?,
    attributes,
    AuthorityUtils.createAuthorityList("SCOPE_message:read")
)

mvc.get("/endpoint") {
    with(opaqueToken().principal(principal))
}

请注意，作为使用 opaqueToken() 测试支持的替代方案，你也可以用 @MockBean 注解来模拟 OpaqueTokenIntrospector Bean本身。