com.consol.citrus.TestCase Java Examples

public void completeTestAction(TestCase testCase, TestAction testAction) {
    if (skipTestAction(testAction)) {
        return;
    }

    ScenarioExecution te = lookupScenarioExecution(testCase);
    Iterator<ScenarioAction> iterator = te.getScenarioActions().iterator();
    ScenarioAction lastScenarioAction = null;
    while (iterator.hasNext()) {
        lastScenarioAction = iterator.next();
    }

    if (lastScenarioAction == null) {
        throw new CitrusRuntimeException(String.format("No test action found with name %s", testAction.getName()));
    }
    if (!lastScenarioAction.getName().equals(testAction.getName())) {
        throw new CitrusRuntimeException(String.format("Expected to find last test action with name %s but got %s", testAction.getName(), lastScenarioAction.getName()));
    }

    lastScenarioAction.setEndDate(getTimeNow());
}
 

private TestcaseModel getTestcaseModel(TestCase testCase) {
    TestcaseModel testModel = new TestcaseModel();
    testModel.setName(testCase.getName());

    VariablesModel variablesModel = new VariablesModel();
    for (Map.Entry<String, Object> entry : testCase.getVariableDefinitions().entrySet()) {
        VariablesModel.Variable variable = new VariablesModel.Variable();
        variable.setName(entry.getKey());
        variable.setValue(entry.getValue().toString());
        variablesModel.getVariables().add(variable);
    }
    testModel.setVariables(variablesModel);

    TestActionsType actions = new TestActionsType();
    for (com.consol.citrus.TestAction action : testCase.getActions()) {
        actions.getActionsAndSendsAndReceives().add(getActionModel(action));
    }

    testModel.setActions(actions);
    return testModel;
}
 

@Step("Run test case {testDesigner}")
private AllureResults run(final TestDesigner testDesigner) {
    final AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(
            CitrusSpringConfig.class, AllureCitrusConfig.class
    );
    final Citrus citrus = Citrus.newInstance(applicationContext);
    final TestContext testContext = citrus.createTestContext();

    final TestActionListeners listeners = applicationContext.getBean(TestActionListeners.class);
    final AllureLifecycle defaultLifecycle = Allure.getLifecycle();
    final AllureLifecycle lifecycle = applicationContext.getBean(AllureLifecycle.class);
    try {
        Allure.setLifecycle(lifecycle);
        final TestCase testCase = testDesigner.getTestCase();
        testCase.setTestActionListeners(listeners);

        citrus.run(testCase, testContext);
    } catch (Exception ignored) {
    } finally {
        Allure.setLifecycle(defaultLifecycle);
    }

    return applicationContext.getBean(AllureResultsWriterStub.class);
}
 

private void stopTestCase(final TestCase testCase,
                          final Status status,
                          final StatusDetails details) {
    final String uuid = removeUuid(testCase);
    final Map<String, Object> definitions = testCase.getVariableDefinitions();
    final List<Parameter> parameters = definitions.entrySet().stream()
            .map(entry -> createParameter(entry.getKey(), entry.getValue()))
            .collect(Collectors.toList());

    getLifecycle().updateTestCase(uuid, result -> {
        result.setParameters(parameters);
        result.setStage(Stage.FINISHED);
        result.setStatus(status);
        result.setStatusDetails(details);
    });
    getLifecycle().stopTestCase(uuid);
    getLifecycle().writeTestCase(uuid);
}
 

private String createUuid(final TestCase testCase) {
    final String uuid = UUID.randomUUID().toString();
    try {
        lock.writeLock().lock();
        testUuids.put(testCase, uuid);
    } finally {
        lock.writeLock().unlock();
    }
    return uuid;
}
 

@Override
public void onTestActionStart(TestCase testCase, TestAction testAction) {
    if (!ignoreTestAction(testAction)) {
        LOG.debug(testCase.getName() + "(" +
                StringUtils.arrayToCommaDelimitedString(getParameters(testCase)) + ") - " +
                testAction.getName() + ": " +
                (StringUtils.hasText(testAction.getDescription()) ? testAction.getDescription() : ""));
        executionService.createTestAction(testCase, testAction);
    }
}
 

@Override
public void onTestFailure(TestCase test, Throwable cause) {
    TestResult result = TestResult.failed(test.getName(), test.getTestClass().getSimpleName(), cause, test.getParameters());
    testResults.addResult(result);

    LOG.info(result.toString());
    LOG.info(result.getFailureType());
    executionService.completeScenarioExecutionFailure(test, cause);
}
 

@Override
public void onTestSuccess(TestCase test) {
    TestResult result = TestResult.success(test.getName(), test.getTestClass().getSimpleName(), test.getParameters());
    testResults.addResult(result);
    LOG.info(result.toString());
    executionService.completeScenarioExecutionSuccess(test);
}
 

private String[] getParameters(TestCase test) {
    List<String> parameterStrings = new ArrayList<String>();
    for (Map.Entry<String, Object> param : test.getParameters().entrySet()) {
        parameterStrings.add(param.getKey() + "=" + param.getValue());
    }

    return parameterStrings.toArray(new String[parameterStrings.size()]);
}
 

private String removeUuid(final TestCase testCase) {
    try {
        lock.writeLock().lock();
        return testUuids.remove(testCase);
    } finally {
        lock.writeLock().unlock();
    }
}
 

private String getUuid(final TestCase testCase) {
    try {
        lock.readLock().lock();
        return testUuids.get(testCase);
    } finally {
        lock.readLock().unlock();
    }
}
 

private void startTestCase(final TestCase testCase) {
    final String uuid = createUuid(testCase);

    final TestResult result = new TestResult()
            .setUuid(uuid)
            .setName(testCase.getName())
            .setStage(Stage.RUNNING);

    result.getLabels().addAll(getProvidedLabels());


    final Optional<? extends Class<?>> testClass = Optional.ofNullable(testCase.getTestClass());
    testClass.map(this::getLabels).ifPresent(result.getLabels()::addAll);
    testClass.map(this::getLinks).ifPresent(result.getLinks()::addAll);

    result.getLabels().addAll(Arrays.asList(
            createHostLabel(),
            createThreadLabel(),
            createFrameworkLabel("citrus"),
            createLanguageLabel("java")
    ));

    testClass.ifPresent(aClass -> {
        final String suiteName = aClass.getCanonicalName();
        result.getLabels().add(createSuiteLabel(suiteName));
    });

    final Optional<String> classDescription = testClass.flatMap(this::getDescription);
    final String description = Stream.of(classDescription)
            .filter(Optional::isPresent)
            .map(Optional::get)
            .collect(Collectors.joining("\n\n"));

    result.setDescription(description);

    getLifecycle().scheduleTestCase(result);
    getLifecycle().startTestCase(uuid);
}
 

private void completeScenarioExecution(ScenarioExecution.Status status, TestCase testCase, Throwable cause) {
    ScenarioExecution te = lookupScenarioExecution(testCase);
    te.setEndDate(getTimeNow());
    te.setStatus(status);
    if (cause != null) {
        StringWriter sw = new StringWriter();
        PrintWriter pw = new PrintWriter(sw);
        cause.printStackTrace(pw);
        te.setErrorMessage(sw.toString());
    }
}
 

public void createTestAction(TestCase testCase, TestAction testAction) {
    if (skipTestAction(testAction)) {
        return;
    }

    ScenarioExecution te = lookupScenarioExecution(testCase);
    ScenarioAction ta = new ScenarioAction();
    ta.setName(testAction.getName());
    ta.setStartDate(getTimeNow());
    te.addScenarioAction(ta);
}
 

@Override
public void onTestStart(TestCase test) {
    runningTests.put(StringUtils.arrayToCommaDelimitedString(getParameters(test)), TestResult.success(test.getName(), test.getTestClass().getSimpleName(), test.getParameters()));
}
 

public void completeScenarioExecutionSuccess(TestCase testCase) {
    completeScenarioExecution(ScenarioExecution.Status.SUCCESS, testCase, null);
}
 

public void completeScenarioExecutionFailure(TestCase testCase, Throwable cause) {
    completeScenarioExecution(ScenarioExecution.Status.FAILED, testCase, cause);
}
 

@Override
public void onTestActionSkipped(TestCase testCase, TestAction testAction) {
}
 

private ScenarioExecution lookupScenarioExecution(TestCase testCase) {
    return scenarioExecutionRepository.findById(lookupScenarioExecutionId(testCase)).orElseThrow(() -> new CitrusRuntimeException(String.format("Failed to look up scenario execution for test %s", testCase.getName())));
}
 

private long lookupScenarioExecutionId(TestCase testCase) {
    return Long.parseLong(testCase.getVariableDefinitions().get(ScenarioExecution.EXECUTION_ID).toString());
}
 

@Override
public void onTestActionFinish(TestCase testCase, TestAction testAction) {
    if (!ignoreTestAction(testAction)) {
        executionService.completeTestAction(testCase, testAction);
    }
}
 

@Override
public void onTestFinish(TestCase test) {
    runningTests.remove(StringUtils.arrayToCommaDelimitedString(getParameters(test)));
}
 

@Override
public void onTestStart(final TestCase test) {
    startTestCase(test);
}
 

@Override
public void onTestActionSkipped(final TestCase testCase, final TestAction testAction) {
    //do nothing
}
 

@Override
public void onTestActionFinish(final TestCase testCase, final TestAction testAction) {
    getLifecycle().stopStep();
}
 

@Override
public void onTestActionStart(final TestCase testCase, final TestAction testAction) {
    final String parentUuid = getUuid(testCase);
    final String uuid = UUID.randomUUID().toString();
    getLifecycle().startStep(parentUuid, uuid, new StepResult().setName(testAction.getName()));
}
 

@Override
public void onTestSkipped(final TestCase test) {
    //do nothing
}
 

@Override
public void onTestFailure(final TestCase test, final Throwable cause) {
    final Status status = ResultsUtils.getStatus(cause).orElse(Status.BROKEN);
    final StatusDetails details = ResultsUtils.getStatusDetails(cause).orElse(null);
    stopTestCase(test, status, details);
}
 

@Override
public void onTestSuccess(final TestCase test) {
    stopTestCase(test, Status.PASSED, null);
}
 

@Override
public void onTestFinish(final TestCase test) {
    //do nothing
}