Seaching dla odpowiedzi nie mogłem znaleźć żadnego, aby być łatwym i elastycznym w tym samym czasie, potem znalazłem Spring Security Reference i zdałem sobie sprawę, że są blisko idealnych rozwiązań. Rozwiązania AOP często są najlepsze do testowania, A Spring zapewnia mu @WithMockUser, @WithUserDetails i @WithSecurityContext, w tym artefakcie:

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

W większości przypadków, @WithUserDetails gromadzi elastyczność i moc, której potrzebuję.

Jak działa @ WithUserDetails?

W zasadzie wystarczy stworzyć custom UserDetailsService ze wszystkimi możliwymi profilami użytkowników, które chcesz przetestować. E. g

@TestConfiguration
public class SpringSecurityWebAuxTestConfig {

    @Bean
    @Primary
    public UserDetailsService userDetailsService() {
        User basicUser = new UserImpl("Basic User", "[email protected]", "password");
        UserActive basicActiveUser = new UserActive(basicUser, Arrays.asList(
                new SimpleGrantedAuthority("ROLE_USER"),
                new SimpleGrantedAuthority("PERM_FOO_READ")
        ));

        User managerUser = new UserImpl("Manager User", "[email protected]", "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
        ));
    }
}

Teraz mamy naszych użytkowników gotowych, więc wyobraź sobie, że chcemy przetestować kontrolę dostępu do tej funkcji kontrolera: {]}

@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());
    }
}

Tutaj mamy get mapped function do trasy /foo/salute i testujemy zabezpieczenia oparte na rolach z adnotacją @Secured, chociaż możesz również przetestować @PreAuthorize i @PostAuthorize. Stwórzmy dwa testy, jeden, aby sprawdzić, czy prawidłowy użytkownik może to zobaczyć odpowiedź i drugi, aby sprawdzić, czy jest to rzeczywiście zabronione.

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

    @Autowired
    private MockMvc mockMvc;

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

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

Jak widzisz zaimportowaliśmy SpringSecurityWebAuxTestConfig, aby zapewnić naszym użytkownikom testy. Każdy z nich został użyty w odpowiednim przypadku testowym poprzez użycie prostej adnotacji, zmniejszając kod i złożoność.

Lepiej używać @ WithMockUser dla prostszego bezpieczeństwa opartego na rolach

Jak widzisz @WithUserDetails ma całą elastyczność, jakiej potrzebujesz dla większości aplikacji. Pozwala na korzystanie z niestandardowych użytkowników z dowolnym GrantedAuthority, takich jak role lub uprawnienia. Ale jeśli pracujesz tylko z rolami, testowanie może być jeszcze łatwiejsze i możesz uniknąć konstruowania niestandardowego UserDetailsService. W takich przypadkach określ prostą kombinację użytkownika, hasła i ról za pomocą @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";
}

Adnotacja definiuje domyślne wartości dla bardzo podstawowego użytkownika. Ponieważ w naszym przypadku testowana trasa wymaga tylko, aby uwierzytelniony użytkownik był menedżerem, możemy zakończyć korzystanie z SpringSecurityWebAuxTestConfig i zrobić to.

@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")));
}

Zauważ, że teraz zamiast użytkownika [email protected] otrzymujemy domyślną wartość dostarczoną przez @WithMockUser: user ; ale to nie ma znaczenia, bo tak naprawdę zależy nam na jego roli: ROLE_MANAGER.

Wnioski

Jak widzisz z adnotacjami, takimi jak @WithUserDetails i @WithMockUser, możemy przełączać się między różnymi scenariuszami uwierzytelnionych użytkowników bez budowania klas wyobcowanych z naszej architektury tylko dla wykonywania prostych testów. Zaleca się również, aby zobaczyć, jak @ WithSecurityContext Działa na jeszcze większą elastyczność.

Dodaj pom.xml:

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

I użyj org.springframework.security.test.web.servlet.request.SecurityMockMvcRequestPostProcessors do żądania autoryzacji. Zobacz przykładowe użycie w https://github.com/rwinch/spring-security-test-blog ( https://jira.spring.io/browse/SEC-2592).

Aktualizacja:

4.0.0.RC2 działa na spring-security 3.x. Dla spring-security 4 Spring-security-test zostań częścią spring-security ( http://docs.spring.io/spring-security/site/docs/4.0.x/reference/htmlsingle/#test , wersja jest taka sama).

Konfiguracja została zmieniona: 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();
}

Próbka dla uwierzytelniania podstawowego: http://docs.spring.io/spring-security/site/docs/4.0.x/reference/htmlsingle/#testing-http-basic-authentication.

Od wiosny 4.0+ najlepszym rozwiązaniem jest adnotacja metody testowej za pomocą @ WithMockUser

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

Pamiętaj, aby dodać następującą zależność do projektu

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

Oto przykład dla tych, którzy chcą przetestować konfigurację zabezpieczeń Spring MockMvc przy użyciu uwierzytelniania Base64 basic.

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

Zależność Mavena

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

Krótka odpowiedź:

@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;
}

Po wykonaniu formLogin Z spring security test każde z Twoich zapytań zostanie automatycznie wywołane jako zalogowany użytkownik.

Długa odpowiedź:

Sprawdź To rozwiązanie (odpowiedź jest dla spring 4): Jak zalogować się do użytkownika z spring 3.2 new mvc testing

Opcje unikania SecurityContextHolder w testach:

• Option 1 : use mocks-mam na myśli mock SecurityContextHolder using some mock library - EasyMock for example
• Opcja 2 : zawijanie wywołania SecurityContextHolder.get... w kodzie w jakiejś usłudze - na przykład w {[2] } z metodą getCurrentPrincipal implementującą interfejs SecurityService, a następnie w testach możesz po prostu stworzyć przykładową implementację tego interfejsu, która zwróci żądaną wartość główną bez dostępu do SecurityContextHolder.