@Test
  public void lockBlockTest() throws Exception {
    Map<String, String> params = new HashMap<>();
    params.put("blockId", "1");
    params.put("sessionId", "1");

    LockBlockResult lockBlockResult = LockBlockResultTest.createRandom();
    Mockito.doReturn(lockBlockResult.getLockId())
        .when(mBlockWorker)
        .lockBlock(Mockito.anyLong(), Mockito.anyLong());
    Mockito.doReturn(lockBlockResult.getBlockPath())
        .when(mBlockWorker)
        .readBlock(Mockito.anyLong(), Mockito.anyLong(), Mockito.anyLong());

    TestCaseFactory.newWorkerTestCase(
            getEndpoint(BlockWorkerClientRestServiceHandler.LOCK_BLOCK),
            params,
            "POST",
            lockBlockResult,
            mResource)
        .run();

    Mockito.verify(mBlockWorker).lockBlock(Mockito.anyLong(), Mockito.anyLong());
    Mockito.verify(mBlockWorker).readBlock(Mockito.anyLong(), Mockito.anyLong(), Mockito.anyLong());
  }
예제 #2
0
  @Test
  public void shouldGetCurrencyPairTradeHistory() throws IOException {
    // given
    final UserTrade[] expectedCpUserTrades = expectedCpUserTrades();

    BitMarketHistoryTradesResponse historyTradesCPResponse =
        parse("trade/example-history-trades-cp-data", BitMarketHistoryTradesResponse.class);
    BitMarketHistoryOperationsResponse marketHistoryOperationsEurResponse =
        parse(
            "trade/example-history-operations-eur-data", BitMarketHistoryOperationsResponse.class);
    BitMarketHistoryOperationsResponse marketHistoryOperationsBtcResponse =
        parse(
            "trade/example-history-operations-btc-data", BitMarketHistoryOperationsResponse.class);

    BitMarketAuthenticated bitMarketAuthenticated = mock(BitMarketAuthenticated.class);
    PowerMockito.when(
            bitMarketAuthenticated.trades(
                Mockito.eq(SPECIFICATION_API_KEY),
                Mockito.any(ParamsDigest.class),
                Mockito.any(SynchronizedValueFactory.class),
                Mockito.eq("BTCEUR"),
                Mockito.eq(1000),
                Mockito.eq(0L)))
        .thenReturn(historyTradesCPResponse);

    PowerMockito.when(
            bitMarketAuthenticated.history(
                Mockito.eq(SPECIFICATION_API_KEY),
                Mockito.any(ParamsDigest.class),
                Mockito.any(SynchronizedValueFactory.class),
                Mockito.eq(Currency.EUR.toString()),
                Mockito.anyInt(),
                Mockito.anyLong()))
        .thenReturn(marketHistoryOperationsEurResponse);
    PowerMockito.when(
            bitMarketAuthenticated.history(
                Mockito.eq(SPECIFICATION_API_KEY),
                Mockito.any(ParamsDigest.class),
                Mockito.any(SynchronizedValueFactory.class),
                Mockito.eq(Currency.BTC.toString()),
                Mockito.anyInt(),
                Mockito.anyLong()))
        .thenReturn(marketHistoryOperationsBtcResponse);

    Whitebox.setInternalState(tradeService, "bitMarketAuthenticated", bitMarketAuthenticated);

    // when
    UserTrades tradesCP =
        tradeService.getTradeHistory(
            new DefaultTradeHistoryParamCurrencyPair(CurrencyPair.BTC_EUR));
    List<UserTrade> userTrades = tradesCP.getUserTrades();

    // then
    assertThat(userTrades).hasSize(2);
    for (int i = 0; i < userTrades.size(); i++) {
      BitMarketAssert.assertEquals(userTrades.get(i), expectedCpUserTrades[i]);
    }
  }
 @Test
 public void scheduleRestartForVmsOnHost() {
   Mockito.when(hostVO.getType()).thenReturn(Host.Type.Routing);
   Mockito.when(hostVO.getHypervisorType()).thenReturn(HypervisorType.KVM);
   Mockito.when(_instanceDao.listByHostId(42l))
       .thenReturn(Arrays.asList(Mockito.mock(VMInstanceVO.class)));
   Mockito.when(_podDao.findById(Mockito.anyLong())).thenReturn(Mockito.mock(HostPodVO.class));
   Mockito.when(_dcDao.findById(Mockito.anyLong())).thenReturn(Mockito.mock(DataCenterVO.class));
   highAvailabilityManager.scheduleRestartForVmsOnHost(hostVO, true);
 }
예제 #4
0
  @Test
  public void shouldGetTradeHistory() throws IOException {
    // given
    BitMarketHistoryTradesResponse historyTradesBMResponse =
        parse("trade/example-history-trades-bm-data", BitMarketHistoryTradesResponse.class);
    BitMarketHistoryOperationsResponse marketHistoryOperationsEurResponse =
        parse(
            "trade/example-history-operations-eur-data", BitMarketHistoryOperationsResponse.class);
    BitMarketHistoryOperationsResponse marketHistoryOperationsBtcResponse =
        parse(
            "trade/example-history-operations-btc-data", BitMarketHistoryOperationsResponse.class);

    BitMarketAuthenticated bitMarketAuthenticated = mock(BitMarketAuthenticated.class);
    PowerMockito.when(
            bitMarketAuthenticated.trades(
                Mockito.eq(SPECIFICATION_API_KEY),
                Mockito.any(ParamsDigest.class),
                Mockito.any(SynchronizedValueFactory.class),
                Mockito.eq("BTCEUR"),
                Mockito.eq(3500),
                Mockito.eq(500L)))
        .thenReturn(historyTradesBMResponse);

    PowerMockito.when(
            bitMarketAuthenticated.history(
                Mockito.eq(SPECIFICATION_API_KEY),
                Mockito.any(ParamsDigest.class),
                Mockito.any(SynchronizedValueFactory.class),
                Mockito.eq(Currency.EUR.toString()),
                Mockito.anyInt(),
                Mockito.anyLong()))
        .thenReturn(marketHistoryOperationsEurResponse);
    PowerMockito.when(
            bitMarketAuthenticated.history(
                Mockito.eq(SPECIFICATION_API_KEY),
                Mockito.any(ParamsDigest.class),
                Mockito.any(SynchronizedValueFactory.class),
                Mockito.eq(Currency.BTC.toString()),
                Mockito.anyInt(),
                Mockito.anyLong()))
        .thenReturn(marketHistoryOperationsBtcResponse);

    Whitebox.setInternalState(tradeService, "bitMarketAuthenticated", bitMarketAuthenticated);

    // when
    UserTrades tradesBM =
        tradeService.getTradeHistory(new BitMarketHistoryParams(CurrencyPair.BTC_EUR, 500L, 3500));
    List<UserTrade> userTrades = tradesBM.getUserTrades();

    // then
    assertThat(userTrades).hasSize(1);
    BitMarketAssert.assertEquals(userTrades.get(0), EXPECTED_BM_USER_TRADES);
  }
예제 #5
0
  @Test(expected = ExchangeException.class)
  public void shouldFailOnUnsuccessfulTradeHistory() throws IOException {
    // given
    BitMarketHistoryTradesResponse response =
        new BitMarketHistoryTradesResponse(
            false, null, new BitMarketAPILimit(3, 100, 12345000L), 502, "Invalid message hash");

    BitMarketHistoryOperationsResponse marketHistoryOperationsPlnResponse =
        parse("trade/example-history-operations-data", BitMarketHistoryOperationsResponse.class);
    BitMarketHistoryOperationsResponse marketHistoryOperationsBtcResponse =
        parse(
            "trade/example-history-operations-btc-data", BitMarketHistoryOperationsResponse.class);

    BitMarketAuthenticated bitMarketAuthenticated = mock(BitMarketAuthenticated.class);
    PowerMockito.when(
            bitMarketAuthenticated.trades(
                Mockito.eq(SPECIFICATION_API_KEY),
                Mockito.any(ParamsDigest.class),
                Mockito.any(SynchronizedValueFactory.class),
                Mockito.eq("BTCPLN"),
                Mockito.eq(1000),
                Mockito.eq(0L)))
        .thenReturn(response);
    PowerMockito.when(
            bitMarketAuthenticated.history(
                Mockito.eq(SPECIFICATION_API_KEY),
                Mockito.any(ParamsDigest.class),
                Mockito.any(SynchronizedValueFactory.class),
                Mockito.eq(Currency.PLN.toString()),
                Mockito.anyInt(),
                Mockito.anyLong()))
        .thenReturn(marketHistoryOperationsPlnResponse);
    PowerMockito.when(
            bitMarketAuthenticated.history(
                Mockito.eq(SPECIFICATION_API_KEY),
                Mockito.any(ParamsDigest.class),
                Mockito.any(SynchronizedValueFactory.class),
                Mockito.eq(Currency.BTC.toString()),
                Mockito.anyInt(),
                Mockito.anyLong()))
        .thenReturn(marketHistoryOperationsBtcResponse);

    Whitebox.setInternalState(tradeService, "bitMarketAuthenticated", bitMarketAuthenticated);

    // when
    tradeService.getTradeHistory(new DefaultTradeHistoryParamPaging(150));

    // then
    fail(
        "BitMarketTradeService should throw ExchangeException when open orders request was unsuccessful");
  }
  @Test
  public void accessBlockTest() throws Exception {
    Map<String, String> params = new HashMap<>();
    params.put("blockId", "1");

    TestCaseFactory.newWorkerTestCase(
            getEndpoint(BlockWorkerClientRestServiceHandler.ACCESS_BLOCK),
            params,
            "POST",
            null,
            mResource)
        .run();

    Mockito.verify(mBlockWorker).accessBlock(Mockito.anyLong(), Mockito.anyLong());
  }
예제 #7
0
 @Test
 public void testWarnings() throws Exception {
   ConnectionImpl conn = Mockito.mock(ConnectionImpl.class);
   DQP dqp = Mockito.mock(DQP.class);
   ResultsFuture<ResultsMessage> results = new ResultsFuture<ResultsMessage>();
   Mockito.stub(dqp.executeRequest(Mockito.anyLong(), (RequestMessage) Mockito.anyObject()))
       .toReturn(results);
   ResultsMessage rm = new ResultsMessage();
   rm.setResults(new List<?>[] {Arrays.asList(1)});
   rm.setWarnings(Arrays.asList(new Throwable()));
   rm.setColumnNames(new String[] {"expr1"});
   rm.setDataTypes(new String[] {"string"});
   results.getResultsReceiver().receiveResults(rm);
   Mockito.stub(conn.getDQP()).toReturn(dqp);
   StatementImpl statement =
       new StatementImpl(conn, ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY) {
         @Override
         protected java.util.TimeZone getServerTimeZone() throws java.sql.SQLException {
           return null;
         }
       };
   statement.execute("select 'a'");
   assertNotNull(statement.getResultSet());
   SQLWarning warning = statement.getWarnings();
   assertNotNull(warning);
   assertNull(warning.getNextWarning());
 }
예제 #8
0
  @Before
  public final void init() {
    workPlanService = new WorkPlansServiceImpl();

    dataDefinitionService = mock(DataDefinitionService.class);
    TranslationService translationService = mock(TranslationService.class);
    workPlan = mock(Entity.class);
    workPlanDD = mock(DataDefinition.class);

    when(dataDefinitionService.get(
            WorkPlansConstants.PLUGIN_IDENTIFIER, WorkPlansConstants.MODEL_WORK_PLAN))
        .thenReturn(workPlanDD);

    when(translationService.translate(
            Mockito.anyString(), Mockito.any(Locale.class), Mockito.anyString()))
        .thenReturn(TRANSLATED_STRING);

    when(workPlanDD.getName()).thenReturn(WorkPlansConstants.MODEL_WORK_PLAN);
    when(workPlanDD.getPluginIdentifier()).thenReturn(WorkPlansConstants.PLUGIN_IDENTIFIER);
    when(workPlanDD.get(Mockito.anyLong())).thenReturn(workPlan);

    when(workPlan.getDataDefinition()).thenReturn(workPlanDD);
    when(workPlan.getId()).thenReturn(1L);

    ReflectionTestUtils.setField(workPlanService, "dataDefinitionService", dataDefinitionService);
    ReflectionTestUtils.setField(workPlanService, "translationService", translationService);
  }
  @Test
  public void requestSpaceTest() throws Exception {
    Map<String, String> params = new HashMap<>();
    params.put("blockId", "1");
    params.put("sessionId", "1");
    params.put("requestBytes", "1");

    TestCaseFactory.newWorkerTestCase(
            getEndpoint(BlockWorkerClientRestServiceHandler.REQUEST_SPACE),
            params,
            "POST",
            null,
            mResource)
        .run();

    Mockito.verify(mBlockWorker)
        .requestSpace(Mockito.anyLong(), Mockito.anyLong(), Mockito.anyLong());
  }
  @Test
  public void canDecreaseValue() {
    when(originalRepository.read(key)).thenReturn(integerItem);
    sut = new CoRepositoryClient(coRepository, originalRepository, keyUpdateTime, 1);

    sut.decrease(key);

    verify(coRepository).decrease(key);
    verify(keyUpdateTime, times(2)).notifyUpdated(Mockito.eq(key), Mockito.anyLong());
  }
예제 #11
0
  @Before
  public void setup() throws Exception {
    MockitoAnnotations.initMocks(this);
    mainClientExec =
        new MainClientExec(
            requestExecutor,
            connManager,
            reuseStrategy,
            keepAliveStrategy,
            proxyHttpProcessor,
            targetAuthStrategy,
            proxyAuthStrategy,
            userTokenHandler);
    target = new HttpHost("foo", 80);
    proxy = new HttpHost("bar", 8888);

    Mockito.when(connManager.requestConnection(Mockito.<HttpRoute>any(), Mockito.any()))
        .thenReturn(connRequest);
    Mockito.when(connRequest.get(Mockito.anyLong(), Mockito.<TimeUnit>any()))
        .thenReturn(managedConn);
    final Map<String, Header> challenges = new HashMap<String, Header>();
    challenges.put("basic", new BasicHeader(AUTH.WWW_AUTH, "Basic realm=test"));
    final AuthOption authOption =
        new AuthOption(new BasicScheme(), new UsernamePasswordCredentials("user:pass"));
    Mockito.when(
            targetAuthStrategy.getChallenges(
                Mockito.eq(target), Mockito.<HttpResponse>any(), Mockito.<HttpClientContext>any()))
        .thenReturn(challenges);
    Mockito.when(
            targetAuthStrategy.getChallenges(
                Mockito.eq(target), Mockito.<HttpResponse>any(), Mockito.<HttpClientContext>any()))
        .thenReturn(challenges);
    Mockito.when(
            targetAuthStrategy.select(
                Mockito.same(challenges),
                Mockito.eq(target),
                Mockito.<HttpResponse>any(),
                Mockito.<HttpClientContext>any()))
        .thenReturn(new LinkedList<AuthOption>(Arrays.asList(authOption)));
    Mockito.when(
            proxyAuthStrategy.getChallenges(
                Mockito.eq(proxy), Mockito.<HttpResponse>any(), Mockito.<HttpClientContext>any()))
        .thenReturn(challenges);
    Mockito.when(
            proxyAuthStrategy.getChallenges(
                Mockito.eq(proxy), Mockito.<HttpResponse>any(), Mockito.<HttpClientContext>any()))
        .thenReturn(challenges);
    Mockito.when(
            proxyAuthStrategy.select(
                Mockito.same(challenges),
                Mockito.eq(proxy),
                Mockito.<HttpResponse>any(),
                Mockito.<HttpClientContext>any()))
        .thenReturn(new LinkedList<AuthOption>(Arrays.asList(authOption)));
  }
 @Override
 protected void setup(TestContainer container) {
   container.enableInterfaceMocking(true);
   dsMock = mock(DataService.class);
   when(dsMock.getCurrentUser()).thenReturn(givenUser());
   localizerMock = mock(LocalizerServiceLocal.class);
   when(localizerMock.getLocalizedTextFromDatabase(
           Mockito.anyString(), Mockito.anyLong(), Mockito.any(LocalizedObjectTypes.class)))
       .thenReturn(LOCALIZED_RESOURCE);
   logCollector.localizer = localizerMock;
 }
  @Test
  public void investigateHostStatusFailure() {
    Mockito.when(_hostDao.findById(Mockito.anyLong())).thenReturn(hostVO);
    // Set the list of investigators, CheckOnAgentInvestigator suffices for now
    // Also no need to mock isAgentAlive() as actual implementation returns null
    Investigator investigator = Mockito.mock(CheckOnAgentInvestigator.class);
    List<Investigator> investigators = new ArrayList<Investigator>();
    investigators.add(investigator);
    highAvailabilityManager.setInvestigators(investigators);

    assertNull(highAvailabilityManager.investigate(1l));
  }
  @Test
  public void investigateHostStatusSuccess() {
    Mockito.when(_hostDao.findById(Mockito.anyLong())).thenReturn(hostVO);
    // Set the list of investigators, CheckOnAgentInvestigator suffices for now
    Investigator investigator = Mockito.mock(CheckOnAgentInvestigator.class);
    List<Investigator> investigators = new ArrayList<Investigator>();
    investigators.add(investigator);
    highAvailabilityManager.setInvestigators(investigators);
    // Mock isAgentAlive to return host status as Down
    Mockito.when(investigator.isAgentAlive(hostVO)).thenReturn(Status.Down);

    assertTrue(highAvailabilityManager.investigate(1l) == Status.Down);
  }
  @BeforeClass(groups = "fast")
  public void beforeMethod() throws Exception {
    super.beforeClass();

    account = Mockito.mock(Account.class);
    Mockito.when(
            accountInternalApi.getAccountByRecordId(
                Mockito.anyLong(), Mockito.<InternalTenantContext>any()))
        .thenReturn(account);
    dateHelper = new EntitlementDateHelper(accountInternalApi, clock);
    clock.resetDeltaFromReality();
    ;
  }
  @Test
  public void writeBlockTest() throws Exception {
    Map<String, String> params = new HashMap<>();
    params.put("blockId", "1");
    params.put("sessionId", "1");
    params.put("offset", "0");
    params.put("length", "-1");

    Random random = new Random();
    byte[] bytes = CommonUtils.randomBytes(random.nextInt(64));

    BlockWriter blockWriter = PowerMockito.mock(BlockWriter.class);
    Mockito.doReturn(blockWriter)
        .when(mBlockWorker)
        .getTempBlockWriterRemote(Mockito.anyLong(), Mockito.anyLong());

    TestCase testCase =
        TestCaseFactory.newWorkerTestCase(
            getEndpoint(BlockWorkerClientRestServiceHandler.WRITE_BLOCK),
            params,
            "POST",
            null,
            mResource);

    HttpURLConnection connection = (HttpURLConnection) testCase.createURL().openConnection();
    connection.setRequestProperty("Content-Type", MediaType.APPLICATION_OCTET_STREAM);
    connection.setRequestMethod(testCase.getMethod());
    connection.setDoOutput(true);
    connection.connect();
    connection.getOutputStream().write(bytes);
    Assert.assertEquals(
        testCase.getEndpoint(), Response.Status.OK.getStatusCode(), connection.getResponseCode());
    Assert.assertEquals("", testCase.getResponse(connection));

    Mockito.verify(mBlockWorker).getTempBlockWriterRemote(Mockito.anyLong(), Mockito.anyLong());
    Mockito.verify(blockWriter).append(ByteBuffer.wrap(bytes));
  }
  @Test
  public void testGetDog() {
    Dog dog =
        new Dog(
            "Martin",
            "doga",
            new LocalDate(1998, 05, 22),
            new Customer("Martin", "Sakac", "Purkynova 4", "111"));
    dog.setId(1L);

    Mockito.stub(dogDaoImplMock.getDog(Mockito.anyLong())).toReturn(dog);

    DogDto dogActual = dogService.getDogById(1L);
    Mockito.verify(dogDaoImplMock).getDog(1L);
    assertDog(dog, dogActual);
  }
예제 #18
0
 @Test
 public void testBatchExecution() throws Exception {
   ConnectionImpl conn = Mockito.mock(ConnectionImpl.class);
   DQP dqp = Mockito.mock(DQP.class);
   ResultsFuture<ResultsMessage> results = new ResultsFuture<ResultsMessage>();
   Mockito.stub(dqp.executeRequest(Mockito.anyLong(), (RequestMessage) Mockito.anyObject()))
       .toReturn(results);
   ResultsMessage rm = new ResultsMessage();
   rm.setResults(new List<?>[] {Arrays.asList(1), Arrays.asList(2)});
   rm.setUpdateResult(true);
   results.getResultsReceiver().receiveResults(rm);
   Mockito.stub(conn.getDQP()).toReturn(dqp);
   StatementImpl statement =
       new StatementImpl(conn, ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY);
   statement.clearBatch(); // previously caused npe
   statement.addBatch("delete from table"); // $NON-NLS-1$
   statement.addBatch("delete from table1"); // $NON-NLS-1$
   assertTrue(Arrays.equals(new int[] {1, 2}, statement.executeBatch()));
 }
  @Test
  public void readBlockTest() throws Exception {
    Map<String, String> params = new HashMap<>();
    params.put("blockId", "1");
    params.put("sessionId", "1");
    params.put("lockId", "1");
    params.put("offset", "0");
    params.put("length", "-1");

    Random random = new Random();
    byte[] bytes = CommonUtils.randomBytes(random.nextInt(64));
    ByteBuffer byteBuffer = ByteBuffer.wrap(bytes);

    BlockReader blockReader = PowerMockito.mock(BlockReader.class);
    Mockito.doReturn(byteBuffer).when(blockReader).read(Mockito.anyLong(), Mockito.anyLong());
    Mockito.doReturn((long) bytes.length).when(blockReader).getLength();
    Mockito.doReturn(blockReader)
        .when(mBlockWorker)
        .readBlockRemote(Mockito.anyLong(), Mockito.anyLong(), Mockito.anyLong());

    TestCase testCase =
        TestCaseFactory.newWorkerTestCase(
            getEndpoint(BlockWorkerClientRestServiceHandler.READ_BLOCK),
            params,
            "GET",
            byteBuffer,
            mResource);

    HttpURLConnection connection = (HttpURLConnection) testCase.createURL().openConnection();
    connection.setRequestMethod(testCase.getMethod());
    connection.connect();
    Assert.assertEquals(
        testCase.getEndpoint(), connection.getResponseCode(), Response.Status.OK.getStatusCode());
    Assert.assertEquals(new String(byteBuffer.array()), testCase.getResponse(connection));

    Mockito.verify(mBlockWorker)
        .readBlockRemote(Mockito.anyLong(), Mockito.anyLong(), Mockito.anyLong());
  }
  @Test
  public void testUpdateRestaurantFail() {

    Restaurant restaurant = createExoticRestaurant();
    when(restaurantRepository.exists(Mockito.anyLong())).thenReturn(false);
    try {
      MvcResult updateRestaurantResponse =
          mockMvc
              .perform(
                  post("/restaurant/delete")
                      .contentType(MediaType.APPLICATION_JSON)
                      .content(mapper.writeValueAsString(restaurant)))
              .andExpect(status().isOk())
              .andReturn();

      String responseContent = updateRestaurantResponse.getResponse().getContentAsString();
      assertTrue(responseContent.contains(Status.FAILED.getStatusValue()));
    } catch (Exception e) {
      fail();
    }
  }
  @Test
  public void testDeleteRestaurantFail() {

    when(restaurantRepository.exists(Mockito.anyLong())).thenReturn(false);
    Vote vote = new Vote();
    vote.setRestaurantId(Long.MAX_VALUE);
    try {
      MvcResult deleteRestaurantResponse =
          mockMvc
              .perform(
                  post("/restaurant/delete")
                      .contentType(MediaType.APPLICATION_JSON)
                      .content(mapper.writeValueAsString(vote)))
              .andExpect(status().isOk())
              .andReturn();

      String responseContent = deleteRestaurantResponse.getResponse().getContentAsString();
      assertTrue(responseContent.contains(Status.FAILED.getStatusValue()));
    } catch (Exception e) {
      fail();
    }
  }
예제 #22
0
 @Test
 public void testAsynchTimeout() throws Exception {
   ConnectionImpl conn = Mockito.mock(ConnectionImpl.class);
   final StatementImpl statement =
       new StatementImpl(conn, ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY);
   statement.setQueryTimeoutMS(1);
   DQP dqp = Mockito.mock(DQP.class);
   Mockito.stub(statement.getDQP()).toReturn(dqp);
   final AtomicInteger counter = new AtomicInteger();
   Mockito.stub(dqp.cancelRequest(0))
       .toAnswer(
           new Answer<Boolean>() {
             @Override
             public Boolean answer(InvocationOnMock invocation) throws Throwable {
               synchronized (statement) {
                 counter.incrementAndGet();
                 statement.notifyAll();
               }
               return true;
             }
           });
   ResultsFuture<ResultsMessage> future = new ResultsFuture<ResultsMessage>();
   Mockito.stub(dqp.executeRequest(Mockito.anyLong(), (RequestMessage) Mockito.anyObject()))
       .toReturn(future);
   statement.submitExecute("select 'hello world'", null);
   synchronized (statement) {
     while (counter.get() != 1) {
       statement.wait();
     }
   }
   statement.setQueryTimeoutMS(1);
   statement.submitExecute("select 'hello world'", null);
   synchronized (statement) {
     while (counter.get() != 2) {
       statement.wait();
     }
   }
 }
예제 #23
0
  @Before
  public void init() throws Exception {
    mutableReview = mock(MutableReview.class);
    comment = mock(Comment.class);
    when(mutableReview.createComment()).thenReturn(comment);
    review = mock(Review.class);
    workflowContext = mock(WorkflowContext.class);
    settings = new Settings();
    when(workflowContext.getProjectSettings()).thenReturn(settings);
    assigneeLogin = "******";

    jiraIssueCreator = mock(JiraIssueCreator.class);
    reviewDao = mock(ReviewDao.class);
    userFinder = mock(UserFinder.class);

    remoteIssue =
        new Issue(
            null, null, "FOO-15", null, null, null, null, null, null, null, null, null, null, null,
            null, null, null, null, null, null, null, null, null, null, null, null, null, null,
            null, null, null);

    parameters = new HashMap<String, String>();
    parameters.put(JiraConstants.JIRA_ISSUE_REPORTER_PROPERTY, workflowContext.getUserLogin());
    parameters.put(JiraConstants.JIRA_ISSUE_ASSIGNEE_PROPERTY, assigneeLogin);

    ReviewDto reviewDto = new ReviewDto();
    reviewDto.setAssigneeId(40L);
    when(reviewDao.findById(Mockito.anyLong())).thenReturn(reviewDto);
    User assignee = new User();
    assignee.setLogin(assigneeLogin);
    when(userFinder.findById(Mockito.anyInt())).thenReturn(assignee);

    when(jiraIssueCreator.createIssue(review, settings, parameters)).thenReturn(remoteIssue);

    action = new LinkFunction(jiraIssueCreator, reviewDao, userFinder);
  }
  @Test
  public void requestBlockLocationTest() throws Exception {
    Map<String, String> params = new HashMap<>();
    params.put("blockId", "1");
    params.put("sessionId", "1");
    params.put("initialBytes", "1");

    String blockLocation = CommonUtils.randomString(10);
    Mockito.doReturn(blockLocation)
        .when(mBlockWorker)
        .createBlock(Mockito.anyLong(), Mockito.anyLong(), Mockito.anyString(), Mockito.anyLong());

    TestCaseFactory.newWorkerTestCase(
            getEndpoint(BlockWorkerClientRestServiceHandler.REQUEST_BLOCK_LOCATION),
            params,
            "POST",
            blockLocation,
            mResource)
        .run();

    Mockito.verify(mBlockWorker)
        .createBlock(Mockito.anyLong(), Mockito.anyLong(), Mockito.anyString(), Mockito.anyLong());
  }
  /**
   * Test that MetaReader will ride over server throwing "Server not running" IOEs.
   *
   * @see https://issues.apache.org/jira/browse/HBASE-3446
   * @throws IOException
   * @throws InterruptedException
   */
  @Test
  public void testRideOverServerNotRunning() throws IOException, InterruptedException {
    // Need a zk watcher.
    ZooKeeperWatcher zkw =
        new ZooKeeperWatcher(
            UTIL.getConfiguration(), this.getClass().getSimpleName(), ABORTABLE, true);
    // This is a servername we use in a few places below.
    ServerName sn = new ServerName("example.com", 1234, System.currentTimeMillis());

    HConnection connection = null;
    CatalogTracker ct = null;
    try {
      // Mock an HRegionInterface. Our mock implementation will fail a few
      // times when we go to open a scanner.
      final HRegionInterface implementation = Mockito.mock(HRegionInterface.class);
      // When openScanner called throw IOE 'Server not running' a few times
      // before we return a scanner id.  Whats WEIRD is that these
      // exceptions do not show in the log because they are caught and only
      // printed if we FAIL.  We eventually succeed after retry so these don't
      // show.  We will know if they happened or not because we will ask
      // mockito at the end of this test to verify that openscanner was indeed
      // called the wanted number of times.
      final long scannerid = 123L;
      Mockito.when(implementation.openScanner((byte[]) Mockito.any(), (Scan) Mockito.any()))
          .thenThrow(new IOException("Server not running (1 of 3)"))
          .thenThrow(new IOException("Server not running (2 of 3)"))
          .thenThrow(new IOException("Server not running (3 of 3)"))
          .thenReturn(scannerid);
      // Make it so a verifiable answer comes back when next is called.  Return
      // the verifiable answer and then a null so we stop scanning.  Our
      // verifiable answer is something that looks like a row in META with
      // a server and startcode that is that of the above defined servername.
      List<KeyValue> kvs = new ArrayList<KeyValue>();
      final byte[] rowToVerify = Bytes.toBytes("rowToVerify");
      kvs.add(
          new KeyValue(
              rowToVerify,
              HConstants.CATALOG_FAMILY,
              HConstants.REGIONINFO_QUALIFIER,
              Writables.getBytes(HRegionInfo.FIRST_META_REGIONINFO)));
      kvs.add(
          new KeyValue(
              rowToVerify,
              HConstants.CATALOG_FAMILY,
              HConstants.SERVER_QUALIFIER,
              Bytes.toBytes(sn.getHostAndPort())));
      kvs.add(
          new KeyValue(
              rowToVerify,
              HConstants.CATALOG_FAMILY,
              HConstants.STARTCODE_QUALIFIER,
              Bytes.toBytes(sn.getStartcode())));
      final Result[] result = new Result[] {new Result(kvs)};
      Mockito.when(implementation.next(Mockito.anyLong(), Mockito.anyInt()))
          .thenReturn(result)
          .thenReturn(null);

      // Associate a spied-upon HConnection with UTIL.getConfiguration.  Need
      // to shove this in here first so it gets picked up all over; e.g. by
      // HTable.
      connection = HConnectionTestingUtility.getSpiedConnection(UTIL.getConfiguration());
      // Fix the location lookup so it 'works' though no network.  First
      // make an 'any location' object.
      final HRegionLocation anyLocation =
          new HRegionLocation(HRegionInfo.FIRST_META_REGIONINFO, sn.getHostname(), sn.getPort());
      // Return the any location object when locateRegion is called in HTable
      // constructor and when its called by ServerCallable (it uses getRegionLocation).
      // The ugly format below comes of 'Important gotcha on spying real objects!' from
      // http://mockito.googlecode.com/svn/branches/1.6/javadoc/org/mockito/Mockito.html
      Mockito.doReturn(anyLocation)
          .when(connection)
          .locateRegion((byte[]) Mockito.any(), (byte[]) Mockito.any());
      Mockito.doReturn(anyLocation)
          .when(connection)
          .getRegionLocation((byte[]) Mockito.any(), (byte[]) Mockito.any(), Mockito.anyBoolean());

      // Now shove our HRI implementation into the spied-upon connection.
      Mockito.doReturn(implementation)
          .when(connection)
          .getHRegionConnection(Mockito.anyString(), Mockito.anyInt());

      // Now start up the catalogtracker with our doctored Connection.
      ct = new CatalogTracker(zkw, null, connection, ABORTABLE, 0);
      ct.start();
      // Scan meta for user tables and verify we got back expected answer.
      NavigableMap<HRegionInfo, Result> hris = MetaReader.getServerUserRegions(ct, sn);
      assertTrue(hris.size() == 1);
      assertTrue(hris.firstEntry().getKey().equals(HRegionInfo.FIRST_META_REGIONINFO));
      assertTrue(Bytes.equals(rowToVerify, hris.firstEntry().getValue().getRow()));
      // Finally verify that openscanner was called four times -- three times
      // with exception and then on 4th attempt we succeed.
      Mockito.verify(implementation, Mockito.times(4))
          .openScanner((byte[]) Mockito.any(), (Scan) Mockito.any());
    } finally {
      if (ct != null) ct.stop();
      HConnectionManager.deleteConnection(UTIL.getConfiguration(), true);
      zkw.close();
    }
  }
  /**
   * Make sure the system will re-attach to running jobs.
   *
   * @throws GenieException on issue
   */
  @Test
  @SuppressWarnings("unchecked")
  public void canAttachToRunningJobs() throws GenieException {
    final ContextRefreshedEvent event = Mockito.mock(ContextRefreshedEvent.class);

    Mockito.when(this.jobSearchService.getAllActiveJobsOnHost(HOSTNAME))
        .thenReturn(Sets.newHashSet());
    this.coordinator.onStartup(event);
    Mockito.verify(this.scheduler, Mockito.never())
        .scheduleWithFixedDelay(Mockito.any(JobMonitor.class), Mockito.anyLong());

    // Simulate a job being started
    final String job1Id = UUID.randomUUID().toString();
    final String job2Id = UUID.randomUUID().toString();
    final String job3Id = UUID.randomUUID().toString();
    final String job4Id = UUID.randomUUID().toString();
    final String job5Id = UUID.randomUUID().toString();
    final JobExecution.Builder builder =
        new JobExecution.Builder(UUID.randomUUID().toString())
            .withProcessId(2818)
            .withCheckDelay(DELAY)
            .withMemory(1024)
            .withTimeout(this.tomorrow);
    builder.withId(job1Id);
    final JobExecution job1 = builder.build();
    builder.withId(job2Id);
    final JobExecution job2 = builder.build();
    builder.withId(job3Id);
    final JobExecution job3 = builder.build();

    final JobStartedEvent event1 = new JobStartedEvent(job1, this);
    final ScheduledFuture future = Mockito.mock(ScheduledFuture.class);
    Mockito.when(
            this.scheduler.scheduleWithFixedDelay(Mockito.any(JobMonitor.class), Mockito.eq(DELAY)))
        .thenReturn(future);
    coordinator.init(job1Id);
    coordinator.schedule(job1Id, null, null, null, null, 1024);
    this.coordinator.onJobStarted(event1);
    Mockito.verify(this.scheduler, Mockito.times(1))
        .scheduleWithFixedDelay(Mockito.any(JobMonitor.class), Mockito.eq(DELAY));

    final Job j1 = Mockito.mock(Job.class);
    Mockito.when(j1.getId()).thenReturn(Optional.of(job1Id));
    Mockito.when(j1.getStatus()).thenReturn(JobStatus.RUNNING);
    final Job j2 = Mockito.mock(Job.class);
    Mockito.when(j2.getId()).thenReturn(Optional.of(job2Id));
    Mockito.when(j2.getStatus()).thenReturn(JobStatus.RUNNING);
    final Job j3 = Mockito.mock(Job.class);
    Mockito.when(j3.getId()).thenReturn(Optional.of(job3Id));
    Mockito.when(j3.getStatus()).thenReturn(JobStatus.RUNNING);
    final Job j4 = Mockito.mock(Job.class);
    Mockito.when(j4.getId()).thenReturn(Optional.of(job4Id));
    Mockito.when(j4.getStatus()).thenReturn(JobStatus.RUNNING);
    final Job j5 = Mockito.mock(Job.class);
    Mockito.when(j5.getId()).thenReturn(Optional.of(job5Id));
    Mockito.when(j5.getStatus()).thenReturn(JobStatus.INIT);
    final Set<Job> jobs = Sets.newHashSet(j1, j2, j3, j4, j5);
    Mockito.when(this.jobSearchService.getAllActiveJobsOnHost(HOSTNAME)).thenReturn(jobs);
    Mockito.when(this.jobSearchService.getJobExecution(job1Id)).thenReturn(job1);
    Mockito.when(this.jobSearchService.getJobExecution(job2Id)).thenReturn(job2);
    Mockito.when(this.jobSearchService.getJobExecution(job3Id)).thenReturn(job3);
    Mockito.when(this.jobSearchService.getJobExecution(job4Id))
        .thenThrow(new GenieNotFoundException("blah"));
    this.coordinator.onStartup(event);

    Mockito.verify(this.eventMulticaster, Mockito.times(2))
        .multicastEvent(Mockito.any(JobFinishedEvent.class));
    Mockito.verify(this.scheduler, Mockito.times(3))
        .scheduleWithFixedDelay(Mockito.any(JobMonitor.class), Mockito.eq(DELAY));
    Assert.assertThat(this.coordinator.getNumActiveJobs(), Matchers.is(3));
    Assert.assertThat(this.coordinator.getUsedMemory(), Matchers.is(3 * 1024));
  }
  @Test
  public void testAuthenticate() throws Exception {
    SAML2LoginAPIAuthenticatorCmd cmd = Mockito.spy(new SAML2LoginAPIAuthenticatorCmd());

    Field apiServerField = SAML2LoginAPIAuthenticatorCmd.class.getDeclaredField("_apiServer");
    apiServerField.setAccessible(true);
    apiServerField.set(cmd, apiServer);

    Field managerField = SAML2LoginAPIAuthenticatorCmd.class.getDeclaredField("_samlAuthManager");
    managerField.setAccessible(true);
    managerField.set(cmd, samlAuthManager);

    Field accountServiceField = BaseCmd.class.getDeclaredField("_accountService");
    accountServiceField.setAccessible(true);
    accountServiceField.set(cmd, accountService);

    Field domainMgrField = SAML2LoginAPIAuthenticatorCmd.class.getDeclaredField("_domainMgr");
    domainMgrField.setAccessible(true);
    domainMgrField.set(cmd, domainMgr);

    Field userAccountDaoField =
        SAML2LoginAPIAuthenticatorCmd.class.getDeclaredField("_userAccountDao");
    userAccountDaoField.setAccessible(true);
    userAccountDaoField.set(cmd, userAccountDao);

    String spId = "someSPID";
    String url = "someUrl";
    KeyPair kp = SAMLUtils.generateRandomKeyPair();
    X509Certificate cert = SAMLUtils.generateRandomX509Certificate(kp);

    SAMLProviderMetadata providerMetadata = new SAMLProviderMetadata();
    providerMetadata.setEntityId("random");
    providerMetadata.setSigningCertificate(cert);
    providerMetadata.setEncryptionCertificate(cert);
    providerMetadata.setKeyPair(kp);
    providerMetadata.setSsoUrl("http://test.local");
    providerMetadata.setSloUrl("http://test.local");

    Mockito.when(session.getAttribute(Mockito.anyString())).thenReturn(null);

    Mockito.when(domain.getId()).thenReturn(1L);
    Mockito.when(domainMgr.getDomain(Mockito.anyString())).thenReturn(domain);
    UserAccountVO user = new UserAccountVO();
    user.setId(1000L);
    Mockito.when(userAccountDao.getUserAccount(Mockito.anyString(), Mockito.anyLong()))
        .thenReturn(user);
    Mockito.when(apiServer.verifyUser(Mockito.anyLong())).thenReturn(false);
    Mockito.when(samlAuthManager.getSPMetadata()).thenReturn(providerMetadata);
    Mockito.when(samlAuthManager.getIdPMetadata(Mockito.anyString())).thenReturn(providerMetadata);

    Map<String, Object[]> params = new HashMap<String, Object[]>();

    // SSO redirection test
    cmd.authenticate(
        "command",
        params,
        session,
        InetAddress.getByName("127.0.0.1"),
        HttpUtils.RESPONSE_TYPE_JSON,
        new StringBuilder(),
        req,
        resp);
    Mockito.verify(resp, Mockito.times(1)).sendRedirect(Mockito.anyString());

    // SSO SAMLResponse verification test, this should throw ServerApiException for auth failure
    params.put(SAMLPluginConstants.SAML_RESPONSE, new String[] {"Some String"});
    Mockito.stub(cmd.processSAMLResponse(Mockito.anyString())).toReturn(buildMockResponse());
    try {
      cmd.authenticate(
          "command",
          params,
          session,
          InetAddress.getByName("127.0.0.1"),
          HttpUtils.RESPONSE_TYPE_JSON,
          new StringBuilder(),
          req,
          resp);
    } catch (ServerApiException ignored) {
    }
    Mockito.verify(userAccountDao, Mockito.times(0))
        .getUserAccount(Mockito.anyString(), Mockito.anyLong());
    Mockito.verify(apiServer, Mockito.times(0)).verifyUser(Mockito.anyLong());
  }
예제 #28
0
  /** Retry addBlock() while another thread is in chooseTarget(). See HDFS-4452. */
  @Test
  public void testRetryAddBlockWhileInChooseTarget() throws Exception {
    final String src = "/testRetryAddBlockWhileInChooseTarget";

    FSNamesystem ns = cluster.getNamesystem();
    BlockManager spyBM = spy(ns.getBlockManager());
    final NamenodeProtocols nn = cluster.getNameNodeRpc();

    // substitute mocked BlockManager into FSNamesystem
    Class<? extends FSNamesystem> nsClass = ns.getClass();
    Field bmField = nsClass.getDeclaredField("blockManager");
    bmField.setAccessible(true);
    bmField.set(ns, spyBM);

    doAnswer(
            new Answer<DatanodeStorageInfo[]>() {
              @Override
              public DatanodeStorageInfo[] answer(InvocationOnMock invocation) throws Throwable {
                LOG.info("chooseTarget for " + src);
                DatanodeStorageInfo[] ret = (DatanodeStorageInfo[]) invocation.callRealMethod();
                count++;
                if (count == 1) { // run second addBlock()
                  LOG.info("Starting second addBlock for " + src);
                  nn.addBlock(src, "clientName", null, null, INodeId.GRANDFATHER_INODE_ID, null);
                  LocatedBlocks lbs = nn.getBlockLocations(src, 0, Long.MAX_VALUE);
                  assertEquals("Must be one block", 1, lbs.getLocatedBlocks().size());
                  lb2 = lbs.get(0);
                  assertEquals("Wrong replication", REPLICATION, lb2.getLocations().length);
                }
                return ret;
              }
            })
        .when(spyBM)
        .chooseTarget4NewBlock(
            Mockito.anyString(),
            Mockito.anyInt(),
            Mockito.<DatanodeDescriptor>any(),
            Mockito.<HashSet<Node>>any(),
            Mockito.anyLong(),
            Mockito.<List<String>>any(),
            Mockito.anyByte());

    // create file
    nn.create(
        src,
        FsPermission.getFileDefault(),
        "clientName",
        new EnumSetWritable<CreateFlag>(EnumSet.of(CreateFlag.CREATE)),
        true,
        (short) 3,
        1024,
        null);

    // start first addBlock()
    LOG.info("Starting first addBlock for " + src);
    nn.addBlock(src, "clientName", null, null, INodeId.GRANDFATHER_INODE_ID, null);

    // check locations
    LocatedBlocks lbs = nn.getBlockLocations(src, 0, Long.MAX_VALUE);
    assertEquals("Must be one block", 1, lbs.getLocatedBlocks().size());
    lb1 = lbs.get(0);
    assertEquals("Wrong replication", REPLICATION, lb1.getLocations().length);
    assertEquals("Blocks are not equal", lb1.getBlock(), lb2.getBlock());
  }