java类org.mockito.ArgumentCaptor的实例源码

public void testPrimaryWaitForRefresh() throws Exception {
    TestRequest request = new TestRequest();
    request.setRefreshPolicy(RefreshPolicy.WAIT_UNTIL);

    TestAction testAction = new TestAction();
    TransportWriteAction.WritePrimaryResult<TestRequest, TestResponse> result =
            testAction.shardOperationOnPrimary(request, indexShard);
    CapturingActionListener<TestResponse> listener = new CapturingActionListener<>();
    result.respond(listener);
    assertNull(listener.response); // Haven't reallresponded yet

    @SuppressWarnings({ "unchecked", "rawtypes" })
    ArgumentCaptor<Consumer<Boolean>> refreshListener = ArgumentCaptor.forClass((Class) Consumer.class);
    verify(indexShard, never()).refresh(any());
    verify(indexShard).addRefreshListener(any(), refreshListener.capture());

    // Now we can fire the listener manually and we'll get a response
    boolean forcedRefresh = randomBoolean();
    refreshListener.getValue().accept(forcedRefresh);
    assertNotNull(listener.response);
    assertNull(listener.failure);
    assertEquals(forcedRefresh, listener.response.forcedRefresh);
}

@SuppressWarnings("rawtypes")
private static DOMDataTreeCandidate findCandidate(ArgumentCaptor<Collection> candidateCapture,
        YangInstanceIdentifier rootPath) {
    for (Object obj: candidateCapture.getValue()) {
        DOMDataTreeCandidate candidate = (DOMDataTreeCandidate)obj;
        if (rootPath.equals(candidate.getRootPath().getRootIdentifier())) {
            return candidate;
        }
    }

    return null;
}

@Test
public void buildCleartext__shouldSucceed() {
    cryptoStatusBuilder.setCryptoMode(CryptoMode.NO_CHOICE);
    pgpMessageBuilder.setCryptoStatus(cryptoStatusBuilder.build());

    Callback mockCallback = mock(Callback.class);
    pgpMessageBuilder.buildAsync(mockCallback);

    ArgumentCaptor<MimeMessage> captor = ArgumentCaptor.forClass(MimeMessage.class);
    verify(mockCallback).onMessageBuildSuccess(captor.capture(), eq(false));
    verifyNoMoreInteractions(mockCallback);

    MimeMessage message = captor.getValue();
    assertMessageHasAutocryptHeader(message, SENDER_EMAIL, false, AUTOCRYPT_KEY_MATERIAL);
}

private CommandInterface getCommandInterface() {
    CommandInterface commandInterface = Mockito.mock(CommandInterface.class);
    argumentPacket = ArgumentCaptor.forClass(ZToolPacket.class);
    argumentListener = ArgumentCaptor.forClass(SynchronousCommandListener.class);
    argumentTimeout = ArgumentCaptor.forClass(Long.class);
    try {
        Mockito.doNothing().when(commandInterface).sendSynchronousCommand(argumentPacket.capture(),
                argumentListener.capture(), argumentTimeout.capture());
    } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }

    return commandInterface;
}

@Test
public void toResponse_shouldLogToEventSink() throws Exception {
    IdpDisabledException exception = new IdpDisabledException("my-entity");
    ArgumentCaptor<EventSinkHubEvent> captor = ArgumentCaptor.forClass(EventSinkHubEvent.class);

    exceptionMapper.toResponse(exception);

    verify(eventSinkProxy).logHubEvent(captor.capture());
    EventSinkHubEvent value = captor.getValue();
    assertThat(value.getOriginatingService()).isEqualTo(SERVICE_NAME);
    assertThat(value.getEventType()).isEqualTo(EventSinkHubEventConstants.EventTypes.ERROR_EVENT);
    assertThat(value.getSessionId()).isEqualTo(SESSION_ID.toString());
    assertThat(value.getDetails().containsKey(idp_entity_id)).as("Details should contain IDP id").isTrue();
}

/**
 * Test that if splitThreshold is zero, then we always get a separate
 * call per storage.
 */
@Test(timeout=300000)
public void testAlwaysSplit() throws IOException, InterruptedException {
  startUpCluster(0);
  NameNode nn = cluster.getNameNode();
  DataNode dn = cluster.getDataNodes().get(0);

  // Create a file with a few blocks.
  createFile(GenericTestUtils.getMethodName(), BLOCKS_IN_FILE);

  // Insert a spy object for the NN RPC.
  DatanodeProtocolClientSideTranslatorPB nnSpy =
      DataNodeTestUtils.spyOnBposToNN(dn, nn);

  // Trigger a block report so there is an interaction with the spy
  // object.
  DataNodeTestUtils.triggerBlockReport(dn);

  ArgumentCaptor<StorageBlockReport[]> captor =
      ArgumentCaptor.forClass(StorageBlockReport[].class);

  Mockito.verify(nnSpy, times(cluster.getStoragesPerDatanode())).blockReport(
      any(DatanodeRegistration.class),
      anyString(),
      captor.capture(),  Mockito.<BlockReportContext>anyObject());

  verifyCapturedArguments(captor, 1, BLOCKS_IN_FILE);
}

@Test
public void shouldAcquireOAuth2Credentials() {
    final OAuth2ConnectionFactory<?> oauth2 = mock(OAuth2ConnectionFactory.class);
    @SuppressWarnings("unchecked")
    final Applicator<AccessGrant> applicator = mock(Applicator.class);
    when(locator.providerWithId("providerId"))
        .thenReturn(new OAuth2CredentialProvider<>("providerId", oauth2, applicator));

    when(oauth2.getScope()).thenReturn("scope");
    when(oauth2.generateState()).thenReturn("state-token");
    final OAuth2Operations operations = mock(OAuth2Operations.class);
    when(oauth2.getOAuthOperations()).thenReturn(operations);
    final ArgumentCaptor<OAuth2Parameters> parameters = ArgumentCaptor.forClass(OAuth2Parameters.class);
    when(operations.buildAuthorizeUrl(parameters.capture())).thenReturn("https://provider.io/oauth/authorize");

    final AcquisitionFlow acquisition = credentials.acquire("providerId", URI.create("https://syndesis.io/api/v1/"),
        URI.create("/ui#state"));

    final CredentialFlowState expectedFlowState = new OAuth2CredentialFlowState.Builder().key("state-token")
        .providerId("providerId").redirectUrl("https://provider.io/oauth/authorize")
        .returnUrl(URI.create("/ui#state")).build();

    final AcquisitionFlow expected = new AcquisitionFlow.Builder().type(Type.OAUTH2)
        .redirectUrl("https://provider.io/oauth/authorize").state(expectedFlowState).build();
    assertThat(acquisition).isEqualTo(expected);

    final OAuth2Parameters capturedParameters = parameters.getValue();
    assertThat(capturedParameters.getRedirectUri()).isEqualTo("https://syndesis.io/api/v1/credentials/callback");
    assertThat(capturedParameters.getScope()).isEqualTo("scope");
    assertThat(capturedParameters.getState()).isEqualTo("state-token");
}

@Before public void setup() {
  MockitoAnnotations.initMocks(this);

  childEventListener = ArgumentCaptor.forClass(ChildEventListener.class);
  valueEventListener = ArgumentCaptor.forClass(ValueEventListener.class);
  transactionHandler = ArgumentCaptor.forClass(Transaction.Handler.class);
  onCompleteListener = ArgumentCaptor.forClass(OnCompleteListener.class);
}

@Test
public void testCallRepo() {
    ArgumentCaptor<String> captor = ArgumentCaptor.forClass(String.class);
    userViewModel.getUser().observeForever(mock(Observer.class));
    userViewModel.setLogin("abc");
    verify(userRepository).loadUser(captor.capture());
    assertThat(captor.getValue(), is("abc"));
    reset(userRepository);
    userViewModel.setLogin("ddd");
    verify(userRepository).loadUser(captor.capture());
    assertThat(captor.getValue(), is("ddd"));
}

@SuppressWarnings("resource")
@Test
public void oneBooleanArgument() throws Exception {
    String sql = "SELECT status, temperature FROM root.ln.wf01.wt01 WHERE temperature < ? and time > 2017-11-1 0:13:00";
    TsfilePrepareStatement ps = new TsfilePrepareStatement(connection, client, sessHandle, sql);
    ps.setBoolean(1, false);
    ps.execute();
    ArgumentCaptor<TSExecuteStatementReq> argument = ArgumentCaptor.forClass(TSExecuteStatementReq.class);
    verify(client).executeStatement(argument.capture());
    assertEquals("SELECT status, temperature FROM root.ln.wf01.wt01 WHERE temperature < false and time > 2017-11-1 0:13:00", argument.getValue().getStatement());
}