Grundlegende und systematische Geschichte Zertifizierungs- / Autorisierungsgeschichte Remember-Me-Geschichte CSRF-Geschichte Session Management Story Die Geschichte des Antwortheaders Method Security Story CORS-Geschichte Die Geschichte von Run-As Die Geschichte von ACL Sprechen Sie über die Zusammenarbeit mit MVC und Boot

Sonderedition Was Spring Security kann und was nicht

Frühlingssicherheitstest

Spring Security bietet einen Mechanismus zur Unterstützung des Testens mit JUnit.

Beispielsweise kann der zum Testen verwendete Benutzer festgelegt und die Berechtigung angegeben werden.

Hello World

Implementierung

`build.gradle`


dependencies {
    compile 'org.springframework.security:spring-security-web:4.2.1.RELEASE'
    compile 'org.springframework.security:spring-security-config:4.2.1.RELEASE'
    testCompile 'junit:junit:4.12'★ Ergänzung
    testCompile 'org.springframework.security:spring-security-test:4.2.1.RELEASE'★ Ergänzung
}

JUnit- und Spring Test-Module wurden Abhängigkeiten hinzugefügt

`MyTestService.java`


package sample.spring.security.test;

import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.security.core.context.SecurityContextHolder;

public class MyTestService {
    
    @PreAuthorize("authenticated")
    public String getMessage() {
        String name = SecurityContextHolder.getContext().getAuthentication().getName();
        return "Hello " + name;
    }
}

Zu testende Klasse --Überprüfen Sie, ob Sie mit @PreAuthorize () authentifiziert sind
Holen Sie sich den Namen der aktuellen "Authentifizierung" und geben Sie ihn in der Form "Hallo Name" zurück

namespace

`src/test/resources/test-applicationContext.xml`


<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:sec="http://www.springframework.org/schema/security"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="
         http://www.springframework.org/schema/beans
         http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
         http://www.springframework.org/schema/security
         http://www.springframework.org/schema/security/spring-security.xsd">

    <sec:global-method-security pre-post-annotations="enabled" />
    
    <bean class="sample.spring.security.test.MyTestService" />
    
</beans>

--Spring-Konfigurationsdatei zum Testen

Eigentlich denke ich, dass Sie mit derselben Einstellungsdatei wie die Produktion testen sollten, aber da der Zweck darin besteht, den Vorgang zu überprüfen, haben wir eine andere Datei vorbereitet
Schalten Sie die Methodensicherheit ein und registrieren Sie die zu testende Klasse als Bean

`MyTestServiceTest.java`


package sample.spring.security.test;

import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.test.context.support.WithMockUser;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("/test-applicationContext.xml")
public class MyTestServiceTest {
    
    @Autowired
    private MyTestService service;

    @Test(expected = AuthenticationException.class)
    public void test_getMessage_no_authentication() throws Exception {
        // exercise
        this.service.getMessage();
    }

    @Test
    @WithMockUser(username = "hoge")
    public void test_getMessage() throws Exception {
        // exercise
        String message = this.service.getMessage();
        
        // verify
        Assert.assertEquals("Hello hoge", message);
    }
}

Testklasse
Lesen Sie die Testkonfigurationsdatei mit @ ContextConfiguration
Testen, ob "AuthenticationException" ausgelöst wird, wenn "getMessage ()" ausgeführt wird, ohne "@ WithMockUser" anzugeben
Wenn Sie "@ WithMockUser" angeben, testen Sie, ob die Rückmeldung mit der durch "@ WithMockUser" angegebenen Zeichenfolge erstellt wurde.

Java Configuration

`MyTestSpringSecurityConfig.java`


package sample.spring.security.test;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;

@Configuration
@EnableGlobalMethodSecurity(prePostEnabled=true)
public class MyTestSpringSecurityConfig {
    
    @Bean
    public MyTestService myTestService() {
        return new MyTestService();
    }
}

--Spring-Konfigurationsklasse zum Testen

Der Inhalt ist der gleiche wie in XML

`MyTestServiceTest.java`


package sample.spring.security.test;

import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.test.context.support.WithMockUser;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes=MyTestSpringSecurityConfig.class)
public class MyTestServiceTest {
    
    @Autowired
    private MyTestService service;

    @Test(expected = AuthenticationException.class)
    public void test_getMessage_no_authentication() throws Exception {
        // exercise
        this.service.getMessage();
    }

    @Test
    @WithMockUser(username = "hoge")
    public void test_getMessage() throws Exception {
        // exercise
        String message = this.service.getMessage();

        // verify
        Assert.assertEquals("Hello hoge", message);
    }
}

Dies ist auch dasselbe wie xml, außer dass die Konfigurationsklasse mit "@ ContextConfiguration" geladen wird.

Funktionsprüfung

Wenn Sie jeweils einen ausführen, ist der Test erfolgreich.

Erläuterung

Federtest-Einstellungen

`MyTestServiceTest.java`


@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("/test-applicationContext.xml")

--Diese beiden Anmerkungen gelten für den Frühlingstest, nicht für die Frühlingssicherheit.

Mit den Einstellungen hier erstellen Sie einen ApplicationContext zum Testen.
Geben Sie in @ ContextConfiguration die Spring-Einstellungen an, die zum Testen verwendet werden sollen.
Übergeben Sie den Speicherort im XML-Klassenpfad für den Namespace oder das Objekt "Class" der Konfigurationsklasse für die Java-Konfiguration.

Angeben eines Scheinbenutzers

`MyTestServiceTest.java`


    @Test
    @WithMockUser(username = "hoge")
    public void test_getMessage() throws Exception {

Sie können die Benutzerinformationen ("Authentifizierung") angeben, die während der Ausführung des Tests verwendet werden, indem Sie mit "@ WithMockUser" kommentieren.
Da username =" hoge " gesetzt ist, wird Authentication mit dem Benutzernamen hoge verwendet. --Spring Security wird in Spring Test integriert, um "SecurityContextHolder" -Informationen vor und nach dem Test festzulegen und zu löschen.

Anmerkung

Beliebige Informationen können im zu testenden "SecurityContext" durch eine Anmerkung festgelegt werden.

@WithMockUser

`MyTestServiceTest.java`


package sample.spring.security.test;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.test.context.support.WithMockUser;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("/test-applicationContext.xml")
public class MyTestServiceTest {
    
    @Test
    @WithMockUser
    public void test() throws Exception {
        Authentication auth = SecurityContextHolder.getContext().getAuthentication();
        String message = "class = " + auth.getClass() + "\n" +
                         "name = " + auth.getName() + "\n" +
                         "credentials = " + auth.getCredentials() + "\n" +
                         "authorities = " + auth.getAuthorities() + "\n" +
                         "principal = " + auth.getPrincipal() + "\n" +
                         "details = " + auth.getDetails();

        System.out.println(message);
    }
}

** Ausführungsergebnis **

class = class org.springframework.security.authentication.UsernamePasswordAuthenticationToken
name = user
credentials = password
authorities = [ROLE_USER]
principal = org.springframework.security.core.userdetails.User@36ebcb: Username: user; Password: [PROTECTED]; Enabled: true; AccountNonExpired: true; credentialsNonExpired: true; AccountNonLocked: true; Granted Authorities: ROLE_USER
details = null

Mit @ WithMockUser werden nachgebildete Benutzerinformationen in SecurityContext gespeichert
Wenn nichts angegeben ist, enthält es standardmäßig die folgenden Informationen.
Benutzername ist "Benutzer"
Das Passwort ist "Passwort"
Die Berechtigung lautet "ROLE_USER" --UsernamePasswordAuthenticationToken wird verwendet, um Authentication zu implementieren
Das User-Objekt wird als Principal verwendet --user ist ein Scheinbenutzer, daher muss der Benutzer mit diesem Namen nicht wirklich existieren
Es ist auch möglich, die Klasse mit Anmerkungen zu versehen (in diesem Fall verwenden alle Methoden den Scheinbenutzer).

Benutzernamen festlegen

`MyTestServiceTest.java`


    @Test
    @WithMockUser("test-user")
    public void test() throws Exception {
        Authentication auth = SecurityContextHolder.getContext().getAuthentication();
        String message = "class = " + auth.getClass() + "\n" +
                         "name = " + auth.getName() + "\n" +
                         "credentials = " + auth.getCredentials() + "\n" +
                         "authorities = " + auth.getAuthorities() + "\n" +
                         "principal = " + auth.getPrincipal() + "\n" +
                         "details = " + auth.getDetails();

        System.out.println(message);
    }

** Ausführungsergebnis **

class = class org.springframework.security.authentication.UsernamePasswordAuthenticationToken
name = test-user
credentials = password
authorities = [ROLE_USER]
principal = org.springframework.security.core.userdetails.User@b6e8d426: Username: test-user; Password: [PROTECTED]; Enabled: true; AccountNonExpired: true; credentialsNonExpired: true; AccountNonLocked: true; Granted Authorities: ROLE_USER
details = null

--Der Zeichensatz in "Wert" wird als Benutzername verwendet

Es ist auch möglich, mit "Benutzername" anstelle von "Wert" anzugeben
Bei der Einstellung mit Rollen, die später beschrieben werden, ist es einfacher zu verstehen, wenn Sie "Benutzername" anstelle von "Wert" verwenden.

Rolle festlegen

`MyTestServiceTest.java`


    @Test
    @WithMockUser(
        username="test-user",
        roles={"FOO", "BAR"}
    )
    public void test() throws Exception {
        Authentication auth = SecurityContextHolder.getContext().getAuthentication();
        String message = "class = " + auth.getClass() + "\n" +
                         "name = " + auth.getName() + "\n" +
                         "credentials = " + auth.getCredentials() + "\n" +
                         "authorities = " + auth.getAuthorities() + "\n" +
                         "principal = " + auth.getPrincipal() + "\n" +
                         "details = " + auth.getDetails();

        System.out.println(message);
    }

** Ausführungsergebnis **

class = class org.springframework.security.authentication.UsernamePasswordAuthenticationToken
name = test-user
credentials = test-pass
authorities = [ROLE_BAR, ROLE_FOO]
principal = org.springframework.security.core.userdetails.User@b6e8d426: Username: test-user; Password: [PROTECTED]; Enabled: true; AccountNonExpired: true; credentialsNonExpired: true; AccountNonLocked: true; Granted Authorities: ROLE_BAR,ROLE_FOO
details = null

Durch Angabe von "Rollen" wird die Autorität festgelegt, der automatisch das Präfix "ROLE_" zugewiesen wurde.
Ein Fehler tritt auf, wenn mit "Behörden" festgelegt

Berechtigungen festlegen

`MyTestServiceTest.java`


    @Test
    @WithMockUser(
        username="test-user",
        authorities={"FOO", "BAR"}
    )
    public void test() throws Exception {
        Authentication auth = SecurityContextHolder.getContext().getAuthentication();
        String message = "class = " + auth.getClass() + "\n" +
                         "name = " + auth.getName() + "\n" +
                         "credentials = " + auth.getCredentials() + "\n" +
                         "authorities = " + auth.getAuthorities() + "\n" +
                         "principal = " + auth.getPrincipal() + "\n" +
                         "details = " + auth.getDetails();

        System.out.println(message);
    }

** Ausführungsergebnis **

class = class org.springframework.security.authentication.UsernamePasswordAuthenticationToken
name = test-user
credentials = password
authorities = [BAR, FOO]
principal = org.springframework.security.core.userdetails.User@b6e8d426: Username: test-user; Password: [PROTECTED]; Enabled: true; AccountNonExpired: true; credentialsNonExpired: true; AccountNonLocked: true; Granted Authorities: BAR,FOO
details = null

Die Behörden werden durch Angabe der "Behörden" festgelegt
Ein Fehler tritt auf, wenn mit "Rollen" gesetzt

Legen Sie ein Passwort fest

`MyTestServiceTest.java`


    @Test
    @WithMockUser(password="test-pass")
    public void test() throws Exception {
        Authentication auth = SecurityContextHolder.getContext().getAuthentication();
        String message = "class = " + auth.getClass() + "\n" +
                         "name = " + auth.getName() + "\n" +
                         "credentials = " + auth.getCredentials() + "\n" +
                         "authorities = " + auth.getAuthorities() + "\n" +
                         "principal = " + auth.getPrincipal() + "\n" +
                         "details = " + auth.getDetails();

        System.out.println(message);
    }

** Ausführungsergebnis **

class = class org.springframework.security.authentication.UsernamePasswordAuthenticationToken
name = user
credentials = test-pass
authorities = [ROLE_USER]
principal = org.springframework.security.core.userdetails.User@36ebcb: Username: user; Password: [PROTECTED]; Enabled: true; AccountNonExpired: true; credentialsNonExpired: true; AccountNonLocked: true; Granted Authorities: ROLE_USER
details = null

Sie können ein Passwort mit "Passwort" festlegen

@WithAnonymousUser

`MyTestServiceTest.java`


package sample.spring.security.test;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.test.context.support.WithAnonymousUser;
import org.springframework.security.test.context.support.WithMockUser;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@WithMockUser
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("/test-applicationContext.xml")
public class MyTestServiceTest {

    @Test
    @WithAnonymousUser
    public void testAnonymous() throws Exception {
        this.printAuthentication("testAnonymous");
    }
    
    @Test
    public void testDefault() throws Exception {
        this.printAuthentication("testDefault");
    }

    private void printAuthentication(String testMethodName) {
        Authentication auth = SecurityContextHolder.getContext().getAuthentication();
        String message =
                "[" + testMethodName + "]\n" +
                "class = " + auth.getClass() + "\n" +
                "name = " + auth.getName() + "\n" +
                "credentials = " + auth.getCredentials() + "\n" +
                "authorities = " + auth.getAuthorities() + "\n" +
                "principal = " + auth.getPrincipal() + "\n" +
                "details = " + auth.getDetails();

        System.out.println(message);
    }
}

** Ausführungsergebnis **

[testAnonymous]
class = class org.springframework.security.authentication.AnonymousAuthenticationToken
name = anonymous
credentials = 
authorities = [ROLE_ANONYMOUS]
principal = anonymous
details = null

[testDefault]
class = class org.springframework.security.authentication.UsernamePasswordAuthenticationToken
name = user
credentials = password
authorities = [ROLE_USER]
principal = org.springframework.security.core.userdetails.User@36ebcb: Username: user; Password: [PROTECTED]; Enabled: true; AccountNonExpired: true; credentialsNonExpired: true; AccountNonLocked: true; Granted Authorities: ROLE_USER
details = null

Mit @ WithAnonymousUser notieren, um einen anonymen Benutzer zu verwenden
Auch wenn die Klasse mit "@ WithMockUser" kommentiert ist, kann die Einstellung überschrieben werden, indem die Methode mit "@ WithAnonymousUser" kommentiert wird.

@WithUserDetails

`MyUserDetailsService.java`


package sample.spring.security.service;

import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.AuthorityUtils;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;

import java.util.Collection;

public class MyUserDetailsService implements UserDetailsService {
    
    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        return new MyUser(username, "test-password", AuthorityUtils.createAuthorityList("FOO", "BAR"));
    }
    
    private static class MyUser extends User {
        private MyUser(String username, String password, Collection<? extends GrantedAuthority> authorities) {
            super(username, password, authorities);
        }
    }
}

`test-applicationContext.xml`


<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
         http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

    <bean class="sample.spring.security.service.MyUserDetailsService" />
</beans>

`MyTestServiceTest.java`


package sample.spring.security.test;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.test.context.support.WithUserDetails;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("/test-applicationContext.xml")
public class MyTestServiceTest {

    @Test
    @WithUserDetails
    public void test() throws Exception {
        this.printAuthentication("test");
    }

    private void printAuthentication(String testMethodName) {
        Authentication auth = SecurityContextHolder.getContext().getAuthentication();
        String message =
                "[" + testMethodName + "]\n" +
                "class = " + auth.getClass() + "\n" +
                "name = " + auth.getName() + "\n" +
                "credentials = " + auth.getCredentials() + "\n" +
                "authorities = " + auth.getAuthorities() + "\n" +
                "principal = " + auth.getPrincipal() + "\n" +
                "details = " + auth.getDetails();

        System.out.println(message);
    }
}

** Ausführungsergebnis **

[test]
class = class org.springframework.security.authentication.UsernamePasswordAuthenticationToken
name = user
credentials = test-password
authorities = [BAR, FOO]
principal = sample.spring.security.service.MyUserDetailsService$MyUser@36ebcb: Username: user; Password: [PROTECTED]; Enabled: true; AccountNonExpired: true; credentialsNonExpired: true; AccountNonLocked: true; Granted Authorities: BAR,FOO
details = null

Wenn Sie mit "@ WithUserDetails" kommentieren, werden die Authentifizierungsinformationen mit den Benutzerinformationen erstellt, die von "UserDetailsService" als Bean registriert wurden.
Verwenden Sie diese Option, wenn Sie Ihre eigenen "UserDetails" verwenden
Sie können den Namen des zu suchenden Benutzers mit "Wert" in "@ WithUserDetails" angeben (Standard ist "Benutzer"). --userDetailsServiceBeanName kann die zu verwendende Bean UserDetailsService angeben.

@WithSecurityContext

`MyTestUser.java`


package sample.spring.security.test;

import org.springframework.security.test.context.support.WithSecurityContext;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD, ElementType.TYPE})
@WithSecurityContext(factory=MyTestUserFactory.class)
public @interface MyTestUser {
    String name();
    String pass();
    String authority();
}

`MyTestUserFactory.java`


package sample.spring.security.test;

import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.authority.AuthorityUtils;
import org.springframework.security.core.context.SecurityContext;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.test.context.support.WithSecurityContextFactory;

public class MyTestUserFactory implements WithSecurityContextFactory<MyTestUser> {
    
    @Override
    public SecurityContext createSecurityContext(MyTestUser annotation) {
        SecurityContext context = SecurityContextHolder.createEmptyContext();

        String name = annotation.name();
        String pass = annotation.pass();
        String authority = annotation.authority();

        UserDetails user = new User(name, pass, AuthorityUtils.createAuthorityList(authority));
        Authentication authentication = new UsernamePasswordAuthenticationToken(
                                            user, user.getPassword(), user.getAuthorities());
        
        context.setAuthentication(authentication);

        return context;
    }
}

`MyTestServiceTest.java`


package sample.spring.security.test;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("/test-applicationContext.xml")
public class MyTestServiceTest {

    @Test
    @MyTestUser(name="foo", pass="FOO", authority="TEST_FOO")
    public void test() throws Exception {
        this.printAuthentication("test");
    }

    private void printAuthentication(String testMethodName) {
        Authentication auth = SecurityContextHolder.getContext().getAuthentication();
        String message =
                "[" + testMethodName + "]\n" +
                "class = " + auth.getClass() + "\n" +
                "name = " + auth.getName() + "\n" +
                "credentials = " + auth.getCredentials() + "\n" +
                "authorities = " + auth.getAuthorities() + "\n" +
                "principal = " + auth.getPrincipal() + "\n" +
                "details = " + auth.getDetails();

        System.out.println(message);
    }
}

** Ausführungsergebnis **

[test]
class = class org.springframework.security.authentication.UsernamePasswordAuthenticationToken
name = foo
credentials = FOO
authorities = [TEST_FOO]
principal = org.springframework.security.core.userdetails.User@18cc6: Username: foo; Password: [PROTECTED]; Enabled: true; AccountNonExpired: true; credentialsNonExpired: true; AccountNonLocked: true; Granted Authorities: TEST_FOO
details = null

Sie können mit jeder Implementierung Ihren eigenen "SecurityContext" erstellen

`MyTestUser.java`


@WithSecurityContext(factory=MyTestUserFactory.class)
public @interface MyTestUser {

--Erstellen Sie eine beliebige Anmerkung und kommentieren Sie mit "@ WithSecurityContext"

Geben Sie das "Class" -Objekt der Klasse an, die die "WithSecurityContextFactory" -Schnittstelle in "factory" implementiert.
Die hier angegebene Factory-Klasse implementiert den Prozess der Erstellung von "SecurityContext".

`MyTestUserFactory.java`


package sample.spring.security.test;

import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.authority.AuthorityUtils;
import org.springframework.security.core.context.SecurityContext;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.test.context.support.WithSecurityContextFactory;

public class MyTestUserFactory implements WithSecurityContextFactory<MyTestUser> {
    
    @Override
    public SecurityContext createSecurityContext(MyTestUser annotation) {
        SecurityContext context = SecurityContextHolder.createEmptyContext();

        ...

        return context;
    }
}

Eine Factory-Klasse, die durch Implementierung der Schnittstelle "WithSecurityContextFactory " erstellt wurde
Geben Sie in der Typvariablen T den Annotationstyp an, der von der Factory-Klasse verarbeitet wird.
Implementieren Sie die Methode "createSecurityContext ()", um Ihren eigenen "SecurityContext" zu erstellen und zurückzugeben --Diese Klasse muss nicht im Spring-Container registriert sein. --WithSecurityContextTestExecutionListener generiert aus der Annotation eine Factory, wenn der Test ausgeführt wird

`MyTestServiceTest.java`


    @MyTestUser(name="foo", pass="FOO", authority="TEST_FOO")
    public void test() throws Exception {

Wenn Sie anschließend die Testmethode mit Ihrer eigenen Anmerkung versehen, wird der in der angegebenen Factory erstellte "SecurityContext" als Authentifizierungsinformation verwendet.

Injizieren Sie containergesteuerte Beans in Factory-Klassen

`MyTestUserFactory.java`


public class MyTestUserFactory implements WithSecurityContextFactory<MyTestUser> {
    private UserDetailsService userDetailsService;

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

Fabrikklassen können andere Bohnen auf die gleiche Weise wie normale Bohnen injizieren --Die obige Implementierung verwendet eine Konstruktorinjektion ("@ Autowired" kann weggelassen werden).

Meta-Annotation

`HogeUser.java`


package sample.spring.security.test;

import org.springframework.security.test.context.support.WithMockUser;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@WithMockUser(username = "hoge", authorities = {"FOO", "BAR"})
public @interface HogeUser {
}

`MyTestServiceTest.java`


package sample.spring.security.test;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("/test-applicationContext.xml")
public class MyTestServiceTest {

    @Test
    @HogeUser
    public void test() throws Exception {
        this.printAuthentication("test");
    }

    private void printAuthentication(String testMethodName) {
        Authentication auth = SecurityContextHolder.getContext().getAuthentication();
        String message =
                "[" + testMethodName + "]\n" +
                "class = " + auth.getClass() + "\n" +
                "name = " + auth.getName() + "\n" +
                "credentials = " + auth.getCredentials() + "\n" +
                "authorities = " + auth.getAuthorities() + "\n" +
                "principal = " + auth.getPrincipal() + "\n" +
                "details = " + auth.getDetails();

        System.out.println(message);
    }
}

** Ausführungsergebnis **

[test]
class = class org.springframework.security.authentication.UsernamePasswordAuthenticationToken
name = hoge
credentials = password
authorities = [BAR, FOO]
principal = org.springframework.security.core.userdetails.User@30f425: Username: hoge; Password: [PROTECTED]; Enabled: true; AccountNonExpired: true; credentialsNonExpired: true; AccountNonLocked: true; Granted Authorities: BAR,FOO
details = null

Sie können Ihre eigene Anmerkung mit der Anmerkung @ @ WithMockUser versehen.
Wenn Sie diese selbst erstellte Annotation für eine Testmethode usw. verwenden, wird die in der selbst erstellten Annotation festgelegte Einstellung von "@ WithMockUser" vererbt. --Dieser Mechanismus heißt ** Meta-Annotation **
Wenn Sie in verschiedenen Tests einen Scheinbenutzer mit denselben Einstellungen verwenden möchten, ist es einfacher, die Meta-Annotation an einer Stelle zu verwenden, als jede Methode mit "@ WithMockUser" zu kommentieren.
Natürlich können Sie es sowohl mit "@ WithUserDetails" als auch mit "@ WithMockUser" verwenden.

Integration mit Spring MVC

Hello World Implementierung

`build.gradle`


dependencies {
    compile 'org.springframework.security:spring-security-web:4.2.1.RELEASE'
    compile 'org.springframework.security:spring-security-config:4.2.1.RELEASE'
    compile 'org.springframework:spring-webmvc:4.2.1.RELEASE'★ Ergänzung
    testCompile 'junit:junit:4.12'
    testCompile 'org.springframework.security:spring-security-test:4.2.1.RELEASE'
}

Hinzufügen einer Abhängigkeit von "spring-webmvc", wenn eine Implementierung von Spring MVC hinzugefügt wird

`MyMvcController.java`


package sample.spring.security.control;

import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
@RequestMapping("/mvc")
public class MyMvcController {
    
    @GetMapping
    public String hello() {
        Authentication auth = SecurityContextHolder.getContext().getAuthentication();
        System.out.println("auth.name = " + auth.getName());
        
        return "test";
    }
}

--Controller-Klasse, die der GET-Anforderung auf / mvc zugeordnet ist

Ausgabe des Namens "Authentifizierung"

`test-applicationContext.xml`


<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:sec="http://www.springframework.org/schema/security"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="
         http://www.springframework.org/schema/beans
         http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
         http://www.springframework.org/schema/security
         http://www.springframework.org/schema/security/spring-security.xsd">

    <bean class="sample.spring.security.control.MyMvcController" />

    <sec:http>
        <sec:intercept-url pattern="/login" access="permitAll" />
        <sec:intercept-url pattern="/**" access="isAuthenticated()" />
        <sec:form-login />
        <sec:logout />
    </sec:http>

    <sec:authentication-manager />
</beans>

Einfache Deklaration für Spring Security und Bean-Deklaration für MyMvcController

`MyMvcControllerTest.java`


package sample.spring.security.test;

import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.mock.web.MockHttpServletResponse;
import org.springframework.security.test.web.servlet.setup.SecurityMockMvcConfigurers;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.web.WebAppConfiguration;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.MvcResult;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
import org.springframework.web.context.WebApplicationContext;

import static org.springframework.security.test.web.servlet.request.SecurityMockMvcRequestPostProcessors.*;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("/test-applicationContext.xml")
@WebAppConfiguration
public class MyMvcControllerTest {
    @Autowired
    private WebApplicationContext context;
    
    private MockMvc mvc;

    @Before
    public void setUp() throws Exception {
        this.mvc = MockMvcBuilders
                    .webAppContextSetup(this.context)
                    .apply(SecurityMockMvcConfigurers.springSecurity())
                    .build();
    }

    @Test
    public void unauthorized() throws Exception {
        MvcResult mvcResult = this.mvc.perform(get("/mvc")).andReturn();
        this.printResponse("unauthorized", mvcResult);
    }

    @Test
    public void authorized() throws Exception {
        MvcResult mvcResult = this.mvc.perform(get("/mvc").with(user("foo"))).andReturn();
        this.printResponse("authorized", mvcResult);
    }
    
    private void printResponse(String method, MvcResult result) throws Exception {
        MockHttpServletResponse response = result.getResponse();
        int status = response.getStatus();
        String locationHeader = response.getHeader("Location");

        System.out.println("[" + method + "]\n" +
                           "status : " + status + "\n" +
                           "Location : " + locationHeader);
    }
}

Zwei Testmethoden, "nicht autorisiert" und "autorisiert" --Jeder Zugriff auf / mvc und druckt den resultierenden HTTP-Status und den Location-Header.

** Ausführungsergebnis **

auth.name = foo
[authorized]
status : 200
Location : null

[unauthorized]
status : 302
Location : http://localhost/login

--authorized kann vom Controller ausgeführt werden und der Benutzername wird ausgegeben. --unauthorized gibt den Status 302 zurück und fordert Sie auf, zum Anmeldebildschirm umzuleiten

Erläuterung

`MyMvcControllerTest.java`


import org.junit.Before;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.test.web.servlet.setup.SecurityMockMvcConfigurers;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.web.WebAppConfiguration;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
import org.springframework.web.context.WebApplicationContext;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("/test-applicationContext.xml")
@WebAppConfiguration
public class MyMvcControllerTest {
    @Autowired
    private WebApplicationContext context;
    
    private MockMvc mvc;

    @Before
    public void setUp() throws Exception {
        this.mvc = MockMvcBuilders
                    .webAppContextSetup(this.context)
                    .apply(SecurityMockMvcConfigurers.springSecurity())
                    .build();
    }

Die Implementierung dieser Testvorbereitung erfolgt wie im Dokument beschrieben, da ich Spring MVC nicht studiert habe und daher nicht viel Bedeutung verstehe.
Die Einstellungen für Spring Security sind "SecurityMockMvcConfigurers.springSecurity ()" in der Methode "setUp ()".
Mit dieser Einstellung scheint Spring Security Filter in das MVC-Modell integriert zu sein und die Spring Security-Verarbeitung funktioniert.

`MyMvcControllerTest.java`



import static org.springframework.security.test.web.servlet.request.SecurityMockMvcRequestPostProcessors.*;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;.

...

    @Test
    public void unauthorized() throws Exception {
        MvcResult mvcResult = this.mvc.perform(get("/mvc")).andReturn();
        this.printResponse("unauthorized", mvcResult);
    }

    @Test
    public void authorized() throws Exception {
        MvcResult mvcResult = this.mvc.perform(get("/mvc").with(user("foo"))).andReturn();
        this.printResponse("authorized", mvcResult);
    }

--get () ist die statische Methode von MockMvcRequestBuilders --user () ist die statische Methode von SecurityMockMvcRequestPostProcessors

Geben Sie zur Laufzeit den Namen des angemeldeten Benutzers an --Spring MVC Test verfügt über einen Mechanismus zum Umschreiben einer Anforderung und verwendet eine Klasse, die die Schnittstelle "RequestPostProcessor" implementiert. --Spring Security bietet viele Klassen, die diesen "RequestPostProcessor" implementieren, um die Konfiguration für Spring Security zu vereinfachen.
Eine Klasse namens "SecurityMockMvcRequestPostProcessors", eine Sammlung von "statischen" Factory-Methoden, wird als Fenster für die Verwendung dieser Klassen bereitgestellt.

CSRF Wenn der CSRF-Schutz aktiviert ist, muss das Token in der Anforderung enthalten sein. Wenn Sie den Controller so aufrufen, wie er ist, ohne etwas zu tun, tritt ein Fehler auf, da kein Token vorhanden ist.

Daher gibt es eine API zum Testen, um die CSRF-Token-Prüfung zu bestehen.

Implementierung

`test-applicationContext.xml`


<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:sec="http://www.springframework.org/schema/security"
       ...>

    <bean class="sample.spring.security.control.MyMvcController" />

    <sec:http>
        <sec:intercept-url pattern="/login" access="permitAll" />
        <sec:intercept-url pattern="/**" access="isAuthenticated()" />
        <sec:form-login />
        <sec:logout />
        <sec:csrf />★ Ergänzung
    </sec:http>

    <sec:authentication-manager />
</beans>

Fügen Sie hinzu, um den CSRF-Schutz zu aktivieren

`MyMvcController.java`


package sample.spring.security.control;

import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
@RequestMapping("/mvc")
public class MyMvcController {
    
    @PostMapping
    public String hello() {
        Authentication auth = SecurityContextHolder.getContext().getAuthentication();
        System.out.println("auth.name = " + auth.getName());
        
        return "test";
    }
}

Änderung der Methodenanmerkung zu @ PostMapping
Weil CSRF-Maßnahmen nicht von der GET-Methode ausgeführt werden

`MyMvcControllerTest.java`


package sample.spring.security.test;

import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.mock.web.MockHttpServletResponse;
import org.springframework.security.test.web.servlet.setup.SecurityMockMvcConfigurers;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.web.WebAppConfiguration;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.MvcResult;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
import org.springframework.web.context.WebApplicationContext;

import static org.springframework.security.test.web.servlet.request.SecurityMockMvcRequestPostProcessors.*;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("/test-applicationContext.xml")
@WebAppConfiguration
public class MyMvcControllerTest {
    @Autowired
    private WebApplicationContext context;
    
    private MockMvc mvc;

    @Before
    public void setUp() throws Exception {
        this.mvc = MockMvcBuilders
                    .webAppContextSetup(this.context)
                    .apply(SecurityMockMvcConfigurers.springSecurity())
                    .build();
    }

    @Test
    public void noToken() throws Exception {
        MvcResult mvcResult = this.mvc.perform(
            post("/mvc")
            .with(user("foo"))
        ).andReturn();
        
        this.printResponse("noToken", mvcResult);
    }

    @Test
    public void useToken() throws Exception {
        MvcResult mvcResult = this.mvc.perform(
            post("/mvc")
            .with(user("bar"))
            .with(csrf())
        ).andReturn();
        
        this.printResponse("useToken", mvcResult);
    }
    
    private void printResponse(String method, MvcResult result) throws Exception {
        MockHttpServletResponse response = result.getResponse();
        int status = response.getStatus();
        String errorMessage = response.getErrorMessage();

        System.out.println("[" + method + "]\n" +
                           "status : " + status + "\n" +
                           "errorMessage : " + errorMessage);
    }
}

** Ausführungsergebnis **

[noToken]
status : 403
errorMessage : Could not verify the provided CSRF token because your session was not found.

auth.name = bar
[useToken]
status : 200
errorMessage : null

--noToken () steckt in der CSRF-Token-Prüfung fest und führt zu einem Fehler --useToken () kann die Methode des Controllers erfolgreich ausführen

Erläuterung

`MyMvcControllerTest.java`


    @Test
    public void noToken() throws Exception {
        MvcResult mvcResult = this.mvc.perform(
            post("/mvc")
            .with(user("foo"))
        ).andReturn();
        
        this.printResponse("noToken", mvcResult);
    }

    @Test
    public void useToken() throws Exception {
        MvcResult mvcResult = this.mvc.perform(
            post("/mvc")
            .with(user("bar"))
            .with(csrf())
        ).andReturn();
        
        this.printResponse("useToken", mvcResult);
    }

Verwenden Sie die Methode csrf (), um das CSRF-Token in die Testlaufanforderung aufzunehmen. --Diese Methode ist auch in "SecurityMockMvcRequestPostProcessors" definiert
Wenn Sie das Token in den Header einfügen möchten, verwenden Sie csrf (). AsHeader ()

Setzen Sie ein illegales Token

Implementierung

`MyMvcControllerTest.java`


    @Test
    public void useInvalidToken() throws Exception {
        MvcResult mvcResult = this.mvc.perform(
            post("/mvc")
            .with(user("bar"))
            .with(csrf().useInvalidToken())
        ).andReturn();
        
        this.printResponse("useInvalidToken", mvcResult);
    }

** Ausführungsergebnis **

[useInvalidToken]
status : 403
errorMessage : Invalid CSRF Token 'invalidd19aed27-65e2-4cf6-9456-157e1f29c984' was found on the request parameter '_csrf' or header 'X-CSRF-TOKEN'.

Erläuterung

--csrf (). useInvalidToken ()setzt ein ungültiges Token

Benutzerspezifikation

Es gibt zwei Möglichkeiten, den Benutzer anzugeben:

--Methode mit RequestPostProcessor --Methode mit Anmerkungen

Methode mit `RequestPostProcessor`

Eine Methode, die den Erweiterungspunkt der von Spring MVC Test bereitgestellten Anforderung verwendet. Im Vergleich zur Angabe durch Annotation scheint das Merkmal zu sein, dass sie dynamisch angegeben werden kann.

Implementierung

`MyMvcController.java`


package sample.spring.security.control;

import org.springframework.security.core.Authentication;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;

import java.util.stream.Collectors;

@Controller
@RequestMapping("/mvc")
public class MyMvcController {
    
    @GetMapping
    public String hello() {
        Authentication auth = SecurityContextHolder.getContext().getAuthentication();

        String name = auth.getName();
        Object credentials = auth.getCredentials();
        Object principal = auth.getPrincipal();
        String authorities = auth.getAuthorities().stream().map(GrantedAuthority::getAuthority).collect(Collectors.joining(", "));

        System.out.println(
            "name = " + name + "\n" + 
            "credentials = " + credentials + "\n" + 
            "authorities = " + authorities + "\n" +
            "principal = " + principal
        );
        
        return "test";
    }
}

`MyMvcControllerTest.java`


package sample.spring.security.test;

import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.AuthorityUtils;
import org.springframework.security.core.context.SecurityContext;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.test.web.servlet.setup.SecurityMockMvcConfigurers;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.web.WebAppConfiguration;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
import org.springframework.web.context.WebApplicationContext;

import java.util.List;

import static org.springframework.security.test.web.servlet.request.SecurityMockMvcRequestPostProcessors.*;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("/test-applicationContext.xml")
@WebAppConfiguration
public class MyMvcControllerTest {
    private static final String USERNAME = "foo";
    private static final String PASSWORD = "test-pass";
    private static final List<GrantedAuthority> AUTHORITIES = AuthorityUtils.createAuthorityList("FOO", "BAR");
    
    @Autowired
    private WebApplicationContext context;
    
    private MockMvc mvc;

    @Before
    public void setUp() throws Exception {
        this.mvc = MockMvcBuilders
                    .webAppContextSetup(this.context)
                    .apply(SecurityMockMvcConfigurers.springSecurity())
                    .build();
    }

    @Test
    public void withUser() throws Exception {
        System.out.println("[withUser]");
        this.mvc.perform(
            get("/mvc").with(user(USERNAME))
        );
    }

    @Test
    public void customized() throws Exception {
        System.out.println("[customized]");
        this.mvc.perform(
            get("/mvc").with(
                user(USERNAME)
                .password(PASSWORD)
                .authorities(AUTHORITIES)
            )
        );
    }

    @Test
    public void userDetails() throws Exception {
        System.out.println("[userDetails]");
        UserDetails user = this.createUserDetails();

        this.mvc.perform(
            get("/mvc").with(user(user))
        );
    }

    @Test
    public void withAnonymous() throws Exception {
        System.out.println("[withAnonymous]");

        this.mvc.perform(
            get("/mvc").with(anonymous())
        );
    }

    @Test
    public void withAuthentication() throws Exception {
        System.out.println("[withAuthentication]");
        Authentication auth = this.createAuthentication();

        this.mvc.perform(
            get("/mvc").with(authentication(auth))
        );
    }

    @Test
    public void withSecurityContext() throws Exception {
        System.out.println("[withAuthentication]");
        Authentication auth = this.createAuthentication();
        SecurityContext context = SecurityContextHolder.createEmptyContext();
        context.setAuthentication(auth);

        this.mvc.perform(
            get("/mvc").with(securityContext(context))
        );
    }

    private UserDetails createUserDetails() {
        return new User(USERNAME, PASSWORD, AUTHORITIES);
    }
    
    private Authentication createAuthentication() {
        UserDetails user = this.createUserDetails();
        return new UsernamePasswordAuthenticationToken(user, user.getPassword(), user.getAuthorities());
    }
}

** Ausführungsergebnis **

[withUser]
name = foo
credentials = password
authorities = ROLE_USER
principal = org.springframework.security.core.userdetails.User@18cc6: Username: foo; Password: [PROTECTED]; Enabled: true; AccountNonExpired: true; credentialsNonExpired: true; AccountNonLocked: true; Granted Authorities: ROLE_USER

[customized]
name = foo
credentials = test-pass
authorities = BAR, FOO
principal = org.springframework.security.core.userdetails.User@18cc6: Username: foo; Password: [PROTECTED]; Enabled: true; AccountNonExpired: true; credentialsNonExpired: true; AccountNonLocked: true; Granted Authorities: BAR,FOO

[userDetails]
name = foo
credentials = test-pass
authorities = BAR, FOO
principal = org.springframework.security.core.userdetails.User@18cc6: Username: foo; Password: [PROTECTED]; Enabled: true; AccountNonExpired: true; credentialsNonExpired: true; AccountNonLocked: true; Granted Authorities: BAR,FOO

[withAnonymous]
name = anonymous
credentials = 
authorities = ROLE_ANONYMOUS
principal = anonymous

[withAuthentication]
name = foo
credentials = test-pass
authorities = BAR, FOO
principal = org.springframework.security.core.userdetails.User@18cc6: Username: foo; Password: [PROTECTED]; Enabled: true; AccountNonExpired: true; credentialsNonExpired: true; AccountNonLocked: true; Granted Authorities: BAR,FOO

[withSecurityContext]
name = foo
credentials = test-pass
authorities = BAR, FOO
principal = org.springframework.security.core.userdetails.User@18cc6: Username: foo; Password: [PROTECTED]; Enabled: true; AccountNonExpired: true; credentialsNonExpired: true; AccountNonLocked: true; Granted Authorities: BAR,FOO

Erläuterung

Wenn nur "user (String)" angegeben wird, ist nur der Benutzername der angegebene Wert.
Das Passwort ist "Passwort"
Die einzige Autorität ist "ROLE_USER"
Sie können detaillierte Einstellungen mit "Benutzer (Zeichenfolge)" gefolgt von "Kennwort (Zeichenfolge)" oder "Berechtigungen (Sammlung <? Erweitert GrantedAuthority>)" vornehmen. --Rolle kann mit Rollen (String ...) angegeben werden --Wenn "user (UserDetails)", können Sie "UserDetails" direkt angeben.
Sie können einen anonymen Benutzer mit "anonym ()" angeben
Sie können "Authentifizierung" direkt mit "Authentifizierung (Authentifizierung)" angeben
Sie können "SecurityContext" direkt mit "securityContext (SecurityContext)" angeben

Legen Sie die Standardbenutzerinformationen fest

Implementierung

`MyMvcControllerTest.java`


package sample.spring.security.test;

import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.authority.AuthorityUtils;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.web.WebAppConfiguration;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
import org.springframework.web.context.WebApplicationContext;

import static org.springframework.security.test.web.servlet.request.SecurityMockMvcRequestPostProcessors.*;
import static org.springframework.security.test.web.servlet.setup.SecurityMockMvcConfigurers.*;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("/test-applicationContext.xml")
@WebAppConfiguration
public class MyMvcControllerTest {
    @Autowired
    private WebApplicationContext context;
    
    private MockMvc mvc;

    @Before
    public void setUp() throws Exception {
        this.mvc = MockMvcBuilders
                    .webAppContextSetup(this.context)
                    .apply(springSecurity())
                    .defaultRequest(get("/")
                        .with(
                            user("foo")
                            .password("test-pass")
                            .authorities(AuthorityUtils.createAuthorityList("FOO", "BAR"))
                        )
                    )
                    .build();
    }

    @Test
    public void test() throws Exception {
        this.mvc.perform(get("/mvc"));
    }
}

** Ausführungsergebnis **

name = foo
credentials = test-pass
authorities = BAR, FOO
principal = org.springframework.security.core.userdetails.User@18cc6: Username: foo; Password: [PROTECTED]; Enabled: true; AccountNonExpired: true; credentialsNonExpired: true; AccountNonLocked: true; Granted Authorities: BAR,FOO

Erläuterung

`MyMvcControllerTest.java`


    @Before
    public void setUp() throws Exception {
        this.mvc = MockMvcBuilders
                    .webAppContextSetup(this.context)
                    .apply(springSecurity())
                    .defaultRequest(get("/")
                        .with(
                            user("foo")
                            .password("test-pass")
                            .authorities(AuthorityUtils.createAuthorityList("FOO", "BAR"))
                        )
                    )
                    .build();
    }

Wenn Sie die Benutzerinformationen beim Erstellen von "MockMvc" mit "defaultRequest ()" angeben, können Sie diese als Standardeinstellung verwenden.

Fassen Sie häufig verwendete Benutzerdefinitionen zusammen

Implementierung

`MyMockUserPostProcessors.java`


package sample.spring.security.test;

import org.springframework.security.core.authority.AuthorityUtils;
import org.springframework.test.web.servlet.request.RequestPostProcessor;

import static org.springframework.security.test.web.servlet.request.SecurityMockMvcRequestPostProcessors.*;

public class MyMockUserPostProcessors {
    
    public static RequestPostProcessor hoge() {
        return user("hoge")
                .password("test-pass")
                .authorities(AuthorityUtils.createAuthorityList("FOO", "BAR"));
    }
}

`MyMvcControllerTest.java`


package sample.spring.security.test;

import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.web.WebAppConfiguration;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
import org.springframework.web.context.WebApplicationContext;

import static org.springframework.security.test.web.servlet.setup.SecurityMockMvcConfigurers.*;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
import static sample.spring.security.test.MyMockUserPostProcessors.*;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("/test-applicationContext.xml")
@WebAppConfiguration
public class MyMvcControllerTest {
    @Autowired
    private WebApplicationContext context;
    
    private MockMvc mvc;

    @Before
    public void setUp() throws Exception {
        this.mvc = MockMvcBuilders
                    .webAppContextSetup(this.context)
                    .apply(springSecurity())
                    .build();
    }
    
    @Test
    public void test() throws Exception {
        this.mvc.perform(get("/mvc").with(hoge()));
    }
}

** Ausführungsergebnis **

name = hoge
credentials = test-pass
authorities = BAR, FOO
principal = org.springframework.security.core.userdetails.User@30f425: Username: hoge; Password: [PROTECTED]; Enabled: true; AccountNonExpired: true; credentialsNonExpired: true; AccountNonLocked: true; Granted Authorities: BAR,FOO

Erläuterung

`MyMockUserPostProcessors.java`


    public static RequestPostProcessor hoge() {
        return user("hoge")
                .password("test-pass")
                .authorities(AuthorityUtils.createAuthorityList("FOO", "BAR"));
    }

Wenn Sie die Definition von "RequestPostProcessor" für häufig verwendete Einstellungen mit der "statischen" Methode aufrufen können, ist die Wiederverwendung einfacher.

Methode mit Anmerkungen

Die Methode, die die am Anfang geschriebene Annotation wie "@ WithMockUser" verwendet.

Im Vergleich zu der Methode mit "RequestPostProcessor" **, wenn keine dynamische Änderung erforderlich ist **, sind Anmerkungen zu Methoden und Klassen ausreichend, und ich bin der Meinung, dass sie eine deklarativere Funktion hat. Danach ist es möglich, die Methode zum Angeben von Scheinbenutzern mit anderen Tests als MVC zu teilen.

Implementierung

`MyMvcControllerTest.java`


package sample.spring.security.test;

import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.test.context.support.WithMockUser;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.web.WebAppConfiguration;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
import org.springframework.web.context.WebApplicationContext;

import static org.springframework.security.test.web.servlet.setup.SecurityMockMvcConfigurers.*;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("/test-applicationContext.xml")
@WebAppConfiguration
public class MyMvcControllerTest {
    @Autowired
    private WebApplicationContext context;
    
    private MockMvc mvc;

    @Before
    public void setUp() throws Exception {
        this.mvc = MockMvcBuilders
                    .webAppContextSetup(this.context)
                    .apply(springSecurity())
                    .build();
    }

    @Test
    @WithMockUser(username="foo", password="test-pass", authorities={"FOO", "BAR"})
    public void test() throws Exception {
        this.mvc.perform(get("/mvc"));
    }
}

** Ausführungsergebnis **

name = foo
credentials = test-pass
authorities = BAR, FOO
principal = org.springframework.security.core.userdetails.User@18cc6: Username: foo; Password: [PROTECTED]; Enabled: true; AccountNonExpired: true; credentialsNonExpired: true; AccountNonLocked: true; Granted Authorities: BAR,FOO

Erläuterung

Da es das gleiche ist wie die Verwendung, wenn es nicht MVC ist, gibt es nichts Besonderes zu erwähnen.

Formular Login

Implementierung

`test-applicationContext.xml`


<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:sec="http://www.springframework.org/schema/security"
       ...>

    <bean class="sample.spring.security.control.MyMvcController" />

    <sec:http>
        <sec:intercept-url pattern="/login" access="permitAll" />
        <sec:intercept-url pattern="/**" access="isAuthenticated()" />
        <sec:form-login />
        <sec:logout />
    </sec:http>

    <sec:authentication-manager>
        <sec:authentication-provider>
            <sec:user-service>
                <sec:user name="user" password="password" authorities="FOO" />
            </sec:user-service>
        </sec:authentication-provider>
    </sec:authentication-manager>
</beans>

`MyMvcControllerTest.java`


package sample.spring.security.test;

import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.mock.web.MockHttpServletResponse;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.web.WebAppConfiguration;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.MvcResult;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
import org.springframework.web.context.WebApplicationContext;

import static org.springframework.security.test.web.servlet.request.SecurityMockMvcRequestBuilders.*;
import static org.springframework.security.test.web.servlet.setup.SecurityMockMvcConfigurers.*;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("/test-applicationContext.xml")
@WebAppConfiguration
public class MyMvcControllerTest {
    @Autowired
    private WebApplicationContext context;
    
    private MockMvc mvc;

    @Before
    public void setUp() throws Exception {
        this.mvc = MockMvcBuilders
                    .webAppContextSetup(this.context)
                    .apply(springSecurity())
                    .build();
    }

    @Test
    public void test() throws Exception {
        MvcResult result = this.mvc.perform(formLogin()).andReturn();
        this.printResponse("test", result);
    }

    private void printResponse(String method, MvcResult result) throws Exception {
        MockHttpServletResponse response = result.getResponse();
        int status = response.getStatus();
        String location = response.getHeader("Location");

        System.out.println("[" + method + "]\n" +
                "status : " + status + "\n" +
                "location : " + location;
    }
}

** Ausführungsergebnis **

[test]
status : 302
location : /

Erfolgreich angemeldet und übersprungen zum Stammverzeichnis /, das nach der Anmeldung das Standardübergangsziel ist

Erläuterung

`test-applicationContext.xml`


    <sec:user name="user" password="password1" authorities="FOO" />

Der Benutzer muss tatsächlich vorhanden sein, da bei der Formularanmeldung eine normale Logik ausgeführt wird.

`MyMvcControllerTest.java`


    @Test
    public void test() throws Exception {
        MvcResult result = this.mvc.perform(formLogin()).andReturn();
        this.printResponse("test", result);
    }

--Form Login wird ausgeführt, indem "SecurityMockMvcRequestBuilders.formLogin ()" auf "perform ()" gesetzt wird

Standardmäßig wird die folgende Anforderung ausgeführt
Pfad anfordern: / login --Methode: POST
Benutzername: Benutzer --Passwort: Passwort
Benutzername Parametername: Benutzername --Password-Parametername: Passwort

Geben Sie verschiedene Einstellungen an

Implementierung

`test-applicationContext.xml`


<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:sec="http://www.springframework.org/schema/security"
       ...>

    <bean class="sample.spring.security.control.MyMvcController" />

    <sec:http>
        <sec:intercept-url pattern="/do-login" access="permitAll" />
        <sec:intercept-url pattern="/**" access="isAuthenticated()" />
        <sec:form-login login-processing-url="/do-login"
                        username-parameter="login-id"
                        password-parameter="pass" />
        <sec:logout />
    </sec:http>

    <sec:authentication-manager>
        <sec:authentication-provider>
            <sec:user-service>
                <sec:user name="user" password="password" authorities="FOO" />
            </sec:user-service>
        </sec:authentication-provider>
    </sec:authentication-manager>
</beans>

--Stellen Sie die Anmelde-URL und die Parameternamen von Benutzername und Kennwort auf andere als die Standardwerte ein

`MyMvcControllerTest.java`


package sample.spring.security.test;

import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.mock.web.MockHttpServletResponse;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.web.WebAppConfiguration;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.MvcResult;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
import org.springframework.web.context.WebApplicationContext;

import static org.springframework.security.test.web.servlet.request.SecurityMockMvcRequestBuilders.*;
import static org.springframework.security.test.web.servlet.setup.SecurityMockMvcConfigurers.*;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("/test-applicationContext.xml")
@WebAppConfiguration
public class MyMvcControllerTest {
    @Autowired
    private WebApplicationContext context;
    
    private MockMvc mvc;

    @Before
    public void setUp() throws Exception {
        this.mvc = MockMvcBuilders
                    .webAppContextSetup(this.context)
                    .apply(springSecurity())
                    .build();
    }

    @Test
    public void test() throws Exception {
        MvcResult result = this.mvc.perform(
            formLogin("/do-login")
            .userParameter("login-id")
            .passwordParam("pass")
            .user("user")
            .password("password")
        ).andReturn();

        this.printResponse("test", result);
    }

    private void printResponse(String method, MvcResult result) throws Exception {
        ...
    }
}

** Ausführungsergebnis **

[test]
status : 302
location : /

Erläuterung

`MyMvcControllerTest.java`


    @Test
    public void test() throws Exception {
        MvcResult result = this.mvc.perform(
            formLogin("/do-login")
            .userParameter("login-id")
            .passwordParam("pass")
            .user("user")
            .password("password")
        ).andReturn();

        this.printResponse("test", result);
    }

--Wenn sich der Anmeldeverarbeitungspfad vom Standardpfad (/ login) unterscheidet, können Sie den Pfad mit dem Argument formLogin () angeben.

Kann auch mit loginProcessingUrl () angegeben werden --Wenn sich der Parametername des Benutzernamens vom Standard unterscheidet (Benutzername), können Sie ihn mit userParameter () angeben. --Wenn sich der Name des Kennwortparameters vom Standard unterscheidet (password), können Sie ihn mit passwordParam () angeben.

Ausloggen

Implementierung

`MyMvcControllerTest.java`


package sample.spring.security.test;

import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.mock.web.MockHttpServletResponse;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.web.WebAppConfiguration;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.MvcResult;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
import org.springframework.web.context.WebApplicationContext;

import static org.springframework.security.test.web.servlet.request.SecurityMockMvcRequestBuilders.*;
import static org.springframework.security.test.web.servlet.setup.SecurityMockMvcConfigurers.*;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("/test-applicationContext.xml")
@WebAppConfiguration
public class MyMvcControllerTest {
    @Autowired
    private WebApplicationContext context;
    
    private MockMvc mvc;

    @Before
    public void setUp() throws Exception {
        this.mvc = MockMvcBuilders
                    .webAppContextSetup(this.context)
                    .apply(springSecurity())
                    .build();
    }

    @Test
    public void test() throws Exception {
        MvcResult result = this.mvc.perform(logout()).andReturn();
        this.printResponse("test", result);
    }

    private void printResponse(String method, MvcResult result) throws Exception {
        ...
    }
}

** Ausführungsergebnis **

[test]
status : 302
location : /login?logout

Erläuterung

Wenn Sie "SecurityMockMvcRequestBuilders.logout ()" an "perform ()" übergeben, wird die Abmeldeanforderung ausgeführt --Wenn sich die Abmelde-URL von der Standard-URL (/ logout) unterscheidet, können Sie sie mit einem Argument wielogout ("/ other-logout-url")angeben.

Überprüfung der Anmeldeinformationen nach der Anmeldung

Implementierung

`test-applicationContext.xml`


<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:sec="http://www.springframework.org/schema/security"
       ...>

    <bean class="sample.spring.security.control.MyMvcController" />

    <sec:http>
        <sec:intercept-url pattern="/login" access="permitAll" />
        <sec:intercept-url pattern="/**" access="isAuthenticated()" />
        <sec:form-login />
        <sec:logout />
    </sec:http>

    <sec:authentication-manager>
        <sec:authentication-provider>
            <sec:user-service>
                <sec:user name="foo" password="foo" authorities="FOO, BAR" />
                <sec:user name="fizz" password="fizz" authorities="ROLE_FIZZ, ROLE_BUZZ" />
            </sec:user-service>
        </sec:authentication-provider>
    </sec:authentication-manager>
</beans>

--Stellen Sie die Berechtigungen "FOO" und "BAR" für den Benutzer "foo" ein --Stellen Sie die Rollen von "ROLE_FIZZ" und "ROLE_BUZZ" für den Benutzer "fizz" ein

`MyMvcControllerTest.java`


package sample.spring.security.test;

import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.AuthorityUtils;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.web.WebAppConfiguration;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
import org.springframework.web.context.WebApplicationContext;

import java.util.List;

import static org.springframework.security.test.web.servlet.request.SecurityMockMvcRequestBuilders.*;
import static org.springframework.security.test.web.servlet.response.SecurityMockMvcResultMatchers.*;
import static org.springframework.security.test.web.servlet.setup.SecurityMockMvcConfigurers.*;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("/test-applicationContext.xml")
@WebAppConfiguration
public class MyMvcControllerTest {
    @Autowired
    private WebApplicationContext context;
    
    private MockMvc mvc;

    @Before
    public void setUp() throws Exception {
        this.mvc = MockMvcBuilders
                    .webAppContextSetup(this.context)
                    .apply(springSecurity())
                    .build();
    }

    @Test
    public void test_unauthenticated() throws Exception {
        this.mvc.perform(formLogin().user("foo").password("invalid"))
                .andExpect(unauthenticated());
    }

    @Test
    public void test_authenticated() throws Exception {
        this.mvc.perform(formLogin().user("foo").password("foo"))
                .andExpect(authenticated());
    }

    @Test
    public void test_withUsername() throws Exception {
        this.mvc.perform(formLogin().user("foo").password("foo"))
                .andExpect(authenticated().withUsername("foo"));
    }

    @Test
    public void test_withAuthorities() throws Exception {
        List<GrantedAuthority> authorities = AuthorityUtils.createAuthorityList("FOO", "BAR");
        
        this.mvc.perform(formLogin().user("foo").password("foo"))
                .andExpect(authenticated().withAuthorities(authorities));
    }

    @Test
    public void test_combine() throws Exception {
        List<GrantedAuthority> authorities = AuthorityUtils.createAuthorityList("FOO", "BAR");
        
        this.mvc.perform(formLogin().user("foo").password("foo"))
                .andExpect(authenticated().withUsername("foo").withAuthorities(authorities));
    }

    @Test
    public void test_withRoles() throws Exception {
        this.mvc.perform(formLogin().user("fizz").password("fizz"))
                .andExpect(authenticated().withRoles("FIZZ", "BUZZ"));
    }
}

** Ausführungsergebnis **

Alle Tests sind erfolgreich

Erläuterung

`MyMvcControllerTest.java`


    @Test
    public void test_unauthenticated() throws Exception {
        this.mvc.perform(formLogin().user("foo").password("invalid"))
                .andExpect(unauthenticated());
    }

Sie können das Authentifizierungsergebnis überprüfen, indem Sie "andExpect ()" nach "perform ()" verwenden. --SecurityMockMvcResultMatchers bietet statische Methoden und verwendet diese.

Methodenname	Überprüfungsinhalt
`unauthenticated()`	Stellen Sie sicher, dass Sie nicht authentifiziert sind
`authenticated()`	Stellen Sie sicher, dass Sie authentifiziert sind dazu`withUsername()`Eine detaillierte Überprüfung ist möglich, indem Sie z
`withUsername(String)`	Überprüfen Sie den Benutzernamen
`withAuthorities(Collection<? extends GrantedAuthority>)`	Überprüfen Sie die erteilte Berechtigung
`withRoles(String...)`	Überprüfen Sie die zugewiesene Rolle

`MyMvcControllerTest.java`


    @Test
    public void test_combine() throws Exception {
        List<GrantedAuthority> authorities = AuthorityUtils.createAuthorityList("FOO", "BAR");
        
        this.mvc.perform(formLogin().user("foo").password("foo"))
                .andExpect(authenticated().withUsername("foo").withAuthorities(authorities));
    }

--Mehrfache withUsername () und withAuthorities () können kombiniert werden

Referenz

Spring Security Reference

[JAVA] Spring Security-Verwendungsnotiztest

Frühlingssicherheitstest

Implementierung

build.gradle

MyTestService.java

src/test/resources/test-applicationContext.xml

MyTestServiceTest.java

MyTestSpringSecurityConfig.java

MyTestServiceTest.java

Funktionsprüfung

Erläuterung

Federtest-Einstellungen

MyTestServiceTest.java

Angeben eines Scheinbenutzers

MyTestServiceTest.java

Anmerkung

MyTestServiceTest.java

Benutzernamen festlegen

MyTestServiceTest.java

Rolle festlegen

MyTestServiceTest.java

Berechtigungen festlegen

MyTestServiceTest.java

Legen Sie ein Passwort fest

MyTestServiceTest.java

MyTestServiceTest.java

MyUserDetailsService.java

test-applicationContext.xml

MyTestServiceTest.java

MyTestUser.java

MyTestUserFactory.java

MyTestServiceTest.java

MyTestUser.java

MyTestUserFactory.java

MyTestServiceTest.java

Injizieren Sie containergesteuerte Beans in Factory-Klassen

MyTestUserFactory.java

Meta-Annotation

HogeUser.java

MyTestServiceTest.java

Integration mit Spring MVC

build.gradle

MyMvcController.java

test-applicationContext.xml

MyMvcControllerTest.java

MyMvcControllerTest.java

MyMvcControllerTest.java

test-applicationContext.xml

MyMvcController.java

MyMvcControllerTest.java

MyMvcControllerTest.java

Setzen Sie ein illegales Token

MyMvcControllerTest.java

Benutzerspezifikation

Methode mit RequestPostProcessor

MyMvcController.java

MyMvcControllerTest.java

Legen Sie die Standardbenutzerinformationen fest

MyMvcControllerTest.java

MyMvcControllerTest.java

Fassen Sie häufig verwendete Benutzerdefinitionen zusammen

MyMockUserPostProcessors.java

MyMvcControllerTest.java

MyMockUserPostProcessors.java

Methode mit Anmerkungen

MyMvcControllerTest.java

Formular Login

test-applicationContext.xml

MyMvcControllerTest.java

test-applicationContext.xml

MyMvcControllerTest.java

Geben Sie verschiedene Einstellungen an

test-applicationContext.xml

MyMvcControllerTest.java

MyMvcControllerTest.java

Ausloggen

MyMvcControllerTest.java

Überprüfung der Anmeldeinformationen nach der Anmeldung

test-applicationContext.xml

MyMvcControllerTest.java

`build.gradle`

`MyTestService.java`

`src/test/resources/test-applicationContext.xml`

`MyTestServiceTest.java`

`MyTestSpringSecurityConfig.java`

`MyTestServiceTest.java`

`MyTestServiceTest.java`

`MyTestServiceTest.java`

`MyTestServiceTest.java`

`MyTestServiceTest.java`

`MyTestServiceTest.java`

`MyTestServiceTest.java`

`MyTestServiceTest.java`

`MyTestServiceTest.java`

`MyUserDetailsService.java`

`test-applicationContext.xml`

`MyTestServiceTest.java`

`MyTestUser.java`

`MyTestUserFactory.java`

`MyTestServiceTest.java`

`MyTestUser.java`

`MyTestUserFactory.java`

`MyTestServiceTest.java`

`MyTestUserFactory.java`

`HogeUser.java`

`MyTestServiceTest.java`

`build.gradle`

`MyMvcController.java`

`test-applicationContext.xml`

`MyMvcControllerTest.java`

`MyMvcControllerTest.java`

`MyMvcControllerTest.java`

`test-applicationContext.xml`

`MyMvcController.java`

`MyMvcControllerTest.java`

`MyMvcControllerTest.java`

`MyMvcControllerTest.java`

Methode mit `RequestPostProcessor`

`MyMvcController.java`

`MyMvcControllerTest.java`

`MyMvcControllerTest.java`

`MyMvcControllerTest.java`

`MyMockUserPostProcessors.java`

`MyMvcControllerTest.java`

`MyMockUserPostProcessors.java`

`MyMvcControllerTest.java`

`test-applicationContext.xml`

`MyMvcControllerTest.java`

`test-applicationContext.xml`

`MyMvcControllerTest.java`

`test-applicationContext.xml`

`MyMvcControllerTest.java`

`MyMvcControllerTest.java`

`MyMvcControllerTest.java`

`test-applicationContext.xml`

`MyMvcControllerTest.java`

`MyMvcControllerTest.java`

`MyMvcControllerTest.java`