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

@Test
public void testGetResourcesWithUserInputBeginning() throws Exception {
    ResourceLookupContext resourceLookupContext = Mockito.mock(ResourceLookupContext.class);
    when(resourceLookupContext.getUserInput()).thenReturn("/pr");

    final List<String> expectedResources = new ArrayList<>();
    expectedResources.add("/provenance");
    expectedResources.add("/proxy");

    List<String> resources = niFiClient.getResources(resourceLookupContext);
    Assert.assertNotNull(resources);
    Assert.assertEquals(expectedResources.size(), resources.size());

    resources.removeAll(expectedResources);
    Assert.assertEquals(0, resources.size());
}
 

@Test
public void test12DeactivateUser() {
	XXPortalUser xxPUserExp = new XXPortalUser();
	xxPUserExp = null;
	XXPortalUserDao xxPortalUserDao = Mockito.mock(XXPortalUserDao.class);

	Mockito.when(daoManager.getXXPortalUser()).thenReturn(xxPortalUserDao);
	Mockito.when(xxPortalUserDao.getById(userId)).thenReturn(xxPUserExp);
	Mockito.when(restErrorUtil.createRESTException(Mockito.anyString(), (MessageEnums) Mockito.any(),
			Mockito.nullable(Long.class), Mockito.nullable(String.class), Mockito.anyString())).thenReturn(new WebApplicationException());
	thrown.expect(WebApplicationException.class);

	userREST.deactivateUser(userId);

	Mockito.verify(daoManager).getXXPortalUser();
	Mockito.verify(xxPortalUserDao).getById(userId);
	Mockito.verify(restErrorUtil).createRESTException(Mockito.anyString(), (MessageEnums) Mockito.any(),
			Mockito.anyLong(), Mockito.anyString(), Mockito.anyString());
}
 

@Test
public void testRequiresAuthorizationAccess() throws Exception {
  Configuration conf = new Configuration();
  ServletContext context = Mockito.mock(ServletContext.class);
  Mockito.when(context.getAttribute(HttpServer2.CONF_CONTEXT_ATTRIBUTE)).thenReturn(conf);
  HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
  HttpServletResponse response = Mockito.mock(HttpServletResponse.class);

  //requires admin access to instrumentation, FALSE by default
  Assert.assertTrue(HttpServer2.isInstrumentationAccessAllowed(context, request, response));

  //requires admin access to instrumentation, TRUE
  conf.setBoolean(CommonConfigurationKeys.HADOOP_SECURITY_INSTRUMENTATION_REQUIRES_ADMIN, true);
  conf.setBoolean(CommonConfigurationKeys.HADOOP_SECURITY_AUTHORIZATION, true);
  AccessControlList acls = Mockito.mock(AccessControlList.class);
  Mockito.when(acls.isUserAllowed(Mockito.<UserGroupInformation>any())).thenReturn(false);
  Mockito.when(context.getAttribute(HttpServer2.ADMINS_ACL)).thenReturn(acls);
  Assert.assertFalse(HttpServer2.isInstrumentationAccessAllowed(context, request, response));
}
 

@Test
public void testOnCharacteristicWriteNextChunk() throws IOException {
    when(gatt.getService(eq(serviceUUID))).thenReturn(gattService);
    when(gattService.getCharacteristic(characteristicUUID)).thenReturn(gattCharacteristic);
    when(gatt.writeCharacteristic(eq(gattCharacteristic))).thenReturn(true);
    InputSource inputSource = Mockito.mock(InputSource.class);
    when(inputSource.nextChunk()).thenReturn(new byte[]{12, 21});

    writeCommand = new WriteCommand(
            serviceUUID,
            characteristicUUID,
            BluetoothGattCharacteristic.WRITE_TYPE_DEFAULT,
            inputSource,
            commandObserver);

    writeCommand.execute(device, operationCommandObserver, gatt);

    writeCommand.onCharacteristicWrite(gatt, gattCharacteristic, BluetoothGatt.GATT_SUCCESS);
    verify(commandObserver, times(0)).finished(any(Command.class), any(CommandResult.class));
    verify(operationCommandObserver, times(0)).finished(any(Command.class), any(CommandResult.class));
}
 

@Test
public void testExistingMultipleBranchesWithNoDefault() throws IOException {
    // Situation: Hitting github and getting back multiple branches where master is not in the list
    githubApi.stubFor(
            get(urlEqualTo("/repos/cloudbeers/yolo/branches"))
                    .willReturn(
                            aResponse()
                                    .withHeader("Content-Type", "application/json; charset=utf-8")
                                    .withBodyFile("../branches/_files/body-yolo-branches-existent-multiple-branches-no-master.json")));
    SCMHeadObserver mockSCMHeadObserver = Mockito.mock(SCMHeadObserver.class);
    GitHubSCMSourceContext context = new GitHubSCMSourceContext(null, mockSCMHeadObserver);
    context.wantTags(true);
    GitHubSCMSourceRequest request = context.newRequest(new GitHubSCMSource("cloudbeers", "yolo", null, false), null);
    Iterator<GHBranch> branches = new GitHubSCMSource.LazyBranches(request, repo).iterator();
    // Expected: In the iterator will be a multiple branches named existent-branch2 and existent-branch1
    assertTrue(branches.hasNext());
    assertEquals("existent-branch1", branches.next().getName());
    assertTrue(branches.hasNext());
    assertEquals("existent-branch2", branches.next().getName());
}
 

@Test
public void testLifecycle() {
  Configuration conf = new Configuration();
  StageLibraryTask libraryTask = Mockito.mock(StageLibraryTask.class);
  CredentialStoresTaskImpl storeTask = new CredentialStoresTaskImpl(null, conf, libraryTask, eventListenerManager);
  Map<String, CredentialStore> stores = storeTask.getStores();
  Assert.assertNotNull(stores);
  Assert.assertTrue(stores.isEmpty());

  storeTask = Mockito.spy(storeTask);

  Mockito.doReturn(Collections.emptyList()).when(storeTask).loadAndInitStores();

  // init
  storeTask.initTask();
  Mockito.verify(storeTask, Mockito.times(1)).loadAndInitStores();
  Assert.assertEquals(stores, CredentialEL.getCredentialStores());

  // stop
  CredentialStore store = Mockito.mock(CredentialStore.class);
  stores.put("id", store);
  storeTask.stopTask();
  Mockito.verify(store, Mockito.times(1)).destroy();
}
 

@Before
public void setup() {
    sharedPreferences = Mockito.mock(SharedPreferences.class);
    Mockito.when(sharedPreferences.getBoolean("key", true)).thenReturn(true);
    editor = Mockito.mock(SharedPreferences.Editor.class);
    BoolTaste = new Taste.BoolTaste(sharedPreferences, "key", defaultValues);
}
 

@Bean
public FirestoreTemplate firestoreTemplate(
		FirestoreClassMapper classMapper, FirestoreMappingContext firestoreMappingContext) {
	FirestoreTemplate template = Mockito.mock(FirestoreTemplate.class);
	Mockito.when(template.getClassMapper()).thenReturn(classMapper);
	Mockito.when(template.getMappingContext()).thenReturn(firestoreMappingContext);
	Mockito.when(template.execute(any(), any())).thenReturn(Flux.empty());
	return template;
}
 

@Test
public void testDoGet() throws Exception {

	// Prepare the servlet
	File configurationDirectory = this.folder.newFolder();

	this.manager = new Manager();
	this.manager.configurationMngr().setWorkingDirectory( configurationDirectory );

	File appDir = ConfigurationUtils.findApplicationDirectory( "app", configurationDirectory );
	File descDir = new File( appDir, Constants.PROJECT_DIR_DESC );
	Assert.assertTrue( descDir.mkdirs());

	IconServlet servlet = new IconServlet( this.manager );

	// Add a fake file
	File trickFile = new File( descDir, "directory.jpg" );
	Assert.assertTrue( trickFile.mkdirs());

	// Prepare our mocks
	HttpServletRequest req = Mockito.mock( HttpServletRequest.class );
	HttpServletResponse resp = Mockito.mock( HttpServletResponse.class );

	Mockito.when( req.getPathInfo()).thenReturn( "/app/whatever.jpg" );
	servlet.doGet( req, resp );
	Mockito.verify( resp ).setStatus( HttpServletResponse.SC_NOT_FOUND );

	// Now, add a real icon and make sure it is returned
	// (it is returned if a MIME type was set).
	File singleJpgFile = new File( descDir, "whatever.jpg" );
	Assert.assertTrue( singleJpgFile.createNewFile());

	ServletOutputStream out = Mockito.mock( ServletOutputStream.class );
	Mockito.when( resp.getOutputStream()).thenReturn( out );
	servlet.doGet( req, resp );
	Mockito.verify( resp ).setContentType( IconUtils.MIME_JPG );
}
 

@Test
void cantGetJobCommandIfCommandDoesNotExist() {
    final String id = UUID.randomUUID().toString();
    final JobEntity entity = Mockito.mock(JobEntity.class);
    Mockito.when(entity.getCommand()).thenReturn(Optional.empty());
    Mockito.when(this.jobRepository.findByUniqueId(id, JobCommandProjection.class)).thenReturn(Optional.of(entity));
    Assertions
        .assertThatExceptionOfType(NotFoundException.class)
        .isThrownBy(() -> this.persistenceService.getJobCommand(id));
}
 

@Test
public void tryToExtractUsernameAndPasswordFromEmptyHeader() {
    final HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
    Mockito.when(request.getHeader("Authorization")).thenReturn("");

    final String[] credentials = HttpBasicHelper.extractUsernameAndPasswordFromBasicHeader(request);
    assertThat(credentials).isNotNull();
    assertThat(credentials[0]).isEqualTo("");
    assertThat(credentials[1]).isEqualTo("");
}
 

/**
 * This test is proves that the streamy way works.
 */
@Test(timeout = 1000)
public void testBufferStreamy() {
    // Create a mock supplier, that way we know how many times get was called
    Supplier<Integer> supplier = Mockito.mock(Supplier.class);
    Mockito.when(supplier.get()).thenReturn(0);

    final Stream<Integer> infiniteStream = Stream.generate(supplier);
    final Stream<List<Integer>> groupedStream = StreamUtils.buffer(infiniteStream.limit(1000000000), 10);
    assertEquals(groupedStream.findFirst().get(), Arrays.asList(0, 0, 0, 0, 0, 0, 0, 0, 0, 0));

    // get should only be called 11 times because we're buffering 10, and we retrieve the
    // 11th to do the check that we're over the limit
    Mockito.verify(supplier, Mockito.times(11)).get();
}
 

@Test
public void getSliGuidByTypeShouldHandleNull() throws Exception {
    setupCustomDataMocking();

    Entity entity = Mockito.mock(Entity.class);
    when(entity.getId()).thenReturn(SLI_ID4);
    List<Entity> queryResult = Arrays.asList(new Entity[] {});
    when(mockSlcInterface.read(eq(SLI_TYPE4), any(Query.class))).thenReturn(queryResult);

    String result = resolver.getSliGuidByType(SIF_REF_ID4, SLI_TYPE4, ZONE_ID1);

    Assert.assertNull(result);
}
 

@Test
public void testFormat() throws Exception {
    //given
    final JumpToCodeService mock = Mockito.mock(JumpToCodeService.class);
    Mockito.when(mock.getContentOptional(Mockito.any(LocationInfo.class))).thenAnswer(invocation -> {
        LocationInfo li = (LocationInfo) invocation.getArguments()[0];
        return li.getLineNumber().map(l->l + ": code");
    });
    final StackTraceFormatter formatter = new StackTraceFormatter(mock);

    //when
    String message = "java.util.concurrent.ExecutionException: java.io.IOException: Error executing request, connection broken.... :)\n" +
      "\tat java.util.concurrent.FutureTask.report(FutureTask.java:122)\n" +
      "\tat test.sampleapp.SampleAppMultiThreadedFix2.lambda$performRequests$16(SampleAppMultiThreadedFix2.java:36)\n" +
      "\tat test.sampleapp.SampleAppMultiThreadedFix2$$Lambda$16/2016207428.accept(Unknown Source)\n" +
      "Caused by: java.io.IOException: Error executing request, connection broken.... :)\n" +
      "\tat test.sampleapp.services.hotels.HotelsService.getHotels(HotelsService.java:30)\n" +
      "\tat test.sampleapp.SampleAppMultiThreadedFix2$$Lambda$9/1549863774.call(Unknown Source)\n" +
      "\tat test.sampleapp.executors.MdcCallableWrapper.call(MdcCallableWrapper.java:32)\n" +
      "\t... 4 more";
    final String format = formatter.format(message);

    //then
    String expected = "java.util.concurrent.ExecutionException: java.io.IOException: Error executing request, connection broken.... :)\n" +
      "  at java.util.concurrent.FutureTask.report(FutureTask.java:122)\t //code\n" +
      "  at test.sampleapp.SampleAppMultiThreadedFix2.lambda$performRequests$16(SampleAppMultiThreadedFix2.java:36)\t //code\n" +
      "  at test.sampleapp.SampleAppMultiThreadedFix2$$Lambda$16/2016207428.accept(Unknown Source)\n" +
      "Caused by: java.io.IOException: Error executing request, connection broken.... :)\n" +
      "  at test.sampleapp.services.hotels.HotelsService.getHotels(HotelsService.java:30)\t //code\n" +
      "  at test.sampleapp.SampleAppMultiThreadedFix2$$Lambda$9/1549863774.call(Unknown Source)\n" +
      "  at test.sampleapp.executors.MdcCallableWrapper.call(MdcCallableWrapper.java:32)\t //code\n" +
      "\t... 4 more";
    Assert.assertEquals(format, expected);

}
 

@Test
public void resourceChainWithOverrides() throws Exception {
	CachingResourceResolver cachingResolver = Mockito.mock(CachingResourceResolver.class);
	VersionResourceResolver versionResolver = Mockito.mock(VersionResourceResolver.class);
	WebJarsResourceResolver webjarsResolver = Mockito.mock(WebJarsResourceResolver.class);
	PathResourceResolver pathResourceResolver = new PathResourceResolver();
	CachingResourceTransformer cachingTransformer = Mockito.mock(CachingResourceTransformer.class);
	AppCacheManifestTransformer appCacheTransformer = Mockito.mock(AppCacheManifestTransformer.class);
	CssLinkResourceTransformer cssLinkTransformer = new CssLinkResourceTransformer();

	this.registration.setCachePeriod(3600)
			.resourceChain(false)
				.addResolver(cachingResolver)
				.addResolver(versionResolver)
				.addResolver(webjarsResolver)
				.addResolver(pathResourceResolver)
				.addTransformer(cachingTransformer)
				.addTransformer(appCacheTransformer)
				.addTransformer(cssLinkTransformer);

	ResourceHttpRequestHandler handler = getHandler("/resources/**");
	List<ResourceResolver> resolvers = handler.getResourceResolvers();
	assertThat(resolvers.toString(), resolvers, Matchers.hasSize(4));
	assertThat(resolvers.get(0), Matchers.sameInstance(cachingResolver));
	assertThat(resolvers.get(1), Matchers.sameInstance(versionResolver));
	assertThat(resolvers.get(2), Matchers.sameInstance(webjarsResolver));
	assertThat(resolvers.get(3), Matchers.sameInstance(pathResourceResolver));

	List<ResourceTransformer> transformers = handler.getResourceTransformers();
	assertThat(transformers, Matchers.hasSize(3));
	assertThat(transformers.get(0), Matchers.sameInstance(cachingTransformer));
	assertThat(transformers.get(1), Matchers.sameInstance(appCacheTransformer));
	assertThat(transformers.get(2), Matchers.sameInstance(cssLinkTransformer));
}
 

@Test
public void testBeat_distributedStorage_eachDatacenterAvailability_repairs_noMetrics()
    throws InterruptedException, ReaperException {

  AppContext context = new AppContext();
  context.config = new ReaperApplicationConfiguration();
  context.config.setDatacenterAvailability(ReaperApplicationConfiguration.DatacenterAvailability.EACH);

  context.repairManager = RepairManager.create(
      context,
      Executors.newScheduledThreadPool(1),
      REPAIR_TIMEOUT_S,
      TimeUnit.SECONDS,
      RETRY_DELAY_S,
      TimeUnit.SECONDS);

  context.repairManager.repairRunners.put(UUID.randomUUID(), Mockito.mock(RepairRunner.class));
  context.repairManager.repairRunners.put(UUID.randomUUID(), Mockito.mock(RepairRunner.class));

  context.storage = Mockito.mock(CassandraStorage.class);
  context.jmxConnectionFactory = Mockito.mock(JmxConnectionFactory.class);

  Mockito
      .when(((CassandraStorage)context.storage).getNodeMetrics(any()))
      .thenReturn(Collections.emptyList());

  try (Heart heart = Heart.create(context)) {
    context.isDistributed.set(true);
    heart.beat();
    Thread.sleep(500);
  }

  Mockito.verify((CassandraStorage)context.storage, Mockito.times(1)).saveHeartbeat();
  Mockito.verify((CassandraStorage)context.storage, Mockito.times(2)).getNodeMetrics(any());
  Mockito.verify(context.jmxConnectionFactory, Mockito.times(0)).connectAny(any(Collection.class));
  Mockito.verify((CassandraStorage)context.storage, Mockito.times(0)).storeNodeMetrics(any(), any());
}
 

@Test
public void fieldModelsTest() {
    String testJobId = "test-job-id";
    FieldModel testFieldModel = Mockito.mock(FieldModel.class);
    FieldModel newTestFieldModel = Mockito.mock(FieldModel.class);

    Set<FieldModel> fieldModels = Set.of(testFieldModel);
    Set<FieldModel> newFieldModels = Set.of(testFieldModel, newTestFieldModel);
    JobFieldModel testJobFieldModel = new JobFieldModel(testJobId, fieldModels);
    testJobFieldModel.setFieldModels(newFieldModels);

    assertEquals(newFieldModels, testJobFieldModel.getFieldModels());
    assertEquals(2, testJobFieldModel.getFieldModels().size());
}
 

@Test
public void shouldFailToBuildFromResourcesWithoutClientID() {
    Resources resources = Mockito.mock(Resources.class);
    when(context.getResources()).thenReturn(resources);
    when(resources.getIdentifier(eq("com_auth0_client_id"), eq("string"), anyString())).thenReturn(0);
    when(resources.getIdentifier(eq("com_auth0_domain"), eq("string"), anyString())).thenReturn(333);

    expectedException.expect(IllegalArgumentException.class);
    expectedException.expectMessage("The 'R.string.com_auth0_client_id' value it's not defined in your project's resources file.");

    new Auth0(context);
}
 

@Bean
public AgentManager agentManager() {
    return Mockito.mock(AgentManager.class);
}
 

@Test
public void test() {

	SecureJobTemplate template = Mockito.mock(SecureJobTemplate.class);
	Mockito.when(template.getUri()).thenReturn(URI.create("my://template"));
	Mockito.when(template.isSecure()).thenReturn(true);
	Mockito.when(template.overridableProperties()).thenReturn(Lists.newArrayList("my.overridable.property1", "my.overridable.property2"));

	// Test simple filtering
	Config config = ConfigFactory.parseMap(ImmutableMap.of(
			"someProperty", "foo",
			"my.overridable.property1", "bar"
	));
	Config result = SecureJobTemplate.filterUserConfig(template, config, log);
	Assert.assertEquals(result.entrySet().size(), 1);
	Assert.assertEquals(result.getString("my.overridable.property1"), "bar");
	Assert.assertFalse(result.hasPath("someProperty"));
	Assert.assertFalse(result.hasPath("my.overridable.property2"));

	// Test allowing override of a subconfig
	config = ConfigFactory.parseMap(ImmutableMap.of(
			"someProperty", "foo",
			"my.overridable.property1.key1", "bar",
			"my.overridable.property1.key2", "baz"
	));
	result = SecureJobTemplate.filterUserConfig(template, config, log);
	Assert.assertEquals(result.entrySet().size(), 2);
	Assert.assertEquals(result.getString("my.overridable.property1.key1"), "bar");
	Assert.assertEquals(result.getString("my.overridable.property1.key2"), "baz");

	// Test multiple overrides
	config = ConfigFactory.parseMap(ImmutableMap.of(
			"someProperty", "foo",
			"my.overridable.property1", "bar",
			"my.overridable.property2", "baz"
	));
	result = SecureJobTemplate.filterUserConfig(template, config, log);
	Assert.assertEquals(result.entrySet().size(), 2);
	Assert.assertEquals(result.getString("my.overridable.property1"), "bar");
	Assert.assertEquals(result.getString("my.overridable.property2"), "baz");
}