此版本仍在开发中，尚未被视为稳定版本。如需最新稳定版本，请使用 Spring Security 7.0.4！spring-doc.cadn.net.cn

测试 OAuth 2.0

当涉及到OAuth 2.0时，前面提到的基本原则仍然适用：最终，这取决于你的测试方法期望在SecurityContextHolder中看到什么。spring-doc.cadn.net.cn

考虑以下控制器示例：spring-doc.cadn.net.cn

Javaspring-doc.cadn.net.cn
Kotlinspring-doc.cadn.net.cn

@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-doc.cadn.net.cn

然而，考虑一个场景，你的控制器绑定到了Spring Security的OAuth 2.0支持的一些方面：spring-doc.cadn.net.cn

Javaspring-doc.cadn.net.cn
Kotlinspring-doc.cadn.net.cn

@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 的测试支持就派上用场了。spring-doc.cadn.net.cn

使用#webflux-testing-oauth2测试前一节中展示的方法需要模拟某种授权流程与授权服务器交互。这是一个艰巨的任务，这也是为什么Spring Security附带了去除这种样板代码的支持。spring-doc.cadn.net.cn

例如，我们可以使用OidcUser方法告诉Spring Security 包含一个默认的SecurityMockServerConfigurers#oidcLogin：spring-doc.cadn.net.cn

Javaspring-doc.cadn.net.cn
Kotlinspring-doc.cadn.net.cn

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

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

那一行配置了关联的MockServerRequest，其中包含一个简单的OidcUser、一个OidcIdToken以及一个被授予权限的集合。spring-doc.cadn.net.cn

具体来说，它包括一个OidcIdToken，其中sub声明被设置为user：spring-doc.cadn.net.cn

Javaspring-doc.cadn.net.cn
Kotlinspring-doc.cadn.net.cn

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

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

这也包括一个没有任何声明的 OidcUserInfospring-doc.cadn.net.cn

Javaspring-doc.cadn.net.cn
Kotlinspring-doc.cadn.net.cn

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

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

它还包括一个包含单一权限Collection的SCOPE_read：spring-doc.cadn.net.cn

Javaspring-doc.cadn.net.cn
Kotlinspring-doc.cadn.net.cn

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 注解。spring-doc.cadn.net.cn

此外，它还将 OidcUser 链接到 OAuth2AuthorizedClient 的一个简单实例，并将其存入一个模拟的 ServerOAuth2AuthorizedClientRepository 中。如果您的测试使用了 @RegisteredOAuth2AuthorizedClient 注解，这会非常有用。spring-doc.cadn.net.cn

在许多情况下，您的方法可能受到过滤器或方法安全性的保护，并且需要您的Authentication具有某些授予的权限以允许该请求。spring-doc.cadn.net.cn

在这些情况下，您可以使用authorities()方法来提供所需的授权信息：spring-doc.cadn.net.cn

Javaspring-doc.cadn.net.cn
Kotlinspring-doc.cadn.net.cn

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的情况下，我们还使用声明。spring-doc.cadn.net.cn

假设，例如，您有一个user_id声明，该声明表示系统中的用户ID。您可以在控制器中这样访问它：spring-doc.cadn.net.cn

Javaspring-doc.cadn.net.cn
Kotlinspring-doc.cadn.net.cn

@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()方法指定该声明：spring-doc.cadn.net.cn

Javaspring-doc.cadn.net.cn
Kotlinspring-doc.cadn.net.cn

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 中收集其声明。spring-doc.cadn.net.cn

有其他方法可以进一步配置身份验证，这取决于控制器期望的数据类型：spring-doc.cadn.net.cn

userInfo(OidcUserInfo.Builder): 配置 OidcUserInfo 实例spring-doc.cadn.net.cn
clientRegistration(ClientRegistration): 配置与给定的OAuth2AuthorizedClient关联的ClientRegistrationspring-doc.cadn.net.cn
oidcUser(OidcUser): 配置完整的 OidcUser 实例spring-doc.cadn.net.cn

那最后一个选项很方便，如果你: spring-doc.cadn.net.cn

有自己的OAuth2User实现，或者
需要更改名称属性

spring-doc.cadn.net.cn

例如，假设你的授权服务器在user_name声明中发送主体名称而不是sub声明。在这种情况下，你可以手动配置一个OidcUser:spring-doc.cadn.net.cn

Javaspring-doc.cadn.net.cn
Kotlinspring-doc.cadn.net.cn

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 使用场景提供了测试支持。spring-doc.cadn.net.cn

假设我们有一个控制器，通过OAuth2User获取已登录用户：spring-doc.cadn.net.cn

Javaspring-doc.cadn.net.cn
Kotlinspring-doc.cadn.net.cn

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

在那种情况下，我们可以告诉Spring Security 包含一个默认的OAuth2User，通过使用SecurityMockServerConfigurers#oauth2User方法：spring-doc.cadn.net.cn

Javaspring-doc.cadn.net.cn
Kotlinspring-doc.cadn.net.cn

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

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

上述示例配置了关联的MockServerRequest，其中包含一个OAuth2User，该对象包括一个简单的Map属性集和一个授予权限的Collection。spring-doc.cadn.net.cn

具体地，它包括一个带有键值对Map的：spring-doc.cadn.net.cn

Javaspring-doc.cadn.net.cn
Kotlinspring-doc.cadn.net.cn

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

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

它还包括一个包含单一权限Collection的SCOPE_read：spring-doc.cadn.net.cn

Javaspring-doc.cadn.net.cn
Kotlinspring-doc.cadn.net.cn

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 注解。spring-doc.cadn.net.cn

此外，它还将 OAuth2User 链接到其存入模拟 ServerOAuth2AuthorizedClientRepository 中的简单 OAuth2AuthorizedClient 实例。如果您的测试使用了 @RegisteredOAuth2AuthorizedClient 注解，这将非常有用。spring-doc.cadn.net.cn

在许多情况下，您的方法可能受到过滤器或方法安全性的保护，并且需要您的Authentication具有某些授予的权限以允许该请求。spring-doc.cadn.net.cn

在这种情况下，您可以使用authorities()方法提供所需的授权：
spring-doc.cadn.net.cn

Javaspring-doc.cadn.net.cn
Kotlinspring-doc.cadn.net.cn

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的情况下，我们也有声明。spring-doc.cadn.net.cn

假设，例如，您有一个user_id属性，该属性表示系统中的用户ID。您可以在控制器中如下访问它：spring-doc.cadn.net.cn

Javaspring-doc.cadn.net.cn
Kotlinspring-doc.cadn.net.cn

@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()方法指定该属性：spring-doc.cadn.net.cn

Javaspring-doc.cadn.net.cn
Kotlinspring-doc.cadn.net.cn

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

有其他方法可以进一步配置身份验证，这取决于控制器期望的数据类型：spring-doc.cadn.net.cn

clientRegistration(ClientRegistration): 配置与给定的OAuth2AuthorizedClient关联的ClientRegistrationspring-doc.cadn.net.cn
oauth2User(OAuth2User): 配置完整的 OAuth2User 实例spring-doc.cadn.net.cn

那最后一个选项很方便，如果你: spring-doc.cadn.net.cn

有自己的OAuth2User实现，或者
需要更改名称属性

spring-doc.cadn.net.cn

例如，假设你的授权服务器在user_name声明中发送主体名称而不是sub声明。在这种情况下，你可以手动配置一个OAuth2User:spring-doc.cadn.net.cn

Javaspring-doc.cadn.net.cn
Kotlinspring-doc.cadn.net.cn

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 客户端

无论用户的认证方式如何，您在测试请求时可能还需要处理其他Tokens和客户端注册信息。例如，您的控制器可能会依赖于客户端凭证授权来获取一个与用户无关的Tokens：spring-doc.cadn.net.cn

Javaspring-doc.cadn.net.cn
Kotlinspring-doc.cadn.net.cn

@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:spring-doc.cadn.net.cn

Javaspring-doc.cadn.net.cn
Kotlinspring-doc.cadn.net.cn

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

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

这会创建一个OAuth2AuthorizedClient，它包含一个简单的ClientRegistration、一个OAuth2AccessToken以及一个资源所有者名称。spring-doc.cadn.net.cn

具体来说，它包括一个ClientRegistration，其客户端ID为test-client，客户端密钥为test-secret：spring-doc.cadn.net.cn

Javaspring-doc.cadn.net.cn
Kotlinspring-doc.cadn.net.cn

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：spring-doc.cadn.net.cn

Javaspring-doc.cadn.net.cn
Kotlinspring-doc.cadn.net.cn

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

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

它还包括一个带有OAuth2AccessToken范围的read：spring-doc.cadn.net.cn

Javaspring-doc.cadn.net.cn
Kotlinspring-doc.cadn.net.cn

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来检索客户端。spring-doc.cadn.net.cn

配置作用域

在许多情况下，OAuth 2.0访问Tokens会包含一组权限范围。考虑以下控制器如何检查这些范围的示例：spring-doc.cadn.net.cn

Javaspring-doc.cadn.net.cn
Kotlinspring-doc.cadn.net.cn

@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()方法来配置作用域：spring-doc.cadn.net.cn

Javaspring-doc.cadn.net.cn
Kotlinspring-doc.cadn.net.cn

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

附加配置

您还可以使用其他方法根据控制器期望的数据进一步配置身份验证：spring-doc.cadn.net.cn

principalName(String); 配置资源所有者名称spring-doc.cadn.net.cn
clientRegistration(Consumer<ClientRegistration.Builder>): 配置关联的 ClientRegistrationspring-doc.cadn.net.cn
clientRegistration(ClientRegistration): 配置完整的 ClientRegistrationspring-doc.cadn.net.cn

那最后一个非常方便，如果你想要使用一个真实的ClientRegistrationspring-doc.cadn.net.cn

例如，假设您希望使用应用程序中定义的一个ClientRegistration，如在您的application.yml中指定的那样。spring-doc.cadn.net.cn

在这种情况下，你的测试可以使用@Autowired 注入 ReactiveClientRegistrationRepository 并查找测试所需的那个项：spring-doc.cadn.net.cn

Javaspring-doc.cadn.net.cn
Kotlinspring-doc.cadn.net.cn

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

要对资源服务器进行授权请求，你需要一个访问Tokens。如果您的资源服务器配置为使用JWT（JSON Web Token），那么访问Tokens需要按照JWT规范进行签名和编码。所有这些操作可能都会显得有些复杂，尤其是在这并不是你测试的重点时更为如此。spring-doc.cadn.net.cn

幸运的是，有许多简单的方法可以克服这个问题，让你的测试专注于授权而不是表示 bearer token。我们在接下来的两个子部分中探讨其中两种方法。spring-doc.cadn.net.cn

`mockJwt() WebTestClientConfigurer`

第一种方式是使用 WebTestClientConfigurer。最简单的方法是使用 SecurityMockServerConfigurers#mockJwt 方法，如下所示：spring-doc.cadn.net.cn

Javaspring-doc.cadn.net.cn
Kotlinspring-doc.cadn.net.cn

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

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

此示例创建一个模拟的Jwt并将其传递给任何身份验证API，以便您的授权机制可以进行验证。spring-doc.cadn.net.cn

默认情况下，它创建的JWT具有以下特征：spring-doc.cadn.net.cn

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

The resulting Jwt, were it tested, would pass in the following way:spring-doc.cadn.net.cn

Javaspring-doc.cadn.net.cn
Kotlinspring-doc.cadn.net.cn

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

注意，您需要配置这些值。spring-doc.cadn.net.cn

您还可以通过相应的方法配置任何标头或声明：spring-doc.cadn.net.cn

Javaspring-doc.cadn.net.cn
Kotlinspring-doc.cadn.net.cn

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

Javaspring-doc.cadn.net.cn
Kotlinspring-doc.cadn.net.cn

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

The scope 和 scp 声明在这里与正常 bearer token 请求中的处理方式相同。然而，可以通过提供你需要的GrantedAuthority 实例列表来覆盖这种默认行为：spring-doc.cadn.net.cn

Javaspring-doc.cadn.net.cn
Kotlinspring-doc.cadn.net.cn

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> 的自定义转换器，也可以使用该转换器来推导权限：spring-doc.cadn.net.cn

Javaspring-doc.cadn.net.cn
Kotlinspring-doc.cadn.net.cn

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

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

您还可以指定完整的 Jwt，此时 Jwt.Builder 非常实用：spring-doc.cadn.net.cn

Javaspring-doc.cadn.net.cn
Kotlinspring-doc.cadn.net.cn

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并提供它：spring-doc.cadn.net.cn

Javaspring-doc.cadn.net.cn
Kotlinspring-doc.cadn.net.cn

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

请注意，除了上述方法外，您还可以使用ReactiveJwtDecoder注解来模拟@MockBean bean本身。spring-doc.cadn.net.cn

测试不透明Tokens身份验证

类似 JWTs，不透明Tokens也需要一个授权服务器来验证其有效性，这可能会使测试更加困难。为了应对这一情况，Spring Security 提供了对不透明Tokens的测试支持。spring-doc.cadn.net.cn

假设你有一个控制器，从认证中获取了一个BearerTokenAuthentication对象：spring-doc.cadn.net.cn

Javaspring-doc.cadn.net.cn
Kotlinspring-doc.cadn.net.cn

@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方法来实现：spring-doc.cadn.net.cn

Javaspring-doc.cadn.net.cn
Kotlinspring-doc.cadn.net.cn

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

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

此示例配置了关联的MockHttpServletRequest，使用了一个包含简单BearerTokenAuthentication、一个OAuth2AuthenticatedPrincipal属性以及一个Map授权对象的Collection。spring-doc.cadn.net.cn

具体地，它包括一个带有键值对Map的：spring-doc.cadn.net.cn

Javaspring-doc.cadn.net.cn
Kotlinspring-doc.cadn.net.cn

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

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

它还包括一个包含单一权限Collection的SCOPE_read：spring-doc.cadn.net.cn

Javaspring-doc.cadn.net.cn
Kotlinspring-doc.cadn.net.cn

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 实例可供你的控制器方法使用。spring-doc.cadn.net.cn

配置权限

在许多情况下，您的方法可能受到过滤器或方法安全性的保护，并且需要您的Authentication具有某些授予的权限以允许该请求。spring-doc.cadn.net.cn

在这种情况中，您可以使用 `authorities()` 方法提供所需的授权权限：spring-doc.cadn.net.cn

Javaspring-doc.cadn.net.cn
Kotlinspring-doc.cadn.net.cn

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的情况下，我们还有属性。spring-doc.cadn.net.cn

假设，例如，您有一个user_id属性，该属性表示系统中的用户ID。您可以在控制器中如下访问它：spring-doc.cadn.net.cn

Javaspring-doc.cadn.net.cn
Kotlinspring-doc.cadn.net.cn

@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()方法指定该属性：spring-doc.cadn.net.cn

Javaspring-doc.cadn.net.cn
Kotlinspring-doc.cadn.net.cn

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

附加配置

您还可以使用其他方法进一步配置身份验证，这取决于控制器期望的数据。spring-doc.cadn.net.cn

一个这样的方法是principal(OAuth2AuthenticatedPrincipal)，你可以使用它来配置底层的OAuth2AuthenticatedPrincipal实例，该实例构成了BearerTokenAuthentication。spring-doc.cadn.net.cn

如果您希望：
spring-doc.cadn.net.cn

使用您自己的OAuth2AuthenticatedPrincipal实现，或
指定不同的主体名称

spring-doc.cadn.net.cn

例如，假设你的授权服务器在 user_name 属性而不是 sub 属性中发送主体名称。在这种情况下，你可以手动配置一个 OAuth2AuthenticatedPrincipal:spring-doc.cadn.net.cn

Javaspring-doc.cadn.net.cn
Kotlinspring-doc.cadn.net.cn

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()测试支持外，您还可以通过OpaqueTokenIntrospector注解模拟@MockBean bean本身。spring-doc.cadn.net.cn

测试 OAuth 2.0

测试 OIDC 登录

配置权限

配置声明

附加配置

测试 OAuth 2.0 登录

配置权限

配置声明

附加配置

测试 OAuth 2.0 客户端

配置作用域

附加配置

测试 JWT 身份验证

mockJwt() WebTestClientConfigurer

authentication()和WebTestClientConfigurer

测试不透明Tokens身份验证

配置权限

配置声明

附加配置

`mockJwt() WebTestClientConfigurer`

`authentication()`和`WebTestClientConfigurer`