src/test/java/TeamSyncTest/contract/TaskContract_Test.java - master - koskv/TeamSync-Tests

src/test/java/TeamSyncTest/contract/TaskContract_Test.java
272 строки10 KB
Koskv
REF: Перед правкой метода getRandomEntity()
20 ноя 2025, 16:11
20 ноя 2025, 16:110544783
package TeamSyncTest.contract;


import TeamSyncTest.constants.Endpoints;
import TeamSyncTest.constants.JsonPath;
import TeamSyncTest.constants.JsonSchemaPath;
import TeamSyncTest.models.*;
import TeamSyncTest.models.error.ApiErrorResponseDto;
import TeamSyncTest.models.error.ErrorExceptionDto;
import TeamSyncTest.models.response.ApiResponse;
import TeamSyncTest.utils.custom.Generator;
import TeamSyncTest.utils.api.ApiMethodsNew;
import io.qameta.allure.Epic;
import io.qameta.allure.Feature;
import io.qameta.allure.Story;
import org.junit.jupiter.api.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import utils.api.BaseContractTest;
import utils.api.SchemaValidator;
import utils.coverage.SchemaCoverageTracker;

import java.io.IOException;

import static TeamSyncTest.constants.JsonSchemaPath.NOT_FOUND_SCHEMA;
import static TeamSyncTest.constants.JsonSchemaPath.TASK_REQUIRED_ERROR_SCHEMA;
import static org.junit.jupiter.api.Assertions.*;

@Tag("contract")
@Epic("Contract Tests")
@Feature("Task - JSON Schema Validation")
@SpringBootTest
public class TaskContract_Test extends BaseContractTest {

    private Long taskId;
    private Long employeeId;
    private Long projectId;
    private Long companyId;

    @Autowired
    private ApiMethodsNew apiMethodsNew;

    @Override
    protected SchemaCoverageTracker getPrimaryTracker() { return SchemaCoverageTracker.TASK; }
    @Override
    protected SchemaCoverageTracker getErrorTracker() { return SchemaCoverageTracker.ERROR_TASK; }

    // ======== ТЕСТЫ =================================================
        // ==== Task_ResponseSchema.json =================
    @Test
    @Story("Task - Task_ResponseSchema.json")
    @DisplayName("POST /api/tasks — успешное создание (201)")
    void createTask_Success() throws IOException {
        // Arrange
        TaskDto body = createTaskBody();

        // Act
        TaskDto response = apiMethodsNew.create(TaskDto.class, body, Endpoints.TASK_API, authToken);
        this.taskId = response.getId();

        // Validate
        SchemaValidator.validateAndTrack(
                response,
                JsonSchemaPath.TASK_RESPONSE_SCHEMA,
                SchemaCoverageTracker.TASK
        );
    }

    @Test
    @Story("Task - Task_ResponseSchema.json")
    @DisplayName("GET /api/tasks/{id} — успешное получение (200)")
    void getTask_Success() {
        // Arrange
        TaskDto body = createTaskBody();

        TaskDto newTask = apiMethodsNew.create(
                TaskDto.class, body, Endpoints.TASK_API, authToken);
        this.taskId = newTask.getId();

        // Act
        ApiResponse<TaskDto> response = apiMethodsNew.getByIdWithResponse(TaskDto.class, Endpoints.TASK_API, taskId, authToken);

        // Validate
        SchemaValidator.validateAndTrack(
                response.getBody(),
                JsonSchemaPath.TASK_RESPONSE_SCHEMA,
                SchemaCoverageTracker.TASK
        );
    }

    @Test
    @Story("Task - Task_ResponseSchema.json")
    @DisplayName("PUT /api/tasks/{id} — успешное обновление (200)")
    void updateTask_Success() {
        // Arrange
        TaskDto createBody = createTaskBody();
        createBody.setDescription("Initial description");

        TaskDto createdTask = apiMethodsNew.create(TaskDto.class, createBody, Endpoints.TASK_API, authToken);
        this.taskId = createdTask.getId();

        TaskDto updateBody = createTaskBody();
        updateBody.setDescription("Updated description");

        // Act
        TaskDto updatedTask = apiMethodsNew.patch(TaskDto.class, updateBody, Endpoints.TASK_API, taskId, authToken);

        // Assert — проверяем, что description обновилась
        assertNotEquals(createdTask.getDescription(), updatedTask.getDescription());
        assertEquals("Updated description", updatedTask.getDescription());

        // Дополнительно: GET для проверки
        ApiResponse<TaskDto> fetchedTask = apiMethodsNew.getByIdWithResponse(TaskDto.class, Endpoints.TASK_API, taskId, authToken);
        assertEquals("Updated description", fetchedTask.getBody().getDescription());

        // Validate — ОДНА СХЕМА для всех ответов с Task
        SchemaValidator.validateAndTrack(
                updatedTask,
                JsonSchemaPath.TASK_RESPONSE_SCHEMA,
                SchemaCoverageTracker.TASK
        );
    }

    // ==== TaskRequiredFieldsSchema.json =================

    @Test
    @Story("Task - TaskRequiredFieldsSchema.json")
    @DisplayName("POST /api/tasks — обязательные поля (400)")
    void createTask_Requared() throws IOException {
        // Arrange
        TaskDto body = new TaskDto();

        ApiResponse<ApiErrorResponseDto> response = apiMethodsNew.createExpectingError(
                ApiErrorResponseDto.class, body, Endpoints.TASK_API, authToken, 400);

        // ОДНА схема для всех успешных ответов с Task
        SchemaValidator.validateAndTrack(
                response,
                TASK_REQUIRED_ERROR_SCHEMA,
                SchemaCoverageTracker.TASK
        );
    }

    @Test
    @Story("Task - TaskRequiredFieldsSchema.json")
    @DisplayName("PUT /api/tasks — обязательные поля (400)")
    void putTask_Requared() throws IOException {
        // Arrange
        TaskDto body = createTaskBody();

        ApiResponse<TaskDto> newTask = apiMethodsNew.createWithResponse(TaskDto.class, body, Endpoints.TASK_API, authToken);
        this.taskId = newTask.getBody().getId();

        TaskDto updateBody = createTaskBody(); // ставим в обязательные поля Null
        updateBody.setTaskNumber(null);
        updateBody.setCompanyId(null);
        updateBody.setProjectId(null);
        updateBody.setTitle(null);
        updateBody.setAssigneeId(null);
        updateBody.setStatus(null);


        // Act
        ApiResponse<ApiErrorResponseDto> response = apiMethodsNew.patchExpectingError(
                ApiErrorResponseDto.class, updateBody, Endpoints.TASK_API, taskId, authToken, 400);

        // ОДНА схема для всех успешных ответов с Task
        SchemaValidator.validateAndTrack(
                response.getBody(),
                TASK_REQUIRED_ERROR_SCHEMA,
                SchemaCoverageTracker.TASK
        );
    }

    // ========= error_invalidJsonFormat.json ================

    @Test
    @Story("Task - error_invalidJsonFormat.json")
    @DisplayName("POST /api/tasks - error Content-Type (415)")
    void createTask_InvalidJson() {
        String xmlBody = "<task><title>Test</title></task>";

        ApiResponse<ErrorExceptionDto> error = apiMethodsNew.createExpectingError(
                ErrorExceptionDto.class,
                xmlBody,
                Endpoints.TASK_API,
                authToken,
                415);

        SchemaValidator.validateAndTrack(
                error,
                JsonSchemaPath.ERROR_INVALID_JSON_FORMAT_SCHEMA,
                SchemaCoverageTracker.ERROR_TASK
        );
    }

    @Test
    @Story("Task - error_invalidJsonFormat.json")
    @DisplayName("PUT /api/tasks/{id} - error Content-Type (415)")
    void updateTask_WithXmlContentType() {
        // Arrange
        TaskDto body = createTaskBody();

        TaskDto newTask = apiMethodsNew.create(TaskDto.class, body, Endpoints.TASK_API, authToken);
        this.taskId = newTask.getId();

        String xmlBody = "<task><title>Test</title></task>";


        ApiResponse<ErrorExceptionDto> error = apiMethodsNew.patchExpectingError(
                ErrorExceptionDto.class,
                xmlBody,
                Endpoints.TASK_API,
                taskId,
                authToken,
                415);

        SchemaValidator.validateAndTrack(
                error,
                TASK_REQUIRED_ERROR_SCHEMA,
                SchemaCoverageTracker.ERROR_TASK
        );

    }


    //=========================================
    @Test
    @Story("Task - error_response.json")
    @DisplayName("GET /api/tasks/999 — Not Found (404)")
    void getTask_NotFound() {
        ApiResponse<ErrorExceptionDto> error = apiMethodsNew.getByIdWithResponse(
                ErrorExceptionDto.class, Endpoints.TASK_API, 99999L,  authToken);

        SchemaValidator.validateAndTrack(
                error,
                NOT_FOUND_SCHEMA,
                SchemaCoverageTracker.ERROR_TASK
        );
    }


//============================================

    @BeforeEach
    public void beforeEach() {

        this.employeeId = apiMethodsNew.getAll(EmployeeDto.class, Endpoints.EMPLOYEE_API, authToken).get(0).getId();
        this.projectId = apiMethodsNew.getAll(ProjectDto.class, Endpoints.PROJECT_API, authToken).get(0).getId();
        this.companyId = apiMethodsNew.getAll(CompanyDto.class, Endpoints.COMPANY_API, authToken).get(0).getId();
    }

    @AfterEach
    void cleanup() {
        if (taskId != null) {
            System.out.println("Try to delete Task with ID: " + taskId);
            apiMethodsNew.deleteWithResponse(Endpoints.TASK_API, taskId, authToken);
            taskId = null;
        }
    }

    // Настройка тела запроса через дженерик
    public TaskDto createTaskBody(){
        return createRequestBody(JsonPath.TASK_JSON, TaskDto.class, body -> {
            body.setTaskNumber(Generator.getRandomNumberWithNDigitsToString(8));
            body.setProjectId(projectId);
            body.setCompanyId(companyId);
            body.setAssigneeId(employeeId);
        });
    }

}