protected void mockUserDatabase(String userId, UaaUser user) {
userDatabase = Mockito.mock(UaaUserDatabase.class);
Mockito.when(userDatabase.retrieveUserById(Matchers.eq(userId))).thenReturn(user);
Mockito.when(userDatabase.retrieveUserById(AdditionalMatchers.not(Matchers.eq(userId))))
.thenThrow(new UsernameNotFoundException("mock"));
tokenServices.setUserDatabase(userDatabase);
}
@SuppressWarnings("unchecked")
@Test
public void checkStorageProcessorAndHandlerNfsVersionAttributeVersionNotSet() {
_resource.checkStorageProcessorAndHandlerNfsVersionAttribute(storageCmd);
verify(_resource)
.examineStorageSubSystemCommandNfsVersion(Matchers.eq(storageCmd), any(EnumMap.class));
verify(_resource)
.examineStorageSubSystemCommandFullCloneFlagForVmware(
Matchers.eq(storageCmd), any(EnumMap.class));
verify(_resource).reconfigureProcessorByHandler(any(EnumMap.class));
assertEquals(NFS_VERSION, _resource.storageNfsVersion);
}
@Test
public void execCreateHeaderTest() {
String id = "1";
boolean tty = true;
Map<String, Object> headers = getDefaultParameters();
headers.put(DockerConstants.DOCKER_EXEC_ID, id);
headers.put(DockerConstants.DOCKER_TTY, tty);
template.sendBodyAndHeaders("direct:in", "", headers);
Mockito.verify(dockerClient, Mockito.times(1)).execStartCmd(Matchers.eq(id));
Mockito.verify(mockObject, Mockito.times(1)).withTty(Matchers.eq(tty));
}
@Test
public void testSetupTableUpdate() {
// verify that eventHandler is added
verify(eventBus)
.addHandler(
Matchers.eq(FilterAppliedEvent.getType()), Matchers.any(FilterAppliedHandler.class));
}
@Test
public void testGetUsersWithAuthority() throws SQLException {
String expectedQuery =
"select \"public\".\"users\".\"username\", \"public\".\"users\".\"locked\", \"public\".\"authorities\".\"authority\", count(\"public\".\"users\".\"username\") over () as \"count\" from \"public\".\"users\" join \"public\".\"authorities\" on \"public\".\"users\".\"username\" = \"public\".\"authorities\".\"username\" where \"public\".\"authorities\".\"authority\" = 'ROLE_ADMIN' order by \"public\".\"users\".\"username\" asc limit 5 offset 0";
Pageable pageable = Mockito.mock(Pageable.class);
ResultSet resultSet = Mockito.mock(ResultSet.class);
Mockito.when(pageable.getPageNumber()).thenReturn(0);
Mockito.when(pageable.getPageSize()).thenReturn(5);
Mockito.when(resultSet.getInt(PagingConstants.COUNT)).thenReturn(1);
Mockito.when(resultSet.getString("username")).thenReturn("admin");
RESTPage<UserDTO> page = userDao.getUsersWithAuthority("ROLE_ADMIN", pageable);
ArgumentCaptor<PagingRowCallbackHandler> pagingRowCallbackHandlerCaptor =
ArgumentCaptor.forClass(PagingRowCallbackHandler.class);
Mockito.verify(jdbcTemplate)
.query(Matchers.eq(expectedQuery), pagingRowCallbackHandlerCaptor.capture());
PagingRowCallbackHandler pagingRowCallbackHandler = pagingRowCallbackHandlerCaptor.getValue();
pagingRowCallbackHandler.processRow(resultSet);
Mockito.verify(resultSet).getInt(PagingConstants.COUNT);
Mockito.verify(resultSet).getString("username");
Assert.assertEquals(1, page.getContentSize());
Assert.assertEquals("admin", page.getContent().get(0).getUsername());
}
@SuppressWarnings("unchecked")
@Test
public void checkStorageProcessorAndHandlerNfsVersionAttributeVersionSet() {
_resource.storageNfsVersion = NFS_VERSION;
_resource.checkStorageProcessorAndHandlerNfsVersionAttribute(storageCmd);
verify(_resource, never())
.examineStorageSubSystemCommandNfsVersion(Matchers.eq(storageCmd), any(EnumMap.class));
}
@Test
public void socketInvalidatedWhenError() throws Exception {
GenericKeyedObjectPool<InetSocketAddress, Socket> pool = mock(GenericKeyedObjectPool.class);
Socket socket = mock(Socket.class);
when(pool.borrowObject(Matchers.any(InetSocketAddress.class))).thenReturn(socket);
UnflushableByteArrayOutputStream out = new UnflushableByteArrayOutputStream();
when(socket.getOutputStream()).thenReturn(out);
GraphiteWriter writer = GraphiteWriter.builder().setHost("localhost").setPort(2003).build();
writer.setPool(pool);
writer.doWrite(dummyServer(), dummyQuery(), dummyResults());
Mockito.verify(pool)
.invalidateObject(Matchers.any(InetSocketAddress.class), Matchers.eq(socket));
Mockito.verify(pool, Mockito.never())
.returnObject(Matchers.any(InetSocketAddress.class), Matchers.eq(socket));
}
private Service getService(Instant delay) {
Mockito.when(dateTimeProvider.now()).thenReturn(now);
Mockito.when(
dateTimeProvider.betweenDateAndNow(
Matchers.any(Instant.class), Matchers.eq(ChronoUnit.SECONDS)))
.thenReturn(ChronoUnit.SECONDS.between(delay, now));
return new Service("service", dateTimeProvider);
}
protected void whenGetAttributeDefinitions(
ExtendedObjectClassDefinition extendedObjectClassDefinition,
ExtendedAttributeDefinition[] extendedAttributeDefinitions,
int filter) {
when(extendedObjectClassDefinition.getAttributeDefinitions(Matchers.eq(filter)))
.thenReturn(extendedAttributeDefinitions);
}
@Test
public void testFlexOffer() {
try {
FlexOffer flexOffer = buildFlexOffer();
controller.action(flexOffer, null);
Mockito.verify(corePlanboardValidatorService, Mockito.times(1))
.validateTimezone(Matchers.eq(flexOffer.getTimeZone()));
Mockito.verify(corePlanboardValidatorService, Mockito.times(1))
.validateCurrency(Matchers.eq(flexOffer.getCurrency()));
Mockito.verify(corePlanboardValidatorService, Mockito.times(1))
.validatePTUDuration(Matchers.eq(flexOffer.getPTUDuration()));
Mockito.verify(corePlanboardBusinessService, Mockito.times(1))
.storeFlexOffer(
Matchers.eq(flexOffer.getMessageMetadata().getSenderDomain()), Matchers.eq(flexOffer),
Matchers.eq(DocumentStatus.ACCEPTED),
Matchers.eq(flexOffer.getMessageMetadata().getSenderDomain()));
Mockito.verify(jmsService, Mockito.times(1))
.sendMessageToOutQueue(Matchers.contains("Accepted"));
} catch (BusinessException e) {
fail(e.getMessage());
}
}
@Test
public void testAuthenticateLogin_JA() throws Exception {
Mockito.when(session.getAttribute(Matchers.eq("loggedInUserId"))).thenReturn(null);
Mockito.when(req.getHeader(Matchers.eq("Authorization"))).thenReturn(null);
Mockito.when(req.getLocale()).thenReturn(new Locale("ja"));
// given
filter.init(config);
// when
filter.doFilter(req, resp, chain);
// then
Mockito.verify(resp).setStatus(Matchers.eq(401));
Mockito.verify(resp)
.setHeader(
Matchers.eq("WWW-Authenticate"),
Matchers.startsWith("Basic realm=\"Please log in as an organization administrator\""));
}
private void mockShard(OperationRouting operationRouting, Integer shardId) {
ShardIterator shardIterator = mock(ShardIterator.class);
when(operationRouting.indexShards(
any(ClusterState.class),
anyString(),
anyString(),
Matchers.eq(shardId.toString()),
anyString()))
.thenReturn(shardIterator);
when(shardIterator.shardId()).thenReturn(new ShardId("foo", shardId));
}
@Before
public void init() {
controller = new FlexOfferController();
Whitebox.setInternalState(controller, messageService);
Whitebox.setInternalState(controller, jmsService);
Whitebox.setInternalState(controller, corePlanboardBusinessService);
Whitebox.setInternalState(controller, corePlanboardValidatorService);
Whitebox.setInternalState(controller, config);
PowerMockito.when(config.getProperty(Matchers.eq(ConfigParam.HOST_DOMAIN)))
.thenReturn("usef-example.com");
}
@Test
public void testConsumeShouldBeGoodWhenGuestIsValid() throws Exception {
// GIVEN
Guest guest = Mockito.mock(Guest.class);
// WHEN
Mockito.when(guest.getHappiness()).thenReturn(BigDecimal.valueOf(ONE_HUNDRED));
testSubject.consume(guest);
Mockito.when(guest.getHappiness()).thenReturn(BigDecimal.valueOf(ONE_HUNDRED_AND_TWO));
// THEN
Mockito.verify(guest).getHappiness();
Mockito.verify(guest)
.setHappiness(Matchers.eq(BigDecimal.valueOf(ONE_HUNDRED).add(BigDecimal.valueOf(TWO))));
Mockito.verify(guest).getHappiness();
}
protected void setUpPropsUtil() throws Exception {
Props props = mock(Props.class);
when(props.get(PropsKeys.DYNAMIC_DATA_MAPPING_IMAGE_EXTENSIONS))
.thenReturn(".gif,.jpeg,.jpg,.png");
when(props.get(PropsKeys.DYNAMIC_DATA_MAPPING_IMAGE_SMALL_MAX_SIZE)).thenReturn("51200");
String ddmStructurePrivateFieldDataTypeKey =
PropsKeys.DYNAMIC_DATA_MAPPING_STRUCTURE_PRIVATE_FIELD_DATATYPE;
when(props.get(Matchers.eq(ddmStructurePrivateFieldDataTypeKey), Matchers.any(Filter.class)))
.thenReturn("string");
String ddmStructurePrivateFieldRepeatableKey =
PropsKeys.DYNAMIC_DATA_MAPPING_STRUCTURE_PRIVATE_FIELD_REPEATABLE;
when(props.get(Matchers.eq(ddmStructurePrivateFieldRepeatableKey), Matchers.any(Filter.class)))
.thenReturn("false");
when(props.get(PropsKeys.INDEX_DATE_FORMAT_PATTERN)).thenReturn("yyyyMMddHHmmss");
PropsUtil.setProps(props);
}
protected void fieldStatsShouldReturn(FieldStatsResult fieldStatsResult) {
try {
when(searches.fieldStats(
anyString(),
Matchers.eq("*"),
anyString(),
any(RelativeRange.class),
anyBoolean(),
anyBoolean(),
anyBoolean()))
.thenReturn(fieldStatsResult);
} catch (InvalidRangeFormatException | Searches.FieldTypeException e) {
assertNotNull("This should not return an exception!", e);
}
}
@Test
public void testGetUsersWithAuthority_page2() {
String expectedQuery =
"select \"public\".\"users\".\"username\", \"public\".\"users\".\"locked\", \"public\".\"authorities\".\"authority\", count(\"public\".\"users\".\"username\") over () as \"count\" from \"public\".\"users\" join \"public\".\"authorities\" on \"public\".\"users\".\"username\" = \"public\".\"authorities\".\"username\" where \"public\".\"authorities\".\"authority\" = 'ROLE_ADMIN' order by \"public\".\"users\".\"username\" asc limit 5 offset 5";
Pageable pageable = Mockito.mock(Pageable.class);
Mockito.when(pageable.getPageNumber()).thenReturn(1);
Mockito.when(pageable.getPageSize()).thenReturn(5);
userDao.getUsersWithAuthority("ROLE_ADMIN", pageable);
Mockito.verify(jdbcTemplate)
.query(Matchers.eq(expectedQuery), Matchers.any(PagingRowCallbackHandler.class));
}
@Test
public void testFetchData() {
// result from server is a list with at least one film -> give this film list to tableView
when(filmDataModel.getAppliedFilter()).thenReturn(demoFilterWithResult);
tablePresenter.fetchData();
// 1st called from constructor (no results info), 2nd called when rpc starts loading (loading
// info),3rd the result from the rpc
verify(tableView, times(3)).setTable(Matchers.anyListOf(Film.class));
// result from server is empty list -> tableView receives pseudo film list with information
when(filmDataModel.getAppliedFilter()).thenReturn(demoFilterWithoutResult);
tablePresenter.fetchData();
// 1st called from constructor (no results info), 2nd the result of the empty rpc
verify(tableView, times(2))
.setTable(Matchers.eq(tablePresenter.createPseudoFilmList("No Search Results Found")));
}
@Test
public void testRequestTopic() throws ServerException {
SlaveServer mockSlave = mock(SlaveServer.class);
AdvertiseAddress address = AdvertiseAddress.newPrivate();
address.setStaticPort(1234);
TcpRosProtocolDescription protocol = new TcpRosProtocolDescription(address);
when(mockSlave.requestTopic(
Matchers.<String>any(),
Matchers.eq(Sets.newHashSet(ProtocolNames.TCPROS, ProtocolNames.UDPROS))))
.thenReturn(protocol);
SlaveXmlRpcEndpointImpl slave = new SlaveXmlRpcEndpointImpl(mockSlave);
Object[][] protocols = new Object[][] {{ProtocolNames.TCPROS}, {ProtocolNames.UDPROS}};
List<Object> response = slave.requestTopic("/foo", "/bar", protocols);
assertEquals(response.get(0), StatusCode.SUCCESS.toInt());
assertEquals(response.get(2), protocol.toList());
}
@Test
public void shouldNotTryToSatisfyDependenciesForOverriddenFieldsOfOneToOneRelationship()
throws Exception {
long leadId = 42L;
TestModels.ContactData contactData =
mTestSubject
.iNeed(TestModels.ContactData.class)
.with("lead_id", leadId)
.in(mContentResolver);
assertThat(contactData).isNotNull();
assertThat(contactData.leadId).isEqualTo(leadId);
verify(mContentResolver, never())
.insert(Matchers.eq(TestModels.LEAD.getUri()), any(ContentValues.class));
}
@Test(expected = AuthorizationException.class)
public void testDeleteExistsNotDelegatable() {
RoleDO notDelegatable = new RoleDO();
Long roleId = Long.valueOf(2);
notDelegatable.setRoleId(roleId);
notDelegatable.setName("notDelgatable");
Mockito.when(roleDAO.getById(Matchers.eq(roleId))).thenReturn(notDelegatable);
Mockito.when(userRoleDAO.getUserRoleByUserIdAndRoleId(any(Long.class), any(Long.class)))
.thenReturn(new UserRoleDO());
Mockito.when(roleDAO.findDelegatableRoles(any(Long.class), any(Long.class)))
.thenReturn(Lists.<RoleDO>newArrayList());
try {
userRoleService.delete(new ServiceContext(), Long.valueOf(1), roleId);
} finally {
Mockito.verify(userRoleDAO, Mockito.never()).delete(any(UserRoleDO.class));
}
}
/**
* JUnit test to test the extract entity method.
*
* @throws IOException if an I/O error occurred
*/
@SuppressWarnings("unchecked")
@Test
public void testExtractEntities() throws IOException {
String testTenant = "Midgar";
String testEntity = "student";
Iterator<Entity> cursor = Mockito.mock(Iterator.class);
List<Entity> students = TestUtils.createStudents();
Mockito.when(cursor.hasNext()).thenReturn(true, true, true, false);
Mockito.when(cursor.next()).thenReturn(students.get(0), students.get(1));
Mockito.when(
mongoEntityRepository.findEach(
Matchers.eq(testEntity), Matchers.any(NeutralQuery.class)))
.thenReturn(cursor);
extractor.extractEntities(archiveFile, testEntity, null);
Mockito.verify(mongoEntityRepository, Mockito.times(1)).findEach("student", new NeutralQuery());
Mockito.verify(writer, Mockito.times(2))
.write(Mockito.any(Entity.class), Mockito.any(ExtractFile.class));
}
@SuppressWarnings("unchecked")
@Override
protected void setup(TestContainer container) throws Exception {
AESEncrypter.generateKey();
container.addBean(configService = Mockito.mock(APPConfigurationServiceBean.class));
container.addBean(Mockito.mock(ServiceInstanceDAO.class));
container.addBean(Mockito.mock(APPConcurrencyServiceBean.class));
container.addBean(Mockito.mock(ProductProvisioningServiceFactoryBean.class));
container.addBean(Mockito.mock(APPCommunicationServiceBean.class));
serviceMock = Mockito.mock(Service.class);
besDAO = Mockito.mock(BesDAO.class);
subcriptionService = Mockito.mock(SubscriptionService.class);
identityService = Mockito.mock(EnhancedIdentityService.class);
Mockito.doReturn(Arrays.asList(new VOUserDetails()))
.when(besDAO)
.getBESTechnologyManagers(Matchers.any(ServiceInstance.class));
Mockito.doReturn(identityService)
.when(besDAO)
.getBESWebService(Matchers.eq(IdentityService.class), Matchers.any(ServiceInstance.class));
Mockito.doNothing()
.when(besDAO)
.setUserCredentialsInContext(
Matchers.any(BindingProvider.class), Matchers.anyString(),
Matchers.anyString(), Matchers.anyMap());
Mockito.doReturn(subcriptionService)
.when(besDAO)
.getBESWebService(
Matchers.eq(SubscriptionService.class), Matchers.any(ServiceInstance.class));
Mockito.doNothing()
.when(subcriptionService)
.completeAsyncSubscription(
Matchers.anyString(), Matchers.anyString(), Matchers.any(VOInstanceInfo.class));
Mockito.doNothing()
.when(subcriptionService)
.abortAsyncSubscription(
Matchers.anyString(), Matchers.anyString(), Matchers.anyListOf(VOLocalizedText.class));
Mockito.doReturn(subcriptionService)
.when(serviceMock)
.getPort(Matchers.any(QName.class), Matchers.eq(SubscriptionService.class));
Mockito.doReturn(serviceMock)
.when(besDAO)
.createWebService(Matchers.any(URL.class), Matchers.any(QName.class));
Mockito.doReturn(identityService)
.when(serviceMock)
.getPort(Matchers.any(QName.class), Matchers.eq(IdentityService.class));
container.addBean(besDAO);
container.addBean(Mockito.mock(OperationDAO.class));
container.addBean(Mockito.mock(ServiceInstanceDAO.class));
container.addBean(Mockito.mock(OperationServiceBean.class));
container.addBean(authService = Mockito.spy(new APPAuthenticationServiceBean()));
container.addBean(Mockito.mock(OperationServiceBean.class));
container.addBean(new APPlatformServiceBean());
controller = Mockito.mock(APPlatformController.class);
InitialContext context = new InitialContext();
context.bind("bss/app/controller/ess.vmware", controller);
container.addBean(controller);
besDAO = container.get(BesDAO.class);
platformService = container.get(APPlatformService.class);
em = container.getPersistenceUnit("oscm-app");
defaultAuth = new PasswordAuthentication("user", "password");
}