Probando Spring Security Auth con JUnit

Aquí vamos a aprender cómo usar InMemoryDaoImpl para verificar la autenticación de seguridad de Spring usando un caso de prueba JUnit y cómo crear mediante programación un objeto de autenticación completamente completo y luego utilizarlo en una aplicación.

SecurityContextHolder: la seguridad de Spring se basa en el concepto de un contexto de seguridad, que es algo estático. Esto simplemente implica que no tiene que inyectar su referencia en sus beans o clases de contenedor de primavera. La función SecurityContextHolder.getContext() se puede usar para obtener el contexto de primavera en cualquier momento.

Este contexto contiene una referencia al principal o usuario real, cuyos permisos de acceso debemos verificar.

Prueba unitaria Spring Security: crearemos un proyecto Maven y escribiremos muy poco código para que uno pueda concentrarse en probar solo los aspectos de la autenticación que son relevantes para este tema. Luego construiré una clase de servicio de muestra simple con solo un método que requiere «USUARIO DE ROL» para acceder. Si intenta usar esta función sin tener «USUARIO DE ROL», obtendrá una AccessDeniedException como se predijo. ¿No es sencillo?

La estructura del proyecto es la siguiente: 

Hagamos un proyecto Java con el siguiente comando:

Consola

$ mvn archetype:generate -DgroupId=com.geeksforgeeks
             -DartifactId=SpringPasswordHashingDemo
             -DarchetypeArtifactId=maven-archetype-quickstart 
             -DinteractiveMode=false

 

Para que el proyecto eclipse sea compatible, edite pom.xml con las siguientes dependencias y ejecute el comando mvn:eclipse:eclipse.

Archivo: pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.geeksforgeeks</groupId>
  <artifactId>SpringPasswordHashingDemo</artifactId>
  <packaging>jar</packaging>
  <version>1.0-SNAPSHOT</version>
  <name>SpringPasswordHashingDemo</name>
  <url>http://maven.apache.org</url>
  <properties>
    <org.springframework.version>3.0.5.RELEASE</org.springframework.version>
  </properties>
  <dependencies>
       <!-- Spring Core -->
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.4</version>
      <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>cglib</groupId>
        <artifactId>cglib</artifactId>
        <version>2.2</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
      <version>${org.springframework.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-expression</artifactId>
      <version>${org.springframework.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-beans</artifactId>
      <version>${org.springframework.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>${org.springframework.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context-support</artifactId>
      <version>${org.springframework.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-test</artifactId>
      <version>${org.springframework.version}</version>
      <scope>test</scope>
    </dependency>
      
    <!-- Spring Security -->
    <dependency>
        <groupId>org.springframework.security</groupId>
        <artifactId>spring-security-core</artifactId>
        <version>${org.springframework.version}</version>
        <type>jar</type>
        <scope>compile</scope>
    </dependency>
    <dependency>
        <groupId>org.springframework.security</groupId>
        <artifactId>spring-security-web</artifactId>
        <version>${org.springframework.version}</version>
        <type>jar</type>
        <scope>compile</scope>
    </dependency>
    <dependency>
        <groupId>org.springframework.security</groupId>
        <artifactId>spring-security-config</artifactId>
        <version>${org.springframework.version}</version>
        <type>jar</type>
        <scope>compile</scope>
    </dependency>
    <dependency>
        <groupId>org.springframework.security</groupId>
        <artifactId>spring-security-taglibs</artifactId>
        <version>${org.springframework.version}</version>
        <type>jar</type>
        <scope>compile</scope>
    </dependency>
      
  </dependencies>
</project>

Paso 2: Cree un archivo para la configuración de seguridad.

Ya hemos creado un archivo llamado application-security.xml y hemos colocado la configuración de seguridad dentro.

Archivo: aplicación-seguridad.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans:beans xmlns="http://www.springframework.org/schema/security"
    xmlns:beans="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
    http://www.springframework.org/schema/security
    http://www.springframework.org/schema/security/spring-security-3.0.3.xsd">
      
    <global-method-security secured-annotations="enabled" />
  
    <authentication-manager alias="authenticationManager">
        <authentication-provider>
            <user-service>
                <user name="geeksforgeeks" password="password1" authorities="ROLE_USER" />
                <user name="geeksforgeeks2" password="password2" authorities="ROLE_ADMIN" />
            </user-service>
        </authentication-provider>
    </authentication-manager>
      
    <beans:bean id="demoService" class="com.geeksforgeeks.DemoService"/>
</beans:beans>

Paso 3: Cree un método seguro

Archivo: DemoService.java

// Java Program to Illustrate DemoService Class
  
package com.geeksforgeeks;
  
// Importing required classes
import org.springframework.security.access.annotation.Secured;
  
// Class
public class DemoService {
    @Secured("ROLE_USER")
  
    // Method
    public void method()
    {
        // Print statement
        System.out.println("Method called");
    }
}

Paso 4: use JUnit para probar la autenticación

En las pruebas de JUnit, estableceremos mediante programación el contexto de primavera y luego accederemos a los usuarios por nombre de usuario desde el servicio de información de usuario predeterminado. En nuestro caso, es una implementación en memoria, que puede diferir de un servicio de información de usuario basado en JDBC o un servicio de detalles de usuario personalizado en su situación. Como resultado, ajuste la búsqueda adecuadamente.

Probaremos una variedad de situaciones, que incluyen usuario válido, usuario no válido y función no válida, entre otras. Tiene la opción de agregar o eliminar situaciones según sus preferencias.

Archivo: TestDemoService.java

// Java Program to Illustrate TestDemoService Class
  
package com.geeksforgeeks;
  
// Importing required classes
import java.util.ArrayList;
import java.util.List;
import org.junit.BeforeClass;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.security.access.AccessDeniedException;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.GrantedAuthorityImpl;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.memory.InMemoryDaoImpl;
  
// Class
public class TestDemoService {
  
    static ApplicationContext applicationContext = null;
    static InMemoryDaoImpl userDetailsService = null;
  
    // Initialize the application context to
    // re-use in all test cases
    @BeforeClass
  
    // Method 1
    public static void setup()
    {
        // Creating application context instance
        applicationContext
            = new ClassPathXmlApplicationContext(
                "application-security.xml");
  
        // Getting user details service configured in
        // configuration
        userDetailsService = applicationContext.getBean(
            InMemoryDaoImpl.class);
    }
  
    @Test
    // Method 2
    // To test the valid user with valid role
    public void testValidRole()
    {
        // Get the user by username from configured user
        // details service
        UserDetails userDetails
            = userDetailsService.loadUserByUsername(
                "geeksforgeeks");
        Authentication authToken
            = new UsernamePasswordAuthenticationToken(
                userDetails.getUsername(),
                userDetails.getPassword(),
                userDetails.getAuthorities());
        SecurityContextHolder.getContext()
            .setAuthentication(authToken);
        DemoService service
            = (DemoService)applicationContext.getBean(
                "demoService");
        service.method();
    }
  
    // Method 3
    // To test the valid user with INVALID role
    @Test(expected = AccessDeniedException.class)
    public void testInvalidRole()
    {
        UserDetails userDetails
            = userDetailsService.loadUserByUsername(
                "geeksforgeeks");
        List<GrantedAuthority> authorities
            = new ArrayList<GrantedAuthority>();
        authorities.add(
            new GrantedAuthorityImpl("ROLE_INVALID"));
        Authentication authToken
            = new UsernamePasswordAuthenticationToken(
                userDetails.getUsername(),
                userDetails.getPassword(), authorities);
        SecurityContextHolder.getContext()
            .setAuthentication(authToken);
        DemoService service
            = (DemoService)applicationContext.getBean(
                "demoService");
        service.method();
    }
  
    // Method 4
    // Test the INVALID user
    @Test(expected = AccessDeniedException.class)
    public void testInvalidUser()
    {
        UserDetails userDetails
            = userDetailsService.loadUserByUsername(
                "geeksforgeeks2");
        List<GrantedAuthority> authorities
            = new ArrayList<GrantedAuthority>();
  
        authorities.add(
            new GrantedAuthorityImpl("ROLE_INVALID"));
        Authentication authToken
            = new UsernamePasswordAuthenticationToken(
                userDetails.getUsername(),
                userDetails.getPassword(), authorities);
  
        SecurityContextHolder.getContext()
            .setAuthentication(authToken);
        DemoService service
            = (DemoService)applicationContext.getBean(
                "demoService");
  
        service.method();
    }
}

Salida: ahora veremos que todos los casos de prueba se ejecutan como se muestra a través de la ayuda visual a continuación que se muestra a continuación: