对于最新的稳定版本，请使用 Spring Security 6.5.3！spring-doc.cadn.net.cn

测试方法安全性

本节演示如何使用 Spring Security 的 Test 支持来测试基于方法的安全性。 我们首先介绍一个MessageService这需要用户经过身份验证才能访问它。spring-doc.cadn.net.cn

public class HelloMessageService implements MessageService {

	@PreAuthorize("authenticated")
	public String getMessage() {
		Authentication authentication = SecurityContextHolder.getContext()
			.getAuthentication();
		return "Hello " + authentication;
	}
}
class HelloMessageService : MessageService {
    @PreAuthorize("authenticated")
    fun getMessage(): String {
        val authentication: Authentication = SecurityContextHolder.getContext().authentication
        return "Hello $authentication"
    }
}

结果getMessage是一个对当前 Spring Security 说“Hello”的字符串Authentication. 输出示例如下所示。spring-doc.cadn.net.cn

Hello org.springframework.security.authentication.UsernamePasswordAuthenticationToken@ca25360: Principal: org.springframework.security.core.userdetails.User@36ebcb: Username: user; Password: [PROTECTED]; Enabled: true; AccountNonExpired: true; credentialsNonExpired: true; AccountNonLocked: true; Granted Authorities: ROLE_USER; Credentials: [PROTECTED]; Authenticated: true; Details: null; Granted Authorities: ROLE_USER

安全测试设置

在使用 Spring Security Test 支持之前，我们必须执行一些设置。下面可以看到一个示例：spring-doc.cadn.net.cn

@ExtendWith(SpringExtension.class) (1)
@ContextConfiguration (2)
public class WithMockUserTests {
@ExtendWith(SpringExtension.class)
@ContextConfiguration
class WithMockUserTests {

这是如何设置 Spring Security Test 的基本示例。亮点是：spring-doc.cadn.net.cn

1 @ExtendWith指示 spring-test 模块它应该创建一个ApplicationContext.有关更多信息，请参阅 Spring 参考。
2 @ContextConfiguration指示 spring-test 用于创建ApplicationContext.由于未指定配置，因此将尝试默认配置位置。这与使用现有的 Spring Test 支持没有什么不同。有关更多信息，请参阅 Spring 参考
Spring Security 使用WithSecurityContextTestExecutionListener这将确保我们的测试使用正确的用户运行。 它通过填充SecurityContextHolder在运行我们的测试之前。 如果您使用的是响应式方法安全性，您还需要ReactorContextTestExecutionListener填充ReactiveSecurityContextHolder. 测试完成后，它将清除SecurityContextHolder. 如果只需要 Spring Security 相关支持，可以将@ContextConfiguration跟@SecurityTestExecutionListeners.

请记住，我们添加了@PreAuthorize注释到我们的HelloMessageService因此，它需要经过身份验证的用户才能调用它。 如果我们运行以下测试，我们预计以下测试将通过：spring-doc.cadn.net.cn

@Test(expected = AuthenticationCredentialsNotFoundException.class)
public void getMessageUnauthenticated() {
	messageService.getMessage();
}
@Test(expected = AuthenticationCredentialsNotFoundException::class)
fun getMessageUnauthenticated() {
    messageService.getMessage()
}

@WithMockUser

问题是“我们如何才能最轻松地以特定用户身份运行测试？ 答案是使用@WithMockUser. 以下测试将以用户名“user”、密码“password”和角色“ROLE_USER”的用户身份运行。spring-doc.cadn.net.cn

@Test
@WithMockUser
public void getMessageWithMockUser() {
String message = messageService.getMessage();
...
}
@Test
@WithMockUser
fun getMessageWithMockUser() {
    val message: String = messageService.getMessage()
    // ...
}

具体来说，以下情况是正确的：spring-doc.cadn.net.cn

我们的例子很好，因为我们能够利用很多默认值。 如果我们想使用不同的用户名运行测试怎么办？ 以下测试将使用用户名“customUser”运行。同样，用户不需要实际存在。spring-doc.cadn.net.cn

@Test
@WithMockUser("customUsername")
public void getMessageWithMockUserCustomUsername() {
	String message = messageService.getMessage();
...
}
@Test
@WithMockUser("customUsername")
fun getMessageWithMockUserCustomUsername() {
    val message: String = messageService.getMessage()
    // ...
}

我们还可以轻松自定义角色。 例如，将使用用户名“admin”和角色“ROLE_USER”和“ROLE_ADMIN”调用此测试。spring-doc.cadn.net.cn

@Test
@WithMockUser(username="admin",roles={"USER","ADMIN"})
public void getMessageWithMockUserCustomUser() {
	String message = messageService.getMessage();
	...
}
@Test
@WithMockUser(username="admin",roles=["USER","ADMIN"])
fun getMessageWithMockUserCustomUser() {
    val message: String = messageService.getMessage()
    // ...
}

如果我们不希望值自动以 ROLE_ 为前缀，我们可以利用 authorities 属性。 例如，将使用用户名“admin”和权限“USER”和“ADMIN”调用此测试。spring-doc.cadn.net.cn

@Test
@WithMockUser(username = "admin", authorities = { "ADMIN", "USER" })
public void getMessageWithMockUserCustomAuthorities() {
	String message = messageService.getMessage();
	...
}
@Test
@WithMockUser(username = "admin", authorities = ["ADMIN", "USER"])
fun getMessageWithMockUserCustomUsername() {
    val message: String = messageService.getMessage()
    // ...
}

当然，将注释放在每个测试方法上可能有点乏味。 相反，我们可以将注释放在类级别，并且每个测试都将使用指定的用户。 例如，以下内容将使用用户名为“admin”、密码为“password”以及角色为“ROLE_USER”和“ROLE_ADMIN”的用户运行每个测试。spring-doc.cadn.net.cn

@ExtendWith(SpringExtension.class)
@ContextConfiguration
@WithMockUser(username="admin",roles={"USER","ADMIN"})
public class WithMockUserTests {
@ExtendWith(SpringExtension.class)
@ContextConfiguration
@WithMockUser(username="admin",roles=["USER","ADMIN"])
class WithMockUserTests {

如果您使用的是 JUnit 5 的@Nested测试支持，您还可以将注释放在封闭类上以应用于所有嵌套类。 例如，以下内容将使用用户名为“admin”、密码为“password”以及两种测试方法的角色为“ROLE_USER”和“ROLE_ADMIN”的用户运行每个测试。spring-doc.cadn.net.cn

@ExtendWith(SpringExtension.class)
@ContextConfiguration
@WithMockUser(username="admin",roles={"USER","ADMIN"})
public class WithMockUserTests {

	@Nested
	public class TestSuite1 {
		// ... all test methods use admin user
	}

	@Nested
	public class TestSuite2 {
		// ... all test methods use admin user
	}
}
@ExtendWith(SpringExtension::class)
@ContextConfiguration
@WithMockUser(username = "admin", roles = ["USER", "ADMIN"])
class WithMockUserTests {
    @Nested
    inner class TestSuite1 { // ... all test methods use admin user
    }

    @Nested
    inner class TestSuite2 { // ... all test methods use admin user
    }
}

默认情况下，SecurityContext在TestExecutionListener.beforeTestMethod事件。 这相当于 JUnit 的@Before. 您可以更改此设置，使其在TestExecutionListener.beforeTestExecution事件，该事件位于 JUnit 的@Before但在调用测试方法之前。spring-doc.cadn.net.cn

@WithMockUser(setupBefore = TestExecutionEvent.TEST_EXECUTION)

@WithAnonymousUser

用@WithAnonymousUser允许以匿名用户身份运行。 当您希望使用特定用户运行大部分测试，但又希望以匿名用户身份运行一些测试时，这尤其方便。 例如，以下内容将使用 @WithMockUser 和 anonymous 作为匿名用户运行 withMockUser1 和 withMockUser2。spring-doc.cadn.net.cn

@ExtendWith(SpringExtension.class)
@WithMockUser
public class WithUserClassLevelAuthenticationTests {

	@Test
	public void withMockUser1() {
	}

	@Test
	public void withMockUser2() {
	}

	@Test
	@WithAnonymousUser
	public void anonymous() throws Exception {
		// override default to run as anonymous user
	}
}
@ExtendWith(SpringExtension.class)
@WithMockUser
class WithUserClassLevelAuthenticationTests {
    @Test
    fun withMockUser1() {
    }

    @Test
    fun withMockUser2() {
    }

    @Test
    @WithAnonymousUser
    fun anonymous() {
        // override default to run as anonymous user
    }
}

默认情况下，SecurityContext在TestExecutionListener.beforeTestMethod事件。 这相当于 JUnit 的@Before. 您可以更改此设置，使其在TestExecutionListener.beforeTestExecution事件，该事件位于 JUnit 的@Before但在调用测试方法之前。spring-doc.cadn.net.cn

@WithAnonymousUser(setupBefore = TestExecutionEvent.TEST_EXECUTION)

@WithUserDetails

而@WithMockUser是一种非常方便的入门方式，它可能并非在所有情况下都有效。 例如，应用程序通常期望Authenticationprincipal 是特定类型的。 这样做是为了让应用程序可以将主体引用为自定义类型，并减少 Spring Security 上的耦合。spring-doc.cadn.net.cn

自定义主体通常由自定义UserDetailsService返回一个实现UserDetails和自定义类型。 对于这种情况，使用自定义UserDetailsService. 这正是@WithUserDetails确实。spring-doc.cadn.net.cn

假设我们有一个UserDetailsService公开为 bean，则将使用Authentication类型UsernamePasswordAuthenticationToken以及从UserDetailsService用户名为“user”。spring-doc.cadn.net.cn

@Test
@WithUserDetails
public void getMessageWithUserDetails() {
	String message = messageService.getMessage();
	...
}
@Test
@WithUserDetails
fun getMessageWithUserDetails() {
    val message: String = messageService.getMessage()
    // ...
}

我们还可以自定义用于从我们的UserDetailsService. 例如，此测试将使用从UserDetailsService用户名为“customUsername”。spring-doc.cadn.net.cn

@Test
@WithUserDetails("customUsername")
public void getMessageWithUserDetailsCustomUsername() {
	String message = messageService.getMessage();
	...
}
@Test
@WithUserDetails("customUsername")
fun getMessageWithUserDetailsCustomUsername() {
    val message: String = messageService.getMessage()
    // ...
}

我们还可以提供一个显式的 bean 名称来查找UserDetailsService. 例如，此测试将使用UserDetailsServicebean 名称为“myUserDetailsService”。spring-doc.cadn.net.cn

@Test
@WithUserDetails(value="customUsername", userDetailsServiceBeanName="myUserDetailsService")
public void getMessageWithUserDetailsServiceBeanName() {
	String message = messageService.getMessage();
	...
}
@Test
@WithUserDetails(value="customUsername", userDetailsServiceBeanName="myUserDetailsService")
fun getMessageWithUserDetailsServiceBeanName() {
    val message: String = messageService.getMessage()
    // ...
}

喜欢@WithMockUser我们还可以将注释放在类级别，以便每个测试都使用相同的用户。 然而，与@WithMockUser,@WithUserDetails需要用户存在。spring-doc.cadn.net.cn

默认情况下，SecurityContext在TestExecutionListener.beforeTestMethod事件。 这相当于 JUnit 的@Before. 您可以更改此设置，使其在TestExecutionListener.beforeTestExecution事件，该事件位于 JUnit 的@Before但在调用测试方法之前。spring-doc.cadn.net.cn

@WithUserDetails(setupBefore = TestExecutionEvent.TEST_EXECUTION)

@WithSecurityContext

我们已经看到@WithMockUser如果我们不使用自定义，这是一个很好的选择Authentication主要。 接下来我们发现@WithUserDetails将允许我们使用自定义UserDetailsService创建我们的Authenticationprincipal 但需要用户存在。 我们现在将看到一个允许最大灵活性的选项。spring-doc.cadn.net.cn

我们可以创建自己的注释，使用@WithSecurityContext创建任何SecurityContext我们想要。 例如，我们可以创建一个名为@WithMockCustomUser如下图所示：spring-doc.cadn.net.cn

@Retention(RetentionPolicy.RUNTIME)
@WithSecurityContext(factory = WithMockCustomUserSecurityContextFactory.class)
public @interface WithMockCustomUser {

	String username() default "rob";

	String name() default "Rob Winch";
}
@Retention(AnnotationRetention.RUNTIME)
@WithSecurityContext(factory = WithMockCustomUserSecurityContextFactory::class)
annotation class WithMockCustomUser(val username: String = "rob", val name: String = "Rob Winch")

你可以看到@WithMockCustomUser用@WithSecurityContext注解。 这就是向 Spring Security Test 支持发出的信号，表明我们打算创建一个SecurityContext用于测试。 这@WithSecurityContext注释要求我们指定一个SecurityContextFactory这将创建一个新的SecurityContext鉴于我们的@WithMockCustomUser注解。 您可以找到我们的WithMockCustomUserSecurityContextFactory实现如下：spring-doc.cadn.net.cn

public class WithMockCustomUserSecurityContextFactory
	implements WithSecurityContextFactory<WithMockCustomUser> {
	@Override
	public SecurityContext createSecurityContext(WithMockCustomUser customUser) {
		SecurityContext context = SecurityContextHolder.createEmptyContext();

		CustomUserDetails principal =
			new CustomUserDetails(customUser.name(), customUser.username());
		Authentication auth =
			UsernamePasswordAuthenticationToken.authenticated(principal, "password", principal.getAuthorities());
		context.setAuthentication(auth);
		return context;
	}
}
class WithMockCustomUserSecurityContextFactory : WithSecurityContextFactory<WithMockCustomUser> {
    override fun createSecurityContext(customUser: WithMockCustomUser): SecurityContext {
        val context = SecurityContextHolder.createEmptyContext()
        val principal = CustomUserDetails(customUser.name, customUser.username)
        val auth: Authentication =
            UsernamePasswordAuthenticationToken(principal, "password", principal.authorities)
        context.authentication = auth
        return context
    }
}

我们现在可以使用我们的新注释和 Spring Security 的WithSecurityContextTestExecutionListener将确保我们的SecurityContext已适当填充。spring-doc.cadn.net.cn

创建自己的时WithSecurityContextFactory实现，很高兴知道它们可以使用标准的 Spring 注释进行注释。 例如，WithUserDetailsSecurityContextFactory使用@Autowired注释来获取UserDetailsService:spring-doc.cadn.net.cn

final class WithUserDetailsSecurityContextFactory
	implements WithSecurityContextFactory<WithUserDetails> {

	private UserDetailsService userDetailsService;

	@Autowired
	public WithUserDetailsSecurityContextFactory(UserDetailsService userDetailsService) {
		this.userDetailsService = userDetailsService;
	}

	public SecurityContext createSecurityContext(WithUserDetails withUser) {
		String username = withUser.value();
		Assert.hasLength(username, "value() must be non-empty String");
		UserDetails principal = userDetailsService.loadUserByUsername(username);
		Authentication authentication = UsernamePasswordAuthenticationToken.authenticated(principal, principal.getPassword(), principal.getAuthorities());
		SecurityContext context = SecurityContextHolder.createEmptyContext();
		context.setAuthentication(authentication);
		return context;
	}
}
class WithUserDetailsSecurityContextFactory @Autowired constructor(private val userDetailsService: UserDetailsService) :
    WithSecurityContextFactory<WithUserDetails> {
    override fun createSecurityContext(withUser: WithUserDetails): SecurityContext {
        val username: String = withUser.value
        Assert.hasLength(username, "value() must be non-empty String")
        val principal = userDetailsService.loadUserByUsername(username)
        val authentication: Authentication =
            UsernamePasswordAuthenticationToken(principal, principal.password, principal.authorities)
        val context = SecurityContextHolder.createEmptyContext()
        context.authentication = authentication
        return context
    }
}

默认情况下，SecurityContext在TestExecutionListener.beforeTestMethod事件。 这相当于 JUnit 的@Before. 您可以更改此设置，使其在TestExecutionListener.beforeTestExecution事件，该事件位于 JUnit 的@Before但在调用测试方法之前。spring-doc.cadn.net.cn

@WithSecurityContext(setupBefore = TestExecutionEvent.TEST_EXECUTION)

测试元注释

如果经常在测试中重复使用同一用户，则必须重复指定属性是不理想的。 例如，如果有许多测试与用户名为“admin”且角色ROLE_USER和ROLE_ADMIN你必须写：spring-doc.cadn.net.cn

@WithMockUser(username="admin",roles={"USER","ADMIN"})
@WithMockUser(username="admin",roles=["USER","ADMIN"])

我们可以使用元注释，而不是到处重复此作。 例如，我们可以创建一个名为WithMockAdmin:spring-doc.cadn.net.cn

@Retention(RetentionPolicy.RUNTIME)
@WithMockUser(value="rob",roles="ADMIN")
public @interface WithMockAdmin { }
@Retention(AnnotationRetention.RUNTIME)
@WithMockUser(value = "rob", roles = ["ADMIN"])
annotation class WithMockAdmin

现在我们可以使用@WithMockAdmin与更冗长的方式相同@WithMockUser.spring-doc.cadn.net.cn

元注解适用于上述任何测试注解。 例如，这意味着我们可以为@WithUserDetails("admin")也。spring-doc.cadn.net.cn