org.mockito.exceptions.base.MockitoAssertionError Java Examples

@Test
public void testFailureWithIntermittentInvocations() {
  // given
  foo.getFoo();
  foo.getBaz();
  foo.getBar();

  // when
  InOrder inOrder = Mockito.inOrder(foo);
  inOrder.verify(foo).getFoo();

  // then
  try {
    inOrder.verify(foo, immediatelyAfter()).getBar();
    Assert.fail("should not verify");
  } catch (MockitoAssertionError e) {
    // happy path
  }
}
 

public void verify(VerificationData data) {
    int soFar = 0;
    MockitoAssertionError error = null;
    while (soFar <= timeout) {
        try {
            delegate.verify(data);
            return;
        } catch (MockitoAssertionError e) {
            error = e;
            soFar += treshhold;
            sleep(treshhold);
        }
    }
    if (error != null) {
        throw error;
    }
}
 

@Test
public void testFailureOnWrongInvocationOrder() {
  // given
  foo.getBar();
  foo.getFoo();

  // when
  InOrder inOrder = Mockito.inOrder(foo);
  inOrder.verify(foo).getFoo();

  // then
  try {
    inOrder.verify(foo, immediatelyAfter()).getBar();
    Assert.fail("should not verify");
  } catch (MockitoAssertionError e) {
    // happy path
  }
}
 

@Test
public void testFailureWhenInvocationNotPresentCase2() {
  // given
  foo.getFoo();

  // when
  InOrder inOrder = Mockito.inOrder(foo);
  inOrder.verify(foo).getFoo();

  // then
  try {
    inOrder.verify(foo, immediatelyAfter()).getBar();
    Assert.fail("should not verify");
  } catch (MockitoAssertionError e) {
    // happy path
  }
}
 

@Test
public void testFailureWhenInvocationNotPresent() {
  // given
  foo.getFoo();
  foo.getBaz();

  // when
  InOrder inOrder = Mockito.inOrder(foo);
  inOrder.verify(foo).getFoo();

  // then
  try {
    inOrder.verify(foo, immediatelyAfter()).getBar();
    Assert.fail("should not verify");
  } catch (MockitoAssertionError e) {
    // happy path
  }
}
 

@Override
public void verifyInOrder(VerificationDataInOrder data) {

  Invocation firstUnverifiedInvocation = finder.findFirstUnverifiedInOrder(data.getOrderingContext(), data.getAllInvocations());

  if (firstUnverifiedInvocation == null) {
    Invocation previouslyVerified = finder.findPreviousVerifiedInOrder(data.getAllInvocations(), data.getOrderingContext());
    new Reporter().wantedButNotInvokedInOrder(data.getWanted(), previouslyVerified);
  }

  if (!data.getWanted().matches(firstUnverifiedInvocation)) {
    StringBuilder sb = new StringBuilder();
    sb.append("Expected next invocation specified here: \n");
    sb.append(data.getWanted().getLocation());
    sb.append("\n");
    sb.append("but next invocation was: \n");
    sb.append(firstUnverifiedInvocation.getLocation());
    sb.append("\n");

    throw new MockitoAssertionError(sb.toString());
  }
}
 

@Test
public void whenLazilyVerified_thenReportsMultipleFailures() {
    VerificationCollector collector = MockitoJUnit.collector()
        .assertLazily();

    List mockList = mock(List.class);
    verify(mockList).add("one");
    verify(mockList).clear();

    try {
        collector.collectAndReport();
    } catch (MockitoAssertionError error) {
        assertTrue(error.getMessage()
            .contains("1. Wanted but not invoked:"));
        assertTrue(error.getMessage()
            .contains("2. Wanted but not invoked:"));
    }
}
 

@Test
public void shouldWaitTheFullTimeIfTheTestCouldPass() throws Exception {
    // given
    Thread t = waitAndExerciseMock(50);

    // when
    t.start();

    // then        
    long startTime = System.currentTimeMillis();
    
    try {
        verify(mock, after(100).atLeast(2)).clear();
        fail();
    } catch (MockitoAssertionError e) {}
    
    assertTrue(System.currentTimeMillis() - startTime >= 100);
}
 

public void expect(LifeCycle... lifeCycles){
    long start = System.currentTimeMillis();
    while(true) {
        long elapse = System.currentTimeMillis() - start;
        try {
            doExpect(lifeCycles);
        } catch (MockitoAssertionError mockitoAssertionError) {
            if (elapse > wait_span) {
                throw mockitoAssertionError;
            } else {
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        }

        //Pass
        break;
    }
}
 

@Test
public void shouldFailVerificationWithTimeout() throws Exception {
    //given
    Thread t = waitAndExerciseMock(80);
    
    //when
    t.start();
    
    //then
    verify(mock, never()).clear();
    try {
        verify(mock, timeout(20).atLeastOnce()).clear();
        fail();
    } catch (MockitoAssertionError e) {}
}
 

@Test
public void should_fail_because_verification_fails() {
    Timeout t = new Timeout(1, 2, mode);
    
    doThrow(error).
    doThrow(error).
    doThrow(error).
    when(mode).verify(data);
    
    try {
        t.verify(data);
        fail();
    } catch (MockitoAssertionError e) {}
}
 

@Test
public void shouldNotMarkAsVerifiedWhenAssertionFailed() {
    //given
    Invocation invocation = new InvocationBuilder().toInvocation();
    assertFalse(invocation.isVerified());
    
    //when
    try {
        only.verify(new VerificationDataStub(new InvocationBuilder().toInvocationMatcher(), invocation));
        fail();
    } catch (MockitoAssertionError e) {}
    
    //then
    assertFalse(invocation.isVerified());
}
 

@Test
public void shouldFailVerifiationAtLeastXTimes() throws Exception {
    mock.add("one");
    verify(mock, atLeast(1)).add(anyString());

    try {
        verify(mock, atLeast(2)).add(anyString());
        fail();
    } catch (MockitoAssertionError e) {}
}
 

@Test
public void shouldPrintDecentMessage() throws Exception {
    mock.clear();
    mock.clear();
    
    try {
        verify(mock, atMost(1)).clear();
        fail();
    } catch (MockitoAssertionError e) {
        assertEquals("\nWanted at most 1 time but was 2", e.getMessage());
    }
}
 

@Test
public void shouldWorkWithArgumentMatchers() throws Exception {
    mock.add("one");
    verify(mock, atMost(5)).add(anyString());
    
    try {
        verify(mock, atMost(0)).add(anyString());
        fail();
    } catch (MockitoAssertionError e) {}
}
 

@Test
public void shouldVerifyAtMostXTimes() throws Exception {
    mock.clear();
    mock.clear();
    
    verify(mock, atMost(2)).clear();
    verify(mock, atMost(3)).clear();
    
    try {
        verify(mock, atMost(1)).clear();
        fail();
    } catch (MockitoAssertionError e) {}
}
 

/**
 * Verify the given ongoing verification data, and confirm that it satisfies the delegate verification mode
 * before the full duration has passed.
 *
 * In practice, this polls the delegate verification mode until it is satisfied. If it is not satisfied once
 * the full duration has passed, the last error returned by the delegate verification mode will be thrown
 * here in turn. This may be thrown early if the delegate is unsatisfied and the verification mode is known
 * to never recover from this situation (e.g. {@link AtMost}).
 *
 * If it is satisfied before the full duration has passed, behaviour is dependent on the returnOnSuccess parameter
 * given in the constructor. If true, this verification mode is immediately satisfied once the delegate is. If
 * false, this verification mode is not satisfied until the delegate is satisfied and the full time has passed.
 *
 * @throws MockitoAssertionError if the delegate verification mode does not succeed before the timeout
 */
public void verify(VerificationData data) {
    MockitoAssertionError error = null;
    
    long startTime = System.currentTimeMillis();
    while (System.currentTimeMillis() - startTime <= durationMillis) {
        try {
            delegate.verify(data);
            
            if (returnOnSuccess) {
                return;
            } else {
                error = null;
            }
        } catch (MockitoAssertionError e) {
            if (canRecoverFromFailure(delegate)) {
                error = e;
                sleep(pollingPeriodMillis);
            } else {
                throw e;
            }
        }
    }
    
    if (error != null) {
        throw error;
    }
}
 

@Test
public void shouldTryToVerifyCorrectNumberOfTimes() {
    Timeout t = new Timeout(1, 4, mode);
    
    doThrow(error).when(mode).verify(data);
    
    try {
        t.verify(data);
        fail();
    } catch (MockitoAssertionError e) {};
    
    verify(mode, times(5)).verify(data);
}
 

@Test
public void shouldFailBecauseVerificationFails() {
    Timeout t = new Timeout(1, 2, mode);
    
    doThrow(error).
    doThrow(error).
    doThrow(error).        
    when(mode).verify(data);
    
    try {
        t.verify(data);
        fail();
    } catch (MockitoAssertionError e) {}
}
 

@Test
public void shouldNotMarkAsVerifiedWhenAssertionFailed() {
    //given
    Invocation invocation = new InvocationBuilder().toInvocation();
    assertFalse(invocation.isVerified());
    
    //when
    try {
        only.verify(new VerificationDataStub(new InvocationBuilder().toInvocationMatcher(), invocation));
        fail();
    } catch (MockitoAssertionError e) {}
    
    //then
    assertFalse(invocation.isVerified());
}
 

@Test
public void shouldFailVerifiationAtLeastXTimes() throws Exception {
    mock.add("one");
    verify(mock, atLeast(1)).add(anyString());

    try {
        verify(mock, atLeast(2)).add(anyString());
        fail();
    } catch (MockitoAssertionError e) {}
}
 

@Test
public void shouldPrintDecentMessage() throws Exception {
    mock.clear();
    mock.clear();
    
    try {
        verify(mock, atMost(1)).clear();
        fail();
    } catch (MockitoAssertionError e) {
        assertEquals("\nWanted at most 1 time but was 2", e.getMessage());
    }
}
 

@Test
public void shouldWorkWithArgumentMatchers() throws Exception {
    mock.add("one");
    verify(mock, atMost(5)).add(anyString());
    
    try {
        verify(mock, atMost(0)).add(anyString());
        fail();
    } catch (MockitoAssertionError e) {}
}
 

@Test
public void shouldVerifyAtMostXTimes() throws Exception {
    mock.clear();
    mock.clear();
    
    verify(mock, atMost(2)).clear();
    verify(mock, atMost(3)).clear();
    
    try {
        verify(mock, atMost(1)).clear();
        fail();
    } catch (MockitoAssertionError e) {}
}
 

@Test
public void shouldFailVerificationWithTimeout() throws Exception {
    //given
    Thread t = waitAndExerciseMock(40);
    
    //when
    t.start();
    
    //then
    verify(mock, never()).clear();
    try {
        verify(mock, timeout(20).atLeastOnce()).clear();
        fail();
    } catch (MockitoAssertionError e) {}
}
 

public void wantedAtMostX(int maxNumberOfInvocations, int foundSize) {
    throw new MockitoAssertionError(join("Wanted at most " + pluralize(maxNumberOfInvocations) + " but was " + foundSize));
}
 

public void wantedAtMostX(int maxNumberOfInvocations, int foundSize) {
    throw new MockitoAssertionError(join("Wanted at most " + pluralize(maxNumberOfInvocations) + " but was " + foundSize));
}