fix: [*]: Solcuionado probalema de configuraciones en los tests

pom.xml

@@ -11,8 +11,8 @@
     <groupId>com.ujaen.tfg</groupId>
     <groupId>com.ujaen.tfg</groupId>
     <artifactId>MangAffinity</artifactId>
     <artifactId>MangAffinity</artifactId>
     <version>0.0.1-SNAPSHOT</version>
     <version>0.0.1-SNAPSHOT</version>
-    <name>MangAfginity</name>
-    <description>MangAfginity</description>
+    <name>MangAffinity</name>
+    <description>MangAffinity</description>
     <url/>
     <url/>
     <licenses>
     <licenses>
         <license/>
         <license/>
@@ -53,10 +53,7 @@
             <groupId>org.springframework.boot</groupId>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-validation</artifactId>
             <artifactId>spring-boot-starter-validation</artifactId>
         </dependency>
         </dependency>
-        <dependency>
-            <groupId>org.springframework.boot</groupId>
-            <artifactId>spring-boot-starter-data-jpa</artifactId>
-        </dependency>
+
         <dependency>
         <dependency>
             <groupId>com.h2database</groupId>
             <groupId>com.h2database</groupId>
             <artifactId>h2</artifactId>
             <artifactId>h2</artifactId>
@@ -68,6 +65,14 @@
             <version>2.2.224</version>
             <version>2.2.224</version>
             <scope>test</scope>
             <scope>test</scope>
         </dependency>
         </dependency>
+        <dependency>
+            <groupId>jakarta.servlet</groupId>
+            <artifactId>jakarta.servlet-api</artifactId>
+            <version>6.0.0</version>
+            <scope>test</scope>
+        </dependency>
+
+
 
 
         <!-- Para encriptar contraseñas con BCrypt -->
         <!-- Para encriptar contraseñas con BCrypt -->
         <dependency>
         <dependency>
@@ -93,6 +98,10 @@
             <version>0.11.5</version>
             <version>0.11.5</version>
             <scope>runtime</scope>
             <scope>runtime</scope>
         </dependency>
         </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-web</artifactId>
+        </dependency>
 
 
 
 
 
 

src/main/java/com/ujaen/tfg/mangaffinity/MangAffinityApplication.java

@@ -12,9 +12,7 @@ import org.springframework.boot.autoconfigure.domain.EntityScan;
 })
 })
 @EntityScan(basePackages="com.ujaen.tfg.mangaffinity")
 @EntityScan(basePackages="com.ujaen.tfg.mangaffinity")
 public class MangAffinityApplication {
 public class MangAffinityApplication {
-
     public static void main(String[] args) {
     public static void main(String[] args) {
         SpringApplication.run(MangAffinityApplication.class, args);
         SpringApplication.run(MangAffinityApplication.class, args);
     }
     }
-
-}
+}
\ No newline at end of file

src/main/java/com/ujaen/tfg/mangaffinity/rest/DTO/DTOUsuario.java

@@ -12,7 +12,8 @@ import lombok.NoArgsConstructor;
 @AllArgsConstructor
 @AllArgsConstructor
 public class DTOUsuario {
 public class DTOUsuario {
 
 
-    private Long id;
+    private Long id = null; // Permitir que sea nulo al crear
+
 
 
     @Email
     @Email
     private String email;
     private String email;

src/main/java/com/ujaen/tfg/mangaffinity/seguridad/ServicioSeguridad.java

@@ -2,28 +2,52 @@ package com.ujaen.tfg.mangaffinity.seguridad;
 
 
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Profile;
 import org.springframework.http.HttpMethod;
 import org.springframework.http.HttpMethod;
+import org.springframework.security.config.Customizer;
 import org.springframework.security.config.annotation.web.builders.HttpSecurity;
 import org.springframework.security.config.annotation.web.builders.HttpSecurity;
+import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
+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.crypto.bcrypt.BCryptPasswordEncoder;
 import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
 import org.springframework.security.crypto.password.PasswordEncoder;
 import org.springframework.security.crypto.password.PasswordEncoder;
+import org.springframework.security.provisioning.InMemoryUserDetailsManager;
 import org.springframework.security.web.SecurityFilterChain;
 import org.springframework.security.web.SecurityFilterChain;
 
 
 @Configuration
 @Configuration
+@EnableWebSecurity
+@Profile("!test") // Desactiva seguridad en tests
 public class ServicioSeguridad {
 public class ServicioSeguridad {
+
+
+    @Bean
+
+    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
+        http
+                .csrf(csrf -> csrf.disable()) // Desactivar CSRF para desarrollo
+                .authorizeHttpRequests(auth -> auth
+                        .requestMatchers("/usuarios/**").permitAll() // Permitir registro
+                        .anyRequest().authenticated() // Requerir autenticación para todo lo demás
+                )
+                .httpBasic(Customizer.withDefaults()); // Solución correcta para httpBasic()
+
+        return http.build();
+    }
+
+
     @Bean
     @Bean
-    PasswordEncoder passwordEncoder() {
+    public PasswordEncoder passwordEncoder() {
         return new BCryptPasswordEncoder();
         return new BCryptPasswordEncoder();
     }
     }
 
 
+    // Usuario en memoria para pruebas (quítalo cuando uses JWT)
     @Bean
     @Bean
-    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
-        return http
-                .csrf(csrf -> csrf.disable())  // Deshabilita CSRF para facilitar pruebas, considerar habilitar en producción
-                .sessionManagement(session -> session.disable()) // Sin gestión de sesiones, ya que usaremos JWT
-                .authorizeHttpRequests(request -> request
-                        .requestMatchers(HttpMethod.POST, "/usuarios/").permitAll() // Permite el registro sin autenticación
-                        .anyRequest().authenticated() // Cualquier otra ruta requiere autenticación
-                )
+    public UserDetailsService userDetailsService() {
+        UserDetails user = User.withUsername("admin")
+                .password(passwordEncoder().encode("admin"))
+                .roles("ADMIN")
                 .build();
                 .build();
+        return new InMemoryUserDetailsManager(user);
     }
     }
 }
 }

src/test/java/com/ujaen/tfg/mangaffinity/MangAffinityApplicationTests.java

 package com.ujaen.tfg.mangaffinity;
 package com.ujaen.tfg.mangaffinity;
 
 
+import com.ujaen.tfg.mangaffinity.config.JpaTestConfig;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.Test;
 import org.springframework.boot.test.context.SpringBootTest;
 import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.context.ActiveProfiles;
 
 
-@SpringBootTest
+@SpringBootTest(classes = {MangAffinityApplication.class, JpaTestConfig.class})
+@ActiveProfiles("test")
 class MangAffinityApplicationTests {
 class MangAffinityApplicationTests {
-
     @Test
     @Test
     void contextLoads() {
     void contextLoads() {
     }
     }
-
 }
 }
+

src/test/java/com/ujaen/tfg/mangaffinity/config/JpaTestConfig.java

@@ -8,6 +8,7 @@ import javax.sql.DataSource;
 import org.springframework.boot.jdbc.DataSourceBuilder;
 import org.springframework.boot.jdbc.DataSourceBuilder;
 import java.util.Properties;
 import java.util.Properties;
 
 
+
 @TestConfiguration
 @TestConfiguration
 public class JpaTestConfig {
 public class JpaTestConfig {
 
 
@@ -15,7 +16,7 @@ public class JpaTestConfig {
     public DataSource dataSource() {
     public DataSource dataSource() {
         return DataSourceBuilder.create()
         return DataSourceBuilder.create()
                 .driverClassName("org.h2.Driver")
                 .driverClassName("org.h2.Driver")
-                .url("jdbc:h2:mem:mangaffinity;MODE=MYSQL;DATABASE_TO_LOWER=TRUE;DB_CLOSE_DELAY=-1")
+                .url("jdbc:h2:mem:mangaffinity;MODE=MYSQL;DB_CLOSE_DELAY=-1") // Eliminado DATABASE_TO_LOWER=TRUE
                 .username("sa")
                 .username("sa")
                 .password("")
                 .password("")
                 .build();
                 .build();
@@ -31,7 +32,7 @@ public class JpaTestConfig {
         em.setJpaVendorAdapter(vendorAdapter);
         em.setJpaVendorAdapter(vendorAdapter);
 
 
         Properties properties = new Properties();
         Properties properties = new Properties();
-        properties.setProperty("hibernate.hbm2ddl.auto", "create-drop");
+        properties.setProperty("hibernate.hbm2ddl.auto", "update"); // Cambiado a "update"
         properties.setProperty("hibernate.dialect", "org.hibernate.dialect.H2Dialect");
         properties.setProperty("hibernate.dialect", "org.hibernate.dialect.H2Dialect");
         properties.setProperty("hibernate.show_sql", "true");
         properties.setProperty("hibernate.show_sql", "true");
         em.setJpaProperties(properties);
         em.setJpaProperties(properties);
@@ -39,3 +40,4 @@ public class JpaTestConfig {
         return em;
         return em;
     }
     }
 }
 }
+

src/test/java/com/ujaen/tfg/mangaffinity/rest/TestUsuariosController.java

+package com.ujaen.tfg.mangaffinity.rest;
+
+import com.ujaen.tfg.mangaffinity.MangAffinityApplication;
+import com.ujaen.tfg.mangaffinity.config.JpaTestConfig;
+import com.ujaen.tfg.mangaffinity.rest.DTO.DTOUsuario;
+import org.assertj.core.api.Assertions;
+import org.junit.jupiter.api.Test;
+import org.springframework.boot.test.context.SpringBootTest;
+
+
+import org.springframework.boot.test.web.client.TestRestTemplate;
+import org.springframework.boot.test.web.server.LocalServerPort;
+import org.springframework.boot.web.client.RestTemplateBuilder;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.security.web.SecurityFilterChain;
+import org.springframework.test.annotation.DirtiesContext;
+import org.springframework.test.context.ActiveProfiles;
+import jakarta.annotation.PostConstruct;
+
+@SpringBootTest(classes = {MangAffinityApplication.class, JpaTestConfig.class}, webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
+@ActiveProfiles("test")
+public class TestUsuariosController {
+
+
+
+    @LocalServerPort
+    int localPort;
+
+    TestRestTemplate restTemplateUsuarios;
+
+
+
+    @PostConstruct
+    void crearRestTemplate() {
+        var restTemplateBuilder = new RestTemplateBuilder()
+                .rootUri("http://localhost:" + localPort + "/usuarios");
+
+        restTemplateUsuarios = new TestRestTemplate(restTemplateBuilder);
+    }
+
+    @Test
+    @DirtiesContext
+    void testRegistrarUsuario() {
+        // Caso 1: Intentar registrar un usuario con datos inválidos (email vacío)
+        var usuarioInvalido = new DTOUsuario(null, "", "UsuarioPrueba", "password123");
+        var respuestaInvalida = restTemplateUsuarios.postForEntity(
+                "/",
+                usuarioInvalido,
+                Void.class
+        );
+        Assertions.assertThat(respuestaInvalida.getStatusCode()).isEqualTo(HttpStatus.UNPROCESSABLE_ENTITY);
+
+        // Caso 2: Registrar un usuario correctamente
+        var usuarioValido = new DTOUsuario(null, "carlitos@gmail.com", "Carlitos", "password123");
+        ResponseEntity<DTOUsuario> respuestaValida = restTemplateUsuarios.postForEntity(
+                "/",
+                usuarioValido,
+                DTOUsuario.class
+        );
+        Assertions.assertThat(respuestaValida.getStatusCode()).isEqualTo(HttpStatus.CREATED);
+
+        // Validar que el usuario devuelto tiene un ID asignado
+        var usuarioCreado = respuestaValida.getBody();
+        Assertions.assertThat(usuarioCreado).isNotNull();
+        Assertions.assertThat(usuarioCreado.getId()).isNotNull(); // Confirmamos que el ID fue generado correctamente
+
+        // Caso 3: Intentar registrar un usuario con el mismo email (debe dar conflicto)
+        var usuarioDuplicado = new DTOUsuario(null, "carlitos@gmail.com", "Carlitos", "password123");
+        var respuestaDuplicado = restTemplateUsuarios.postForEntity(
+                "/",
+                usuarioDuplicado,
+                Void.class
+        );
+        Assertions.assertThat(respuestaDuplicado.getStatusCode()).isEqualTo(HttpStatus.CONFLICT);
+    }
+}

src/test/resources/application-test.yml

 spring:
 spring:
   datasource:
   datasource:
-    url: jdbc:h2:mem:mangaffinity;DB_CLOSE_DELAY=-1
+    url: jdbc:h2:mem:mangaffinity;MODE=MYSQL
     driver-class-name: org.h2.Driver
     driver-class-name: org.h2.Driver
     username: sa
     username: sa
-    password:
+    password: ""
   jpa:
   jpa:
     database-platform: org.hibernate.dialect.H2Dialect
     database-platform: org.hibernate.dialect.H2Dialect
     hibernate:
     hibernate:
@@ -14,4 +14,4 @@ spring:
         show_sql: true
         show_sql: true
   sql:
   sql:
     init:
     init:
-      mode: always
+      mode: never