@Override public Object answer(InvocationOnMock invocation) throws Throwable { super.answer(invocation); return result; } }
protected Result run(TestRunnerAdaptor adaptor, Class<?>... classes) throws Exception { return run(adaptor, null, classes); }
@After public void after() throws Throwable { wasCalled(Cycle.AFTER); }
@Test public void shouldNotReturnExceptionToClientIfAnnotatedExpectedAndFailingOnNoExceptionThrown() throws Exception { JUnitTestRunner runner = new JUnitTestRunner(); TestResult result = runner.execute(TestScenarios.class, "shouldFailAnnotatedExpected"); Assert.assertEquals(TestResult.Status.FAILED, result.getStatus()); Assert.assertNull(result.getThrowable()); //Assert.assertEquals(IllegalArgumentException.class, result.getThrowable().getClass()); }
protected void executeAllLifeCycles(TestRunnerAdaptor adaptor) throws Exception { doAnswer(new ExecuteLifecycle()).when(adaptor).fireCustomLifecycle(isA(BeforeRules.class)); doAnswer(new ExecuteLifecycle()).when(adaptor).fireCustomLifecycle(isA(AfterRules.class)); doAnswer(new ExecuteLifecycle()).when(adaptor).beforeClass(any(Class.class), any(LifecycleMethodExecutor.class)); doAnswer(new ExecuteLifecycle()).when(adaptor).afterClass(any(Class.class), any(LifecycleMethodExecutor.class)); doAnswer(new ExecuteLifecycle()).when(adaptor) .before(any(Object.class), any(Method.class), any(LifecycleMethodExecutor.class)); doAnswer(new ExecuteLifecycle()).when(adaptor) .after(any(Object.class), any(Method.class), any(LifecycleMethodExecutor.class)); doAnswer(new TestExecuteLifecycle(TestResult.passed())).when(adaptor).test(any(TestMethodExecutor.class)); }
@Test public void shouldGenerateDependencies() throws Exception { Archive<?> archive = new JUnitDeploymentAppender().createAuxiliaryArchive(); Assert.assertTrue( "Should have added Extension", archive.contains( ArchivePaths.create("/META-INF/services/org.jboss.arquillian.container.test.spi.TestRunner"))); Assert.assertTrue( "Should have added TestRunner Impl", archive.contains(ArchivePaths.create("/org/jboss/arquillian/junit/container/JUnitTestRunner.class"))); } }
@After public void clearCallbacks() { callbackCount.clear(); for (Cycle tmp : Cycle.values()) { callbackCount.put(tmp, 0); } callbackException.clear(); }
protected Result run(TestRunnerAdaptor adaptor, RunListener listener, Class<?>... classes) throws Exception { try { setAdaptor(adaptor); JUnitCore core = new JUnitCore(); if (listener != null) { core.addListener(listener); } return core.run(classes); } finally { setAdaptor(null); } }
@Test public void shouldReturnExceptionThrownInBeforeToClientWhenTestFails() throws Exception { Exception expectedException = new Exception("Expected"); TestScenarios.exceptionThrownInBefore = expectedException; Exception unexpectedException = new Exception("Not expected"); TestScenarios.exceptionThrownInAfter = unexpectedException; JUnitTestRunner runner = new JUnitTestRunner(); TestResult result = runner.execute(TestScenarios.class, "shouldFailOnException"); Assert.assertEquals(TestResult.Status.FAILED, result.getStatus()); Assert.assertSame(expectedException, result.getThrowable()); }
@Test public void shouldBeInvoked() throws Throwable { wasCalled(Cycle.TEST); } }
@Test public void shouldNotReturnExceptionToClientIfAsumptionPassing() throws Exception { JUnitTestRunner runner = new JUnitTestRunner(); TestResult result = runner.execute(TestScenarios.class, "shouldPassOnAssumption"); Assert.assertEquals(TestResult.Status.PASSED, result.getStatus()); Assert.assertNull(result.getThrowable()); }
@Before public void before() throws Throwable { wasCalled(Cycle.BEFORE); }
@Test public void shouldReturnExceptionThrownInAfterClientWhenTestSucceeds() throws Exception { Exception expectedException = new Exception("Expected"); TestScenarios.exceptionThrownInAfter = expectedException; JUnitTestRunner runner = new JUnitTestRunner(); TestResult result = runner.execute(TestScenarios.class, "shouldSucceed"); Assert.assertEquals(TestResult.Status.FAILED, result.getStatus()); Assert.assertSame(expectedException, result.getThrowable()); }
@BeforeClass public static void beforeClass() throws Throwable { wasCalled(Cycle.BEFORE_CLASS); }
@Test public void shouldReturnExceptionToClientIfAsumptionFailing() throws Exception { JUnitTestRunner runner = new JUnitTestRunner(); TestResult result = runner.execute(TestScenarios.class, "shouldSkipOnAssumption"); Assert.assertEquals(TestResult.Status.SKIPPED, result.getStatus()); Assert.assertNotNull(result.getThrowable()); Assert.assertEquals(AssumptionViolatedException.class, result.getThrowable().getClass()); }
@AfterClass public static void afterClass() throws Throwable { wasCalled(Cycle.AFTER_CLASS); }
@Test public void shouldReturnExceptionToClientIfExpectedRuleFailing() throws Exception { JUnitTestRunner runner = new JUnitTestRunner(); TestResult result = runner.execute(TestScenarios.class, "shouldFailOnException"); Assert.assertEquals(TestResult.Status.FAILED, result.getStatus()); Assert.assertNotNull(result.getThrowable()); Assert.assertEquals(AssertionError.class, result.getThrowable().getClass()); }
@Test public void shouldNotReturnExceptionToClientIfExpectedRulePassing() throws Exception { State.caughtTestException(new IllegalArgumentException()); JUnitTestRunner runner = new JUnitTestRunner(); TestResult result = runner.execute(TestScenarios.class, "shouldPassOnException"); Assert.assertEquals(TestResult.Status.PASSED, result.getStatus()); Assert.assertNull(result.getThrowable()); }
@Test public void shouldReturnAssertionErrorToClientWhenAfterThrowsException() throws Exception { Exception unexpectedException = new Exception("Not expected"); TestScenarios.exceptionThrownInAfter = unexpectedException; JUnitTestRunner runner = new JUnitTestRunner(); TestResult result = runner.execute(TestScenarios.class, "shouldFailOnException"); Assert.assertEquals(TestResult.Status.FAILED, result.getStatus()); Assert.assertNotNull(result.getThrowable()); Assert.assertEquals(AssertionError.class, result.getThrowable().getClass()); }
@Test public void shouldReturnExceptionToClientIfAnnotatedExpectedAndFailingOnWrongExceptionThrown() throws Exception { State.caughtTestException(new UnsupportedOperationException()); JUnitTestRunner runner = new JUnitTestRunner(); TestResult result = runner.execute(TestScenarios.class, "shouldFailAnnotatedExpectedWrongException"); Assert.assertEquals(TestResult.Status.FAILED, result.getStatus()); Assert.assertNotNull(result.getThrowable()); Assert.assertEquals(UnsupportedOperationException.class, result.getThrowable().getClass()); }