@Test(expected = FunctionException.class) public void testIndexRepoQueryFails() throws Exception { when(mockContext.getDataSet()).thenReturn(mockRegion); when(mockContext.getArguments()).thenReturn(searchArgs); when(mockContext.getResultSender()).thenReturn(mockResultSender); when(mockRepoManager.getRepositories(eq(mockContext), eq(false))).thenReturn(repos); doThrow(IOException.class).when(mockRepository1).query(eq(query), eq(LuceneQueryFactory.DEFAULT_LIMIT), any(IndexResultCollector.class)); LuceneQueryFunction function = new LuceneQueryFunction(); function.execute(mockContext); }
@Test public void shouldHandleBucketNotFoundException() throws BucketNotFoundException { Mockito.when(manager.getRepository(any(), any(), any())) .thenThrow(BucketNotFoundException.class); AsyncEvent event = Mockito.mock(AsyncEvent.class); boolean result = listener.processEvents(Arrays.asList(event)); assertFalse(result); verify(listener, times(1)) .logDebugMessage(startsWith("Bucket not found"), any(BucketNotFoundException.class)); }
@Override public void destroy(boolean initiator) { // Find and delete the appropriate extension Extension extensionToDelete = null; for (Extension extension : getDataRegion().getExtensionPoint().getExtensions()) { LuceneIndexCreation index = (LuceneIndexCreation) extension; if (index.getName().equals(indexName)) { extensionToDelete = extension; break; } } if (extensionToDelete != null) { getDataRegion().getExtensionPoint().removeExtension(extensionToDelete); } // Destroy the async event queue destroyAsyncEventQueue(initiator); // Close the repository manager repositoryManager.close(); RegionListener listenerToRemove = getRegionListener(); if (listenerToRemove != null) { cache.removeRegionListener(listenerToRemove); } // Remove cache service profile dataRegion .removeCacheServiceProfile(LuceneIndexCreationProfile.generateId(indexName, regionPath)); }
@Test(expected = InternalFunctionInvocationTargetException.class) public void whenCacheIsClosedDuringLuceneQueryExecutionInternalFunctionShouldBeThrownToTriggerFunctionServiceRetry() throws Exception { when(mockContext.getDataSet()).thenReturn(mockRegion); when(mockContext.getArguments()).thenReturn(searchArgs); LuceneQueryFunction function = new LuceneQueryFunction(); when(mockRepoManager.getRepositories(eq(mockContext), eq(false))) .thenThrow(new CacheClosedException()); function.execute(mockContext); }
@Test public void shouldHandleAlreadyClosedException() throws BucketNotFoundException { Mockito.when(manager.getRepository(any(), any(), any())) .thenThrow(AlreadyClosedException.class); AsyncEvent event = Mockito.mock(AsyncEvent.class); boolean result = listener.processEvents(Arrays.asList(event)); assertFalse(result); verify(listener, times(1)) .logDebugMessage(contains("the lucene index is already closed"), any(AlreadyClosedException.class)); }
@Test(expected = FunctionException.class) public void testReduceError() throws Exception { final CollectorManager mockManager = mock(CollectorManager.class); searchArgs = new LuceneFunctionContext<IndexResultCollector>(queryProvider, "indexName", mockManager); when(mockContext.getDataSet()).thenReturn(mockRegion); when(mockContext.getArguments()).thenReturn(searchArgs); when(mockContext.getResultSender()).thenReturn(mockResultSender); repos.remove(1); when(mockRepoManager.getRepositories(eq(mockContext))).thenReturn(repos); when(mockManager.newCollector(eq("repo1"))).thenReturn(mockCollector); doAnswer((m) -> { throw new IOException(); }).when(mockManager).reduce(any(Collection.class)); LuceneQueryFunction function = new LuceneQueryFunction(); function.execute(mockContext); }
@Test public void shouldHandleCacheClosedException() throws BucketNotFoundException { Mockito.when(manager.getRepository(any(), any(), any())) .thenThrow(CacheClosedException.class); AsyncEvent event = Mockito.mock(AsyncEvent.class); boolean result = listener.processEvents(Arrays.asList(event)); assertFalse(result); verify(listener, times(1)) .logDebugMessage(contains("cache has been closed"), any(CacheClosedException.class)); }
@Before public void createMocks() throws BucketNotFoundException { GemFireCacheImpl cache = Fakes.cache(); context = mock(RegionFunctionContext.class); ResultSender sender = mock(ResultSender.class); Region region = mock(Region.class); InternalLuceneService service = mock(InternalLuceneService.class); InternalLuceneIndex index = mock(InternalLuceneIndex.class); RepositoryManager repoManager = mock(RepositoryManager.class); IndexRepository repo = mock(IndexRepository.class); IndexWriter writer = mock(IndexWriter.class); RegionDirectory directory = mock(RegionDirectory.class); fileSystem = mock(FileSystem.class); Region bucket = mock(Region.class); when(bucket.getFullPath()).thenReturn(bucketName); when(context.getArguments()).thenReturn(new String[] {directoryName, indexName}); when(context.getResultSender()).thenReturn(sender); when(context.getDataSet()).thenReturn(region); when(region.getCache()).thenReturn(cache); when(cache.getService(any())).thenReturn(service); when(repoManager.getRepositories(eq(context))).thenReturn(Collections.singleton(repo)); when(index.getRepositoryManager()).thenReturn(repoManager); when(index.getName()).thenReturn(indexName); when(service.getIndex(eq(indexName), any())).thenReturn(index); when(directory.getFileSystem()).thenReturn(fileSystem); when(writer.getDirectory()).thenReturn(directory); when(repo.getWriter()).thenReturn(writer); when(repo.getRegion()).thenReturn(bucket); }
@Test public void shouldThrowAndCaptureIOException() throws BucketNotFoundException { doAnswer((m) -> { throw new IOException(); }).when(manager).getRepository(any(), any(), any()); AtomicReference<Throwable> lastException = new AtomicReference<>(); LuceneEventListener.setExceptionObserver(lastException::set); AsyncEvent event = Mockito.mock(AsyncEvent.class); try { listener.processEvents(Arrays.asList(event)); fail("should have thrown an exception"); } catch (InternalGemFireError expected) { assertEquals(expected, lastException.get()); } } }
final Collection<IndexRepository> repositories = repoManager.getRepositories(ctx); repositories.stream().forEach(repo -> { final IndexWriter writer = repo.getWriter();
Mockito.when(manager.getRepository(eq(region1), any(), eq(callback1))).thenReturn(repo1); Mockito.when(manager.getRepository(eq(region2), any(), eq(null))).thenReturn(repo2); List<AsyncEvent> events = new ArrayList<AsyncEvent>();
@Test public void injectCustomCollectorManager() throws Exception { final CollectorManager mockManager = mock(CollectorManager.class); searchArgs = new LuceneFunctionContext<IndexResultCollector>(queryProvider, "indexName", mockManager); when(mockContext.getDataSet()).thenReturn(mockRegion); when(mockContext.getArguments()).thenReturn(searchArgs); when(mockContext.getResultSender()).thenReturn(mockResultSender); repos.remove(0); when(mockRepoManager.getRepositories(eq(mockContext), eq(false))).thenReturn(repos); when(mockManager.newCollector(eq("repo2"))).thenReturn(mockCollector); when(mockManager.reduce(any(Collection.class))).thenAnswer(invocation -> { Collection<IndexResultCollector> collectors = invocation.getArgument(0); assertEquals(1, collectors.size()); assertEquals(mockCollector, collectors.iterator().next()); return new TopEntriesCollector(null); }); doAnswer(invocation -> { IndexResultCollector collector = invocation.getArgument(2); collector.collect(r2_1.getKey(), r2_1.getScore()); return null; }).when(mockRepository2).query(eq(query), eq(LuceneQueryFactory.DEFAULT_LIMIT), any(IndexResultCollector.class)); LuceneQueryFunction function = new LuceneQueryFunction(); function.execute(mockContext); verify(mockCollector).collect(eq("key-2-1"), eq(.45f)); verify(mockResultSender).lastResult(any(TopEntriesCollector.class)); }
Object callbackArgument = event.getCallbackArgument(); IndexRepository repository = repositoryManager.getRepository(region, key, callbackArgument);
repositories = repoManager.getRepositories(ctx, waitForRepository);
when(mockContext.getArguments()).thenReturn(searchArgs); when(mockContext.getResultSender()).thenReturn(mockResultSender); when(mockRepoManager.getRepositories(eq(mockContext), eq(false))).thenReturn(repos); doAnswer(invocation -> { IndexResultCollector collector = invocation.getArgument(2);
when(mockContext.getArguments()).thenReturn(searchArgs); when(mockContext.getResultSender()).thenReturn(mockResultSender); when(mockRepoManager.getRepositories(eq(mockContext), eq(false))).thenReturn(repos);