private void addValueToResults() { TopEntries entries = new TopEntries(); entries.addHit(new EntryScore("hi", 5)); when(collector.getResult()).thenReturn(entries); when(results.getMaxScore()).thenReturn(5f); when(results.size()).thenReturn(1); List<LuceneResultStruct<Object, Object>> page = Collections.singletonList(new LuceneResultStructImpl<>("hi", "value", 5f)); when(results.next()).thenReturn(page); when(results.hasNext()).thenReturn(true); }
@Test public void shouldInvokeLuceneFunctionWithCorrectArguments() throws Exception { addValueToResults(); PageableLuceneQueryResults<Object, Object> results = query.findPages(); verify(execution).execute(eq(LuceneQueryFunction.ID)); ArgumentCaptor<LuceneFunctionContext> captor = ArgumentCaptor.forClass(LuceneFunctionContext.class); verify(execution).setArguments(captor.capture()); LuceneFunctionContext context = captor.getValue(); assertEquals(LIMIT, context.getLimit()); assertEquals(provider, context.getQueryProvider()); assertEquals("index", context.getIndexName()); assertEquals(5, results.getMaxScore(), 0.01); assertEquals(1, results.size()); final List<LuceneResultStruct<Object, Object>> page = results.next(); assertEquals(1, page.size()); LuceneResultStruct element = page.iterator().next(); assertEquals("hi", element.getKey()); assertEquals("value", element.getValue()); assertEquals(5, element.getScore(), 0.01); }
/** * @inheritDoc */ @Override public boolean hasNext() { return getQueryResults().hasNext(); }
/** * @inheritDoc */ @Override public long getTotalElements() { return getQueryResults().size(); }
/** * @inheritDoc */ @Override public boolean hasNext() { return getQueryResults().hasNext(); }
/** * @inheritDoc */ @Override public long getTotalElements() { return getQueryResults().size(); }
/** * Verify that a query returns the expected map of key-value. Ordering is ignored. */ public static <K> void verifyQueryKeyAndValues(LuceneQuery<K, Object> query, HashMap expectedResults) throws LuceneQueryException { HashMap actualResults = new HashMap<>(); final PageableLuceneQueryResults<K, Object> results = query.findPages(); while (results.hasNext()) { results.next().stream().forEach(struct -> { Object value = struct.getValue(); actualResults.put(struct.getKey(), value); }); } assertEquals(expectedResults, actualResults); }
private InternalLuceneService getMockLuceneService(String resultKey, String resultValue, String resultScore) throws LuceneQueryException { InternalLuceneService service = mock(InternalLuceneService.class); LuceneQueryFactory mockQueryFactory = spy(LuceneQueryFactory.class); LuceneQuery mockQuery = mock(LuceneQuery.class); PageableLuceneQueryResults pageableLuceneQueryResults = mock(PageableLuceneQueryResults.class); LuceneResultStruct<String, String> resultStruct = new LuceneResultStructImpl(resultKey, resultValue, Float.valueOf(resultScore)); List<LuceneResultStruct<String, String>> queryResults = new ArrayList<>(); queryResults.add(resultStruct); doReturn(mock(LuceneIndex.class)).when(service).getIndex(anyString(), anyString()); doReturn(mockQueryFactory).when(service).createLuceneQueryFactory(); doReturn(mockQueryFactory).when(mockQueryFactory).setLimit(anyInt()); doReturn(mockQuery).when(mockQueryFactory).create(any(), any(), any(), any()); when(mockQuery.findPages()).thenReturn(pageableLuceneQueryResults); when(pageableLuceneQueryResults.hasNext()).thenReturn(true).thenReturn(false); when(pageableLuceneQueryResults.next()).thenReturn(queryResults); return service; }
/** * Constructs a new instance of {@link LucenePage} initialized with * the given {@link PageableLuceneQueryResults Lucene query results}, {@link Integer page size}, * {@link Class projection type} and {@link LucenePage previous page}, if one exists. * * @param template {@link ProjectingLuceneAccessor} used to perform Lucene queries and data access operations * along with projections. * @param queryResults {@link PageableLuceneQueryResults} wrapped by this {@link LucenePage}. * @param pageSize number of elements on a {@link LucenePage}. * @param projectionType {@link Class} type of the projection used to view an individual {@link LuceneResultStruct} * in the {@link PageableLuceneQueryResults Lucene query results}. * @param previous {@link LucenePage previous page} in the chain of {@link LucenePage pages}, * if this {@link LucenePage} is not the first {@link LucenePage}. Can be {@literal null}. * @throws IllegalArgumentException if {@link ProjectingLuceneAccessor} or the {@link PageableLuceneQueryResults} * are {@literal null}, or the {@link PageableLuceneQueryResults} do not have * a {@link PageableLuceneQueryResults#hasNext() next page}. * @see #materialize(ProjectingLuceneAccessor, List, Class) */ public LucenePage(ProjectingLuceneAccessor template, PageableLuceneQueryResults<K, V> queryResults, int pageSize, Class<T> projectionType, LucenePage<T, K, V> previous) { Assert.notNull(template, "ProjectingLuceneAccessor must not be null"); Assert.notNull(queryResults, "PageableLuceneQueryResults must not be null"); Assert.isTrue(queryResults.hasNext(), "PageableLuceneQueryResults must have content"); this.template = template; this.queryResults = queryResults; this.pageSize = pageSize; this.projectionType = projectionType; this.previous = previous; this.content = materialize(template, queryResults.next(), projectionType); }
/** * Constructs a new instance of {@link LucenePage} initialized with * the given {@link PageableLuceneQueryResults Lucene query results}, {@link Integer page size}, * {@link Class projection type} and {@link LucenePage previous page}, if one exists. * * @param template {@link ProjectingLuceneAccessor} used to perform Lucene queries and data access operations * along with projections. * @param queryResults {@link PageableLuceneQueryResults} wrapped by this {@link LucenePage}. * @param pageSize number of elements on a {@link LucenePage}. * @param projectionType {@link Class} type of the projection used to view an individual {@link LuceneResultStruct} * in the {@link PageableLuceneQueryResults Lucene query results}. * @param previous {@link LucenePage previous page} in the chain of {@link LucenePage pages}, * if this {@link LucenePage} is not the first {@link LucenePage}. Can be {@literal null}. * @throws IllegalArgumentException if {@link ProjectingLuceneAccessor} or the {@link PageableLuceneQueryResults} * are {@literal null}, or the {@link PageableLuceneQueryResults} do not have * a {@link PageableLuceneQueryResults#hasNext() next page}. * @see #materialize(ProjectingLuceneAccessor, List, Class) */ public LucenePage(ProjectingLuceneAccessor template, PageableLuceneQueryResults<K, V> queryResults, int pageSize, Class<T> projectionType, LucenePage<T, K, V> previous) { Assert.notNull(template, "ProjectingLuceneAccessor must not be null"); Assert.notNull(queryResults, "PageableLuceneQueryResults must not be null"); Assert.isTrue(queryResults.hasNext(), "PageableLuceneQueryResults must have content"); this.template = template; this.queryResults = queryResults; this.pageSize = pageSize; this.projectionType = projectionType; this.previous = previous; this.content = materialize(template, queryResults.next(), projectionType); }