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"); }