测试 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 通过使用SecurityMockServerConfigurers#oidcLogin方法包含默认的OidcUser

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

它还包含一个权限的Collection，只有一个权限，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 的情况下，我们还有声明。

例如，假设您有一个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")

它还包含一个权限的Collection，只有一个权限，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的情况下，我们还有声明。

例如，假设您有一个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和资源所有者名称。

具体来说，它包含一个ClientRegistration，其客户端ID为test-client，客户端密钥为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")

它还包含一个具有一个范围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身份验证

要在资源服务器上发出授权请求，您需要一个Bearer令牌。如果您的资源服务器配置为使用JWT，则Bearer令牌需要根据JWT规范进行签名和编码。所有这些都可能非常困难，尤其是在这不是测试重点的情况下。

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

`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声明在此处的处理方式与在正常的Bearer令牌请求中的处理方式相同。但是，只需提供测试所需的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")

它还包含一个权限的Collection，只有一个权限，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实例。

配置权限

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