org.jboss.arquillian.test.spi.event.suite.After Java Examples

public void on(@Observes(precedence = DEFAULT_PRECEDENCE) After event) throws Throwable {
    //we are outside the runtime class loader, so we don't have direct access to the container
    ClassLoader classLoader = appClassloader.get();
    if (classLoader != null) {
        Class<?> arcClz = classLoader.loadClass(Arc.class.getName());
        Object container = arcClz.getMethod("container").invoke(null);
        if (container != null) {
            boolean running = (boolean) container.getClass().getMethod("isRunning").invoke(container);
            if (running) {
                Object context = container.getClass().getMethod("requestContext").invoke(container);
                context.getClass().getMethod("terminate").invoke(context);
                LOGGER.debug("RequestContextLifecycle activating CDI Request context.");
            }
        }
    }
}
 

@Test
public void startBeforeSuiteTrueTest() throws Exception {

    Mockito.when(configuration.getStartBeforeSuite()).thenReturn(true);

    fire(new VideoExtensionConfigured());

    fire(new BeforeSuite());
    fire(new BeforeClass(DummyTestCase.class));
    fire(new Before(DummyTestCase.class, DummyTestCase.class.getMethod("test")));

    bind(TestScoped.class, TestResult.class, TestResult.passed());

    fire(new After(DummyTestCase.class, DummyTestCase.class.getMethod("test")));
    fire(new AfterClass(DummyTestCase.class));
    fire(new AfterSuite());

    assertEventFired(BeforeVideoStart.class, 1);
    assertEventFired(StartRecordSuiteVideo.class, 1);
    assertEventFired(AfterVideoStart.class, 1);

    assertEventFired(BeforeVideoStop.class, 1);
    assertEventFired(StopRecordSuiteVideo.class, 1);
    assertEventFired(AfterVideoStop.class, 1);
}
 

@Override
public boolean isTakingAction(Event event, TestResult result) {
    if (event instanceof AfterTestLifecycleEvent && !(event instanceof After)) {
        Screenshot screenshotAnnotation = ScreenshotAnnotationScanner.getScreenshotAnnotation(((AfterTestLifecycleEvent) event).getTestMethod());

        if (screenshotAnnotation != null) {
            if (screenshotAnnotation.takeAfterTest()) {
                return true;
            }
            if (result.getStatus() == Status.FAILED && screenshotAnnotation.takeWhenTestFailed()) {
                return true;
            }
        }
    }

    return false;
}
 

@Test
public void sholdReportGitHubGovernorParamsForClass(){
    After after = new After(new FakeTestClass(), getMethod("someTestMethod"));
    gitHubGovernorRecorder.gitHubReportEntries(after);

    verify(propertyReportEvent, times(2)).fire(propertyReportEventArgumentCaptor.capture());

    List<PropertyReportEvent> propertyReportEvents = propertyReportEventArgumentCaptor.getAllValues();

    KeyValueEntry gitHubURL = new KeyValueEntry("GitHub URL","https://github.com/dipak-pawar/governor-recorder-test/issues/1");

    LinkedHashMap<String, String> tableOptions = new LinkedHashMap<String, String>();
    tableOptions.put("Force", "true");
    tableOptions.put("Detector Value", "And");
    tableOptions.put("Detector Strategy", "True");

    assertThat(propertyReportEvents).hasSize(2).extracting("propertyEntry.class").contains(KeyValueEntry.class, TableEntry.class);
    assertThat(propertyReportEvents).extracting("propertyEntry").filteredOn("class", KeyValueEntry.class).contains(gitHubURL);
    assertThat(propertyReportEvents).extracting("propertyEntry").filteredOn("class", TableEntry.class) .contains(getTableEntry("GitHubOptions", tableOptions));
}
 

@Test
public void sholdReportJiraGovernorParamsForClass(){
    After after = new After(new FakeTestClass(), getMethod("someTestMethod"));
    jiraGovernorRecorder.jiraReportEntries(after);

    verify(propertyReportEvent, times(2)).fire(propertyReportEventArgumentCaptor.capture());

    List <PropertyReportEvent> propertyReportEvents = propertyReportEventArgumentCaptor.getAllValues();

    KeyValueEntry jiraURL = new KeyValueEntry("JIRA URL","https://jboss.issues.org/browse/ARQ-234");

    LinkedHashMap<String, String> tableOptions = new LinkedHashMap<String, String>();
    tableOptions.put("Force", "false");
    tableOptions.put("Detector Value", "And");
    tableOptions.put("Detector Strategy", "Windows");

    assertThat(propertyReportEvents).hasSize(2).extracting("propertyEntry.class").contains(KeyValueEntry.class, TableEntry.class);
    assertThat(propertyReportEvents).extracting("propertyEntry").filteredOn("class", KeyValueEntry.class).contains(jiraURL);
    assertThat(propertyReportEvents).extracting("propertyEntry").filteredOn("class", TableEntry.class) .contains(getTableEntry("JiraOptions", tableOptions));
}
 

@Test
public void shouldReportJiraGovernorParamsForMethod() {

    After after = new After(new FakeTestClass(), getMethod("dummyTest"));
    jiraGovernorRecorder.jiraReportEntries(after);

    verify(propertyReportEvent, times(2)).fire(propertyReportEventArgumentCaptor.capture());

    List <PropertyReportEvent> propertyReportEvents = propertyReportEventArgumentCaptor.getAllValues();

    KeyValueEntry keyValueEntry = new KeyValueEntry("JIRA URL","https://jboss.issues.org/browse/ARQ-123");

    LinkedHashMap<String, String> tableOptions = new LinkedHashMap<String, String>();
    tableOptions.put("Force", "true");
    tableOptions.put("Detector Value", "And");
    tableOptions.put("Detector Strategy", "Unix");

    assertThat(propertyReportEvents).hasSize(2).extracting("propertyEntry.class").contains(KeyValueEntry.class, TableEntry.class);
    assertThat(propertyReportEvents).extracting("propertyEntry").filteredOn("class", KeyValueEntry.class).contains(keyValueEntry);
    assertThat(propertyReportEvents).extracting("propertyEntry").filteredOn("class", TableEntry.class) .contains(getTableEntry("JiraOptions", tableOptions));
}
 

public void redmineReportEntries(@Observes After event) {

        final Method testMethod = event.getTestMethod();
        final TestClass testClass = event.getTestClass();
        final String redmineServerURL = redmineGovernorConfigurationInstance.get().getServer();

        final Redmine redmineValue = getRedmineValue(testMethod, testClass);
        if (redmineValue != null) {
            final String issueURL = constructRedmineIssueURL(redmineServerURL, redmineValue.value());

            final TableEntry redmineDetector = new TableEntry();
            redmineDetector.setTableName("RedmineOptions");
            redmineDetector.getTableHead().getRow().addCells(new TableCellEntry("Force"));

            final TableRowEntry row = new TableRowEntry();

            row.addCells(new TableCellEntry(String.valueOf(redmineValue.force())));
            redmineDetector.getTableBody().addRow(row);

            propertyReportEvent.fire(new PropertyReportEvent(new KeyValueEntry("Redmine URL", issueURL)));
            propertyReportEvent.fire(new PropertyReportEvent(redmineDetector));
        }
    }
 

@Override
public boolean isTakingAction(Event event, TestResult result) {
    if (event instanceof AfterTestLifecycleEvent && !(event instanceof After)) {
        if (configuration.getTakeAfterTest()) {
            return true;
        }
        if (result.getStatus() == Status.FAILED && configuration.getTakeWhenTestFailed()) {
            return true;
        }
    }
    return false;
}
 

@Override
public boolean isTakingAction(Event event, TestResult result) {
    if (event instanceof AfterTestLifecycleEvent && !(event instanceof After)) {
        switch (result.getStatus()) {
            case FAILED:
                return configuration.getTakeOnlyOnFail();
            case PASSED:
                return configuration.getStartBeforeTest() || configuration.getTakeOnlyOnFail();
            case SKIPPED:
            default:
                return false;
        }
    }
    return false;
}
 

@org.junit.After
public void teardown() {
    if (videoFile != null && videoFile.exists()) {
        if (!videoFile.delete()) {
            throw new IllegalStateException("Unable to delete temporary file: " + videoFile.getAbsolutePath());
        }
    }
}
 

public void destroy(@Observes EventContext<After> event) throws IOException {
    try {
        event.proceed();
    } finally {
        InjectionEnricher.CreationContextHolder cc = creationalContext.get();
        if (cc != null) {
            cc.close();
        }
    }
}
 

private boolean shouldReport(org.jboss.arquillian.core.spi.event.Event event, String frequency) {
    if (event instanceof AfterClass && ReportFrequency.CLASS.toString().equals(frequency)
            || (event instanceof After && ReportFrequency.METHOD.toString().equals(frequency)) ) {
        return true;
    }
    return false;
}
 

public void afterTestShutdownUnsharedAsciidoctorInstance(@Observes After after) {
    Asciidoctor asciidoctor = scopedAsciidoctor.get().getUnsharedAsciidoctor();
    if (asciidoctor != null) {
        asciidoctor.shutdown();
        scopedAsciidoctor.get().setUnsharedAsciidoctor(null);
    }
}
 

public void afterTestShutdownUnsharedTemporaryFolderInstance(@Observes After after) {
    TemporaryFolder temporaryFolder = scopedTemporaryFolder.get().getUnsharedTemporaryFolder();
    if (temporaryFolder != null) {
        temporaryFolder.delete();
        scopedTemporaryFolder.get().setUnsharedTemporaryFolder(null);
    }
}
 

@Test
public void sholdReportRedmineGovernorParamsForClass(){
    After after = new After(new FakeTestClass(), getMethod("someTestMethod"));
    redmineGovernorRecorder.redmineReportEntries(after);

    verify(propertyReportEvent, times(2)).fire(propertyReportEventArgumentCaptor.capture());

    List <PropertyReportEvent> propertyReportEvents = propertyReportEventArgumentCaptor.getAllValues();

    KeyValueEntry redmineURL = new KeyValueEntry("Redmine URL","http://redmine.test/issues/1");

    LinkedHashMap<String, String> tableOptions = new LinkedHashMap<String, String>();
    tableOptions.put("Force","true");

    assertThat(propertyReportEvents).hasSize(2).extracting("propertyEntry.class").contains(KeyValueEntry.class, TableEntry.class);
    assertThat(propertyReportEvents).extracting("propertyEntry").filteredOn("class", KeyValueEntry.class).contains(redmineURL);
    assertThat(propertyReportEvents).extracting("propertyEntry").filteredOn("class", TableEntry.class) .contains(getTableEntry("RedmineOptions", tableOptions));

}
 

@Test
public void shouldReportGitHubGovernorParamsForMethod() {

    After after = new After(new FakeTestClass(), getMethod("dummyTest"));
    gitHubGovernorRecorder.gitHubReportEntries(after);

    verify(propertyReportEvent, times(2)).fire(propertyReportEventArgumentCaptor.capture());

    List<PropertyReportEvent> propertyReportEvents = propertyReportEventArgumentCaptor.getAllValues();

    KeyValueEntry gitHubURL = new KeyValueEntry("GitHub URL","https://github.com/dipak-pawar/governor-recorder-test/issues/2");

    LinkedHashMap<String, String> tableOptions = new LinkedHashMap<String, String>();
    tableOptions.put("Force", "false");
    tableOptions.put("Detector Value", "And");
    tableOptions.put("Detector Strategy", "True");

    assertThat(propertyReportEvents).hasSize(2).extracting("propertyEntry.class").contains(KeyValueEntry.class, TableEntry.class);
    assertThat(propertyReportEvents).extracting("propertyEntry").filteredOn("class", KeyValueEntry.class).contains(gitHubURL);
    assertThat(propertyReportEvents).extracting("propertyEntry").filteredOn("class", TableEntry.class) .contains(getTableEntry("GitHubOptions", tableOptions));

}
 

@Test
public void shouldReportRedmineGovernorParamsForMethod() {

    After after = new After(new FakeTestClass(), getMethod("dummyTest"));
    redmineGovernorRecorder.redmineReportEntries(after);

    verify(propertyReportEvent, times(2)).fire(propertyReportEventArgumentCaptor.capture());

    List<PropertyReportEvent> propertyReportEvents = propertyReportEventArgumentCaptor.getAllValues();

    KeyValueEntry redmineURL = new KeyValueEntry("Redmine URL","http://redmine.test/issues/2");

    LinkedHashMap<String, String> tableOptions = new LinkedHashMap<String, String>();
    tableOptions.put("Force","false");

    assertThat(propertyReportEvents).hasSize(2).extracting("propertyEntry.class").contains(KeyValueEntry.class, TableEntry.class);
    assertThat(propertyReportEvents).extracting("propertyEntry").filteredOn("class", KeyValueEntry.class).contains(redmineURL);
    assertThat(propertyReportEvents).extracting("propertyEntry").filteredOn("class", TableEntry.class) .contains(getTableEntry("RedmineOptions", tableOptions));
}
 

public void afterTest(@Observes(precedence = -1) After event) throws IOException {
    if (event.getTestMethod().getAnnotation(UncaughtServerErrorExpected.class) == null) {
        suiteContext.getServerLogChecker().checkFiles(false, this::checkForNoUnexpectedUncaughtError);
    }
}
 

public void handleEnableFeaturesAnnotationAfterTest(@Observes(precedence = 2) After event) throws Exception {
    checkAnnotatedElementForFeatureAnnotations(event.getTestMethod(), State.AFTER);
}
 

public void afterTest(@Observes After event) {
    if (!suiteContext.isAuthServerCrossDc()) return;

    restorePeriodicTasks();
}