Spring Test & Security：如何模拟身份验证？

寻找答案我找不到任何既简单又灵活的方法，然后我找到了Spring Security Reference，我意识到有近乎完美的解决方案。 AOP 解决方案通常是最适合测试的解决方案，Spring 为它提供了 @WithMockUser、@WithUserDetails 和 @WithSecurityContext，在这个工件中：

<dependency>
    <groupId>org.springframework.security</groupId>
    <artifactId>spring-security-test</artifactId>
    <version>4.2.2.RELEASE</version>
    <scope>test</scope>
</dependency>

在大多数情况下，@WithUserDetails 收集了我需要的灵活性和功能。

@WithUserDetails 是如何工作的？

基本上，您只需要创建一个自定义 UserDetailsService，其中包含您想要测试的所有可能的用户配置文件。例如

@TestConfiguration
public class SpringSecurityWebAuxTestConfig {

    @Bean
    @Primary
    public UserDetailsService userDetailsService() {
        User basicUser = new UserImpl("Basic User", "user@company.com", "password");
        UserActive basicActiveUser = new UserActive(basicUser, Arrays.asList(
                new SimpleGrantedAuthority("ROLE_USER"),
                new SimpleGrantedAuthority("PERM_FOO_READ")
        ));

        User managerUser = new UserImpl("Manager User", "manager@company.com", "password");
        UserActive managerActiveUser = new UserActive(managerUser, Arrays.asList(
                new SimpleGrantedAuthority("ROLE_MANAGER"),
                new SimpleGrantedAuthority("PERM_FOO_READ"),
                new SimpleGrantedAuthority("PERM_FOO_WRITE"),
                new SimpleGrantedAuthority("PERM_FOO_MANAGE")
        ));

        return new InMemoryUserDetailsManager(Arrays.asList(
                basicActiveUser, managerActiveUser
        ));
    }
}

现在我们的用户已经准备好了，想象一下我们要测试这个控制器函数的访问控制：

@RestController
@RequestMapping("/foo")
public class FooController {

    @Secured("ROLE_MANAGER")
    @GetMapping("/salute")
    public String saluteYourManager(@AuthenticationPrincipal User activeUser)
    {
        return String.format("Hi %s. Foo salutes you!", activeUser.getUsername());
    }
}

这里我们有一个 get mapped function 到路由 /foo/salute 并且我们正在使用 @Secured 注释测试基于角色的安全性，尽管您可以测试 @PreAuthorize和 @PostAuthorize 也是如此。让我们创建两个测试，一个检查有效用户是否可以看到这个敬礼响应，另一个检查它是否真的被禁止。

@RunWith(SpringRunner.class)
@SpringBootTest(
        webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT,
        classes = SpringSecurityWebAuxTestConfig.class
)
@AutoConfigureMockMvc
public class WebApplicationSecurityTest {

    @Autowired
    private MockMvc mockMvc;

    @Test
    @WithUserDetails("manager@company.com")
    public void givenManagerUser_whenGetFooSalute_thenOk() throws Exception
    {
        mockMvc.perform(MockMvcRequestBuilders.get("/foo/salute")
                .accept(MediaType.ALL))
                .andExpect(status().isOk())
                .andExpect(content().string(containsString("manager@company.com")));
    }

    @Test
    @WithUserDetails("user@company.com")
    public void givenBasicUser_whenGetFooSalute_thenForbidden() throws Exception
    {
        mockMvc.perform(MockMvcRequestBuilders.get("/foo/salute")
                .accept(MediaType.ALL))
                .andExpect(status().isForbidden());
    }
}

如您所见，我们导入了 SpringSecurityWebAuxTestConfig 来为我们的用户提供测试。每一个都在其对应的测试用例上使用，只需使用简单的注释，减少代码和复杂性。

更好地使用 @WithMockUser 以获得更简单的基于角色的安全性

如您所见，@WithUserDetails 具有大多数应用程序所需的所有灵活性。它允许您使用具有任何 GrantedAuthority 的自定义用户，例如角色或权限。但是，如果您只是使用角色，则测试会更加容易，并且您可以避免构建自定义 UserDetailsService。在这种情况下，使用 @WithMockUser 指定用户、密码和角色的简单组合。

@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
@WithSecurityContext(
    factory = WithMockUserSecurityContextFactory.class
)
public @interface WithMockUser {
    String value() default "user";

    String username() default "";

    String[] roles() default {"USER"};

    String password() default "password";
}

注释为非常基本的用户定义了默认值。在我们的例子中，我们正在测试的路由只要求经过身份验证的用户是管理员，我们可以使用 SpringSecurityWebAuxTestConfig 退出并执行此操作。

@Test
@WithMockUser(roles = "MANAGER")
public void givenManagerUser_whenGetFooSalute_thenOk() throws Exception
{
    mockMvc.perform(MockMvcRequestBuilders.get("/foo/salute")
            .accept(MediaType.ALL))
            .andExpect(status().isOk())
            .andExpect(content().string(containsString("user")));
}

请注意，现在我们得到的是 @WithMockUser 提供的默认值，而不是用户 manager@company.com：user;但这并不重要，因为我们真正关心的是他的角色：ROLE_MANAGER。

结论

正如您看到的 @WithUserDetails 和 @WithMockUser 等注释，我们可以在不同的经过身份验证的用户场景之间切换，而无需构建与我们的架构疏远的类，而只是为了进行简单的测试。它还建议您了解 @WithSecurityContext 如何工作以获得更大的灵活性。

---

从 Spring 4.0+ 开始，最好的解决方案是使用 @WithMockUser 注释测试方法

@Test
@WithMockUser(username = "user1", password = "pwd", roles = "USER")
public void mytest1() throws Exception {
    mockMvc.perform(get("/someApi"))
        .andExpect(status().isOk());
}

请记住将以下依赖项添加到您的项目中

'org.springframework.security:spring-security-test:4.2.3.RELEASE'

---

事实证明，作为 Spring Security 过滤器链的一部分的 SecurityContextPersistenceFilter 总是重置我的 SecurityContext，我设置它调用 SecurityContextHolder.getContext().setAuthentication(principal)（或使用 .principal(principal) 方法）。此过滤器将 SecurityContextHolder 中的 SecurityContext 设置为 SecurityContextRepository OVERWRITING 中的 SecurityContext，这是我之前设置的。默认情况下，存储库是 HttpSessionSecurityContextRepository。 HttpSessionSecurityContextRepository 检查给定的 HttpRequest 并尝试访问相应的 HttpSession。如果存在，它将尝试从 HttpSession 读取 SecurityContext。如果失败，存储库会生成一个空的 SecurityContext。

因此，我的解决方案是将 HttpSession 与包含 SecurityContext 的请求一起传递：

import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;

import org.junit.Test;
import org.springframework.mock.web.MockHttpSession;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.web.context.HttpSessionSecurityContextRepository;

import eu.ubicon.webapp.test.WebappTestEnvironment;

public class Test extends WebappTestEnvironment {

    public static class MockSecurityContext implements SecurityContext {

        private static final long serialVersionUID = -1386535243513362694L;

        private Authentication authentication;

        public MockSecurityContext(Authentication authentication) {
            this.authentication = authentication;
        }

        @Override
        public Authentication getAuthentication() {
            return this.authentication;
        }

        @Override
        public void setAuthentication(Authentication authentication) {
            this.authentication = authentication;
        }
    }

    @Test
    public void signedIn() throws Exception {

        UsernamePasswordAuthenticationToken principal = 
                this.getPrincipal("test1");

        MockHttpSession session = new MockHttpSession();
        session.setAttribute(
                HttpSessionSecurityContextRepository.SPRING_SECURITY_CONTEXT_KEY, 
                new MockSecurityContext(principal));


        super.mockMvc
            .perform(
                    get("/api/v1/resource/test")
                    .session(session))
            .andExpect(status().isOk());
    }
}

---

在 pom.xml 中添加：

    <dependency>
        <groupId>org.springframework.security</groupId>
        <artifactId>spring-security-test</artifactId>
        <version>4.0.0.RC2</version>
    </dependency>

并使用 org.springframework.security.test.web.servlet.request.SecurityMockMvcRequestPostProcessors 进行授权请求。请参阅 https://github.com/rwinch/spring-security-test-blog (https://jira.spring.io/browse/SEC-2592) 中的示例用法。

更新：

4.0.0.RC2 适用于 spring-security 3.x。对于 spring-security 4 spring-security-test 成为 spring-security 的一部分（http://docs.spring.io/spring-security/site/docs/4.0.x/reference/htmlsingle/#test，版本相同）。

设置已更改：http://docs.spring.io/spring-security/site/docs/4.0.x/reference/htmlsingle/#test-mockmvc

public void setup() {
    mvc = MockMvcBuilders
            .webAppContextSetup(context)
            .apply(springSecurity())  
            .build();
}

基本身份验证示例：http://docs.spring.io/spring-security/site/docs/4.0.x/reference/htmlsingle/#testing-http-basic-authentication。

---

这是一个示例，供那些想要使用 Base64 基本身份验证测试 Spring MockMvc 安全配置的人使用。

String basicDigestHeaderValue = "Basic " + new String(Base64.encodeBase64(("<username>:<password>").getBytes()));
this.mockMvc.perform(get("</get/url>").header("Authorization", basicDigestHeaderValue).accept(MediaType.APPLICATION_JSON)).andExpect(status().isOk());

Maven 依赖

    <dependency>
        <groupId>commons-codec</groupId>
        <artifactId>commons-codec</artifactId>
        <version>1.3</version>
    </dependency>

---

简短的回答：

@Autowired
private WebApplicationContext webApplicationContext;

@Autowired
private Filter springSecurityFilterChain;

@Before
public void setUp() throws Exception {
    final MockHttpServletRequestBuilder defaultRequestBuilder = get("/dummy-path");
    this.mockMvc = MockMvcBuilders.webAppContextSetup(this.webApplicationContext)
            .defaultRequest(defaultRequestBuilder)
            .alwaysDo(result -> setSessionBackOnRequestBuilder(defaultRequestBuilder, result.getRequest()))
            .apply(springSecurity(springSecurityFilterChain))
            .build();
}

private MockHttpServletRequest setSessionBackOnRequestBuilder(final MockHttpServletRequestBuilder requestBuilder,
                                                             final MockHttpServletRequest request) {
    requestBuilder.session((MockHttpSession) request.getSession());
    return request;
}

从 spring security test 执行 formLogin 后，您的每个请求都将被自动调用为登录用户。

长答案：

检查此解决方案（答案是春季 4）：How to login a user with spring 3.2 new mvc testing

---

避免在测试中使用 SecurityContextHolder 的选项：

选项 1：使用模拟 - 我的意思是使用一些模拟库模拟 SecurityContextHolder - 例如 EasyMock

选项 2：在您的代码中的某些服务中包装调用 SecurityContextHolder.get... - 例如在 SecurityServiceImpl 中使用实现 SecurityService 接口的 getCurrentPrincipal 方法，然后在您的测试中，您可以简单地创建此接口的模拟实现，该接口无需访问即可返回所需的主体到 SecurityContextHolder。

---

虽然很晚的答案。但这对我有用，并且可能有用。

在使用 Spring Security 和 mockMvc 时，您只需使用 @WithMockUser 注释，就像提到的其他注释一样。

Spring security 还提供了另一个名为 @WithAnonymousUser 的注解，用于测试未经身份验证的请求。但是，您应该在这里小心。你会期待 401，但默认情况下我得到 403 Forbidden Error。在实际场景中，当您运行实际服务时，它会被重定向，最终您会得到正确的 401 响应代码。匿名请求使用此注解。

您也可以考虑省略注释并简单地保持未经授权。但这通常会引发正确的异常（如 AuthenticationException），但如果处理正确（如果您使用自定义处理程序），您将获得正确的状态代码。我曾经为此得到500。所以寻找调试器中引发的异常，检查是否处理正确并返回正确的状态码。

---

在您的测试包上创建一个类 TestUserDetailsImpl：

@Service
@Primary
@Profile("test")
public class TestUserDetailsImpl implements UserDetailsService {
    public static final String API_USER = "apiuser@example.com";

    private User getAdminUser() {
        User user = new User();
        user.setUsername(API_USER);

        SimpleGrantedAuthority role = new SimpleGrantedAuthority("ROLE_API_USER");
        user.setAuthorities(Collections.singletonList(role));

        return user;
    }

    @Override
    public UserDetails loadUserByUsername(String username) 
                                         throws UsernameNotFoundException {
        if (Objects.equals(username, ADMIN_USERNAME))
            return getAdminUser();
        throw new UsernameNotFoundException(username);
    }
}

休息端点：

@GetMapping("/invoice")
@Secured("ROLE_API_USER")
public Page<InvoiceDTO> getInvoices(){
   ...
}

测试端点：

@Test
@WithUserDetails("apiuser@example.com")
public void testApi() throws Exception {
     ...
}

---

当使用 MockMvcBuilders.webAppContextSetup(wac).addFilters(...) 而不是 springSecurityFilterChain（更具体地说是 SecurityContextPersistenceFilter）将接管并删除 @WithMockUser 准备的 SecurityContext（很傻）；发生这种情况是因为 SecurityContextPersistenceFilter 试图从 HttpSession 中“恢复”SecurityContext，但没有找到。好吧，使用下面定义的这个简单的 AutoStoreSecurityContextHttpFilter，它将负责将 @WithMockUser 准备好的 SecurityContext 放入 HttpSession，以便以后 SecurityContextPersistenceFilter 能够找到它。

@ContextConfiguration(...) // the issue doesn't occur when using @SpringBootTest
public class SomeTest {
    @Autowired
    private Filter springSecurityFilterChain;
    private MockMvc mockMvc;

    @BeforeEach
    void setup(WebApplicationContext wac) {
        this.mockMvc = MockMvcBuilders.webAppContextSetup(wac)
                .addFilters(new AutoStoreSecurityContextHttpFilter(), springSecurityFilterChain).build();
    }

    @WithMockUser
    @Test
    void allowAccessToAuthenticated() {
        ...
    }
}

// don't use this Filter in production because it's only intended for tests, to solve the 
// @WithMockUser & springSecurityFilterChain (more specifically SecurityContextPersistenceFilter) "misunderstandings"
public class AutoStoreSecurityContextHttpFilter extends HttpFilter {
    protected void doFilter(HttpServletRequest req, HttpServletResponse res, FilterChain chain) throws IOException, ServletException {
        req.getSession().setAttribute(HttpSessionSecurityContextRepository.SPRING_SECURITY_CONTEXT_KEY, SecurityContextHolder.getContext());
        super.doFilter(req, res, chain);
    }
}

---