src/test/java/com/example/onlineshop/AuthControllerTest.java - Spring_Branch - Renonr/SpringProject

src/test/java/com/example/onlineshop/AuthControllerTest.java
140 строк5 KB
Renonr
"First half-work app"
11 фев 2025, 00:59
11 фев 2025, 00:5954b1f79
package com.example.onlineshop;

import com.example.onlineshop.controllers.AuthController;
import com.example.onlineshop.models.User;
import com.example.onlineshop.security.JwtUtil;
import com.example.onlineshop.services.UserService;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.springframework.http.ResponseEntity;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.crypto.password.PasswordEncoder;
import java.util.HashMap;
import java.util.Map;
import java.util.Optional;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;


public class AuthControllerTest {

    @Mock
    private UserService userService;

    @Mock
    private JwtUtil jwtUtil;

    @Mock
    private PasswordEncoder passwordEncoder;

    @Mock
    private AuthenticationManager authenticationManager;

    @InjectMocks
    private AuthController authController;

    @BeforeEach
    public void setUp() {
        MockitoAnnotations.initMocks(this);
    }

    @Test
    public void register_ShouldReturnSuccessMessage_WhenUserIsNew() {
        User user = new User();
        user.setEmail("newuser@example.com");
        user.setPassword("password");

        when(userService.findByEmail(user.getEmail())).thenReturn(Optional.empty());
        when(userService.registerUser(any(User.class))).thenReturn(user);

        ResponseEntity<?> response = authController.register(user);

        assertEquals(200, response.getStatusCodeValue());
        assertEquals("Регистрация успешна", ((Map<?, ?>) response.getBody()).get("message"));
        verify(userService, times(1)).registerUser(any(User.class));
    }

    @Test
    public void register_ShouldReturnErrorMessage_WhenEmailAlreadyExists() {
        User user = new User();
        user.setEmail("existing@example.com");

        when(userService.findByEmail(user.getEmail())).thenReturn(Optional.of(user));

        ResponseEntity<?> response = authController.register(user);

        assertEquals(400, response.getStatusCodeValue());
        assertEquals("Email уже зарегистрирован", ((Map<?, ?>) response.getBody()).get("message"));
        verify(userService, never()).registerUser(any(User.class));
    }

    @Test
    public void login_ShouldReturnToken_WhenCredentialsAreValid() {
        String email = "valid@example.com";
        String password = "password";
        User user = new User();
        user.setEmail(email);
        user.setPassword("encoded-password");

        when(userService.findByEmail(email)).thenReturn(Optional.of(user));
        when(passwordEncoder.matches(password, user.getPassword())).thenReturn(true);
        when(jwtUtil.generateToken(email)).thenReturn("mock-jwt-token");

        Map<String, String> request = new HashMap<>();
        request.put("email", email);
        request.put("password", password);

        ResponseEntity<?> response = authController.login(request);

        assertEquals(200, response.getStatusCodeValue());
        assertNotNull(((Map<?, ?>) response.getBody()).get("token"));
        assertEquals("mock-jwt-token", ((Map<?, ?>) response.getBody()).get("token"));
    }

    @Test
    public void login_ShouldReturnErrorMessage_WhenPasswordIsIncorrect() {
        String email = "valid@example.com";
        String password = "wrongpassword";
        User user = new User();
        user.setEmail(email);
        user.setPassword("encoded-password");

        when(userService.findByEmail(email)).thenReturn(Optional.of(user));
        when(passwordEncoder.matches(password, user.getPassword())).thenReturn(false);

        Map<String, String> request = new HashMap<>();
        request.put("email", email);
        request.put("password", password);

        ResponseEntity<?> response = authController.login(request);

        assertEquals(400, response.getStatusCodeValue());
        assertEquals("Неверный пароль", ((Map<?, ?>) response.getBody()).get("message"));
    }

    @Test
    public void login_ShouldReturnErrorMessage_WhenUserNotFound() {
        String email = "notfound@example.com";
        String password = "password";

        when(userService.findByEmail(email)).thenReturn(Optional.empty());

        Map<String, String> request = new HashMap<>();
        request.put("email", email);
        request.put("password", password);

        try {
            ResponseEntity<?> response = authController.login(request);
        } catch (RuntimeException e) {
            assertEquals("Пользователь не найден", e.getMessage());
        }
    }
}