@Override public ExtendedSearchIntegrator getUninitializedSearchIntegrator() { return searchFactoryHolder.getSearchFactory(); }; }
private void assertThatFilterExists(String filterName) { FilterDef filterDefinition = sfHolder.getSearchFactory().getFilterDefinition( filterName ); assertThat( filterDefinition ).isNotNull(); assertThat( filterDefinition.getImpl() ).isEqualTo( RoleFilterFactory.class ); }
@Test public void shouldcontainsExactlyInAnyOrderTheDefinedFilters() throws Exception { Map<String, FilterDef> filterDefinitions = ( (SearchFactoryState) sfHolder.getSearchFactory() ).getFilterDefinitions(); assertThat( filterDefinitions.keySet() ).containsExactlyInAnyOrder( "package-filter", "class-filter" ); }
@Test public void shouldcontainsExactlyInAnyOrderTheDefinedFilters() throws Exception { Map<String, FilterDef> filterDefinitions = ( (SearchFactoryState) sfHolder.getSearchFactory() ).getFilterDefinitions(); assertThat( filterDefinitions.keySet() ).contains( "package-filter-1", "package-filter-2", "class-filter-1", "class-filter-2" ); }
private AssertHSQueryContext assertQuery(Query luceneQuery, int fromHour, int toHour) { ExtendedSearchIntegrator searchFactory = sfHolder.getSearchFactory(); HSQuery hsQuery = searchFactory.createHSQuery( luceneQuery, LogMessage.class ); hsQuery .enableFullTextFilter( "timeRange" ) .setParameter( "from", Integer.valueOf( fromHour ) ) .setParameter( "to", Integer.valueOf( toHour ) ) ; return helper.assertThat( hsQuery ); }
private List<EntityInfo> search(String field, String keyword) throws ParseException { ExtendedSearchIntegrator integrator = sfHolder.getSearchFactory(); QueryParser parser = new QueryParser( field, TestConstants.standardAnalyzer ); Query query = parser.parse( keyword ); List<EntityInfo> result = integrator.createHSQuery( query, Book.class ).queryEntityInfos(); return result; }
private void expectingForArgument(Class[] argument, Class... expectedInResult) { ExtendedSearchIntegrator searchIntegrator = factoryHolder.getSearchFactory(); IndexedTypeSet set = searchIntegrator.getIndexedTypesPolymorphic( IndexedTypeSets.fromClasses( argument ) ); IndexedTypeSet expectation = IndexedTypeSets.fromClasses( expectedInResult ); assertEquals( expectation, set ); }
@Test public void testNotAnalyzedFieldAndScopedAnalyzer() throws Exception { SearchIntegrator searchFactory = sfHolder.getSearchFactory(); Analyzer analyzer = searchFactory.getAnalyzer( MY_ENTITY_TYPE_ID ); // you can pass what so ever into the analysis since the used analyzers are // returning the same tokens all the time. We just want to make sure that // the right analyzers are used. Token[] tokens = AnalyzerUtils.tokensFromAnalysis( analyzer, "notAnalyzed", "pass through" ); assertTokensEqual( tokens, new String[] { "pass through" } ); }
private void storeObject(Object entity, Serializable id) { Work work = new Work( entity, id, WorkType.UPDATE, false ); TransactionContextForTest tc = new TransactionContextForTest(); slaveNode.getSearchFactory().getWorker().performWork( work, tc ); tc.end(); }
@Test public void forEntity_configured_notIndexed() { thrown.expectMessage( "HSEARCH000278" ); thrown.expectMessage( "indexed" ); thrown.expectMessage( ConfiguredNotIndexed.class.getSimpleName() ); sfHolder.getSearchFactory().buildQueryBuilder().forEntity( ConfiguredNotIndexed.class ).get(); }
@Test public void forEntity_notConfigured_indexed() { thrown.expectMessage( "HSEARCH000331" ); thrown.expectMessage( "configured" ); thrown.expectMessage( NotConfiguredIndexed.class.getSimpleName() ); sfHolder.getSearchFactory().buildQueryBuilder().forEntity( NotConfiguredIndexed.class ).get(); }
@Test public void forEntity_notConfigured_notIndexed() { thrown.expectMessage( "HSEARCH000331" ); thrown.expectMessage( "configured" ); thrown.expectMessage( NotConfiguredNotIndexed.class.getSimpleName() ); sfHolder.getSearchFactory().buildQueryBuilder().forEntity( NotConfiguredNotIndexed.class ).get(); }
private HSQuery getQuery(Query luceneQuery) { ExtendedSearchIntegrator sf = sfHolder.getSearchFactory(); HSQuery hsQuery = sf.createHSQuery( luceneQuery, IndexedObject.class ); return hsQuery .projection( "id" ) .sort( new Sort( new SortField( "idSort", SortField.Type.INT ) ) ); }
@Test public void testExceptionMessage() { thrown.expect( SearchException.class ); thrown.expectMessage( "HSEARCH000275" ); thrown.expectMessage( "hibernate-search-serialization-avro" ); ExtendedSearchIntegrator searchFactory = factoryHolder.getSearchFactory(); searchFactory.getServiceManager().requestService( LuceneWorkSerializer.class ); }
private Object getUnwrappedBridge(Class<?> clazz, String string, Class<?> expectedBridgeClass) { FieldBridge bridge = sfHolder.getSearchFactory().getIndexBindings().get( clazz ).getDocumentBuilder() .getTypeMetadata().getDocumentFieldMetadataFor( string ).getFieldBridge(); return unwrapBridge( bridge, expectedBridgeClass ); }
private LuceneQueryParsingResult<Class<?>> parseAndTransform(String queryString, Map<String, Object> namedParameters) { ExtendedSearchIntegrator searchFactory = factoryHolder.getSearchFactory(); HibernateSearchPropertyHelper propertyHelper = new HibernateSearchPropertyHelper(searchFactory, new ReflectionEntityNamesResolver(null)); IckleParsingResult<Class<?>> ickleParsingResult = IckleParser.parse(queryString, propertyHelper); LuceneQueryMaker<Class<?>> luceneQueryMaker = new LuceneQueryMaker<>(searchFactory, propertyHelper.getDefaultFieldBridgeProvider()); return luceneQueryMaker.transform(ickleParsingResult, namedParameters, ickleParsingResult.getTargetEntityMetadata()); } }
private void expectedProjections(NumericRangeQuery<Long> numericRangeQuery, String... expectedProjections) { SearchIntegrator searchFactory = factoryHolder.getSearchFactory(); QueryBuilder queryBuilder = helper.queryBuilder( Staff.class ); HSQuery hsQuery = searchFactory.createHSQuery( numericRangeQuery, Staff.class ) .projection( "name" ) .sort( queryBuilder.sort().byField( "idSort" ).createSort() ); helper.assertThat( hsQuery ) .matchesExactlySingleProjections( expectedProjections ) .hasResultSize( expectedProjections.length ); }
@Test(expected = ClassCastException.class) public void singleField_numericFieldBridge_missingValue_use_nonRaw() throws Exception { Sort sort = builder().sort() .byField( "fieldBridgedNumericField" ) .onMissingValue().use( new WrappedDoubleValue( 1.5d ) ) .createSort(); sfHolder.getSearchFactory().createHSQuery( new MatchAllDocsQuery(), IndexedEntry.class ) .sort( sort ) .queryEntityInfos(); }
@Test(expected = ClassCastException.class) public void singleField_numericFieldBridge_nonMetadataProviding_missingValue_use_nonRaw() throws Exception { Query query = builder().all().createQuery(); Sort sort = builder().sort() .byField( "nonMetadataProvidingFieldBridgedNumericField", SortField.Type.DOUBLE ) .onMissingValue().use( new WrappedDoubleValue( 1.5d ) ) .createSort(); sfHolder.getSearchFactory().createHSQuery( query, IndexedEntry.class ) .sort( sort ) .queryEntityInfos(); }
@Test public void mutationTest() { ExtendedSearchIntegrator searchFactory = sfHolder.getSearchFactory(); Assert.assertNull( searchFactory.getIndexManagerHolder().getIndexManager( "phoneNumbersIndex" ) ); searchFactory.addClasses( TelephoneRecord.class ); Assert.assertNotNull( searchFactory.getIndexManagerHolder().getIndexManager( "phoneNumbersIndex" ) ); Assert.assertNull( searchFactory.getIndexManagerHolder().getIndexManager( "addressBookIndex" ) ); searchFactory.addClasses( AddressBook.class ); Assert.assertNotNull( searchFactory.getIndexManagerHolder().getIndexManager( "addressBookIndex" ) ); }