测试 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 提供支持以消除此样板代码的原因。

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

Java
Kotlin

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

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

这将配置关联的 MockHttpServletRequest，其中包含一个 OidcUser，该 OidcUser 包含一个简单的 OidcIdToken、OidcUserInfo 和一组授权。

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

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

Java
Kotlin

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

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

这将配置关联的 MockHttpServletRequest，其中包含一个 OAuth2User，该 OAuth2User 包含一个简单的属性 Map 和一组授予权限。

具体来说，它将包含一个键/值对为 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")
    )
}

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

在这种情况下，我们可以通过 opaqueToken RequestPostProcessor 方法告诉 Spring Security 包含一个默认的 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`