pruebas

src/main/java/com/jnz/teamManager/config/ApplicationConfig.java

@@ -1,6 +1,5 @@
 package com.jnz.teamManager.config;
 
-import com.jnz.teamManager.exception.controller.RestResponseEntityExceptionHandler;
 import com.jnz.teamManager.service.UserService;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.context.annotation.Bean;
@@ -12,7 +11,12 @@
 import org.springframework.security.core.userdetails.UserDetailsService;
 import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
 import org.springframework.security.crypto.password.PasswordEncoder;
-import org.springframework.web.servlet.mvc.method.annotation.ResponseEntityExceptionHandler;
+import org.springframework.web.cors.CorsConfiguration;
+import org.springframework.web.cors.CorsConfigurationSource;
+import org.springframework.web.cors.UrlBasedCorsConfigurationSource;
+import org.springframework.web.cors.reactive.CorsWebFilter;
+
+import java.util.Arrays;
 
 @Configuration
 public class ApplicationConfig {
@@ -42,6 +46,15 @@ public PasswordEncoder passwordEncoder(){
         return new BCryptPasswordEncoder();
     }
 
+    @Bean
+    CorsConfigurationSource corsConfigurationSource() {
+        CorsConfiguration configuration = new CorsConfiguration();
+        configuration.setAllowedOrigins(Arrays.asList("https://team-manager-front.vercel.app", "http://localhost"));
+        configuration.setAllowedMethods(Arrays.asList("GET","POST", "DELETE", "PUT"));
+        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
+        source.registerCorsConfiguration("/**", configuration);
+        return source;
+    }
 
 
 

src/main/java/com/jnz/teamManager/config/SecurityConfiguration.java

@@ -4,13 +4,16 @@
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.security.authentication.AuthenticationProvider;
+import org.springframework.security.config.Customizer;
 import org.springframework.security.config.annotation.web.builders.HttpSecurity;
 import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
+import org.springframework.security.config.annotation.web.configurers.AbstractHttpConfigurer;
 import org.springframework.security.config.http.SessionCreationPolicy;
 import org.springframework.security.core.context.SecurityContextHolder;
 import org.springframework.security.web.SecurityFilterChain;
 import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
 import org.springframework.security.web.authentication.logout.LogoutHandler;
+import org.springframework.web.cors.CorsConfigurationSource;
 
 @Configuration
 @EnableWebSecurity
@@ -28,10 +31,10 @@ public class SecurityConfiguration {
     @Autowired
     private ExceptionFilterHandler exceptionFilterHandler;
 
-
     @Bean
     public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
-        http.csrf().disable().authorizeHttpRequests().requestMatchers("/auth/**").permitAll()
+            http.cors(AbstractHttpConfigurer::disable)
+                .csrf().disable().authorizeHttpRequests().requestMatchers("/auth/**").permitAll()
                 .anyRequest().authenticated()
                 .and().sessionManagement()
                 .sessionCreationPolicy(SessionCreationPolicy.STATELESS)

src/main/resources/application.properties

@@ -1,5 +1,6 @@
 spring.datasource.url=${MYSQL_URL}
 spring.datasource.username=${MYSQLUSER}
 spring.datasource.password=${MYSQLPASSWORD}
+server.port=${PORT}
 spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
 spring.jpa.hibernate.ddl-auto = update

src/test/java/com/jnz/teamManager/AuthenticationServiceEncoderTest.java

@@ -0,0 +1,26 @@
+package com.jnz.teamManager;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.security.crypto.password.PasswordEncoder;
+
+@SpringBootTest
+public class AuthenticationServiceEncoderTest {
+
+    @Autowired
+    private PasswordEncoder passwordEncoder;
+
+    @Test
+    void testPasswordEncoder() {
+        String password = "password123";
+        String encodedPassword = passwordEncoder.encode(password);
+
+        Assertions.assertNotEquals(password, encodedPassword);
+        Assertions.assertTrue(passwordEncoder.matches(password, encodedPassword));
+    }
+
+
+
+}

src/test/java/com/jnz/teamManager/AuthenticationServiceTest.java

@@ -0,0 +1,50 @@
+package com.jnz.teamManager;
+
+import com.jnz.teamManager.auth.dto.RegisterRequest;
+import com.jnz.teamManager.entity.User;
+import com.jnz.teamManager.service.UserService;
+import com.jnz.teamManager.service.auth.AuthenticationService;
+import com.jnz.teamManager.service.auth.JwtService;
+
+import org.junit.jupiter.api.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.security.crypto.password.PasswordEncoder;
+
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+@SpringBootTest
+public class AuthenticationServiceTest {
+
+    @Mock
+    private UserService userService;
+
+    @Mock
+    private PasswordEncoder passwordEncoder;
+
+    @Mock
+    private JwtService jwtService;
+
+    @InjectMocks
+    private AuthenticationService authenticationService;
+
+    @Test
+    public void register_shouldCreateUser() {
+        // given
+        RegisterRequest registerRequest = new RegisterRequest();
+        registerRequest.setUsername("testuser");
+        registerRequest.setEmail("testuser@test.com");
+        registerRequest.setPassword("password123");
+
+        when(passwordEncoder.encode(registerRequest.getPassword())).thenReturn("encodedpassword");
+
+        // when
+        authenticationService.register(registerRequest);
+
+        // then
+        verify(userService).addUser(any(User.class));
+    }
+}

src/test/java/com/jnz/teamManager/InvitationServiceTest.java

@@ -0,0 +1,132 @@
+package com.jnz.teamManager;
+
+import com.jnz.teamManager.entity.Invitation;
+import com.jnz.teamManager.entity.Team;
+import com.jnz.teamManager.entity.User;
+import com.jnz.teamManager.exception.error.InvitationAlreadyExistsException;
+import com.jnz.teamManager.repository.InvitationsRepository;
+import com.jnz.teamManager.service.InvitationsService;
+import com.jnz.teamManager.service.TeamService;
+import com.jnz.teamManager.service.UserService;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import static org.mockito.ArgumentMatchers.anyLong;
+import org.springframework.boot.test.context.SpringBootTest;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.stream.StreamSupport;
+
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.*;
+
+@SpringBootTest
+public class InvitationServiceTest {
+
+    @Mock
+    private InvitationsRepository invitationsRepository;
+
+    @Mock
+    private UserService userService;
+
+    @Mock
+    private TeamService teamService;
+
+    private InvitationsService invitationsService;
+
+    @BeforeEach
+    public void setUp() {
+        MockitoAnnotations.initMocks(this);
+        invitationsService = new InvitationsService();
+        invitationsService.invitationsRepository = invitationsRepository;
+        invitationsService.userService = userService;
+        invitationsService.teamService = teamService;
+    }
+
+    @Test
+    public void testAddInvitation() {
+        // Mock de datos de entrada
+        Map<String, String> invitation = new HashMap<>();
+        invitation.put("userReceiverId", "1");
+        invitation.put("userOwnerId", "2");
+        invitation.put("teamId", "3");
+        invitation.put("message", "Test invitation");
+
+        // Mock de servicio de usuario
+        when(userService.getUserById(1L)).thenReturn(new User());
+        when(userService.getUserById(2L)).thenReturn(new User());
+
+        // Mock de servicio de equipo
+        when(teamService.getTeamById(3L)).thenReturn(new Team());
+
+        // Mock de repositorio de invitaciones
+        when(invitationsRepository.findAll()).thenReturn(Collections.emptyList());
+
+        // Ejecución de método a probar
+        invitationsService.addInvitation(invitation);
+
+        // Verificación de llamadas a métodos
+        verify(userService, times(1)).getUserById(1L);
+        verify(userService, times(1)).getUserById(2L);
+        verify(teamService, times(1)).getTeamById(3L);
+        verify(invitationsRepository, times(1)).save(any(Invitation.class));
+    }
+
+    @Test
+    public void testAddInvitation_DuplicateInvitation() {
+        // Mock de datos de entrada
+        Map<String, String> invitation = new HashMap<>();
+        invitation.put("userReceiverId", "1");
+        invitation.put("userOwnerId", "2");
+        invitation.put("teamId", "3");
+        invitation.put("message", "Test invitation");
+
+        // Mock de servicio de usuario
+        when(userService.getUserById(1L)).thenReturn(new User());
+        when(userService.getUserById(2L)).thenReturn(new User());
+
+        // Mock de servicio de equipo
+        when(teamService.getTeamById(3L)).thenReturn(new Team());
+
+        // Mock de repositorio de invitaciones con una invitación existente
+        Invitation existingInvitation = new Invitation();
+        existingInvitation.setUser(new User());
+        existingInvitation.setTeamId(new Team());
+        when(invitationsRepository.findAll()).thenReturn(Collections.singletonList(existingInvitation));
+
+        // Ejecución de método a probar y verificación de excepción
+        assertThrows(InvitationAlreadyExistsException.class, () -> invitationsService.addInvitation(invitation));
+
+        // Verificación de llamadas a métodos
+        verify(userService, times(1)).getUserById(1L);
+        verify(userService, times(1)).getUserById(2L);
+        verify(teamService, times(1)).getTeamById(3L);
+        verify(invitationsRepository, never()).save(any(Invitation.class));
+        }
+
+    @Test
+    public void testDeleteInvitation() {
+        // Mock de datos de entrada
+        Invitation invitation = new Invitation();
+        invitation.setUser(new User());
+        invitation.setTeamId(new Team());
+
+        // Ejecución de método a probar
+        invitationsService.deleteInvitation(invitation);
+
+        // Verificación de llamadas a métodos
+        verify(invitationsRepository, times(1)).delete(any(Invitation.class));
+    }
+
+
+
+}

src/test/java/com/jnz/teamManager/JwtServiceTest.java

@@ -0,0 +1,40 @@
+package com.jnz.teamManager;
+
+import com.jnz.teamManager.entity.User;
+import com.jnz.teamManager.service.UserService;
+import com.jnz.teamManager.service.auth.JwtService;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.security.core.userdetails.UserDetails;
+
+@SpringBootTest
+public class JwtServiceTest {
+
+    @Autowired
+    private JwtService jwtService;
+
+    @Autowired
+    private UserService userService;
+
+    @Test
+    public void testGenerateAndValidateToken() {
+        // Creamos un nuevo usuario
+        User user = User.builder()
+                .username("testUser")
+                .email("test@example.com")
+                .password("password123")
+                .build();
+        userService.addUser(user);
+
+        // Generamos un token para el usuario
+        UserDetails userDetails = userService.getUserByUsername(user.getUsername());
+        String token = jwtService.generateToken(userDetails);
+
+        // Verificamos si el token es válido
+        boolean isTokenValid = jwtService.isTokenValid(token, userDetails);
+        Assertions.assertTrue(isTokenValid);
+    }
+}