/** * 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); }
/** * Verify that a query returns the expected list of keys. Ordering is ignored. */ public static <K> void verifyQueryKeys(LuceneQuery<K, Object> query, K... expectedKeys) throws LuceneQueryException { Set<K> expectedKeySet = new HashSet<>(Arrays.asList(expectedKeys)); Set<K> actualKeySet = new HashSet<>(query.findKeys()); assertEquals(expectedKeySet, actualKeySet); }
@Test public void shouldCreateQueryWithCorrectAttributes() { Cache cache = mock(Cache.class); Region region = mock(Region.class); when(cache.getRegion(any())).thenReturn(region); LuceneQueryFactoryImpl f = new LuceneQueryFactoryImpl(cache); f.setPageSize(5); f.setLimit(25); LuceneQuery<Object, Object> query = f.create("index", "region", new StringQueryProvider("test", DEFAULT_FIELD)); assertEquals(25, query.getLimit()); assertEquals(5, query.getPageSize()); Mockito.verify(cache).getRegion(Mockito.eq("region")); }
private static LuceneQuery mockLuceneQuery(int limit, int pageSize) { LuceneQuery mockLuceneQuery = mock(LuceneQuery.class); when(mockLuceneQuery.getLimit()).thenReturn(limit); when(mockLuceneQuery.getPageSize()).thenReturn(pageSize); ObjectUtils.doOperationSafely(() -> when(mockLuceneQuery.findKeys()) .thenReturn(Collections.emptySet()), Collections.emptySet()); rethrowAsRuntimeException(() -> when(mockLuceneQuery.findPages()) .thenThrow(newUnsupportedOperationException("Operation Not Supported!"))); ObjectUtils.doOperationSafely(() -> when(mockLuceneQuery.findResults()) .thenReturn(Collections.emptyList()), Collections.emptyList()); ObjectUtils.doOperationSafely(() -> when(mockLuceneQuery.findValues()) .thenReturn(Collections.emptyList()), Collections.emptyList()); return mockLuceneQuery; }
queryInfo.getRegionPath(), queryInfo.getQueryString(), queryInfo.getDefaultField()); if (queryInfo.getKeysOnly()) { query.findKeys().forEach(key -> result.add(new LuceneSearchResults(key.toString()))); } else { PageableLuceneQueryResults pageableLuceneQueryResults = query.findPages(); while (pageableLuceneQueryResults.hasNext()) { List<LuceneResultStruct> page = pageableLuceneQueryResults.next();
public static void findNearbyTrainStops(LuceneService luceneService) throws InterruptedException, LuceneQueryException { LuceneQuery<Integer, TrainStop> query = luceneService.createLuceneQueryFactory().create("simpleIndex", "example-region", index -> SpatialHelper.findWithin(-122.8515139, 45.5099231, 0.25)); Collection<TrainStop> results = query.findValues(); System.out.println("Found stops: " + results); }
private static void query(ClientCache cache) throws LuceneQueryException { LuceneService lucene = LuceneServiceProvider.get(cache); LuceneQuery<Integer, EmployeeData> query = lucene.createLuceneQueryFactory() .create(SIMPLE_INDEX, EXAMPLE_REGION, "firstName:Chris~2", "firstname"); System.out.println("Employees with first names like Chris: " + query.findValues()); }
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; }
private static void queryNestedObject(ClientCache cache) throws LuceneQueryException { LuceneService lucene = LuceneServiceProvider.get(cache); LuceneQuery<Integer, EmployeeData> query = lucene.createLuceneQueryFactory().create( NESTEDOBJECT_INDEX, EXAMPLE_REGION, "5035330001 AND 5036430001", "contacts.phoneNumbers"); System.out.println("Employees with phone number 5035330001 and 5036430001 in their contacts: " + query.findValues()); }