测试 OAuth 2.0

在 OAuth 2.0 中，前面介绍的相同原则仍然适用：最终取决于您的测试方法希望在 SecurityContextHolder 中有什么。

例如，对于一个类似这样的控制器

Java
Kotlin

@GetMapping("/endpoint")
public String foo(Principal user) {
    return user.getName();
}

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

它没有与 OAuth2 相关的任何内容，因此您可能只需要简单地使用 @WithMockUser 就可以了。

但是，在您的控制器绑定到 Spring Security 的 OAuth 2.0 支持的某些方面的情况下，如下所示

Java
Kotlin

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

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

那么 Spring Security 的测试支持就派上用场了。

使用 Spring MVC Test 测试上述方法需要模拟某种授权服务器的授权流程。这当然是一项艰巨的任务，这就是为什么 Spring Security 附带支持来删除此样板代码的原因。

例如，我们可以告诉 Spring Security 使用 oidcLogin RequestPostProcessor 包含一个默认的 OidcUser，如下所示

Java
Kotlin

mvc
    .perform(get("/endpoint").with(oidcLogin()));

mvc.get("/endpoint") {
    with(oidcLogin())
}

这将对关联的 MockHttpServletRequest 配置一个 OidcUser，其中包括一个简单的 OidcIdToken、OidcUserInfo 和已授予的权限的 Collection。

具体来说，它将包含一个 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 的一个简单实例，该实例存储在模拟 OAuth2AuthorizedClientRepository 中。如果您的测试使用 @RegisteredOAuth2AuthorizedClient 注释，这会很方便。

在许多情况下，您的方法受过滤器或方法安全保护，并且需要您的 Authentication 具有某些已授予的权限才能允许该请求。

在这种情况下，您可以使用 authorities() 方法提供您需要的已授予的权限

Java
Kotlin

mvc
    .perform(get("/endpoint")
        .with(oidcLogin()
            .authorities(new SimpleGrantedAuthority("SCOPE_message:read"))
        )
    );

mvc.get("/endpoint") {
    with(oidcLogin()
        .authorities(SimpleGrantedAuthority("SCOPE_message:read"))
    )
}

虽然已授予的权限在所有 Spring Security 中都非常常见，但我们也有 OAuth 2.0 中的声明。

例如，假设您有一个 user_id 声明，表示您系统中的用户 ID。您可以在控制器中像这样访问它

Java
Kotlin

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

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

在这种情况下，您需要使用 idToken() 方法指定该声明

Java
Kotlin

mvc
    .perform(get("/endpoint")
        .with(oidcLogin()
                .idToken(token -> token.claim("user_id", "1234"))
        )
    );

mvc.get("/endpoint") {
    with(oidcLogin()
        .idToken {
            it.claim("user_id", "1234")
        }
    )
}

因为 OidcUser 从 OidcIdToken 收集其声明。

还有其他方法可用于进一步配置身份验证；这取决于您的控制器期望什么数据

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

如果您：1. 有自己的 OidcUser 实现，或者 2. 需要更改名称属性，那么最后一个非常方便

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

mvc
    .perform(get("/endpoint")
        .with(oidcLogin().oidcUser(oidcUser))
    );

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

mvc.get("/endpoint") {
    with(oidcLogin().oidcUser(oidcUser))
}

与测试 OIDC 登录一样，测试 OAuth 2.0 登录也面临着模拟授权流程的类似挑战。因此，Spring Security 还为非 OIDC 使用案例提供测试支持。

假设我们有一个控制器，它将登录用户作为 OAuth2User 获取

Java
Kotlin

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

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

在这种情况下，我们可以告诉 Spring Security 使用 oauth2Login RequestPostProcessor 包含一个默认 OAuth2User，如下所示

Java
Kotlin

mvc
    .perform(get("/endpoint").with(oauth2Login()));

mvc.get("/endpoint") {
    with(oauth2Login())
}

这将使用一个 OAuth2User 配置关联的 MockHttpServletRequest，其中包括一个简单的属性 Map 和已授予的权限 Collection。

具体来说，它将包含一个 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 的简单实例，该实例存储在模拟的 OAuth2AuthorizedClientRepository 中。如果您的测试使用 @RegisteredOAuth2AuthorizedClient 注释，这会很方便。

在许多情况下，您的方法受过滤器或方法安全保护，并且需要您的 Authentication 具有某些已授予的权限才能允许该请求。

在这种情况下，您可以使用 authorities() 方法提供您需要的已授予的权限

Java
Kotlin

mvc
    .perform(get("/endpoint")
        .with(oauth2Login()
            .authorities(new SimpleGrantedAuthority("SCOPE_message:read"))
        )
    );

mvc.get("/endpoint") {
    with(oauth2Login()
        .authorities(SimpleGrantedAuthority("SCOPE_message:read"))
    )
}

虽然已授予的权限在所有 Spring Security 中都非常常见，但我们也有 OAuth 2.0 中的声明。

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

Java
Kotlin

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

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

在这种情况下，您需要使用 attributes() 方法指定该属性

Java
Kotlin

mvc
    .perform(get("/endpoint")
        .with(oauth2Login()
                .attributes(attrs -> attrs.put("user_id", "1234"))
        )
    );

mvc.get("/endpoint") {
    with(oauth2Login()
        .attributes { attrs -> attrs["user_id"] = "1234" }
    )
}

还有其他方法可用于进一步配置身份验证；这取决于您的控制器期望什么数据

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

如果您：1. 有自己实现的 OAuth2User，或 2. 需要更改名称属性，那么最后一个会很方便

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

Java
Kotlin

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

mvc
    .perform(get("/endpoint")
        .with(oauth2Login().oauth2User(oauth2User))
    );

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

mvc.get("/endpoint") {
    with(oauth2Login().oauth2User(oauth2User))
}

测试 OAuth 2.0 客户端

无论您的用户如何进行身份验证，您可能还有其他令牌和客户端注册，它们在您正在测试的请求中发挥作用。例如，您的控制器可能依赖于客户端凭据授予，以获取与用户完全不关联的令牌

Java
Kotlin

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

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

模拟与授权服务器的这种握手可能很麻烦。相反，您可以使用 oauth2Client RequestPostProcessor 将 OAuth2AuthorizedClient 添加到模拟的 OAuth2AuthorizedClientRepository 中

Java
Kotlin

mvc
    .perform(get("/endpoint").with(oauth2Client("my-app")));

mvc.get("/endpoint") {
    with(
        oauth2Client("my-app")
    )
}

这将创建一个具有简单 ClientRegistration、OAuth2AccessToken 和资源所有者名称的 OAuth2AuthorizedClient。

具体来说，它将包含一个客户端 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 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)
            .block();
    }
    // ...
}

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

那么您可以使用 accessToken() 方法配置范围

Java
Kotlin

mvc
    .perform(get("/endpoint")
        .with(oauth2Client("my-app")
            .accessToken(new OAuth2AccessToken(BEARER, "token", null, null, Collections.singleton("message:read"))))
        )
    );

mvc.get("/endpoint") {
    with(oauth2Client("my-app")
            .accessToken(OAuth2AccessToken(BEARER, "token", null, null, Collections.singleton("message:read")))
    )
}

其他配置

还有其他方法可用于进一步配置身份验证；这取决于您的控制器期望什么数据

principalName(String) - 用于配置资源所有者名称
clientRegistration(Consumer<ClientRegistration.Builder>) - 用于配置关联的 ClientRegistration
clientRegistration(ClientRegistration) - 用于配置完整的 ClientRegistration

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

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

在这种情况下，你的测试可以自动装配 ClientRegistrationRepository 并查找测试所需的那个

Java
Kotlin

@Autowired
ClientRegistrationRepository clientRegistrationRepository;

// ...

mvc
    .perform(get("/endpoint")
        .with(oauth2Client()
            .clientRegistration(this.clientRegistrationRepository.findByRegistrationId("facebook"))));

@Autowired
lateinit var clientRegistrationRepository: ClientRegistrationRepository

// ...

mvc.get("/endpoint") {
    with(oauth2Client("my-app")
        .clientRegistration(clientRegistrationRepository.findByRegistrationId("facebook"))
    )
}

测试 JWT 认证

要在资源服务器上进行授权请求，你需要一个承载令牌。

如果你的资源服务器针对 JWT 进行配置，则这意味着承载令牌需要根据 JWT 规范进行签名并编码。所有这些都可能非常令人生畏，尤其当这不是你的测试重点时。

幸运的是，有许多简单的方法可以克服这个困难，并允许你的测试专注于授权而不是表示承载令牌。我们现在来看其中两个

`jwt() RequestPostProcessor`

第一种方法是通过 jwt RequestPostProcessor。最简单的方法如下所示

Java
Kotlin

mvc
    .perform(get("/endpoint").with(jwt()));

mvc.get("/endpoint") {
    with(jwt())
}

这将创建一个模拟 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

mvc
    .perform(get("/endpoint")
        .with(jwt().jwt(jwt -> jwt.header("kid", "one").claim("iss", "https://idp.example.org"))));

mvc.get("/endpoint") {
    with(
        jwt().jwt { jwt -> jwt.header("kid", "one").claim("iss", "https://idp.example.org") }
    )
}

Java
Kotlin

mvc
    .perform(get("/endpoint")
        .with(jwt().jwt(jwt -> jwt.claims(claims -> claims.remove("scope")))));

mvc.get("/endpoint") {
    with(
        jwt().jwt { jwt -> jwt.claims { claims -> claims.remove("scope") } }
    )
}

scope 和 scp 声明在此处的处理方式与在普通承载令牌请求中的处理方式相同。但是，只需提供测试所需的 GrantedAuthority 实例列表即可覆盖此项

Java
Kotlin

mvc
    .perform(get("/endpoint")
        .with(jwt().authorities(new SimpleGrantedAuthority("SCOPE_messages"))));

mvc.get("/endpoint") {
    with(
        jwt().authorities(SimpleGrantedAuthority("SCOPE_messages"))
    )
}

或者，如果你有一个自定义的 Jwt 到 Collection<GrantedAuthority> 转换器，你也可以使用它来派生权限

Java
Kotlin

mvc
    .perform(get("/endpoint")
        .with(jwt().authorities(new MyConverter())));

mvc.get("/endpoint") {
    with(
        jwt().authorities(MyConverter())
    )
}

你还可以指定一个完整的 Jwt，其中 Jwt.Builder 非常方便

Java
Kotlin

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

mvc
    .perform(get("/endpoint")
        .with(jwt().jwt(jwt)));

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

mvc.get("/endpoint") {
    with(
        jwt().jwt(jwt)
    )
}

`authentication()` `RequestPostProcessor`

第二种方法是使用 authentication() RequestPostProcessor。从本质上讲，你可以实例化自己的 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);

mvc
    .perform(get("/endpoint")
        .with(authentication(token)));

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)

mvc.get("/endpoint") {
    with(
        authentication(token)
    )
}

请注意，作为这些方法的替代方法，您还可以使用 @MockBean 注解来模拟 JwtDecoder bean 本身。

测试不透明令牌身份验证

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

假设我们有一个控制器，它将身份验证检索为 BearerTokenAuthentication

Java
Kotlin

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

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

在这种情况下，我们可以告诉 Spring Security 使用 opaqueToken RequestPostProcessor 方法包含一个默认的 BearerTokenAuthentication，如下所示

Java
Kotlin

mvc
    .perform(get("/endpoint").with(opaqueToken()));

mvc.get("/endpoint") {
    with(opaqueToken())
}

这将对关联的 MockHttpServletRequest 进行配置，其中包含一个 BearerTokenAuthentication，该 BearerTokenAuthentication 包含一个简单的 OAuth2AuthenticatedPrincipal、属性的 Map 以及已授予权限的 Collection。

具体来说，它将包含一个 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

mvc
    .perform(get("/endpoint")
        .with(opaqueToken()
            .authorities(new SimpleGrantedAuthority("SCOPE_message:read"))
        )
    );

mvc.get("/endpoint") {
    with(opaqueToken()
        .authorities(SimpleGrantedAuthority("SCOPE_message:read"))
    )
}

配置声明

虽然已授予的权限在 Spring Security 中非常常见，但我们也有 OAuth 2.0 中的属性。

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

Java
Kotlin

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

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

在这种情况下，您需要使用 attributes() 方法指定该属性

Java
Kotlin

mvc
    .perform(get("/endpoint")
        .with(opaqueToken()
                .attributes(attrs -> attrs.put("user_id", "1234"))
        )
    );

mvc.get("/endpoint") {
    with(opaqueToken()
        .attributes { attrs -> attrs["user_id"] = "1234" }
    )
}

其他配置

还有其他方法可用于进一步配置身份验证；这完全取决于您的控制器期望的数据。

其中之一是 principal(OAuth2AuthenticatedPrincipal)，您可以使用它来配置构成 BearerTokenAuthentication 基础的完整 OAuth2AuthenticatedPrincipal 实例

如果您：1. 有自己的 OAuth2AuthenticatedPrincipal 实现，或者 2. 想指定不同的主体名称，这会很方便

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

mvc
    .perform(get("/endpoint")
        .with(opaqueToken().principal(principal))
    );

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

mvc.get("/endpoint") {
    with(opaqueToken().principal(principal))
}

请注意，作为使用 opaqueToken() 测试支持的替代方法，您还可以使用 @MockBean 注解模拟 OpaqueTokenIntrospector bean 本身。

测试 OAuth 2.0

测试 OIDC 登录

配置权限

配置声明

其他配置

测试 OAuth 2.0 登录

配置权限

配置声明

其他配置

测试 OAuth 2.0 客户端

配置范围

其他配置

测试 JWT 认证

jwt() RequestPostProcessor

authentication() RequestPostProcessor

测试不透明令牌身份验证

配置权限

配置声明

其他配置

`jwt() RequestPostProcessor`

`authentication()` `RequestPostProcessor`