Refine search
@Test public void deferredQueryWithSingleResult() { EntityManagerFactory emf = mock(EntityManagerFactory.class); EntityManager targetEm = mock(EntityManager.class); Query query = mock(Query.class); given(emf.createEntityManager()).willReturn(targetEm); given(targetEm.createQuery("x")).willReturn(query); given(targetEm.isOpen()).willReturn(true); EntityManager em = SharedEntityManagerCreator.createSharedEntityManager(emf); em.createQuery("x").getSingleResult(); verify(query).getSingleResult(); verify(targetEm).close(); }
@Test public void shouldReturnLongIfNoClassIdTypeColumn() throws SQLException { // given given(resultSet.getString("class_id_type")).willThrow(SQLException.class); // when Serializable newIdentifier = aclClassIdUtils.identifierFrom(DEFAULT_IDENTIFIER_AS_STRING, resultSet); // then assertThat(newIdentifier).isEqualTo(DEFAULT_IDENTIFIER); }
private DataSource createMockDataSource() { try { final DataSource dataSource = mock(DataSource.class); given(dataSource.getConnection()).willAnswer(new Answer<Connection>() { @Override public Connection answer(final InvocationOnMock invocation) throws Throwable { return jdbcRule.getConnectionSource().getConnection(); } }); return dataSource; } catch (final SQLException e) { Throwables.rethrow(e); throw new InternalError("unreachable"); } }
@Override @Before public void setUp() throws Exception { super.setUp(); session = MgnlContext.getJCRSession(RepositoryConstants.WEBSITE); Node node = session.getRootNode().addNode("testNode", NodeTypes.ContentNode.NAME); registryFacade = mock(RegistryFacade.class); Registry registry = mock(Registry.class); DefinitionProvider definitionProvider = mock(DefinitionProvider.class); DefinitionMetadata definitionMetadata = mock(DefinitionMetadata.class); given(definitionProvider.getMetadata()).willReturn(definitionMetadata); given(registry.getAllProviders()).willReturn(newArrayList(definitionProvider)); given(registryFacade.all()).willReturn(Arrays.asList(registry)); given(definitionProvider.getMetadata().getLocation()).willReturn(node.getPath()); rule = new IsDefinitionRule(registryFacade); }
@Test(expected = Test.None.class) public void deletedItemSelectionDoesNotThrowException() { // GIVEN given(activeContentPresenter.getSelectedItemIds()).willReturn(Lists.<Object>newArrayList("/b")); given(contentConnector.canHandleItem("/b")).willReturn(false); given(contentConnector.getItemUrlFragment("/b")).willThrow(Exception.class); // WHEN barPresenter.refresh(); }
@Override @Before public void setUp() throws Exception { super.setUp(); Session session = MgnlContext.getJCRSession(RepositoryConstants.WEBSITE); root = session.getRootNode(); properties = mock(MagnoliaConfigurationProperties.class); WorkspaceMapping workspaceMapping = mock(WorkspaceMapping.class); given(workspaceMapping.getLogicalWorkspaceNames()).willReturn(newArrayList("website")); Provider provider = mock(Provider.class); given(workspaceMapping.getRepositoryProvider(anyString())).willReturn(provider); RepositoryDefinition repositoryDefinition = mock(RepositoryDefinition.class); Map<String, String> definitionMap = newHashMap(); definitionMap.put("website", "website"); given(repositoryDefinition.getParameters()).willReturn(definitionMap); given(repositoryDefinition.getWorkspaces()).willReturn(newArrayList("website")); given(workspaceMapping.getRepositoryDefinitions()).willReturn(newArrayList(repositoryDefinition)); DefaultRepositoryManager repositoryManager = new DefaultRepositoryManager(properties, workspaceMapping); repoMan = Components.getComponent(RepositoryManager.class); ComponentsTestUtil.setInstance(RepositoryManager.class, repositoryManager); }
@Before public void setUp() throws Exception { registryFacade = mock(RegistryFacade.class); Registry registry = mock(Registry.class); outputStream = new ByteArrayOutputStream(); context = new MockContext(); cmd = new ExportJcrNodeToYamlCommand(registryFacade, new DefinitionRawViewToYamlConverterImpl()); MgnlContext.setInstance(context); MockSession webSiteSession = new MockSession("website"); context.addSession("website", webSiteSession); toCopyNode = webSiteSession.getRootNode().addNode("toCopy"); definitionProvider = mock(DefinitionProvider.class); DefinitionMetadata definitionMetadata = mock(DefinitionMetadata.class); given(definitionProvider.getMetadata()).willReturn(definitionMetadata); given(definitionProvider.getMetadata().getLocation()).willReturn(toCopyNode.getPath()); given(registry.getAllProviders()).willReturn(newArrayList(definitionProvider)); doReturn(Arrays.asList(registry)).when(registryFacade).all(); accessManager = mock(AccessManager.class); context.setAccessManager(accessManager); when(accessManager.isGranted(anyString(), eq(Permission.READ))).thenReturn(true); cmd.setOutputStream(outputStream); cmd.setPath(toCopyNode.getPath()); cmd.setRepository(RepositoryConstants.WEBSITE); }
super.setUp(); Context systemContext = spy(MgnlContext.getInstance()); MgnlContext.setInstance(systemContext); AccessManager ami = mock(AccessManager.class); doReturn(true).when(ami).isGranted(anyString(), anyLong()); doReturn(ami).when(systemContext).getAccessManager(anyString()); context = mock(Context.class); given(context.get(MarkNodeAsDeletedCommand.DELETED_NODE_PROP_NAME)).willReturn("rootFolder"); given(context.containsKey(RestorePreviousVersionCommand.ATTRIBUTE_PARENT_NODE_TYPE_ONLY)).willReturn(true); given(context.get(RestorePreviousVersionCommand.ATTRIBUTE_PARENT_NODE_TYPE_ONLY)).willReturn(true); ActivationManager activationManager = mock(ActivationManager.class); Subscriber subscriber = mock(Subscriber.class); Collection<Subscriber> subscribers = Lists.newArrayList(subscriber); ComponentsTestUtil.setInstance(ActivationManager.class, activationManager); given(activationManager.getSubscribers()).willReturn(subscribers); given(subscriber.isActive()).willReturn(true);
@SuppressWarnings({ "unchecked", "rawtypes" }) @Test public void testNonResponsiveConsumerEventNotIssuedWithActiveConsumer() throws Exception { ConsumerFactory<Integer, String> cf = mock(ConsumerFactory.class); Consumer<Integer, String> consumer = mock(Consumer.class); given(cf.createConsumer(isNull(), eq(""), isNull())).willReturn(consumer); ConsumerRecords records = new ConsumerRecords(Collections.emptyMap()); CountDownLatch latch = new CountDownLatch(20); given(consumer.poll(any(Duration.class))).willAnswer(i -> { Thread.sleep(100); latch.countDown(); containerProps.setPollTimeout(100); containerProps.setMonitorInterval(1); containerProps.setMessageListener(mock(MessageListener.class)); KafkaMessageListenerContainer<Integer, String> container = new KafkaMessageListenerContainer<>(cf, containerProps); assertThat(latch.await(10, TimeUnit.SECONDS)).isTrue(); container.stop(); assertThat(eventCounter.get()).isEqualTo(0);
@Test public void testProcessShouldDoNothingWhenResponseFISCompressionIsNotNeeded() { //GIVEN given(resp.getContentType()).willReturn("html"); given(req.getHeader(ACCEPT_HEADER_KEY)).willReturn(ACCEPT_VALUE_XML); //WHEN underTest.process(req, resp, RESPONSE_BODY.getBytes()); //THEN verify(fastInfosetCompressor, times(0)).compress(any(ByteArrayInputStream.class)); verify(resp, times(0)).setHeader(ACCEPT_HEADER_KEY, ACCEPT_VALUE_FASTINFOSET); }
@Test public void contentChangedEventCheckIfItemCanBeHandledByContentConnector() throws Exception { // GIVEN given(contentConnector.canHandleItem(node.getIdentifier())).willReturn(true); given(contentConnector.getItem(anyObject())).willReturn(null); given(presenter.getSelectedItemIds()).willReturn(Lists.<Object>newArrayList(node.getIdentifier())); // Save the deletion request. node.remove(); session.save(); // WHEN admincentralEventBus.fireEvent(new ContentChangedEvent(node.getIdentifier())); // THEN verify(workbenchPresenter).select(eq(Collections.emptyList())); } }
@Test public void argumentsConverterFails() throws Exception { PropertyResolveRequest propertyResolveRequest = mock(PropertyResolveRequest.class, RETURNS_DEEP_STUBS); given(propertyResolveRequest.getArguments()).willReturn(asList()); given(argumentsConverter.convert(eq(javaMethod), argThat(arrayWithSize(0)))).willReturn(Optional.<Object[]>absent()); Optional<Value> result = underTest.resolve(propertyResolveRequest); assertEquals(Optional.<Value>absent(), result); }
@Test public void shouldFilterOutRecordsBeforeOrAtCheckpoint() { given(checkpoint.isBeforeOrAt(record1)).willReturn(false); given(checkpoint.isBeforeOrAt(record2)).willReturn(true); given(checkpoint.isBeforeOrAt(record3)).willReturn(true); given(checkpoint.isBeforeOrAt(record4)).willReturn(false); given(checkpoint.isBeforeOrAt(record5)).willReturn(true); List<KinesisRecord> records = Lists.newArrayList(record1, record2, record3, record4, record5); RecordFilter underTest = new RecordFilter(); List<KinesisRecord> retainedRecords = underTest.apply(records, checkpoint); Assertions.assertThat(retainedRecords).containsOnly(record2, record3, record5); }
@SuppressWarnings({ "unchecked", "rawtypes" }) @Test public void testInitialSeek() throws Exception { ConsumerFactory<Integer, String> cf = mock(ConsumerFactory.class); Consumer<Integer, String> consumer = mock(Consumer.class); given(cf.createConsumer(eq("grp"), eq("clientId"), isNull())).willReturn(consumer); ConsumerRecords<Integer, String> emptyRecords = new ConsumerRecords<>(Collections.emptyMap()); final CountDownLatch latch = new CountDownLatch(1); given(consumer.poll(any(Duration.class))).willAnswer(i -> { latch.countDown(); Thread.sleep(50); new KafkaMessageListenerContainer<>(cf, containerProps); container.start(); assertThat(latch.await(10, TimeUnit.SECONDS)).isTrue(); ArgumentCaptor<Collection<TopicPartition>> captor = ArgumentCaptor.forClass(List.class); verify(consumer).seekToBeginning(captor.capture()); assertThat(captor.getValue()) .isEqualTo(new HashSet<>(Arrays.asList(new TopicPartition("foo", 0), new TopicPartition("foo", 4)))); verify(consumer).seekToEnd(captor.capture()); assertThat(captor.getValue()) .isEqualTo(new HashSet<>(Arrays.asList(new TopicPartition("foo", 1), new TopicPartition("foo", 5)))); verify(consumer).seek(new TopicPartition("foo", 2), 0L);
@Test public void shouldMapAllShardsToCheckpoints() throws Exception { given(shard1.getShardId()).willReturn("shard-01"); given(shard2.getShardId()).willReturn("shard-02"); given(shard3.getShardId()).willReturn("shard-03"); Set<Shard> shards = Sets.newHashSet(shard1, shard2, shard3); StartingPoint startingPoint = new StartingPoint(InitialPositionInStream.LATEST); given( startingPointShardsFinder.findShardsAtStartingPoint( kinesisClient, "stream", startingPoint)) .willReturn(shards); DynamicCheckpointGenerator underTest = new DynamicCheckpointGenerator("stream", startingPoint, startingPointShardsFinder); KinesisReaderCheckpoint checkpoint = underTest.generate(kinesisClient); assertThat(checkpoint).hasSize(3); }
@SuppressWarnings({ "unchecked", "rawtypes" }) @Test public void testCommitErrorHandlerCalled() throws Exception { ConsumerFactory<Integer, String> cf = mock(ConsumerFactory.class); Consumer<Integer, String> consumer = mock(Consumer.class); given(cf.createConsumer(eq("grp"), eq("clientId"), isNull())).willReturn(consumer); final Map<TopicPartition, List<ConsumerRecord<Integer, String>>> records = new HashMap<>(); records.put(new TopicPartition("foo", 0), Arrays.asList( ConsumerRecords<Integer, String> emptyRecords = new ConsumerRecords<>(Collections.emptyMap()); AtomicBoolean first = new AtomicBoolean(true); given(consumer.poll(any(Duration.class))).willAnswer(i -> { Thread.sleep(50); return first.getAndSet(false) ? consumerRecords : emptyRecords; }); willAnswer(i -> { throw new RuntimeException("Commit failed"); }).given(consumer).commitSync(any(Map.class)); }); container.start(); assertThat(ehl.await(10, TimeUnit.SECONDS)).isTrue(); container.stop(); containerProps.setMessageListener((BatchMessageListener) r -> { first.set(true); container.start(); assertThat(behl.await(10, TimeUnit.SECONDS)).isTrue(); container.stop();
@Test public void shouldDecorateCallableAndReturnWithSuccess() throws Throwable { // Given Bulkhead bulkhead = Bulkhead.of("test", config); BDDMockito.given(helloWorldService.returnHelloWorldWithException()).willReturn("Hello world"); // When Callable<String> callable = Bulkhead.decorateCallable(bulkhead, helloWorldService::returnHelloWorldWithException); // Then assertThat(callable.call()).isEqualTo("Hello world"); assertThat(bulkhead.getMetrics().getAvailableConcurrentCalls()).isEqualTo(1); BDDMockito.then(helloWorldService).should(times(1)).returnHelloWorldWithException(); }
@Test public void testDefaultLayoutType() throws IOException, URISyntaxException { NFSv41DeviceManager dm = mock(NFSv41DeviceManager.class); RpcCall call = mock(RpcCall.class); RpcTransport transport = mock(RpcTransport.class); ExportFile exportFile = new ExportFile(ClassLoader.getSystemResource("org/dcache/nfs/exports").toURI()); given(dm.getLayoutTypes()).willReturn(Sets.newHashSet(layouttype4.values())); given(transport.getRemoteSocketAddress()).willReturn(new InetSocketAddress("172.16.4.1", 0)); given(call.getCredential()).willReturn(new RpcAuthTypeNone()); given(call.getTransport()).willReturn(transport); CompoundContext context = new CompoundContextBuilder() .withDeviceManager(dm) .withCall(call) .withExportFile(exportFile) .build(); Optional<fattr4_fs_layout_types> res = (Optional<fattr4_fs_layout_types>) OperationGETATTR.fattr2xdr(nfs4_prot.FATTR4_FS_LAYOUT_TYPES, null, null, null, context); assertArrayEquals("export without explicit layout type must return nfsv41_files layout", new int[] {layouttype4.LAYOUT4_NFSV4_1_FILES.getValue()}, res.get().value); }
@Test @SuppressWarnings("unchecked") public void testUserDetailsPresenterInitialize() { given(mockUserDetailsView.context()).willReturn(mockContext); userDetailsPresenter.initialize(USER_ID); verify(mockUserDetailsView).hideRetry(); verify(mockUserDetailsView).showLoading(); verify(mockGetUserDetails).execute(any(DisposableObserver.class), any(Params.class)); } }
@Test public void handleSubscribe() { given(this.brokerChannel.send(Mockito.any(Message.class))).willReturn(true); this.handler.handleMessage(createWith(SimpMessageType.SUBSCRIBE, "joe", SESSION_ID, "/user/queue/foo")); ArgumentCaptor<Message> captor = ArgumentCaptor.forClass(Message.class); Mockito.verify(this.brokerChannel).send(captor.capture()); Message message = captor.getValue(); assertEquals("/queue/foo-user123", SimpMessageHeaderAccessor.getDestination(message.getHeaders())); }