ru.testit.writers.HttpWriter Maven / Gradle / Ivy

Go to download
package ru.testit.writers;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import ru.testit.client.invoker.ApiException;
import ru.testit.client.model.*;
import ru.testit.clients.ApiClient;
import ru.testit.clients.ClientConfiguration;
import ru.testit.models.ClassContainer;
import ru.testit.models.ItemStatus;
import ru.testit.models.MainContainer;
import ru.testit.models.TestResult;
import ru.testit.services.ResultStorage;

import java.util.*;

public class HttpWriter implements Writer {
    private static final Logger LOGGER = LoggerFactory.getLogger(HttpWriter.class);
    private final Map testResults;
    private final ApiClient apiClient;
    private final ResultStorage storage;
    private final ClientConfiguration config;

    public HttpWriter(ClientConfiguration config, ApiClient client, ResultStorage storage) {
        this.config = config;
        this.apiClient = client;
        this.storage = storage;
        this.testResults = new HashMap<>();
    }

    @Override
    public void writeTest(TestResult testResult) {
        try {
            if (LOGGER.isDebugEnabled()) {
                LOGGER.debug("Write auto test {}", testResult.getExternalId());
            }

            AutoTestModel test = apiClient.getAutoTestByExternalId(testResult.getExternalId());
            List workItemId = testResult.getWorkItemId();
            String autoTestId;

            if (test != null) {
                if (LOGGER.isDebugEnabled()) {
                    LOGGER.debug("Auto test is exist. Update auto test {}", testResult.getExternalId());
                }

                AutoTestPutModel autoTestPutModel;

                if (testResult.getItemStatus() == ItemStatus.FAILED) {
                    autoTestPutModel = Converter.autoTestModelToAutoTestPutModel(test);
                    autoTestPutModel.links(Converter.convertPutLinks(testResult.getLinkItems()));
                } else {
                    autoTestPutModel = Converter.testResultToAutoTestPutModel(testResult);
                    autoTestPutModel.setProjectId(UUID.fromString(config.getProjectId()));
                }

                autoTestPutModel.setIsFlaky(test.getIsFlaky());

                apiClient.updateAutoTest(autoTestPutModel);
                autoTestId = test.getId().toString();
            } else {
                if (LOGGER.isDebugEnabled()) {
                    LOGGER.debug("Create new auto test {}", testResult.getExternalId());
                }

                AutoTestPostModel model = Converter.testResultToAutoTestPostModel(testResult);
                model.setProjectId(UUID.fromString(config.getProjectId()));
                autoTestId = apiClient.createAutoTest(model);
            }

            AutoTestResultsForTestRunModel autoTestResultsForTestRunModel = Converter.testResultToAutoTestResultsForTestRunModel(testResult);
            autoTestResultsForTestRunModel.setConfigurationId(UUID.fromString(config.getConfigurationId()));

            List results = new ArrayList<>();
            results.add(autoTestResultsForTestRunModel);
            List ids = apiClient.sendTestResults(config.getTestRunId(), results);
            testResults.put(testResult.getUuid(), ids.get(0));

            if (workItemId.size() == 0 || (test != null && testResult.getItemStatus() == ItemStatus.FAILED)) {
                return;
            }

            workItemId.forEach(i -> {
                try {
                    if (LOGGER.isDebugEnabled()) {
                        LOGGER.debug("Link work item {} to auto test {}", i, testResult.getExternalId());
                    }
                    apiClient.linkAutoTestToWorkItem(autoTestId, i);
                } catch (ApiException e) {
                    LOGGER.error("Can not link the autotest: ".concat(e.getMessage()));
                }
            });
        } catch (ApiException e) {
            LOGGER.error("Can not write the autotest: ".concat(e.getMessage()));
        }
    }

    @Override
    public void writeClass(ClassContainer container) {
        for (final String testUuid : container.getChildren()) {
            storage.getTestResult(testUuid).ifPresent(test -> {
                try {
                    AutoTestModel autoTestModel = apiClient.getAutoTestByExternalId(test.getExternalId());

                    if (autoTestModel == null) {
                        return;
                    }

                    AutoTestPutModel autoTestPutModel = Converter.autoTestModelToAutoTestPutModel(autoTestModel);

                    List beforeClass = Converter.convertFixture(container.getBeforeClassMethods(), null);
                    List beforeEach = Converter.convertFixture(container.getBeforeEachTest(), testUuid);
                    beforeClass.addAll(beforeEach);

                    List afterClass = Converter.convertFixture(container.getAfterClassMethods(), null);
                    List afterEach = Converter.convertFixture(container.getAfterEachTest(), testUuid);
                    afterClass.addAll(afterEach);

                    autoTestPutModel.setSetup(beforeClass);
                    autoTestPutModel.setTeardown(afterClass);

                    autoTestPutModel.setIsFlaky(autoTestModel.getIsFlaky());

                    apiClient.updateAutoTest(autoTestPutModel);
                } catch (ApiException e) {
                    LOGGER.error("Can not write the class: ".concat(e.getMessage()));
                }
            });
        }
    }

    @Override
    public void writeTests(MainContainer container) {
        List beforeAll = Converter.convertFixture(container.getBeforeMethods(), null);
        List afterAll = Converter.convertFixture(container.getAfterMethods(), null);
        List beforeResultAll = Converter.convertResultFixture(container.getBeforeMethods(), null);
        List afterResultAll = Converter.convertResultFixture(container.getAfterMethods(), null);

//        List results = new ArrayList<>();

        for (final String classUuid : container.getChildren()) {
            storage.getClassContainer(classUuid).ifPresent(cl -> {
                List beforeResultClass = Converter.convertResultFixture(cl.getBeforeClassMethods(), null);
                List afterResultClass = Converter.convertResultFixture(cl.getAfterClassMethods(), null);

                for (final String testUuid : cl.getChildren()) {
                    storage.getTestResult(testUuid).ifPresent(test -> {
                        try {
                            AutoTestModel autoTestModel = apiClient.getAutoTestByExternalId(test.getExternalId());

                            if (autoTestModel == null) {
                                return;
                            }

                            AutoTestPutModel autoTestPutModel = Converter.autoTestModelToAutoTestPutModel(autoTestModel);

                            List beforeFinish = new ArrayList<>(beforeAll);
                            beforeFinish.addAll(autoTestPutModel.getSetup());
                            autoTestPutModel.setSetup(beforeFinish);

                            List afterClass = Converter.convertFixture(cl.getAfterClassMethods(), null);

                            List afterFinish = autoTestPutModel.getTeardown();
                            afterFinish.addAll(afterClass);
                            afterFinish.addAll(afterAll);
                            autoTestPutModel.setTeardown(afterFinish);

                            autoTestPutModel.setIsFlaky(autoTestModel.getIsFlaky());

                            apiClient.updateAutoTest(autoTestPutModel);

                            AutoTestResultsForTestRunModel autoTestResultsForTestRunModel = Converter.testResultToAutoTestResultsForTestRunModel(test);

                            List beforeResultEach = Converter.convertResultFixture(cl.getBeforeEachTest(), testUuid);
                            List beforeResultFinish = new ArrayList<>();
                            beforeResultFinish.addAll(beforeResultAll);
                            beforeResultFinish.addAll(beforeResultClass);
                            beforeResultFinish.addAll(beforeResultEach);

                            List afterResultEach = Converter.convertResultFixture(cl.getAfterEachTest(), testUuid);
                            List afterResultFinish = new ArrayList<>();
                            afterResultFinish.addAll(afterResultEach);
                            afterResultFinish.addAll(afterResultClass);
                            afterResultFinish.addAll(afterResultAll);

                            autoTestResultsForTestRunModel.setSetupResults(beforeResultFinish);
                            autoTestResultsForTestRunModel.setTeardownResults(afterResultFinish);

                            UUID testResultId = testResults.get(test.getUuid());

                            TestResultModel resultModel = apiClient.getTestResult(testResultId);
                            TestResultUpdateModel model = Converter.testResultToTestResultUpdateModel(resultModel);
                            model.setSetupResults(beforeResultFinish);
                            model.setTeardownResults(afterResultFinish);

                            apiClient.updateTestResult(testResultId, model);

                        } catch (ApiException e) {
                            LOGGER.error("Can not update the autotest: ".concat(e.getMessage()));
                        }
                    });
                }
            });
        }
    }

    @Override
    public String writeAttachment(String path) {
        try {
            return apiClient.addAttachment(path);
        } catch (ApiException e) {
            LOGGER.error("Can not write attachment: ".concat(e.getMessage()));

            return "";
        }
    }

    void addUuid(String key, UUID uuid) {
        this.testResults.put(key, uuid);
    }
}