private static final LdapConnection verify( LdapConnection connection, VerificationMode mode ) { if ( MOCK_UTIL.isMock( connection ) ) { return org.mockito.Mockito.verify( connection, mode ); } else { if ( connection instanceof Wrapper ) { @SuppressWarnings("unchecked") LdapConnection unwrapped = ( ( Wrapper<LdapConnection> ) connection ).wrapped(); return verify( unwrapped, mode ); } } throw new NotAMockException( "connection is not a mock, nor a wrapper for a connection that is one" ); }
public void verifyNoMoreInteractions(Object... mocks) { assertMocksNotEmpty(mocks); mockingProgress.validateState(); for (Object mock : mocks) { try { if (mock == null) { reporter.nullPassedToVerifyNoMoreInteractions(); } InvocationContainer invocations = mockUtil.getMockHandler(mock).getInvocationContainer(); VerificationDataImpl data = new VerificationDataImpl(invocations, null); VerificationModeFactory.noMoreInteractions().verify(data); } catch (NotAMockException e) { reporter.notAMockPassedToVerifyNoMoreInteractions(); } } }
@Test public void should_scream_when_enhanced_but_not_a_mock_passed() { Object o = Enhancer.create(ArrayList.class, NoOp.INSTANCE); try { mockUtil.getMockHandler(o); fail(); } catch (NotAMockException e) {} }
public void notAMockPassedToVerify(Class type) { throw new NotAMockException(join( "Argument passed to verify() is of type " + type.getSimpleName() + " and is not a mock!", "Make sure you place the parenthesis correctly!", "See the examples of correct verifications:", " verify(mock).someMethod();", " verify(mock, times(10)).someMethod();", " verify(mock, atLeastOnce()).someMethod();" )); }
public void notAMockPassedToWhenMethod() { throw new NotAMockException(join( "Argument passed to when() is not a mock!", "Example of correct stubbing:", " doThrow(new RuntimeException()).when(mock).someMethod();" )); }
public void notAMockPassedToVerifyNoMoreInteractions() { throw new NotAMockException(join( "Argument(s) passed is not a mock!", "Examples of correct verifications:", " verifyNoMoreInteractions(mockOne, mockTwo);", " verifyZeroInteractions(mockOne, mockTwo);", "" )); }
public void notAMockPassedWhenCreatingInOrder() { throw new NotAMockException(join( "Argument(s) passed is not a mock!", "Pass mocks that require verification in order.", "For example:", " InOrder inOrder = inOrder(mockOne, mockTwo);" )); }
public <T> MockHandlerInterface<T> getMockHandler(T mock) { if (mock == null) { throw new NotAMockException("Argument should be a mock, but is null!"); } if (isMockitoMock(mock)) { return (MockHandlerInterface) getInterceptor(mock).getHandler(); } else { throw new NotAMockException("Argument should be a mock, but is: " + mock.getClass()); } }
@Test public void shouldScreamWhenEnhancedButNotAMockPassed() { Object o = Enhancer.create(ArrayList.class, NoOp.INSTANCE); try { mockUtil.getMockHandler(o); fail(); } catch (NotAMockException e) {} }
public <T> InternalMockHandler<T> getMockHandler(T mock) { if (mock == null) { throw new NotAMockException("Argument should be a mock, but is null!"); } if (isMockitoMock(mock)) { MockHandler handler = mockMaker.getHandler(mock); return (InternalMockHandler) handler; } else { throw new NotAMockException("Argument should be a mock, but is: " + mock.getClass()); } }
@Test(expected=NotAMockException.class) public void shouldScreamWhenWholeMethodPassedToVerify() { verify(mock.booleanReturningMethod()); }
@Test(expected=NotAMockException.class) public void shouldScreamWhenWholeMethodPassedToVerifyNoMoreInteractions() { verifyNoMoreInteractions(mock.byteReturningMethod()); }
@Test(expected=NotAMockException.class) public void shouldScreamWhenInOrderCreatedWithDodgyMock() { inOrder("not a mock"); }
@Test (expected=NotAMockException.class) public void shouldScreamWhenNotAMockPassed() { mockUtil.getMockHandler(""); }
@Test(expected=NotAMockException.class) public void shouldValidateMockWhenVerifying() { Mockito.verify("notMock"); }
@Test(expected=NotAMockException.class) public void shouldValidateMockWhenVerifyingWithExpectedNumberOfInvocations() { Mockito.verify("notMock", times(19)); }
@Test(expected=NotAMockException.class) public void shouldValidateMockWhenVerifyingNoMoreInteractions() { Mockito.verifyNoMoreInteractions("notMock"); }
@Test(expected=NotAMockException.class) public void shouldValidateMockWhenVerifyingZeroInteractions() { Mockito.verifyZeroInteractions("notMock"); }
@SuppressWarnings("deprecation") @Test(expected=NotAMockException.class) public void shouldValidateMockWhenStubbingVoid() { Mockito.stubVoid("notMock"); }
@Test(expected=NotAMockException.class) public void shouldValidateMockWhenCreatingInOrderObject() { Mockito.inOrder("notMock"); }
@Test(expected = NotAMockException.class) public void shouldValidateMockWhenVerifying() { then("notMock").should(); }
@Test(expected = NotAMockException.class) public void shouldValidateMockWhenVerifyingWithExpectedNumberOfInvocations() { then("notMock").should(times(19)); }
@Test(expected = NotAMockException.class) public void shouldValidateMockWhenVerifyingNoMoreInteractions() { then("notMock").should(); }
@Test(expected = NotAMockException.class) public void resettingNonMockIsSafe() { reset(""); }
@Test(expected = NotAMockException.class) public void resettingNullIsSafe() { reset(new Object[] {null}); }
@Test(expected = NotAMockException.class) public void shouldIgnoringStubsDetectNulls() throws Exception { ignoreStubs(mock, null); }
@Test(expected = NotAMockException.class) public void shouldIgnoringStubsDetectNonMocks() throws Exception { ignoreStubs(mock, new Object()); }
@Test (expected=NotAMockException.class) public void should_scream_when_not_a_mock_passed() { mockUtil.getMockHandler(""); }