How to use

getSearchFactory

method

in

org.hibernate.search.testsupport.junit.SearchFactoryHolder

  @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" ) );
}