io.qameta.allure.Step Java Examples

@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);
}
 

@Step("Run classes {classes}")
private AllureResults runClasses(final Class<?>... classes) {
    final AllureResultsWriterStub writerStub = new AllureResultsWriterStub();
    final AllureLifecycle lifecycle = new AllureLifecycle(writerStub);
    final JUnitCore core = new JUnitCore();
    core.addListener(new AllureJunit4(lifecycle));

    final AllureLifecycle defaultLifecycle = Allure.getLifecycle();
    try {
        Allure.setLifecycle(lifecycle);
        StepsAspects.setLifecycle(lifecycle);
        AttachmentsAspects.setLifecycle(lifecycle);
        core.run(classes);
        return writerStub;
    } finally {
        Allure.setLifecycle(defaultLifecycle);
        StepsAspects.setLifecycle(defaultLifecycle);
        AttachmentsAspects.setLifecycle(defaultLifecycle);
    }
}
 

@Step
private String storeRandomArtifactAndVerify(final String tenant) throws NoSuchAlgorithmException, IOException {
    final int filelengthBytes = 128;
    final String filename = "testfile.json";
    final MessageDigest mdSHA1 = MessageDigest.getInstance("SHA1");
    final MessageDigest mdMD5 = MessageDigest.getInstance("MD5");

    storeArtifact(tenant, filename, generateInputStream(filelengthBytes), mdSHA1, mdMD5, null);

    final String sha1Hash16 = BaseEncoding.base16().lowerCase().encode(mdSHA1.digest());
    final String md5Hash16 = BaseEncoding.base16().lowerCase().encode(mdMD5.digest());

    final AbstractDbArtifact loaded = artifactStoreUnderTest.getArtifactBySha1(tenant, sha1Hash16);
    assertThat(loaded).isNotNull();
    assertThat(loaded.getContentType()).isEqualTo("application/json");
    assertThat(loaded.getHashes().getSha1()).isEqualTo(sha1Hash16);
    assertThat(loaded.getHashes().getMd5()).isEqualTo(md5Hash16);
    assertThat(loaded.getSize()).isEqualTo(filelengthBytes);

    return sha1Hash16;
}
 

@Override
@Step("Logging in to AEM")
public void execute() {
  webDriver.get(authorUrl + "/libs/granite/core/content/login.html");
  webDriver.manage()
      .addCookie(aemAuthCookieFactory.getCookie(authorUrl, authorLoginProperty, authorPassword));
}
 

@SuppressWarnings("unchecked")
@Step("Check after fixtures")
private static void assertAfterFixtures(String containerName, List<TestResultContainer> containers,
                                        Object... afters) {
    assertThat(containers)
            .filteredOn(container -> container.getName().equals(containerName))
            .as("After fixtures are not attached to container " + containerName)
            .flatExtracting(TestResultContainer::getAfters)
            .is(ALL_FINISHED)
            .is(WITH_STEPS)
            .flatExtracting(FixtureResult::getName)
            .containsExactly(afters);
}
 

@Override
@Step("Create test page {data.contentPath}")
public void execute(SlingPageData data) throws AemPageManipulationException {
  HttpPost request = new HttpPost(authorIP + data.getContentPath());
  request.setEntity(new UrlEncodedFormEntity(data.getContent(), Consts.UTF_8));
  try {
    httpClient.execute(request);
  } catch (IOException e) {
    throw new AemPageManipulationException(e);
  } finally {
    request.releaseConnection();
  }
}
 

@Override
@Step("Submit page for creation")
public void submit() {
  wait.until(input -> getCreateButton().isEnabled());
  getCreateButton().click();
  List<WebElement> elements =
      pageCreatedModal.findElements(By.xpath("//coral-button-label[contains(text(),'Done')]"));

  elements.stream()
      .findFirst()
      .orElseThrow(() -> new NoSuchElementException("\"Done\" button not found"))
      .click();
}
 

@Step("Find results by name")
private TestResult findTestResultByName(final AllureResults results, final String name) {
    return results.getTestResults().stream()
            .filter(testResult -> name.equalsIgnoreCase(testResult.getName()))
            .findFirst()
            .orElseThrow(() -> new IllegalStateException("can not find result by name " + name));
}
 

@Override
@Step("Edit component")
public void execute(ComponentData data) {
  sidePanel.selectTab(SidePanelTabs.CONTENT_TREE.getCssClass());
  sidePanel.selectComponentToEdit(data.getComponentPath(), data.getComponentName(),
      data.getComponentOrder()).click();
  componentToolbar.clickOption(CommonToolbarOptions.EDIT.getTitle());
}
 

@Step("Check containers children")
private static void assertContainersChildren(String name, List<TestResultContainer> containers, List<String> uids) {
    assertThat(containers)
            .filteredOn("name", name)
            .flatExtracting(TestResultContainer::getChildren)
            .as("Unexpected children for testng container " + name)
            .containsOnlyElementsOf(uids);
}
 

@Step("Check containers per method")
private static void assertContainersPerMethod(String name, List<TestResultContainer> containersList,
                                              List<String> uids) {
    final Condition<List<? extends TestResultContainer>> singlyMapped = new Condition<>(containers ->
            containers.stream().allMatch(c -> c.getChildren().size() == 1),
            format("All containers for per-method fixture %s should be linked to only one testng result", name));

    assertThat(containersList)
            .filteredOn("name", name)
            .is(singlyMapped)
            .flatExtracting(TestResultContainer::getChildren)
            .as("Unexpected children for per-method fixtures " + name)
            .containsOnlyElementsOf(uids);
}
 

@Step("Find container by name")
private TestResultContainer findTestContainerByName(final AllureResults results, final String name) {
    return results.getTestResultContainers().stream()
            .filter(testResultContainer -> name.equalsIgnoreCase(testResultContainer.getName()))
            .findFirst()
            .orElseThrow(() -> new IllegalStateException("can not find container by name " + name));
}
 

@Step("Run classes {classes}")
private AllureResults runClasses(final Class<?>... classes) {
    final AllureResultsWriterStub writerStub = new AllureResultsWriterStub();
    final AllureLifecycle lifecycle = new AllureLifecycle(writerStub);

    final ClassSelector[] classSelectors = Stream.of(classes)
            .map(DiscoverySelectors::selectClass)
            .toArray(ClassSelector[]::new);

    final LauncherDiscoveryRequest request = LauncherDiscoveryRequestBuilder.request()
            .configurationParameter("junit.jupiter.extensions.autodetection.enabled", "true")
            .selectors(classSelectors)
            .build();

    final LauncherConfig config = LauncherConfig.builder()
            .enableTestExecutionListenerAutoRegistration(false)
            .addTestExecutionListeners(new AllureJunitPlatform(lifecycle))
            .build();
    final Launcher launcher = LauncherFactory.create(config);

    final AllureLifecycle defaultLifecycle = Allure.getLifecycle();
    try {
        Allure.setLifecycle(lifecycle);
        StepsAspects.setLifecycle(lifecycle);
        AttachmentsAspects.setLifecycle(lifecycle);
        launcher.execute(request);
        return writerStub;
    } finally {
        Allure.setLifecycle(defaultLifecycle);
        StepsAspects.setLifecycle(defaultLifecycle);
        AttachmentsAspects.setLifecycle(defaultLifecycle);
    }
}
 

@SuppressWarnings("unchecked")
@Step("Check before fixtures")
private static void assertBeforeFixtures(String containerName, List<TestResultContainer> containers,
                                         Object... befores) {
    assertThat(containers)
            .filteredOn(container -> container.getName().equals(containerName))
            .as("Before fixtures are not attached to container " + containerName)
            .flatExtracting(TestResultContainer::getBefores)
            .is(ALL_FINISHED)
            .is(WITH_STEPS)
            .flatExtracting(FixtureResult::getName)
            .containsExactly(befores);
}
 

@Step("Check that javadoc description of tests refer to correct test methods")
private static void checkTestJavadocDescriptions(List<TestResult> results, String methodReference, String expectedDescriptionHtml) {
    assertThat(results).as("Test results has not been written")
            .isNotEmpty()
            .filteredOn(result -> result.getFullName().equals(methodReference))
            .extracting(result -> result.getDescriptionHtml().trim())
            .as("Javadoc description of befores have been processed incorrectly")
            .containsOnly(expectedDescriptionHtml);
}
 

@Before("anyMethod() && withStepAnnotation()")
public void stepStart(final JoinPoint joinPoint) {
    final MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
    final Step step = methodSignature.getMethod().getAnnotation(Step.class);

    final String uuid = UUID.randomUUID().toString();
    final String name = getName(step.value(), joinPoint);
    final List<Parameter> parameters = getParameters(methodSignature, joinPoint.getArgs());

    final StepResult result = new StepResult()
            .setName(name)
            .setParameters(parameters);

    getLifecycle().startStep(uuid, result);
}
 

@Step
@Then("^I should see information about \"([^\"]*)\"$")
public void i_should_see_information_about(String searchTerm) {
    MapInfoPane mapInfoPaneWithTimeout =
            new MapInfoPane().get(Duration.ofSeconds(30));
    assertThat(mapInfoPaneWithTimeout.getInfoHeaderText())
            .contains(searchTerm);
}
 

@SuppressWarnings("unchecked")
@Override
@Step("Configure component")
public void execute(ConfigureComponentData data) {
  selectComponent(data);
  componentToolbar.clickOption(CommonToolbarOptions.CONFIGURE.getTitle());
  ComponentConfiguration componentConfiguration =
      componentConfigReader.readConfiguration(data.getConfigLocation());
  configDialog.configureWith(componentConfiguration);
}
 

@Override
@Step("Select template {templateName}")
public CreatePageWizard selectTemplate(String templateName) {
  templateList.selectTemplate(templateName);
  getNextButton().click();
  return this;
}
 

@Override
@Step("Edit component")
public void execute(ComponentData data) {
  sidePanel.selectTab(SidePanelTabs.CONTENT_TREE.getCssClass());
  sidePanel.selectComponentToEdit(data.getComponentPath(), data.getComponentName(),
      data.getComponentOrder()).click();
  componentToolbar.clickOption(CommonToolbarOptions.EDIT.getTitle());
}
 

/**
 * Open the page in browser
 */
@Step("Open page")
@Override
public T open() {
  webDriver.get(authorUrl + getFullUrl());
  return (T) this;
}
 

@Override
@Step("Create test page {data.contentPath}")
public void execute(SlingPageData data) throws AemPageManipulationException {
  HttpPost request = new HttpPost(authorIP + data.getContentPath());
  request.setEntity(new UrlEncodedFormEntity(data.getContent(), Consts.UTF_8));
  try {
    httpClient.execute(request);
  } catch (IOException e) {
    throw new AemPageManipulationException(e);
  }
}
 

@SuppressWarnings("unchecked")
@Override
@Step("Configure component")
public void execute(ConfigureComponentData data) {
  selectComponent(data);
  componentToolbar.clickOption(CommonToolbarOptions.CONFIGURE.getTitle());
  ComponentConfiguration componentConfiguration =
      componentConfigReader.readConfiguration(data.getConfigLocation());
  configDialog.configureWith(componentConfiguration);
}
 

@Step("use {method}")
void stepWithMethodParameter(final String method) {
}
 

@Override
@Step("Logging out of AEM")
public void execute() {
  webDriver.get(authorUrl + "/system/sling/logout.html");
  aemAuthCookieFactory.removeCookie(authorUrl);
}
 

@Step("\"{user.emails.address}\", \"{user.emails}\", \"{user.emails.attachments}\", \"{user.password}\", \"{}\"," +
        " \"{user.card.number}\", \"{missing}\", {staySignedIn}")
private void loginWith(final DummyUser user, final boolean staySignedIn) {
}
 

@Step
void stepWithParams(final String a, final String b) {
}
 

@Step("TestData = {value}")
public void checkData(@SuppressWarnings("unused") final String value) {
}
 

@Step
@When("^I click downloads$")
public void i_click_downloads() {
    new SeleniumHomePage().get().gotoDownloadsPage();
}
 

@Step
void stepWithAssertion() {
    throw new AssertionError("some assertion");
}