测试 OAuth 2.0

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

考虑以下控制器示例：spring-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

@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

测试 OIDC 登录

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

例如，我们可以使用OidcUser方法告诉Spring Security 包含一个默认的SecurityMockServerConfigurers#oidcLogin：spring-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

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

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

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

它还包括一个包含单一权限Collection的SCOPE_read：spring-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

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

@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

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

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

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

spring-doc.cadn.net.cn

例如，假设你的授权服务器在user_name声明中发送主体名称而不是sub声明。 在这种情况下，你可以手动配置一个OidcUser:spring-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()

测试 OAuth 2.0 登录

与测试 OIDC 登录类似，测试 OAuth 2.0 登录同样面临一个类似的挑战：模拟授权流程。 由于这个原因，Spring Security 同样为非 OIDC 使用场景提供了测试支持。spring-doc.cadn.net.cn

假设我们有一个控制器，通过OAuth2User获取已登录用户：spring-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

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

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

它还包括一个包含单一权限Collection的SCOPE_read：spring-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

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

@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

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

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

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

spring-doc.cadn.net.cn

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

@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

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

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

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

它还包括一个带有OAuth2AccessToken范围的read：spring-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

@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

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

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

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

在这种情况下，你的测试可以使用@Autowired 注入 ReactiveClientRegistrationRepository 并查找测试所需的那个项：spring-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

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

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

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

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

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

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

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

@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

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

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

它还包括一个包含单一权限Collection的SCOPE_read：spring-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

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

@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

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

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