Java Code Examples for org.mockito.Mockito#clearInvocations()

The following examples show how to use org.mockito.Mockito#clearInvocations() . These examples are extracted from open source projects. You can vote up the ones you like or vote down the ones you don't like, and go to the original project or source file by following the links above each example. You may check out the related API usage on the sidebar.
Example 1
@Test
public void verifyThatKeyIsCached() throws InterruptedException, TimeoutException, ExecutionException {

    mockSuccessfulDiscoveryEndpointRequest();
    mockSuccessfulPublicKeysRequest();

    final Optional<PublicKey> publicKeyFromEndpoint =
            underTest.getPublicKey("google.com", KEY_ID).get(LATCH_TIMEOUT, TimeUnit.SECONDS);
    assertThat(publicKeyFromEndpoint).isNotEmpty();
    verify(httpClientMock).createSingleHttpRequest(DISCOVERY_ENDPOINT_REQUEST);
    verify(httpClientMock).createSingleHttpRequest(PUBLIC_KEYS_REQUEST);

    Mockito.clearInvocations(httpClientMock);

    final Optional<PublicKey> publicKeyFromCache =
            underTest.getPublicKey("google.com", KEY_ID).get(LATCH_TIMEOUT, TimeUnit.SECONDS);
    assertThat(publicKeyFromCache).contains(publicKeyFromEndpoint.get());
    assertThat(publicKeyFromCache).isNotEmpty();
    verifyNoMoreInteractions(httpClientMock);
}
 
Example 2
@Test
public void verifyThatKeyIsNotCachedOnErrorResponseFromDiscoveryEndpoint() {

    mockErrorDiscoveryEndpointRequest();

    assertThatExceptionOfType(ExecutionException.class)
            .isThrownBy(() -> underTest.getPublicKey("google.com", KEY_ID).get(LATCH_TIMEOUT, TimeUnit.SECONDS))
            .withCauseExactlyInstanceOf(GatewayAuthenticationProviderUnavailableException.class);
    verify(httpClientMock).createSingleHttpRequest(DISCOVERY_ENDPOINT_REQUEST);
    verify(httpClientMock, never()).createSingleHttpRequest(PUBLIC_KEYS_REQUEST);

    Mockito.clearInvocations(httpClientMock);

    assertThatExceptionOfType(ExecutionException.class)
            .isThrownBy(() -> underTest.getPublicKey("google.com", KEY_ID).get(LATCH_TIMEOUT, TimeUnit.SECONDS))
            .withCauseExactlyInstanceOf(GatewayAuthenticationProviderUnavailableException.class);
    verify(httpClientMock).createSingleHttpRequest(DISCOVERY_ENDPOINT_REQUEST);
    verify(httpClientMock, never()).createSingleHttpRequest(PUBLIC_KEYS_REQUEST);
}
 
Example 3
@Test
public void verifyThatKeyIsNotCachedIfResponseDoesNotContainKeyId()
        throws InterruptedException, ExecutionException, TimeoutException {

    mockSuccessfulDiscoveryEndpointRequest();
    mockSuccessfulPublicKeysRequestWithoutMatchingKeyId();

    assertThat(underTest.getPublicKey("google.com", KEY_ID).get(LATCH_TIMEOUT, TimeUnit.SECONDS)).isEmpty();
    verify(httpClientMock).createSingleHttpRequest(DISCOVERY_ENDPOINT_REQUEST);
    verify(httpClientMock).createSingleHttpRequest(PUBLIC_KEYS_REQUEST);

    Mockito.clearInvocations(httpClientMock);

    assertThat(underTest.getPublicKey("google.com", KEY_ID).get(LATCH_TIMEOUT, TimeUnit.SECONDS)).isEmpty();
    verify(httpClientMock).createSingleHttpRequest(DISCOVERY_ENDPOINT_REQUEST);
    verify(httpClientMock).createSingleHttpRequest(PUBLIC_KEYS_REQUEST);
}
 
Example 4
@Test
public void shouldReconnectIfSocketIsClosed() {
    new TestKit(actorSystem) {{
        final ConnectionId randomConnectionId = TestConstants.createRandomConnectionId();
        final Connection connection =
                TestConstants.createConnection(randomConnectionId, new Target[0])
                        .toBuilder()
                        .uri("amqps://username:[email protected]:65536") // port 65536 does not even exist ;)
                        .build();
        final Props props = DummyClientActor.props(connection, getRef(), getRef(), getRef(), delegate);

        final ActorRef dummyClientActor = watch(actorSystem.actorOf(props));

        whenOpeningConnection(dummyClientActor, OpenConnection.of(randomConnectionId, DittoHeaders.empty()),
                getRef());

        expectMsgClass(Status.Failure.class);

        thenExpectCleanupResourcesCalled();
        Mockito.clearInvocations(delegate);
        thenExpectCleanupResourcesCalledAfterTimeout(
                connectivityConfig.getClientConfig().getConnectingMinTimeout());
        thenExpectNoConnectClientCalled();
    }};
}
 
Example 5
@Test
public void doesNotReconnectIfConnectionSuccessful() {
    new TestKit(actorSystem) {{
        final ConnectionId randomConnectionId = TestConstants.createRandomConnectionId();
        final Connection connection =
                TestConstants.createConnection(randomConnectionId, new Target[0]);
        final Props props = DummyClientActor.props(connection, getRef(), getRef(), getRef(), delegate);

        final ActorRef dummyClientActor = watch(actorSystem.actorOf(props));

        whenOpeningConnection(dummyClientActor, OpenConnection.of(randomConnectionId, DittoHeaders.empty()),
                getRef());
        thenExpectConnectClientCalled();
        Mockito.clearInvocations(delegate);
        andConnectionSuccessful(dummyClientActor, getRef());

        expectMsgClass(Status.Success.class);
        thenExpectNoConnectClientCalledAfterTimeout(connectivityConfig.getClientConfig().getConnectingMinTimeout());
    }};
}
 
Example 6
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);
}
 
Example 7
@Test
void should_ReturnDefinitionEntity_When_ConvertingWorkbasketToDefinition()
    throws NotAuthorizedException, WorkbasketNotFoundException {
  WorkbasketImpl workbasket = (WorkbasketImpl) workbasketService.newWorkbasket("1", "DOMAIN_A");
  String id = "ID1";
  workbasket.setId(id);
  List<WorkbasketAccessItem> workbasketAccessItems =
      Arrays.asList(
          workbasketService.newWorkbasketAccessItem(id, "a"),
          workbasketService.newWorkbasketAccessItem(id, "b"));

  WorkbasketImpl target1 = (WorkbasketImpl) workbasketService.newWorkbasket("2", "DOMAIN_A");
  WorkbasketImpl target2 = (WorkbasketImpl) workbasketService.newWorkbasket("3", "DOMAIN_A");
  target1.setId("target1");
  target2.setId("target2");
  List<WorkbasketSummary> workbasketSummaries = Arrays.asList(target1, target2);

  Mockito.doReturn(workbasketAccessItems).when(workbasketService).getWorkbasketAccessItems(id);
  Mockito.doReturn(workbasketSummaries).when(workbasketService).getDistributionTargets(id);

  Object[] mocks = {workbasketService, workbasketAssembler, accessItemAssembler};
  Mockito.clearInvocations(mocks);

  WorkbasketDefinitionRepresentationModel repModel = assembler.toModel(workbasket);

  assertThat(repModel).isNotNull();
  // workbasketAssembler does the conversion. Thus no further testing needed.
  assertThat(repModel.getWorkbasket()).isNotNull();
  // accessItemAssembler does the conversion. Thus no further testing needed.
  assertThat(repModel.getAuthorizations()).hasSize(2);
  assertThat(repModel.getDistributionTargets()).containsExactlyInAnyOrder("target1", "target2");
  InOrder inOrder = Mockito.inOrder(mocks);
  inOrder.verify(workbasketAssembler).toModel(workbasket);
  inOrder.verify(workbasketService).getWorkbasketAccessItems(id);
  inOrder.verify(accessItemAssembler).toCollectionModel(workbasketAccessItems);
  inOrder.verify(accessItemAssembler, times(2)).toModel(any());
  inOrder.verify(workbasketService).getDistributionTargets(id);
  inOrder.verifyNoMoreInteractions();
  Mockito.verifyNoMoreInteractions(mocks);
}
 
Example 8
@Test
public void connectsAutomaticallyAfterActorStart() {
    new TestKit(actorSystem) {{
        final ConnectionId randomConnectionId = TestConstants.createRandomConnectionId();
        final Connection connection =
                TestConstants.createConnection(randomConnectionId, new Target[0]);
        final Props props = DummyClientActor.props(connection, getRef(), getRef(), getRef(), delegate);

        final ActorRef dummyClientActor = watch(actorSystem.actorOf(props));

        thenExpectConnectClientCalledAfterTimeout(Duration.ofSeconds(5L));
        Mockito.clearInvocations(delegate);
        andConnectionSuccessful(dummyClientActor, getRef());
    }};
}
 
Example 9
Source Project: aion   File: CliTest.java    License: MIT License 4 votes vote down vote up
@Parameters(method = "parametersFortestAccountCliParseAndRun")
@Test
public void testAccountCliParseAndRun(String[] options, ReturnType expected ){

    CommandLine commandLine = new CommandLine(Arguments.class).addSubcommand(EditCli.class);
    ParseResult result;
    try{
        result = commandLine.parseArgs(options);
    }catch (Exception e){
        if (expected.equals(ERROR)) {
            return;
        }
        else {
            throw e;
        }
    }
    CommandSpec commandSpec = Cli.findCommandSpec(result, AccountCli.class);

    //noinspection ConstantConditions
    AccountCli spiedAccountCLI = spy((AccountCli) commandSpec.userObject());
    doReturn(true).when(spiedAccountCLI).exportPrivateKey(anyString(),any());
    doReturn(true).when(spiedAccountCLI).listAccounts();
    doReturn(true).when(spiedAccountCLI).createAccount(any());
    doReturn(true).when(spiedAccountCLI).importPrivateKey(anyString(), any());
    doCallRealMethod().when(spiedAccountCLI).runCommand(any());
    assertThat(spiedAccountCLI.runCommand(mockpr)).isEqualTo(expected);
    if (spiedAccountCLI.getList()) {
        verify(spiedAccountCLI, times(1)).listAccounts();
    } else {
        verify(spiedAccountCLI, times(0)).listAccounts();
    }

    if (!spiedAccountCLI.getGroup().getImportAcc().isEmpty()) {
        verify(spiedAccountCLI, times(1)).importPrivateKey(anyString(), any());
    } else {
        verify(spiedAccountCLI, times(0)).importPrivateKey(anyString(),any());
    }

    if (!spiedAccountCLI.getGroup().getExport().isEmpty()) {
        verify(spiedAccountCLI, times(1)).exportPrivateKey(anyString(),any());
    } else {
        verify(spiedAccountCLI, times(0)).exportPrivateKey(anyString(), any());
    }

    if (spiedAccountCLI.getGroup().getCreate()) {
        verify(spiedAccountCLI, times(1)).createAccount(any());
    } else {
        verify(spiedAccountCLI, times(0)).createAccount(any());
    }
    Mockito.clearInvocations(spiedAccountCLI);
}
 
Example 10
Source Project: pandroid   File: TemplatesTest.java    License: Apache License 2.0 4 votes vote down vote up
@Test
public void testFeatureTemplate() throws Throwable {

    MainActivity activity = activityRule.getActivity();
    FeatureFragment fragment = new FeatureFragment();
    fragment.toastManager = Mockito.mock(ToastManager.class);

    fragment.presenter = new FeatureFragmentPresenter();
    FeatureManager featureManager = Mockito.mock(FeatureManager.class);
    fragment.presenter.featureManager = featureManager;

    Mockito.when(featureManager.loadData()).thenReturn(Observable.error(new Exception("error")));
    activity.getSupportFragmentManager()
            .beginTransaction()
            .replace(R.id.main_content_container, fragment)
            .commit();

    Espresso.onView(ViewMatchers.withId(R.id.feature_loader))
            .check(ViewAssertions.matches(ViewMatchers.withEffectiveVisibility(ViewMatchers.Visibility.GONE)));

    Mockito.verify(fragment.toastManager, VerificationModeFactory.times(1)).makeToast(Mockito.any(), Mockito.eq("error"), Mockito.any(), Mockito.anyInt());

    ArrayList<FeatureModel> models = new ArrayList<>();
    models.add(new FeatureModel());
    models.add(new FeatureModel());
    models.add(new FeatureModel());

    Mockito.when(featureManager.loadData()).thenReturn(Observable.fromIterable(models).delay(3, TimeUnit.SECONDS));
    Mockito.when(fragment.toastManager.makeToast(Mockito.any(), Mockito.anyString(), Mockito.any(), Mockito.anyInt()))
            .thenThrow(new IllegalStateException("Error should not apprend"));


    Espresso.onView(ViewMatchers.withId(R.id.feature_retry))
            .check(ViewAssertions.matches(ViewMatchers.withEffectiveVisibility(ViewMatchers.Visibility.VISIBLE)))
            .perform(ViewActions.click())
            .check(ViewAssertions.matches(ViewMatchers.withEffectiveVisibility(ViewMatchers.Visibility.GONE)));

    Espresso.onView(ViewMatchers.withId(R.id.feature_loader))
            .check(ViewAssertions.matches(ViewMatchers.withEffectiveVisibility(ViewMatchers.Visibility.GONE)));
    Espresso.onView(ViewMatchers.withId(R.id.feature_rv))
            .perform(RecyclerViewActions.actionOnItemAtPosition(2, ViewActions.click()));

    Mockito.clearInvocations(featureManager);
    Mockito.verify(featureManager, VerificationModeFactory.noMoreInteractions()).loadData();


    activityRule.runOnUiThread(fragment::reload);

    Espresso.onIdle();

}