Как авторизовать тест в JUnit

Авторизация тестов в JUnit: Стратегии и лучшие практики

В мире тестирования авторизация тестов — это процесс предоставления тестовым сценариям необходимых учетных данных или токенов для доступа к защищенным ресурсам. В JUnit, как в одном из самых популярных фреймворков для модульного тестирования в Java, не существует встроенной специфической функциональности для авторизации. Вместо этого используются различные стратегии интеграции и проектирования тестов.

Основные подходы к авторизации в тестах

1. Использование тестовых заглушек (Mocks)

    Для модульных тестов лучшей практикой является **изоляция** тестируемой логики от внешних систем, таких как сервисы авторизации. Здесь на помощь приходят моки, созданные с помощью библиотек вроде **Mockito**.

```java
import static org.mockito.Mockito.*;
import org.junit.jupiter.api.Test;

public class ServiceTest {
    @Test
    void testAuthorizedOperation() {
        // 1. Создаем мок зависимостей
        AuthService mockAuthService = mock(AuthService.class);
        UserRepository mockUserRepo = mock(UserRepository.class);

        // 2. Настраиваем поведение: мок возвращает валидный токен
        String testToken = "test-jwt-token-123";
        when(mockAuthService.validateToken(testToken)).thenReturn(true);
        when(mockAuthService.getUserIdFromToken(testToken)).thenReturn("user-123");

        // 3. Создаем тестируемый сервис, инжектим моки
        UserService userService = new UserService(mockAuthService, mockUserRepo);

        // 4. Вызываем метод, передавая токен
        UserProfile profile = userService.getProfile(testToken);

        // 5. Проверяем, что логика отработала корректно
        assertNotNull(profile);
        // ... дополнительные ассерты
    }
}
```

2. Предоставление учетных данных через конфигурацию

    Для интеграционных или end-to-end тестов, взаимодействующих с реальным API, учетные данные часто выносятся в конфигурационные файлы или переменные окружения. **Никогда не хардкодьте** пароли или секретные ключи в код тестов.

```java
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.Properties;

public class ApiIntegrationTest {
    private static String API_BASE_URL;
    private static String TEST_USERNAME;
    private static String TEST_PASSWORD;

    @BeforeAll
    static void setUp() throws IOException {
        // Чтение конфигурации из файла .properties
        Properties props = new Properties();
        props.load(Files.newInputStream(Paths.get("src/test/resources/test-config.properties")));

        API_BASE_URL = props.getProperty("api.url");
        TEST_USERNAME = props.getProperty("test.user");
        // Пароль может быть зашифрован или храниться в переменной окружения
        TEST_PASSWORD = System.getenv("TEST_API_PASSWORD") != null ?
                System.getenv("TEST_API_PASSWORD") :
                props.getProperty("test.password");
    }

    @Test
    void testAuthenticatedApiCall() {
        // Используем TEST_USERNAME и TEST_PASSWORD для получения токена
        // ... код HTTP-клиента для логина и последующих вызовов API
    }
}
```

Расширенные сценарии и паттерны

• Использование @BeforeEach / @BeforeAll для получения токена: Для набора тестов, требующих одного токена, эффективно получать его один раз.

  import org.junit.jupiter.api.BeforeAll;
  import okhttp3.OkHttpClient;
  
  public class SecuredApiTestSuite {
      protected static String authToken;
      protected static OkHttpClient client;
  
      @BeforeAll
      static void globalSetUp() {
          client = new OkHttpClient();
          // Выполняем запрос на логин и сохраняем токен
          authToken = loginAndGetToken("testUser", "testPass");
      }
  
      // В каждом тесте используем предварительно полученный authToken
      @Test
      void testGetUserData() {
          Request request = new Request.Builder()
              .url(API_URL + "/user/profile")
              .addHeader("Authorization", "Bearer " + authToken)
              .build();
          // ... выполнение запроса и ассерты
      }
  }
  

• Создание кастомных расширений JUnit Jupiter: Для сложных сценариев можно реализовать BeforeEachCallback или BeforeAllCallback в JUnit 5, который будет автоматически добавлять заголовок авторизации к HTTP-запросам теста.

• Работа с Spring Security в Spring Boot приложениях: Используйте аннотации @WithMockUser или @WithUserDetails для симуляции аутентифицированного пользователя прямо в контексте теста.

  import org.springframework.security.test.context.support.WithMockUser;
  import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
  
  @WebMvcTest
  class UserControllerTest {
  
      @Test
      @WithMockUser(username = "admin", roles = {"USER", "ADMIN"})
      void whenAdminAccess_thenOk() throws Exception {
          mockMvc.perform(get("/admin/users"))
                 .andExpect(status().isOk());
      }
  }
  

Ключевые принципы безопасного тестирования

• Изоляция тестовых данных: Используйте отдельные тестовые учетные записи, не затрагивающие прод.
• Использование секретов: Храните пароли, ключи и токены в защищенных хранилищах (например, HashiCorp Vault) или в переменных окружения CI/CD-системы (GitHub Secrets, GitLab CI Variables).
• Очистка данных: После выполнения тестов, которые создают сущности с помощью тестового пользователя, реализуйте очистку в методах, помеченных @AfterEach или @AfterAll.

Выбор конкретной стратегии зависит от типа теста (модульный, интеграционный, E2E), используемого стека технологий (Spring, Micronaut, простой Servlet) и требований к безопасности. Для модульных тестов предпочтительно мокирование, для проверки интеграции — работа с конфигурацией и реальными (но тестовыми) учетными данными.