org.mockito.verification.VerificationMode Java Examples

/**
 * Wrapper around {@link Mockito#verify}, to keep log spam down on failure.
 */
private static <T> T verify(T mock, VerificationMode mode) {
  try {
    return Mockito.verify(mock, mode);
  } catch (final AssertionError e) {
    String msg = e.getMessage();
    if (msg.length() >= 256) {
      // AssertionError(String, Throwable) only present in Android API 19+
      throw new AssertionError(msg.substring(0, 256)) {
        @Override
        public synchronized Throwable getCause() {
          return e;
        }
      };
    }
    throw e;
  }
}
 

/**
 * Wait for the coordinator task to complete, and verify all the mocks
 * @param op the {@link Subprocedure} to use
 * @param prepare the mock prepare
 * @param commit the mock commit
 * @param cleanup the mock cleanup
 * @param finish the mock finish
 * @param opHasError the operation error state
 * @throws Exception on unexpected failure
 */
private void waitAndVerifySubproc(Subprocedure op, VerificationMode prepare,
    VerificationMode commit, VerificationMode cleanup, VerificationMode finish, boolean opHasError)
    throws Exception {
  boolean caughtError = false;
  try {
    op.waitForLocallyCompleted();
  } catch (ForeignException fe) {
    caughtError = true;
  }
  // make sure that the task called all the expected phases
  Mockito.verify(op, prepare).acquireBarrier();
  Mockito.verify(op, commit).insideBarrier();
  // We cannot guarantee that cleanup has run so we don't check it.

  assertEquals("Operation error state was unexpected", opHasError, op.getErrorCheckable()
      .hasException());
  assertEquals("Operation error state was unexpected", opHasError, caughtError);

}
 

@Override
public void verifyTriggerCallback(
		Trigger<?, TimeWindow> mockTrigger,
		VerificationMode verificationMode,
		Long time,
		TimeWindow window) throws Exception {
	if (time == null && window == null) {
		verify(mockTrigger, verificationMode).onEventTime(
				anyLong(),
				anyTimeWindow(),
				anyTriggerContext());
	} else if (time == null) {
		verify(mockTrigger, verificationMode).onEventTime(
				anyLong(),
				eq(window),
				anyTriggerContext());
	} else if (window == null) {
		verify(mockTrigger, verificationMode).onEventTime(
				eq(time),
				anyTimeWindow(),
				anyTriggerContext());
	} else {
		verify(mockTrigger, verificationMode).onEventTime(
				eq(time),
				eq(window),
				anyTriggerContext());
	}
}
 

public void verifyAddProjectAdapterCalls(VerificationMode times, VerificationMode confluenceTimes)
    throws IOException, CreateProjectPreconditionException {
  Mockito.verify(jenkinsPipelineAdapter, times).createPlatformProjects(isNotNull());
  // check preconditions should be always called
  Mockito.verify(bitbucketAdapter, times(1)).checkCreateProjectPreconditions(isNotNull());
  Mockito.verify(bitbucketAdapter, times).createSCMProjectForODSProject(isNotNull());
  Mockito.verify(bitbucketAdapter, times).createComponentRepositoriesForODSProject(isNotNull());
  // jira components
  Mockito.verify(jiraAdapter, times)
      .createComponentsForProjectRepositories(isNotNull(), isNotNull());

  Mockito.clearInvocations(
      jiraAdapter, confluenceAdapter, bitbucketAdapter, jenkinsPipelineAdapter);
}
 

@Override
public final ArgumentCaptor<P> executed(final VerificationMode verificationMode) {
  try {
    doVerify(verificationMode);
  } catch (final Exception e) {
    throw new RuntimeException(e);
  }
  return argumentCaptor;
}
 

private void verifyErrorMessageForParentJobLogLevel( LogLevel parentJobLogLevel, VerificationMode mode ) {
  action.setLogMessage( "TEST" );
  action.setEntryLogLevel( LogLevel.ERROR );

  doReturn( parentJobLogLevel ).when( parentWorkflow ).getLogLevel();
  action.setParentWorkflow( parentWorkflow );

  ILogChannel logChannel = spy( action.createLogChannel() );
  doReturn( logChannel ).when( action ).createLogChannel();

  action.evaluate( new Result() );
  verify( logChannel, mode ).logError( "TEST" + Const.CR );
}
 

@Override
public void verifyTriggerCallback(
		Trigger<?, TimeWindow> mockTrigger,
		VerificationMode verificationMode,
		Long time,
		TimeWindow window) throws Exception {
	if (time == null && window == null) {
		verify(mockTrigger, verificationMode).onProcessingTime(
				anyLong(),
				anyTimeWindow(),
				anyTriggerContext());
	} else if (time == null) {
		verify(mockTrigger, verificationMode).onProcessingTime(
				anyLong(),
				eq(window),
				anyTriggerContext());
	} else if (window == null) {
		verify(mockTrigger, verificationMode).onProcessingTime(
				eq(time),
				anyTimeWindow(),
				anyTriggerContext());
	} else {
		verify(mockTrigger, verificationMode).onProcessingTime(
				eq(time),
				eq(window),
				anyTriggerContext());
	}
}
 

static void verify(
    final ErrorHandler mockErrorHandler,
    final VerificationMode times,
    final Class<? extends Throwable> exception)
{
    try
    {
        Mockito.verify(mockErrorHandler, times).onError(any(exception));
    }
    finally
    {
        reset(mockErrorHandler);
    }
}
 

private void verifyNewMetricDefinitionMessages(List<Alarm> alarms, final OutputCollector collector,
      final MetricFilteringBolt bolt, VerificationMode howMany) {
  for (final Alarm alarm : alarms) {
    for (MetricDefinitionAndTenantId mtid : alarm.getAlarmedMetrics()) {
      verify(collector, howMany)
          .emit(MetricFilteringBolt.NEW_METRIC_FOR_ALARM_DEFINITION_STREAM, new Values(mtid, alarm.getAlarmDefinitionId()));
    }
  }
}
 

public <T> T verify(T mock, VerificationMode mode) {
    if (mock == null) {
        reporter.nullPassedToVerify();
    } else if (!mockUtil.isMock(mock)) {
        reporter.notAMockPassedToVerify(mock.getClass());
    }
    mockingProgress.verificationStarted(new MockAwareVerificationMode(mock, mode));
    return mock;
}
 

private void assertSentGapFill(
    final int msgSeqNum,
    final int newSeqNo,
    final int offset,
    final VerificationMode times)
{
    verifyClaim();
    assertResultBufferHasGapFillMessage(resultBuffer.capacity() - offset, msgSeqNum, newSeqNo);
    verifyCommit(times);
}
 

public <T> T verify(T mock, VerificationMode mode) {
    if (!mocksToBeVerifiedInOrder.contains(mock)) {
        reporter.inOrderRequiresFamiliarMock();
    } else if (!(mode instanceof VerificationInOrderMode)) {
        throw new MockitoException(mode.getClass().getSimpleName() + " is not implemented to work with InOrder");
    }
    return mockitoCore.verify(mock, new InOrderWrapper((VerificationInOrderMode) mode, this));
}
 

private void verifySessionsAcquired(final SessionState state, final VerificationMode times)
{
    verify(gatewaySessions, times).acquire(
        any(),
        eq(state),
        eq(false),
        eq(HEARTBEAT_INTERVAL_IN_S),
        anyInt(),
        anyInt(),
        any(),
        any(),
        any());
}
 

@Override
public void verifyTriggerCallback(
		Trigger<?, TimeWindow> mockTrigger,
		VerificationMode verificationMode,
		Long time,
		TimeWindow window) throws Exception {
	if (time == null && window == null) {
		verify(mockTrigger, verificationMode).onEventTime(
				anyLong(),
				anyTimeWindow(),
				anyTriggerContext());
	} else if (time == null) {
		verify(mockTrigger, verificationMode).onEventTime(
				anyLong(),
				eq(window),
				anyTriggerContext());
	} else if (window == null) {
		verify(mockTrigger, verificationMode).onEventTime(
				eq(time),
				anyTimeWindow(),
				anyTriggerContext());
	} else {
		verify(mockTrigger, verificationMode).onEventTime(
				eq(time),
				eq(window),
				anyTriggerContext());
	}
}
 

private void savesInvalidChecksumMessage(final VerificationMode mode)
{
    verify(publication, mode).saveMessage(
        anyBuffer(),
        eq(0),
        eq(INVALID_CHECKSUM_LEN),
        eq(LIBRARY_ID),
        eq(MESSAGE_TYPE),
        anyLong(),
        anyInt(),
        eq(CONNECTION_ID),
        eq(INVALID_CHECKSUM),
        eq(0),
        eq(TIMESTAMP));
}
 

private void savesInvalidMessage(
    final int length, final VerificationMode mode, final MessageStatus status, final long timestamp)
{
    verify(publication, mode).saveMessage(
        anyBuffer(), eq(0), eq(length), eq(LIBRARY_ID),
        anyLong(), anyLong(), anyInt(), eq(CONNECTION_ID),
        eq(status), eq(0), eq(timestamp));
}
 

private void verifySeenStatusReporter(VerificationMode verificationMode) throws InterruptedException {
    String[] messageIds = {"1"};
    mobileMessagingCore.setMessagesSeen(messageIds);
    seenStatusReporter.sync();

    verify(coreBroadcaster, verificationMode).seenStatusReported(any(String[].class));
}
 

private void byteBufferWritten(final VerificationMode times)
{
    try
    {
        verify(tcpChannel, times).write(byteBuffer);
        reset(tcpChannel);
    }
    catch (final IOException e)
    {
        LangUtil.rethrowUnchecked(e);
    }
}
 

public VerificationMode pullVerificationMode() {
    if (verificationMode == null) {
        return null;
    }
    
    VerificationMode temp = verificationMode.getObject();
    verificationMode = null;
    return temp;
}
 

protected Connection<String, String> assertNextConnection(SocketAddress host,
                                                          ConnectionFactory<String, String> cfMock,
                                                          ConnectionObservable<String, String> connectionObservable,
                                                          VerificationMode verificationMode) {
    Connection<String, String> c = loadBalancerRule.connect(connectionObservable);
    verify(cfMock, verificationMode).newConnection(host);
    return c;
}
 

private void savesInvalidOutOfRequiredMessage(final VerificationMode mode, final long timestamp)
{
    savesInvalidMessage(TAG_SPECIFIED_OUT_OF_REQUIRED_ORDER_MESSAGE_BYTES.length, mode, INVALID, timestamp);
}
 

public void verifyLogout(final int msgSeqNo, final VerificationMode times)
{
    verify(sessionProxy, times).sendLogout(msgSeqNo, SEQUENCE_INDEX, NO_LAST_MSG_SEQ_NUM_PROCESSED);
}
 

private void verifySlowConsumerDisconnect(final VerificationMode times)
{
    verify(framer, times).onDisconnect(LIBRARY_ID, CONNECTION_ID, SLOW_CONSUMER);
}
 

private void verifyNotifiesLoginListener(final VerificationMode verificationMode)
{
    verify(mockLogonListener, verificationMode).onLogon(any());
}
 

public VerificationMode getDelegate() {
    return delegate;
}
 

private void verifyNewGame(PlayerGame playerGame, VerificationMode mode) {
    verify(playerGame.getField(), mode).newGame(playerGame.getGame().getPlayer());
}
 

/**
 * Delegates call to {@link Mockito#calls(int)}.
 */
default VerificationMode calls(int wantedNumberOfInvocations){
    return Mockito.calls(wantedNumberOfInvocations);
}
 

private void verifyFieldTicks(GameField field, VerificationMode count) {
    verify(field, count).quietTick();
}
 

/**
 * Delegates call to {@link Mockito#times(int)}.
 */
default VerificationMode times(int wantedNumberOfInvocations) {
    return Mockito.times(wantedNumberOfInvocations);
}
 

private void verifyAllFieldsTicks(VerificationMode count) {
    getFileds.forEach(field -> verifyFieldTicks(field.get(), count));
}