org.mockito.exceptions.misusing.NotAMockException Java Examples

private static final LdapConnection verify( LdapConnection connection, VerificationMode mode )
{
    if ( MockUtil.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();
        }
    }
}
 

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

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();"
    ));
}
 

@Test
public void givenNotASpy_whenDoReturn_thenThrowNotAMock() {
    try {
        List<String> list = new ArrayList<String>();

        Mockito.doReturn(100, Mockito.withSettings().lenient())
            .when(list)
            .size();

        fail("Should have thrown a NotAMockException because 'list' is not a mock!");
    } catch (NotAMockException e) {
        assertThat(e.getMessage(), containsString("Argument passed to when() is not a mock!"));
    }
}
 

@Override
public boolean matches(Object item) {
    try {
        verifyNoMoreInteractions(item);
        return true;
    } catch (NoInteractionsWanted unexpectedInteractions) {
        return false;
    } catch (NotAMockException notVerifiable) {
        throw new AssertionError("Can't do verifications on non-mocked objects.");
    }
}
 

@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 <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 
public void shouldScreamWhenEnhancedButNotAMockPassed() {
    Object o = Enhancer.create(ArrayList.class, NoOp.INSTANCE);
    try {
        mockUtil.getMockHandler(o);
        fail();
    } catch (NotAMockException e) {}
}
 

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

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

@Test(expected=NotAMockException.class)
public void shouldScreamWhenWholeMethodPassedToVerifyNoMoreInteractions() {
    verifyNoMoreInteractions(mock.byteReturningMethod());
}
 

@Test(expected=NotAMockException.class)
public void shouldValidateMockWhenCreatingInOrderObject() {
    Mockito.inOrder("notMock");
}
 

@SuppressWarnings("deprecation")
@Test(expected=NotAMockException.class)
public void shouldValidateMockWhenStubbingVoid() {
    Mockito.stubVoid("notMock");
}
 

@Test(expected=NotAMockException.class)
public void shouldValidateMockWhenVerifyingZeroInteractions() {
    Mockito.verifyZeroInteractions("notMock");
}
 

@Test(expected=NotAMockException.class)
public void shouldValidateMockWhenVerifyingNoMoreInteractions() {
    Mockito.verifyNoMoreInteractions("notMock");
}
 

@Test(expected=NotAMockException.class)
public void shouldValidateMockWhenVerifyingWithExpectedNumberOfInvocations() {
    Mockito.verify("notMock", times(19));
}
 

@Test(expected=NotAMockException.class)
public void shouldValidateMockWhenVerifying() {
    Mockito.verify("notMock");
}
 

@Test (expected=NotAMockException.class)
public void should_scream_when_not_a_mock_passed() {
    mockUtil.getMockHandler("");
}
 

@Test(expected = NotAMockException.class)
public void shouldIgnoringStubsDetectNonMocks() throws Exception {
    ignoreStubs(mock, new Object());
}
 

@Test(expected = NotAMockException.class)
public void shouldIgnoringStubsDetectNulls() throws Exception {
    ignoreStubs(mock, null);
}
 

@Test(expected = NotAMockException.class)
public void resettingNullIsSafe() {
    reset(new Object[] {null});
}
 

@Test(expected = NotAMockException.class)
public void resettingNonMockIsSafe() {
    reset("");
}
 

@Test(expected=NotAMockException.class)
public void shouldScreamWhenInOrderCreatedWithDodgyMock() {
    inOrder("not a mock");
}
 

@Test(expected=NotAMockException.class)
public void shouldScreamWhenInOrderCreatedWithDodgyMock() {
    inOrder("not a mock");
}
 

@Test(expected=NotAMockException.class)
public void shouldScreamWhenWholeMethodPassedToVerify() {
    verify(mock.booleanReturningMethod());
}
 

@Test(expected = NotAMockException.class)
public void shouldValidateMockWhenVerifyingNoMoreInteractions() {

    then("notMock").should();
}
 

@Test(expected = NotAMockException.class)
public void shouldValidateMockWhenVerifyingWithExpectedNumberOfInvocations() {

    then("notMock").should(times(19));
}