测试 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 Mono<String> foo(Principal user) {
    return Mono.just(user.getName());
}

@GetMapping("/endpoint")
fun foo(user: Principal): Mono<String> {
    return Mono.just(user.name)
}

它与OAuth2没有任何关系，所以你可以使用 @WithMockUser 而不会有事。

然而，考虑到你的控制器与Spring Security的OAuth 2.0支持的某些方面绑定的情况。

Java
Kotlin

@GetMapping("/endpoint")
public Mono<String> foo(@AuthenticationPrincipal OidcUser user) {
    return Mono.just(user.getIdToken().getSubject());
}

@GetMapping("/endpoint")
fun foo(@AuthenticationPrincipal user: OidcUser): Mono<String> {
    return Mono.just(user.idToken.subject)
}

在这种情况下，Spring Security的测试支持就很方便了。

使用 WebTestClient 测试上一节所示的方法需要模拟某种授权服务器的授予流程。这是一项艰巨的任务，这就是为什么Spring Security支持删除这些模板的原因。

例如，我们可以通过使用 SecurityMockServerConfigurers#oidcLogin 方法告诉Spring Security包含一个默认的 OidcUser。

Java

client
    .mutateWith(mockOidcLogin()).get().uri("/endpoint").exchange();

Kotlin

client
    .mutateWith(mockOidcLogin())
    .get().uri("/endpoint")
    .exchange()

这一行用一个 OidcUser 来配置相关的 MockServerRequest，其中包括一个简单的 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 的一个简单实例，并将其存入一个模拟的 ServerOAuth2AuthorizedClientRepository。如果你的测试使用 @RegisteredOAuth2AuthorizedClient 注解，这就很方便了。

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

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

Java
Kotlin

client
    .mutateWith(mockOidcLogin()
        .authorities(new SimpleGrantedAuthority("SCOPE_message:read"))
    )
    .get().uri("/endpoint").exchange();

client
    .mutateWith(mockOidcLogin()
        .authorities(SimpleGrantedAuthority("SCOPE_message:read"))
    )
    .get().uri("/endpoint").exchange()

虽然授权在所有Spring Security中都是通用的，但在OAuth 2.0的情况下，我们也有 claim。

例如，假设你有一个 user_id claim，表示用户在系统中的ID。你可以在一个 controller 中以如下方式访问它。

Java
Kotlin

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

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

在这种情况下，你可以用 idToken() 方法指定该 claim。

Java
Kotlin

client
    .mutateWith(mockOidcLogin()
        .idToken(token -> token.claim("user_id", "1234"))
    )
    .get().uri("/endpoint").exchange();

client
    .mutateWith(mockOidcLogin()
        .idToken { token -> token.claim("user_id", "1234") }
    )
    .get().uri("/endpoint").exchange()

这一点是可行的，因为 OidcUser 从 OidcIdToken 中收集其 claim。

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

userInfo(OidcUserInfo.Builder): 配置 OidcUserInfo 实例。
clientRegistration(ClientRegistration): 通过 ClientRegistration 配置相关的 OAuth2AuthorizedClient。
oidcUser(OidcUser): 配置完整的 OidcUser 实例。

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

有自己的 OidcUser 实现，或
需要改变name属性

例如，假设你的授权服务器在 user_name claim 中发送了 principal 的名字，而不是 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");

client
    .mutateWith(mockOidcLogin().oidcUser(oidcUser))
    .get().uri("/endpoint").exchange();

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

client
    .mutateWith(mockOidcLogin().oidcUser(oidcUser))
    .get().uri("/endpoint").exchange()

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

假设我们有一个 controller，可以获得作为 OAuth2User 的登录用户。

Java
Kotlin

@GetMapping("/endpoint")
public Mono<String> foo(@AuthenticationPrincipal OAuth2User oauth2User) {
    return Mono.just(oauth2User.getAttribute("sub"));
}

@GetMapping("/endpoint")
fun foo(@AuthenticationPrincipal oauth2User: OAuth2User): Mono<String> {
    return Mono.just(oauth2User.getAttribute("sub"))
}

在这种情况下，我们可以通过使用 SecurityMockServerConfigurers#oauth2User 方法告诉 Spring Security 包含一个默认的 OAuth2User。

Java
Kotlin

client
    .mutateWith(mockOAuth2Login())
    .get().uri("/endpoint").exchange();

client
    .mutateWith(mockOAuth2Login())
    .get().uri("/endpoint").exchange()

前面的例子用一个 OAuth2User 来配置相关的 MockServerRequest，其中包括一个简单的 attribute Map 和一个授权集合。

具体来说，它包括一个带有 sub/user 键值对的 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 实例，并将其存入一个模拟的 ServerOAuth2AuthorizedClientRepository 中。如果你的测试使用 @RegisteredOAuth2AuthorizedClient 注解，这就很方便了。

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

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

Java
Kotlin

client
    .mutateWith(mockOAuth2Login()
        .authorities(new SimpleGrantedAuthority("SCOPE_message:read"))
    )
    .get().uri("/endpoint").exchange();

client
    .mutateWith(mockOAuth2Login()
        .authorities(SimpleGrantedAuthority("SCOPE_message:read"))
    )
    .get().uri("/endpoint").exchange()

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

例如，假设你有一个 user_id 属性，表示系统中用户的ID。你可以在一个controller中这样访问它。

Java
Kotlin

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

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

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

Java
Kotlin

client
    .mutateWith(mockOAuth2Login()
        .attributes(attrs -> attrs.put("user_id", "1234"))
    )
    .get().uri("/endpoint").exchange();

client
    .mutateWith(mockOAuth2Login()
        .attributes { attrs -> attrs["user_id"] = "1234" }
    )
    .get().uri("/endpoint").exchange()

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

clientRegistration(ClientRegistration): 通过给定的 ClientRegistration 配置相关的 OAuth2AuthorizedClient。
oauth2User(OAuth2User): 配置完整的 OAuth2User 实例。

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

有自己的 OAuth2User 的实现，或
需要改变 name 属性

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

Java
Kotlin

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

client
    .mutateWith(mockOAuth2Login().oauth2User(oauth2User))
    .get().uri("/endpoint").exchange();

val oauth2User: OAuth2User = DefaultOAuth2User(
    AuthorityUtils.createAuthorityList("SCOPE_message:read"),
    mapOf(Pair("user_name", "foo_user")),
    "user_name"
)

client
    .mutateWith(mockOAuth2Login().oauth2User(oauth2User))
    .get().uri("/endpoint").exchange()

测试 OAuth 2.0 客户端

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

Java
Kotlin

@GetMapping("/endpoint")
public Mono<String> foo(@RegisteredOAuth2AuthorizedClient("my-app") OAuth2AuthorizedClient authorizedClient) {
    return this.webClient.get()
        .attributes(oauth2AuthorizedClient(authorizedClient))
        .retrieve()
        .bodyToMono(String.class);
}

import org.springframework.web.reactive.function.client.bodyToMono

// ...

@GetMapping("/endpoint")
fun foo(@RegisteredOAuth2AuthorizedClient("my-app") authorizedClient: OAuth2AuthorizedClient?): Mono<String> {
    return this.webClient.get()
        .attributes(oauth2AuthorizedClient(authorizedClient))
        .retrieve()
        .bodyToMono()
}

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

Java
Kotlin

client
    .mutateWith(mockOAuth2Client("my-app"))
    .get().uri("/endpoint").exchange();

client
    .mutateWith(mockOAuth2Client("my-app"))
    .get().uri("/endpoint").exchange()

这将创建一个 OAuth2AuthorizedClient，它有一个简单的 ClientRegistration，一个 OAuth2AccessToken，以及一个资源所有者的名字。

具体来说，它包括一个 ClientRegistration，client ID 为 test-client，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，有一个 scope，即 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 如何检查 scope。

Java
Kotlin

@GetMapping("/endpoint")
public Mono<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);
    }
    // ...
}

import org.springframework.web.reactive.function.client.bodyToMono

// ...

@GetMapping("/endpoint")
fun foo(@RegisteredOAuth2AuthorizedClient("my-app") authorizedClient: OAuth2AuthorizedClient): Mono<String> {
    val scopes = authorizedClient.accessToken.scopes
    if (scopes.contains("message:read")) {
        return webClient.get()
            .attributes(oauth2AuthorizedClient(authorizedClient))
            .retrieve()
            .bodyToMono()
    }
    // ...
}

给定一个检查作用域的controller，你可以通过使用 accessToken() 方法配置 scope。

Java
Kotlin

client
    .mutateWith(mockOAuth2Client("my-app")
        .accessToken(new OAuth2AccessToken(BEARER, "token", null, null, Collections.singleton("message:read")))
    )
    .get().uri("/endpoint").exchange();

client
    .mutateWith(mockOAuth2Client("my-app")
        .accessToken(OAuth2AccessToken(BEARER, "token", null, null, setOf("message:read")))
)
.get().uri("/endpoint").exchange()

其他配置

你也可以根据你的控制器所期望的数据，使用额外的方法来进一步配置认证。

principalName(String); 配置资源所有者名称。
clientRegistration(Consumer<ClientRegistration.Builder>): 配置相关的 ClientRegistration。
clientRegistration(ClientRegistration): 配置完整的 ClientRegistration。

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

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

在这种情况下，你的测试可以自动连接 ReactiveClientRegistrationRepository，并查找你的测试需要的那个。

Java
Kotlin

@Autowired
ReactiveClientRegistrationRepository clientRegistrationRepository;

// ...

client
    .mutateWith(mockOAuth2Client()
        .clientRegistration(this.clientRegistrationRepository.findByRegistrationId("facebook").block())
    )
    .get().uri("/exchange").exchange();

@Autowired
lateinit var clientRegistrationRepository: ReactiveClientRegistrationRepository

// ...

client
    .mutateWith(mockOAuth2Client()
        .clientRegistration(this.clientRegistrationRepository.findByRegistrationId("facebook").block())
    )
    .get().uri("/exchange").exchange()

测试 JWT 认证

要在资源服务器上发出授权请求，你需要一个 bearer token。如果你的资源服务器被配置为JWT，bearer token 需要被签署，然后根据JWT规范进行编码。所有这些都可能是相当艰巨的任务，特别是当这不是你测试的重点时。

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

`mockJwt() WebTestClientConfigurer`

第一种方法是使用 WebTestClientConfigurer。其中最简单的是使用 SecurityMockServerConfigurers#mockJwt 方法，如下所示。

Java
Kotlin

client
    .mutateWith(mockJwt()).get().uri("/endpoint").exchange();

client
    .mutateWith(mockJwt()).get().uri("/endpoint").exchange()

这个例子创建了一个模拟的 Jwt，并通过任何认证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

client
	.mutateWith(mockJwt().jwt(jwt -> jwt.header("kid", "one")
		.claim("iss", "https://idp.example.org")))
	.get().uri("/endpoint").exchange();

client
    .mutateWith(mockJwt().jwt { jwt -> jwt.header("kid", "one")
        .claim("iss", "https://idp.example.org")
    })
    .get().uri("/endpoint").exchange()

Java
Kotlin

client
	.mutateWith(mockJwt().jwt(jwt -> jwt.claims(claims -> claims.remove("scope"))))
	.get().uri("/endpoint").exchange();

client
    .mutateWith(mockJwt().jwt { jwt ->
        jwt.claims { claims -> claims.remove("scope") }
    })
    .get().uri("/endpoint").exchange()

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

Java
Kotlin

client
	.mutateWith(mockJwt().authorities(new SimpleGrantedAuthority("SCOPE_messages")))
	.get().uri("/endpoint").exchange();

client
    .mutateWith(mockJwt().authorities(SimpleGrantedAuthority("SCOPE_messages")))
    .get().uri("/endpoint").exchange()

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

Java
Kotlin

client
	.mutateWith(mockJwt().authorities(new MyConverter()))
	.get().uri("/endpoint").exchange();

client
    .mutateWith(mockJwt().authorities(MyConverter()))
    .get().uri("/endpoint").exchange()

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

Java
Kotlin

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

client
	.mutateWith(mockJwt().jwt(jwt))
	.get().uri("/endpoint").exchange();

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

client
    .mutateWith(mockJwt().jwt(jwt))
    .get().uri("/endpoint").exchange()

`authentication()` 和 `WebTestClientConfigurer`

第二种方式是通过使用 authentication() Mutator。你可以实例化你自己的 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);

client
	.mutateWith(mockAuthentication(token))
	.get().uri("/endpoint").exchange();

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)

client
    .mutateWith(mockAuthentication<JwtMutator>(token))
    .get().uri("/endpoint").exchange()

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

测试 Opaque Token 认证

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

假设你有一个 controller，以 BearerTokenAuthentication 的形式检索认证。

Java
Kotlin

@GetMapping("/endpoint")
public Mono<String> foo(BearerTokenAuthentication authentication) {
    return Mono.just((String) authentication.getTokenAttributes().get("sub"));
}

@GetMapping("/endpoint")
fun foo(authentication: BearerTokenAuthentication): Mono<String?> {
    return Mono.just(authentication.tokenAttributes["sub"] as String?)
}

在这种情况下，你可以通过使用 SecurityMockServerConfigurers#opaqueToken 方法告诉 Spring Security 包含一个默认的 BearerTokenAuthentication。

Java
Kotlin

client
    .mutateWith(mockOpaqueToken())
    .get().uri("/endpoint").exchange();

client
    .mutateWith(mockOpaqueToken())
    .get().uri("/endpoint").exchange()

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

具体来说，它包括一个带有 sub/user 键/值对的 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

client
    .mutateWith(mockOpaqueToken()
        .authorities(new SimpleGrantedAuthority("SCOPE_message:read"))
    )
    .get().uri("/endpoint").exchange();

client
    .mutateWith(mockOpaqueToken()
        .authorities(SimpleGrantedAuthority("SCOPE_message:read"))
    )
    .get().uri("/endpoint").exchange()

配置 Claim

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

例如，假设你有一个 user_id 属性，表示系统中用户的ID。你可以在一个 controller 这样访问它。

Java
Kotlin

@GetMapping("/endpoint")
public Mono<String> foo(BearerTokenAuthentication authentication) {
    String userId = (String) authentication.getTokenAttributes().get("user_id");
    // ...
}

@GetMapping("/endpoint")
fun foo(authentication: BearerTokenAuthentication): Mono<String?> {
    val userId = authentication.tokenAttributes["user_id"] as String?
    // ...
}

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

Java
Kotlin

client
    .mutateWith(mockOpaqueToken()
        .attributes(attrs -> attrs.put("user_id", "1234"))
    )
    .get().uri("/endpoint").exchange();

client
    .mutateWith(mockOpaqueToken()
        .attributes { attrs -> attrs["user_id"] = "1234" }
    )
    .get().uri("/endpoint").exchange()

其他配置

你也可以使用额外的方法来进一步配置认证，这取决于你的 controller 期望得到什么数据。

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

这很方便，如果你：

有自己的 OAuth2AuthenticatedPrincipal 的实现或
想指定一个不同的 principal name

例如，假设你的授权服务器在 user_name 属性中发送 principal 的名字，而不是在 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"));

client
    .mutateWith(mockOpaqueToken().principal(principal))
    .get().uri("/endpoint").exchange();

val attributes: Map<String, Any> = mapOf(Pair("user_name", "foo_user"))
val principal: OAuth2AuthenticatedPrincipal = DefaultOAuth2AuthenticatedPrincipal(
    attributes["user_name"] as String?,
    attributes,
    AuthorityUtils.createAuthorityList("SCOPE_message:read")
)

client
    .mutateWith(mockOpaqueToken().principal(principal))
    .get().uri("/endpoint").exchange()

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

测试 OAuth 2.0

测试 OIDC 登录

配置授权

配置 Claim

其他配置

测试 OAuth 2.0 登录

配置授权

配置 Claim

其他配置

测试 OAuth 2.0 客户端

配置 Scope

其他配置

测试 JWT 认证

mockJwt() WebTestClientConfigurer

authentication() 和 WebTestClientConfigurer

测试 Opaque Token 认证

配置授权

配置 Claim

其他配置

`mockJwt() WebTestClientConfigurer`

`authentication()` 和 `WebTestClientConfigurer`