How to use method of org.jmock.junit5.acceptance.FailureRecordingTestExecutionListener class

1package org.jmock.junit5.acceptance;
2
3import org.jmock.junit5.testdata.jmock.acceptance.DerivedJUnit5TestThatDoesNotSatisfyExpectations;
4import org.jmock.junit5.testdata.jmock.acceptance.JUnit5TestThatAutoInstantiatesMocks;
5import org.jmock.junit5.testdata.jmock.acceptance.JUnit5TestThatCreatesNoMockery;
6import org.jmock.junit5.testdata.jmock.acceptance.JUnit5TestThatCreatesTwoMockeries;
7import org.jmock.junit5.testdata.jmock.acceptance.JUnit5TestThatDoesNotCreateAMockery;
8import org.jmock.junit5.testdata.jmock.acceptance.JUnit5TestThatDoesNotSatisfyExpectations;
9import org.jmock.junit5.testdata.jmock.acceptance.JUnit5TestThatDoesSatisfyExpectations;
10import org.jmock.junit5.testdata.jmock.acceptance.JUnit5TestThatThrowsExpectedException;
11import org.junit.jupiter.api.Test;
12
13/**
14 * Wrap, running "testdata" testcases. Some of which are supposed to fail
15 * @author oliverbye
16 *
17 */
18public class JUnit5TestRunnerTests {
19
20    FailureRecordingTestExecutionListener listener = new FailureRecordingTestExecutionListener();
21
22    @Test
23    public void testTheJUnit5TestRunnerReportsPassingTestsAsSuccessful() {
24        listener.runTestIn(JUnit5TestThatDoesSatisfyExpectations.class);
25        listener.assertTestSucceeded();
26    }
27
28    @Test
29    public void testTheJUnit5TestRunnerAutomaticallyAssertsThatAllExpectationsHaveBeenSatisfied() {
30        listener.runTestIn(JUnit5TestThatDoesNotSatisfyExpectations.class);
31        listener.assertTestFailedWith(AssertionError.class);
32    }
33
34    @Test
35    public void testTheJUnit5TestRunnerLooksForTheMockeryInBaseClasses() {
36        listener.runTestIn(DerivedJUnit5TestThatDoesNotSatisfyExpectations.class);
37        listener.assertTestFailedWith(AssertionError.class);
38    }
39
40    @Test
41    public void testTheJUnit5TestRunnerReportsAHelpfulErrorIfTheMockeryIsNull() {
42        listener.runTestIn(JUnit5TestThatDoesNotCreateAMockery.class);
43        listener.assertTestFailedWith(org.junit.platform.commons.util.PreconditionViolationException.class);
44    }
45
46    // See issue JMOCK-156
47    @Test
48    public void testReportsMocksAreNotSatisfiedWhenExpectedExceptionIsThrown() {
49        listener.runTestIn(JUnit5TestThatThrowsExpectedException.class);
50        listener.assertTestFailedWith(AssertionError.class);
51    }
52
53    // See issue JMOCK-219
54    @Test
55    public void testTheJUnit5TestRunnerReportsIfNoMockeryIsFound() {
56        listener.runTestIn(JUnit5TestThatCreatesNoMockery.class);
57        listener.assertTestFailedWithInitializationError();
58    }
59
60    // See issue JMOCK-219
61    @Test
62    public void testTheJUnit4TestRunnerReportsIfMoreThanOneMockeryIsFound() {
63        listener.runTestIn(JUnit5TestThatCreatesTwoMockeries.class);
64        listener.assertTestFailedWithInitializationError();
65    }
66
67    @Test
68    public void testAutoInstantiatesMocks() {
69        listener.runTestIn(JUnit5TestThatAutoInstantiatesMocks.class);
70        listener.assertTestSucceeded();
71    }
72}
73

Source: JUnit5TestRunnerTests.java

package org.jmock.junit5.acceptance;

import org.jmock.junit5.testdata.jmock.acceptance.DerivedJUnit5TestThatDoesNotSatisfyExpectations;
import org.jmock.junit5.testdata.jmock.acceptance.JUnit5TestThatAutoInstantiatesMocks;
import org.jmock.junit5.testdata.jmock.acceptance.JUnit5TestThatCreatesNoMockery;
import org.jmock.junit5.testdata.jmock.acceptance.JUnit5TestThatCreatesTwoMockeries;
import org.jmock.junit5.testdata.jmock.acceptance.JUnit5TestThatDoesNotCreateAMockery;
import org.jmock.junit5.testdata.jmock.acceptance.JUnit5TestThatDoesNotSatisfyExpectations;
import org.jmock.junit5.testdata.jmock.acceptance.JUnit5TestThatDoesSatisfyExpectations;
import org.jmock.junit5.testdata.jmock.acceptance.JUnit5TestThatThrowsExpectedException;
import org.junit.jupiter.api.Test;

/**
 * Wrap, running "testdata" testcases. Some of which are supposed to fail
 * @author oliverbye
 *
 */
public class JUnit5TestRunnerTests {

    FailureRecordingTestExecutionListener listener = new FailureRecordingTestExecutionListener();

    @Test
    public void testTheJUnit5TestRunnerReportsPassingTestsAsSuccessful() {
        listener.runTestIn(JUnit5TestThatDoesSatisfyExpectations.class);
        listener.assertTestSucceeded();
    }

    @Test
    public void testTheJUnit5TestRunnerAutomaticallyAssertsThatAllExpectationsHaveBeenSatisfied() {
        listener.runTestIn(JUnit5TestThatDoesNotSatisfyExpectations.class);
        listener.assertTestFailedWith(AssertionError.class);
    }

    @Test
    public void testTheJUnit5TestRunnerLooksForTheMockeryInBaseClasses() {
        listener.runTestIn(DerivedJUnit5TestThatDoesNotSatisfyExpectations.class);
        listener.assertTestFailedWith(AssertionError.class);
    }

    @Test
    public void testTheJUnit5TestRunnerReportsAHelpfulErrorIfTheMockeryIsNull() {
        listener.runTestIn(JUnit5TestThatDoesNotCreateAMockery.class);
        listener.assertTestFailedWith(org.junit.platform.commons.util.PreconditionViolationException.class);
    }

    // See issue JMOCK-156
    @Test
    public void testReportsMocksAreNotSatisfiedWhenExpectedExceptionIsThrown() {
        listener.runTestIn(JUnit5TestThatThrowsExpectedException.class);
        listener.assertTestFailedWith(AssertionError.class);
    }

    // See issue JMOCK-219
    @Test
    public void testTheJUnit5TestRunnerReportsIfNoMockeryIsFound() {
        listener.runTestIn(JUnit5TestThatCreatesNoMockery.class);
        listener.assertTestFailedWithInitializationError();
    }

    // See issue JMOCK-219
    @Test
    public void testTheJUnit4TestRunnerReportsIfMoreThanOneMockeryIsFound() {
        listener.runTestIn(JUnit5TestThatCreatesTwoMockeries.class);
        listener.assertTestFailedWithInitializationError();
    }

    @Test
    public void testAutoInstantiatesMocks() {
        listener.runTestIn(JUnit5TestThatAutoInstantiatesMocks.class);
        listener.assertTestSucceeded();
    }
}

1package org.jmock.junit5.acceptance;
2
3import org.jmock.junit5.testdata.jmock.acceptance.JUnit5WithRulesExamples;
4import org.junit.jupiter.api.Test;
5import org.junit.jupiter.api.extension.ExtensionConfigurationException;
6
7public class JUnit5WithRulesTestRunnerTests {
8    FailureRecordingTestExecutionListener listener = new FailureRecordingTestExecutionListener();
9    
10    @Test
11    public void testTheJUnit4TestRunnerReportsPassingTestsAsSuccessful() {
12        listener.runTestIn(JUnit5WithRulesExamples.SatisfiesExpectations.class);
13        listener.assertTestSucceeded();
14    }
15    
16    @Test
17    public void testTheJUnit4TestRunnerAutomaticallyAssertsThatAllExpectationsHaveBeenSatisfied() {
18        listener.runTestIn(JUnit5WithRulesExamples.DoesNotSatisfyExpectations.class);
19        listener.assertTestFailedWith(AssertionError.class);
20    }
21    
22    @Test
23    public void testTheJUnit4TestRunnerLooksForTheMockeryInBaseClasses() {
24        listener.runTestIn(JUnit5WithRulesExamples.DerivedAndDoesNotSatisfyExpectations.class);
25        listener.assertTestFailedWith(AssertionError.class);
26    }
27
28    
29    // See issue JMOCK-156
30    @Test
31    public void testReportsMocksAreNotSatisfiedWhenExpectedExceptionIsThrown() {
32        listener.runTestIn(JUnit5WithRulesExamples.ThrowsExpectedException.class);
33        listener.assertTestFailedWith(AssertionError.class);
34    }
35    
36    @Test
37    public void testFailsWhenMoreThanOneJMockContextField() {
38        listener.runTestIn(JUnit5WithRulesExamples.CreatesTwoMockeries.class);
39        listener.assertTestFailedWith(ExtensionConfigurationException.class);
40    }
41
42    @Test
43    public void testAutoInstantiatesMocks() {
44        listener.runTestIn(JUnit5WithRulesExamples.AutoInstantiatesMocks.class);
45        listener.assertTestSucceeded();
46    }
47}
48

Source: JUnit5WithRulesTestRunnerTests.java

package org.jmock.junit5.acceptance;

import org.jmock.junit5.testdata.jmock.acceptance.JUnit5WithRulesExamples;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtensionConfigurationException;

public class JUnit5WithRulesTestRunnerTests {
    FailureRecordingTestExecutionListener listener = new FailureRecordingTestExecutionListener();
    
    @Test
    public void testTheJUnit4TestRunnerReportsPassingTestsAsSuccessful() {
        listener.runTestIn(JUnit5WithRulesExamples.SatisfiesExpectations.class);
        listener.assertTestSucceeded();
    }
    
    @Test
    public void testTheJUnit4TestRunnerAutomaticallyAssertsThatAllExpectationsHaveBeenSatisfied() {
        listener.runTestIn(JUnit5WithRulesExamples.DoesNotSatisfyExpectations.class);
        listener.assertTestFailedWith(AssertionError.class);
    }
    
    @Test
    public void testTheJUnit4TestRunnerLooksForTheMockeryInBaseClasses() {
        listener.runTestIn(JUnit5WithRulesExamples.DerivedAndDoesNotSatisfyExpectations.class);
        listener.assertTestFailedWith(AssertionError.class);
    }

    
    // See issue JMOCK-156
    @Test
    public void testReportsMocksAreNotSatisfiedWhenExpectedExceptionIsThrown() {
        listener.runTestIn(JUnit5WithRulesExamples.ThrowsExpectedException.class);
        listener.assertTestFailedWith(AssertionError.class);
    }
    
    @Test
    public void testFailsWhenMoreThanOneJMockContextField() {
        listener.runTestIn(JUnit5WithRulesExamples.CreatesTwoMockeries.class);
        listener.assertTestFailedWith(ExtensionConfigurationException.class);
    }

    @Test
    public void testAutoInstantiatesMocks() {
        listener.runTestIn(JUnit5WithRulesExamples.AutoInstantiatesMocks.class);
        listener.assertTestSucceeded();
    }
}

1package org.jmock.junit5.acceptance;
2
3import static org.junit.jupiter.api.Assertions.assertEquals;
4import static org.junit.jupiter.api.Assertions.assertTrue;
5import static org.junit.jupiter.api.Assertions.fail;
6import static org.junit.platform.engine.discovery.DiscoverySelectors.selectClass;
7
8import java.util.function.Predicate;
9
10import org.junit.jupiter.api.extension.ExtensionConfigurationException;
11import org.junit.platform.engine.TestExecutionResult;
12import org.junit.platform.engine.TestExecutionResult.Status;
13import org.junit.platform.launcher.Launcher;
14import org.junit.platform.launcher.TestExecutionListener;
15import org.junit.platform.launcher.TestIdentifier;
16import org.junit.platform.launcher.core.LauncherDiscoveryRequestBuilder;
17import org.junit.platform.launcher.core.LauncherFactory;
18
19import com.google.auto.service.AutoService;
20
21@AutoService(TestExecutionListener.class)
22public class FailureRecordingTestExecutionListener implements TestExecutionListener {
23
24    TestExecutionResult testExecutionResult;
25
26    @Override
27    public void executionFinished(TestIdentifier testIdentifier, TestExecutionResult testExecutionResult) {
28        if (testIdentifier.isTest() /* ignore non test containers */) {
29            this.testExecutionResult = testExecutionResult;
30        }
31    }
32
33    public void assertTestSucceeded() {
34        if (testExecutionResult.getStatus().equals(Status.FAILED)) {
35            fail("test should have passed but reported failure: " + testExecutionResult.toString());
36        }
37    }
38
39    public void assertTestFailedWith(Class<? extends Throwable> exceptionType) {
40        assertEquals(Status.FAILED, testExecutionResult.getStatus(), "test should have failed");
41        Throwable cause = testExecutionResult.getThrowable().get();
42        assertTrue(exceptionType.isInstance(cause),
43                "should have failed with " + exceptionType.getName() + " but threw " + cause);
44    }
45
46    public void assertTestFailedWithInitializationError() {
47        assertEquals(Status.FAILED, testExecutionResult.getStatus(), "test should have failed");
48        assertTrue(
49                testExecutionResult.getThrowable()
50                        .filter(new Predicate<Throwable>() {
51                            @Override
52                            public boolean test(Throwable t) {
53                                return t.getClass().equals(ExtensionConfigurationException.class);
54                            }
55                        })
56                        .isPresent(),
57                testExecutionResult.toString());
58    }
59
60    public void runTestIn(Class<?> testClass) {
61        Launcher launcher = LauncherFactory.create();
62        launcher.registerTestExecutionListeners(this);
63        launcher.execute(LauncherDiscoveryRequestBuilder.request()
64                .selectors(selectClass(testClass))
65                .build());
66    }
67}

Source: FailureRecordingTestExecutionListener.java

package org.jmock.junit5.acceptance;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.api.Assertions.fail;
import static org.junit.platform.engine.discovery.DiscoverySelectors.selectClass;

import java.util.function.Predicate;

import org.junit.jupiter.api.extension.ExtensionConfigurationException;
import org.junit.platform.engine.TestExecutionResult;
import org.junit.platform.engine.TestExecutionResult.Status;
import org.junit.platform.launcher.Launcher;
import org.junit.platform.launcher.TestExecutionListener;
import org.junit.platform.launcher.TestIdentifier;
import org.junit.platform.launcher.core.LauncherDiscoveryRequestBuilder;
import org.junit.platform.launcher.core.LauncherFactory;

import com.google.auto.service.AutoService;

@AutoService(TestExecutionListener.class)
public class FailureRecordingTestExecutionListener implements TestExecutionListener {

    TestExecutionResult testExecutionResult;

    @Override
    public void executionFinished(TestIdentifier testIdentifier, TestExecutionResult testExecutionResult) {
        if (testIdentifier.isTest() /* ignore non test containers */) {
            this.testExecutionResult = testExecutionResult;
        }
    }

    public void assertTestSucceeded() {
        if (testExecutionResult.getStatus().equals(Status.FAILED)) {
            fail("test should have passed but reported failure: " + testExecutionResult.toString());
        }
    }

    public void assertTestFailedWith(Class<? extends Throwable> exceptionType) {
        assertEquals(Status.FAILED, testExecutionResult.getStatus(), "test should have failed");
        Throwable cause = testExecutionResult.getThrowable().get();
        assertTrue(exceptionType.isInstance(cause),
                "should have failed with " + exceptionType.getName() + " but threw " + cause);
    }

    public void assertTestFailedWithInitializationError() {
        assertEquals(Status.FAILED, testExecutionResult.getStatus(), "test should have failed");
        assertTrue(
                testExecutionResult.getThrowable()
                        .filter(new Predicate<Throwable>() {
                            @Override
                            public boolean test(Throwable t) {
                                return t.getClass().equals(ExtensionConfigurationException.class);
                            }
                        })
                        .isPresent(),
                testExecutionResult.toString());
    }

    public void runTestIn(Class<?> testClass) {
        Launcher launcher = LauncherFactory.create();
        launcher.registerTestExecutionListeners(this);
        launcher.execute(LauncherDiscoveryRequestBuilder.request()
                .selectors(selectClass(testClass))
                .build());
    }
}