ru.yandex.qatools.allure.model.TestCaseResult Java Examples

private void validateTestSuiteResult(TestSuiteResult testSuiteResult) {
    String brokenMethod = testSuiteResult.getName().replace(SUITE_PREFIX, "config");
    for (TestCaseResult result : testSuiteResult.getTestCases()) {
        String methodName = result.getName();
        Status status = result.getStatus();
        Status expectedStatus = Status.CANCELED;
        if (brokenMethod.startsWith(methodName)) {
            expectedStatus = Status.BROKEN;
        }
        if (brokenMethod.contains("After") && methodName.equalsIgnoreCase("test")) {
            expectedStatus = Status.PASSED;
        }
        assertThat(String.format("Wrong status for test <%s>, method <%s>", brokenMethod, methodName),
                status, equalTo(expectedStatus));
    }
}
 

@Override
public TestCaseResult next() {
    if (!hasNext()) {
        return null;
    }

    TestCaseResult result = testCases.next();

    Set<Label> labels = new HashSet<>(currentSuite.getLabels());
    labels.add(new Label().withName(SUITE_NAME).withValue(currentSuite.getName()));
    labels.add(new Label().withName(SUITE_TITLE).withValue(currentSuite.getTitle()));
    labels.addAll(result.getLabels());

    result.setLabels(new ArrayList<>(labels));

    Description description = mergeDescriptions(currentSuite, result);
    result.setDescription(description);

    return result;
}
 

@Override
protected void configure() {
    bind(File[].class).annotatedWith(ResultDirectories.class).toInstance(inputDirectories);
    bind(ClassLoader.class).annotatedWith(PluginClassLoader.class).toInstance(classLoader);

    bind(new TypeLiteral<Reader<TestSuiteResult>>() {
    }).to(TestSuiteReader.class);
    bind(new TypeLiteral<Reader<TestCaseResult>>() {
    }).to(TestCaseReader.class);
    bind(new TypeLiteral<Reader<Environment>>() {
    }).to(EnvironmentReader.class);
    bind(new TypeLiteral<Reader<AttachmentInfo>>() {
    }).to(AttachmentReader.class);

    bind(PluginLoader.class).to(DefaultPluginLoader.class);
    bind(AttachmentsIndex.class).to(DefaultAttachmentsIndex.class);

    bind(TestCaseConverter.class).to(DefaultTestCaseConverter.class);
}
 

@Test
public void allureClearStorageTest() {
    String suiteUid = UUID.randomUUID().toString();
    TestSuiteResult testSuite = fireTestSuiteStart(suiteUid);
    TestCaseResult testCase = fireTestCaseStart(suiteUid);
    assertThat(testSuite.getTestCases(), hasSize(1));
    assertEquals(testSuite.getTestCases().get(0), testCase);

    Step parentStep = fireStepStart();
    Step nestedStep = fireStepStart();
    fireStepFinished();

    assertThat(parentStep.getSteps(), hasSize(1));
    assertTrue(parentStep.getSteps().get(0) == nestedStep);

    fireStepFinished();
    fireClearStepStorage();

    assertThat(testCase.getSteps(), hasSize(0));
    fireClearTestStorage();
    TestCaseResult afterClearing = Allure.LIFECYCLE.getTestCaseStorage().get();
    assertFalse(testCase == afterClearing);
    checkTestCaseIsNew(afterClearing);

}
 

/**
 * Process TestCaseFinishedEvent. Add steps and attachments from
 * top step from stepStorage to current testCase, then remove testCase
 * and step from stores. Also remove attachments matches removeAttachments
 * config.
 *
 * @param event to process
 */
public void fire(TestCaseFinishedEvent event) {
    TestCaseResult testCase = testCaseStorage.get();
    event.process(testCase);

    Step root = stepStorage.pollLast();

    if (Status.PASSED.equals(testCase.getStatus())) {
        new RemoveAttachmentsEvent(AllureConfig.newInstance().getRemoveAttachments()).process(root);
    }

    testCase.getSteps().addAll(root.getSteps());
    testCase.getAttachments().addAll(root.getAttachments());

    stepStorage.remove();
    testCaseStorage.remove();

    notifier.fire(event);
}
 

private TestCaseResult buildTestCaseData(File resultDirectory, Scenario scenario, List<StepResult> stepResults) {
    List<Step> steps = buildStepsData(resultDirectory, stepResults);
    return new TestCaseResult()
            .withName(scenario.getName())
            .withStart(steps.stream().mapToLong(Step::getStart).min().orElse(0))
            .withStop(steps.stream().mapToLong(Step::getStop).max().orElse(0))
            .withStatus(steps.stream().anyMatch(step -> FAILED.equals(step.getStatus())) ? FAILED : PASSED)
            .withSteps(steps);
}
 

@Test
public void validatePendingTest() throws IOException {
    TestSuiteResult testSuite = AllureFileUtils.unmarshalSuites(resultsDir.toFile()).get(0);
    TestCaseResult testResult = testSuite.getTestCases().get(0);

    assertThat(testResult.getStatus(), equalTo(Status.PENDING));  
    assertThat(testResult.getDescription().getValue(), equalTo("This is pending test"));
}
 

@Test
public void someTest() throws Exception {
    Allure.LIFECYCLE.fire(new TestCaseEvent() {
        @Override
        public void process(TestCaseResult context) {
            context.setTitle(TestWithTimeoutAnnotation.NAME);
        }
    });
}
 

@Test(timeout = 10000)
public void someTest() throws Exception {
    Allure.LIFECYCLE.fire(new TestCaseEvent() {
        @Override
        public void process(TestCaseResult context) {
            context.setTitle(NAME);
        }
    });
}
 

public void generate(ReportWriter writer) {
    if (!testCaseReader.iterator().hasNext()) {
        throw new ReportGenerationException("Could not find any allure results");
    }

    writer.writeIndexHtml(pluginManager.getPluginsNames());

    for (TestCaseResult result : testCaseReader) {
        pluginManager.prepare(result);

        AllureTestCase testCase = converter.convert(result);
        pluginManager.prepare(testCase);
        pluginManager.process(testCase);
        writer.write(testCase);
    }

    for (Environment environment : environmentReader) {
        pluginManager.prepare(environment);
        pluginManager.process(environment);
    }

    for (AttachmentInfo attachment : attachmentReader) {
        pluginManager.prepare(attachment);
        writer.write(attachment);
    }

    pluginManager.writePluginData(writer);
    pluginManager.writePluginResources(writer);
    pluginManager.writePluginList(writer);
    pluginManager.writePluginWidgets(writer);

    writer.writeReportInfo();
}
 

@Test
public void testcaseEventTest() throws Exception {
    allure.fire(new TestCaseEvent() {
        @Override
        public void process(TestCaseResult context) {
        }
    });
    assertThat(listener.get(SimpleListener.EventType.TESTCASE_EVENT), is(1));
}
 

public TestCaseResult fireCustomTestCaseEvent() {
    Allure.LIFECYCLE.fire(new ChangeTestCaseTitleEvent("new.case.title"));
    TestCaseResult testCase = Allure.LIFECYCLE.getTestCaseStorage().get();
    assertNotNull(testCase);
    assertThat(testCase.getTitle(), is("new.case.title"));
    return testCase;
}
 

public TestCaseResult fireTestCaseStart(String uid) {
    Allure.LIFECYCLE.fire(new TestCaseStartedEvent(uid, "some.case.name"));
    TestCaseResult testCase = Allure.LIFECYCLE.getTestCaseStorage().get();
    assertNotNull(testCase);
    assertThat(testCase.getName(), is("some.case.name"));
    return testCase;
}
 

private void checkTestCaseIsNew(TestCaseResult testCaseResult) {
    assertNull(testCaseResult.getName());
    assertNull(testCaseResult.getTitle());
    assertNull(testCaseResult.getDescription());
    assertNull(testCaseResult.getFailure());
    assertNull(testCaseResult.getStatus());
    assertTrue(testCaseResult.getSteps().isEmpty());
    assertTrue(testCaseResult.getAttachments().isEmpty());
    assertTrue(testCaseResult.getLabels().isEmpty());
    assertTrue(testCaseResult.getParameters().isEmpty());
    assertTrue(testCaseResult.getStart() == 0 && testCaseResult.getStop() == 0);
}
 

private List<TestCaseResult> buildTestCasesData(
        File resultDirectory,
        String group,
        Map<Scenario, List<StepResult>> scenarioStepResultMap
) {
    return scenarioStepResultMap.entrySet().stream()
            .filter(entry -> group.equals(entry.getKey().getScenarioGroup() == null ?
                                          WITHOUT_GROUP :
                                          entry.getKey().getScenarioGroup()))
            .map(entry -> buildTestCaseData(resultDirectory, entry.getKey(), entry.getValue()))
            .collect(Collectors.toList());
}
 

/**
 * Process TestCaseEvent. You can change current testCase context
 * using this method.
 *
 * @param event to process
 */
public void fire(TestCaseEvent event) {
    TestCaseResult testCase = testCaseStorage.get();
    event.process(testCase);

    notifier.fire(event);
}
 

/**
 * Process TestCaseStartedEvent. New testCase will be created and added
 * to suite as child.
 *
 * @param event to process
 */
public void fire(TestCaseStartedEvent event) {
    //init root step in parent thread if needed
    stepStorage.get();

    TestCaseResult testCase = testCaseStorage.get();
    event.process(testCase);

    synchronized (TEST_SUITE_ADD_CHILD_LOCK) {
        testSuiteStorage.get(event.getSuiteUid()).getTestCases().add(testCase);
    }

    notifier.fire(event);
}
 

/**
 * Add parameter to testCase
 *
 * @param context which can be changed
 */
@Override
public void process(TestCaseResult context) {
    context.getParameters().add(new Parameter()
                    .withName(getName())
                    .withValue(getValue())
                    .withKind(ParameterKind.valueOf(getKind()))
    );
}
 

private List<Parameter> getParameters(final TestCaseResult source) {
    final TreeSet<Parameter> parametersSet = new TreeSet<>(
            comparing(Parameter::getName, nullsFirst(naturalOrder()))
                    .thenComparing(Parameter::getValue, nullsFirst(naturalOrder()))
    );
    parametersSet.addAll(convert(source.getParameters(), this::hasArgumentType, this::convert));
    return new ArrayList<>(parametersSet);
}
 

/**
 * Mark unfinished test cases as interrupted for each unfinished test suite, then write
 * test suite result
 * @see #createFakeTestcaseWithWarning(ru.yandex.qatools.allure.model.TestSuiteResult)
 * @see #markTestcaseAsInterruptedIfNotFinishedYet(ru.yandex.qatools.allure.model.TestCaseResult)
 */
@Override
public void run() {
    for (Map.Entry<String, TestSuiteResult> entry : testSuites) {
        for (TestCaseResult testCase : entry.getValue().getTestCases()) {
            markTestcaseAsInterruptedIfNotFinishedYet(testCase);
        }
        entry.getValue().getTestCases().add(createFakeTestcaseWithWarning(entry.getValue()));

        Allure.LIFECYCLE.fire(new TestSuiteFinishedEvent(entry.getKey()));
    }
}
 

/**
 * Create fake test case, which will used for mark suite as interrupted.
 */
public TestCaseResult createFakeTestcaseWithWarning(TestSuiteResult testSuite) {
    return new TestCaseResult()
            .withName(testSuite.getName())
            .withTitle(testSuite.getName())
            .withStart(testSuite.getStart())
            .withStop(System.currentTimeMillis())
            .withFailure(new Failure().withMessage("Test suite was interrupted, some test cases may be lost"))
            .withStatus(Status.BROKEN);
}
 

/**
 * Sets to testCase start time, default status, name, title, description and labels
 *
 * @param testCase to change
 */
@Override
public void process(TestCaseResult testCase) {
    testCase.setStart(System.currentTimeMillis());
    testCase.setStatus(Status.PASSED);
    testCase.setName(getName());
    testCase.setTitle(getTitle());
    testCase.setDescription(getDescription());
    testCase.setLabels(getLabels());
}
 

/**
 * If test not finished yet (in our case if stop time is zero) mark it as interrupted.
 * Set message, stop time and status.
 */
public void markTestcaseAsInterruptedIfNotFinishedYet(TestCaseResult testCase) {
    if (testCase.getStop() == 0L) {
        testCase.setStop(System.currentTimeMillis());
        testCase.setStatus(Status.BROKEN);
        testCase.setFailure(new Failure().withMessage("Test was interrupted"));
    }
}
 

public static Description mergeDescriptions(TestSuiteResult testSuiteResult, TestCaseResult testCaseResult) {
    return mergeDescriptions(testSuiteResult.getDescription(), testCaseResult.getDescription());
}
 

private List<ru.yandex.qatools.allure.model.Parameter> getEnvironmentParameters(final TestCaseResult testCase) {
    return testCase.getParameters().stream().filter(this::hasEnvType).collect(toList());
}
 

@Override
public Iterator<TestCaseResult> iterator() {
    return new TestCaseResultIterator();
}
 

@Test
public void simpleTest() throws Exception {
    TestCaseStorage storage = new TestCaseStorage();
    TestCaseResult testCase = storage.get();
    assertTrue(testCase == storage.get());
}
 

@Test
public void allureLifecycleTest() throws Exception {
    String uid = UUID.randomUUID().toString();
    TestSuiteResult testSuite = fireTestSuiteStart(uid);
    TestSuiteResult anotherTestSuite = fireCustomTestSuiteEvent(uid);
    assertEquals(testSuite, anotherTestSuite);

    TestCaseResult testCase = fireTestCaseStart(uid);
    TestCaseResult anotherTestCase = fireCustomTestCaseEvent();
    assertEquals(testCase, anotherTestCase);

    assertThat(testSuite.getTestCases(), hasSize(1));
    assertEquals(testSuite.getTestCases().get(0), testCase);

    Step parentStep = fireStepStart();
    Attachment firstAttach = fireMakeAttachment();

    assertThat(parentStep.getAttachments(), hasSize(1));
    assertEquals(parentStep.getAttachments().get(0), firstAttach);

    Step nestedStep = fireStepStart();
    Attachment secondAttach = fireMakeAttachment();

    assertFalse(firstAttach == secondAttach);

    assertThat(nestedStep.getAttachments(), hasSize(1));
    assertTrue(nestedStep.getAttachments().get(0) == secondAttach);

    fireStepFinished();

    assertThat(parentStep.getSteps(), hasSize(1));
    assertEquals(parentStep.getSteps().get(0), nestedStep);

    fireStepFinished();

    Attachment testCaseAttachment = fireMakeAttachment();

    fireTestCaseFinished();

    assertThat(testCase.getSteps(), hasSize(1));
    assertEquals(testCase.getSteps().get(0), parentStep);

    assertThat(testCase.getAttachments(), hasSize(1));
    assertEquals(testCase.getAttachments().get(0), testCaseAttachment);

    fireTestSuiteFinished(uid);
    validateTestSuite();

    assertThat(testSuite.getTestCases(), hasSize(1));

    String otherUid = UUID.randomUUID().toString();
    TestSuiteResult nextTestSuite = fireTestSuiteStart(otherUid);
    assertNotEquals(anotherTestSuite, nextTestSuite);
}
 

@Override
public void process(TestCaseResult context) {
    context.setTitle(title);
}
 

/**
 * Returns the current thread's "initial value". Construct an new
 * {@link ru.yandex.qatools.allure.model.TestCaseResult}
 *
 * @return the initial value for this thread-local
 */
@Override
protected TestCaseResult initialValue() {
    return new TestCaseResult();
}