测试 OAuth 2.0

在谈到 OAuth 2.0 时，之前介绍的相同原则仍然适用：最终，这取决于您的测试方法期望在 SecurityContextHolder 中存在什么。

考虑以下控制器示例

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 附带支持以消除此样板代码的原因。

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

Java
Kotlin

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

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

该行使用包含简单 OidcIdToken、OidcUserInfo 和已授予权限的 Collection 的 OidcUser 配置关联的 MockServerRequest。

具体来说，它包含一个 OidcIdToken，其 sub 声明设置为 user

Java
Kotlin

assertThat(user.getIdToken().getClaim("sub")).isEqualTo("user");

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

它还包含一个 OidcUserInfo，其中没有设置声明

Java
Kotlin

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

assertThat(user.userInfo.claims).isEmpty()

它还包含一个仅包含一个权限 SCOPE_read 的权限 Collection

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 的情况下，我们还有声明。

例如，假设您有一个user_id声明，它指示用户在您系统中的 ID。您可以在控制器中按如下方式访问它

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()方法指定该声明。

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收集其声明。

还有其他方法，用于根据您的控制器期望的数据进一步配置身份验证。

userInfo(OidcUserInfo.Builder)：配置OidcUserInfo实例
clientRegistration(ClientRegistration)：使用给定的ClientRegistration配置关联的OAuth2AuthorizedClient
oidcUser(OidcUser)：配置完整的OidcUser实例

如果您有以下情况，最后一个方法将非常有用：* 拥有您自己的OidcUser实现，或者 * 需要更改名称属性。

例如，假设您的授权服务器在user_name声明而不是sub声明中发送主体名称。在这种情况下，您可以手动配置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 用例提供了测试支持。

假设我们有一个控制器，它将登录的用户作为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()

上面的示例使用包含简单属性 `Map` 和授予权限 `Collection` 的 `OAuth2User` 配置关联的 `MockServerRequest`。

具体来说，它包含一个键值对为 `sub`/`user` 的 `Map`。

Java
Kotlin

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

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

它还包含一个仅包含一个权限 SCOPE_read 的权限 Collection

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 的情况下，我们还有声明。

例如，假设您有一个 `user_id` 属性，它指示用户在您系统中的 ID。您可以在控制器中按如下方式访问它。

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()

还有其他方法，用于根据您的控制器期望的数据进一步配置身份验证。

clientRegistration(ClientRegistration)：使用给定的ClientRegistration配置关联的OAuth2AuthorizedClient
oauth2User(OAuth2User)：配置完整的 `OAuth2User` 实例

如果您有以下情况，最后一个将非常有用：* 有您自己的 `OAuth2User` 实现，或者 * 需要更改名称属性。

例如，假设您的授权服务器在 `user_name` 声明而不是 `sub` 声明中发送主体名称。在这种情况下，您可以手动配置 `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 客户端

无论用户如何进行身份验证，您可能还有其他令牌和客户端注册参与您正在测试的请求。例如，您的控制器可能依赖于客户端凭据授权来获取与用户完全无关的令牌。

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` 和资源所有者名称。

具体来说，它包含一个客户端 ID 为 `test-client`、客户端密钥为 `test-secret` 的 `ClientRegistration`。

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")

它还包含一个具有一个范围 `read` 的 `OAuth2AccessToken`。

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` 检索客户端。

配置范围

在许多情况下，OAuth 2.0 访问令牌会附带一组范围。考虑以下关于控制器如何检查范围的示例

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()
    }
    // ...
}

给定一个检查范围的控制器，您可以使用 accessToken() 方法配置范围

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 身份验证

要在资源服务器上进行授权请求，您需要一个承载令牌。如果您的资源服务器配置为 JWT，则承载令牌需要根据 JWT 规范进行签名，然后进行编码。所有这些都可能非常令人生畏，尤其是在这并非您测试的重点时。

幸运的是，您可以通过多种简单的方法克服这个困难，让您的测试专注于授权，而不是表示承载令牌。我们将在接下来的两个小节中介绍其中两种方法。

`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")

请注意，您可以配置这些值。

您还可以使用相应的方法配置任何标头或声明。

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 声明在此处的处理方式与在普通承载令牌请求中的处理方式相同。但是，您可以通过简单地提供测试所需的 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 本身。

测试不透明令牌身份验证

与 JWT 类似，不透明令牌需要授权服务器才能验证其有效性，这可能会使测试变得更加困难。为了帮助解决这个问题，Spring Security 为不透明令牌提供了测试支持。

假设您有一个控制器，它将身份验证检索为 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?)
}

在这种情况下，您可以告诉 Spring Security 包含默认的 BearerTokenAuthentication，方法是使用 SecurityMockServerConfigurers#opaqueToken 方法。

Java
Kotlin

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

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

此示例使用包含简单 OAuth2AuthenticatedPrincipal、属性 Map 和授予权限 Collection 的 BearerTokenAuthentication 配置关联的 MockHttpServletRequest。

具体来说，它包含一个键值对为 `sub`/`user` 的 `Map`。

Java
Kotlin

assertThat((String) token.getTokenAttributes().get("sub")).isEqualTo("user");

assertThat(token.tokenAttributes["sub"] as String?).isEqualTo("user")

它还包含一个仅包含一个权限 SCOPE_read 的权限 Collection

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 实例可用于您的控制器方法。

配置权限

在许多情况下，您的方法受过滤器或方法安全性的保护，并且需要您的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()

配置声明

虽然授予权限在所有 Spring Security 中都很常见，但在 OAuth 2.0 的情况下，我们还有属性。

例如，假设您有一个 `user_id` 属性，它指示用户在您系统中的 ID。您可以在控制器中按如下方式访问它。

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()

其他配置

您还可以使用其他方法来进一步配置身份验证，具体取决于您的控制器期望的数据。

一种这样的方法是principal(OAuth2AuthenticatedPrincipal)，您可以使用它来配置BearerTokenAuthentication的基础的完整OAuth2AuthenticatedPrincipal实例。

如果您有以下情况，它会很方便：* 您有自己的OAuth2AuthenticatedPrincipal实现，或者 * 您想指定不同的主体名称

例如，假设您的授权服务器在user_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"));

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 登录

配置权限

配置声明

其他配置

测试 OAuth 2.0 登录

配置权限

配置声明

其他配置

测试 OAuth 2.0 客户端

配置范围

其他配置

测试 JWT 身份验证

mockJwt() WebTestClientConfigurer

authentication() 和 WebTestClientConfigurer

测试不透明令牌身份验证

配置权限

配置声明

其他配置

`mockJwt() WebTestClientConfigurer`

`authentication()` 和 `WebTestClientConfigurer`