org.mockito.stubbing.Stubber Java Examples

/**
 * Throw an exception from the mock/spy only in the case that the
 * call stack at the time the method has a line which matches the given
 * pattern.
 *
 * @param t the Throwable to throw
 * @param pattern the pattern against which to match the call stack trace
 * @return the stub in progress
 */
public static Stubber doThrowWhenCallStackMatches(
    final Throwable t, final String pattern) {
  return Mockito.doAnswer(new Answer<Object>() {
    @Override
    public Object answer(InvocationOnMock invocation) throws Throwable {
      t.setStackTrace(Thread.currentThread().getStackTrace());
      for (StackTraceElement elem : t.getStackTrace()) {
        if (elem.toString().matches(pattern)) {
          throw t;
        }
      }
      return invocation.callRealMethod();
    }
  });
}
 

private TorrentFileProvider createMockedTorrentFileProviderWithTorrent(final Iterable<MockedTorrent> mockedTorrents) {
    final TorrentFileProvider torrentFileProvider = mock(TorrentFileProvider.class);
    Stubber stubber = null;
    for (final MockedTorrent torrent : mockedTorrents) {
        if (stubber == null) {
            stubber = doReturn(torrent);
        } else {
            stubber = stubber.doReturn(torrent);
        }
    }
    try {
        if (stubber == null) {
            Mockito.doThrow(new NoMoreTorrentsFileAvailableException("no more")).when(torrentFileProvider).getTorrentNotIn(anyList());
        } else {
            stubber
                    .doThrow(new NoMoreTorrentsFileAvailableException("no more"))
                    .when(torrentFileProvider).getTorrentNotIn(anyList());
        }
    } catch (final NoMoreTorrentsFileAvailableException ignore) {
    }

    return torrentFileProvider;
}
 

/**
 * Throw an exception from the mock/spy only in the case that the
 * call stack at the time the method has a line which matches the given
 * pattern.
 *
 * @param t the Throwable to throw
 * @param pattern the pattern against which to match the call stack trace
 * @return the stub in progress
 */
public static Stubber doThrowWhenCallStackMatches(
    final Throwable t, final String pattern) {
  return Mockito.doAnswer(new Answer<Object>() {
    @Override
    public Object answer(InvocationOnMock invocation) throws Throwable {
      t.setStackTrace(Thread.currentThread().getStackTrace());
      for (StackTraceElement elem : t.getStackTrace()) {
        if (elem.toString().matches(pattern)) {
          throw t;
        }
      }
      return invocation.callRealMethod();
    }
  });
}
 

private static Stubber setupDoAnswer(final LocationEngineResult expectedResult) {
  return doAnswer(new Answer() {
    @Override
    public Object answer(InvocationOnMock invocation) {
      LocationEngineCallback<LocationEngineResult> callback = invocation.getArgument(0);
      callback.onSuccess(expectedResult);
      return null;
    }
  });
}
 

private  Stubber doAnswer(final Consumer<Object[]> method, final int argumentCount) {
    return Mockito.doAnswer(invocation -> {
        Object[] arguments = invocation.getArguments();
        if (arguments.length >= argumentCount) {
            method.accept(arguments);
        } else {
            failure("Invocation requires at least " + argumentCount + " argument");
        }
        return null;
    });
}
 

@SuppressWarnings("unchecked")
public <T> Stubber toAnswer(final Runnable method) {
    return Mockito.doAnswer(invocation -> {
        Object[] arguments = invocation.getArguments();
        method.run();
        return null;
    });
}
 

private Stubber captureUpdatesAndTags(final List<Update> updates, final Set<String> tags) {
    return doAnswer(new Answer() {
        @Override
        public Object answer(InvocationOnMock invocation)
                throws Throwable {
            //noinspection unchecked
            Iterables.addAll(updates, (Iterable<Update>) invocation.getArguments()[0]);
            //noinspection unchecked
            tags.addAll((Collection<? extends String>) invocation.getArguments()[1]);
            return null;
        }
    });
}
 

private Stubber doUpdateInto(final List<Update> updates) {
    return doAnswer(new Answer() {
        @Override
        public Object answer(InvocationOnMock invocation)
                throws Throwable {
            //noinspection unchecked
            Iterables.addAll(updates, (Iterable<Update>) invocation.getArguments()[0]);
            return null;
        }
    });
}
 

private AuthenticationCommand testRequiredAuthentication(boolean requiredJwtValidation, String jwtToken) throws Exception {
    Authentication authentication = new Authentication(AuthenticationScheme.HTTP_BASIC_PASSTICKET, "applid");
    ServiceAuthenticationServiceImpl.UniversalAuthenticationCommand universalAuthenticationCommand =
        serviceAuthenticationServiceImpl.new UniversalAuthenticationCommand();

    AuthenticationCommand ac = mock(AuthenticationCommand.class);
    QueryResponse queryResponse = mock(QueryResponse.class);
    AbstractAuthenticationScheme schema = mock(AbstractAuthenticationScheme.class);
    HttpServletRequest request = mock(HttpServletRequest.class);
    RequestContext.getCurrentContext().setRequest(request);

    Stubber stubber;
    if (StringUtils.equals(jwtToken, "validJwt")) {
        stubber = doReturn(Optional.of(jwtToken));
    } else {
        stubber = doThrow(new TokenNotValidException("Token is not valid."));
    }
    stubber.when(getUnProxy(authenticationService)).getJwtTokenFromRequest(request);
    doReturn(ac).when(schema).createCommand(eq(authentication), argThat(x -> Objects.equals(x.get(), queryResponse)));
    doReturn(schema).when(getUnProxy(authenticationSchemeFactory)).getSchema(authentication.getScheme());
    doReturn(queryResponse).when(getUnProxy(authenticationService)).parseJwtToken("validJwt");
    doReturn(requiredJwtValidation).when(ac).isRequiredValidJwt();

    universalAuthenticationCommand.apply(createInstanceInfo("id", authentication));

    return ac;
}
 

public Stubber doThrow(Throwable toBeThrown) {
    answers.add(new ThrowsException(toBeThrown));
    return this;
}
 

public Stubber doReturn(Object toBeReturned) {
    answers.add(new Returns(toBeReturned));
    return this;
}
 

public Stubber doNothing() {
    answers.add(new DoesNothing());
    return this;
}
 

public Stubber doAnswer(Answer answer) {
    answers.add(answer);
    return this;
}
 

public BDDStubberImpl(Stubber mockitoStubber) {
    this.mockitoStubber = mockitoStubber;
}
 

public Stubber doAnswer(Answer answer) {
    mockingProgress.stubbingStarted();
    mockingProgress.resetOngoingStubbing();
    return new StubberImpl().doAnswer(answer);
}
 

public Stubber doReturn(Object toBeReturned) {
    answers.add(new Returns(toBeReturned));
    return this;
}
 

public Stubber doThrow(Throwable toBeThrown) {
    answers.add(new ThrowsException(toBeThrown));
    return this;
}
 

public Stubber doThrow(Class<? extends Throwable> toBeThrown) {
    answers.add(new ThrowsExceptionClass(toBeThrown));
    return this;
}
 

public Stubber doNothing() {
    answers.add(new DoesNothing());
    return this;
}
 

public Stubber doAnswer(Answer answer) {
    answers.add(answer);
    return this;
}
 

public Stubber doCallRealMethod() {
    answers.add(new CallsRealMethods());
    return this;
}
 

public BDDStubberImpl(Stubber mockitoStubber) {
    this.mockitoStubber = mockitoStubber;
}
 

@SuppressWarnings("unchecked")
static <T extends Metric> T configureMatcher(T mock, Stubber stub) throws Exception {
  stub.when(mock).processWith(any(MetricProcessor.class), any(MetricName.class), any());
  return mock;
}
 

StaticCapableStubber(Stubber instanceStubber) {
    this.instanceStubber = instanceStubber;
}
 

private Stubber injectIOE() {
  return futureThrows(new IOException("Injected"));
}
 

@SuppressWarnings("unchecked")
public <T> Stubber toAnswer(final Consumer<T> method) {
    return doAnswer(arguments -> method.accept((T) arguments[0]), 1);
}
 

@SuppressWarnings("unchecked")
public <F, S> Stubber toAnswer(final BiConsumer<F, S> method) {
    return doAnswer(arguments ->
        method.accept((F) arguments[0], (S) arguments[1]), 2);
}
 

@SuppressWarnings("unchecked")
public <F, S, T> Stubber toAnswer(final TriConsumer<F, S, T> method) {
    return doAnswer(arguments ->
            method.accept((F) arguments[0], (S) arguments[1], (T) arguments[2]), 3);
}
 

/**
 * Delegates call to {@link Mockito#doAnswer(Answer)}.
 */
default Stubber doAnswer(Answer answer) {
    return Mockito.doAnswer(answer);
}
 

static Stubber futureThrows(Throwable t) {
  ListenableFuture<?> ret = Futures.immediateFailedFuture(t);
  return Mockito.doReturn(ret);
}