How to use

SearchFactoryHolder

in

org.hibernate.search.testsupport.junit

  @Override
  public ExtendedSearchIntegrator getUninitializedSearchIntegrator() {
    return searchFactoryHolder.getSearchFactory();
  };
}

@Override
protected void before() throws Throwable {
  searchIntegrator = new SearchIntegrator[numberOfSessionFactories];
  for ( int i = 0; i < numberOfSessionFactories; i++ ) {
    searchIntegrator[i] = createSearchFactory();
  }
}

private void flushIndex() {
  sfHolder.extractIndexManager( testType ).flushAndReleaseResources();
}

private CommitPolicy getCommitPolicy(SearchFactoryHolder sfHolder) {
  AbstractWorkspaceImpl workspace = sfHolder.extractWorkspace( testType );
  return workspace.getCommitPolicy();
}

private void indexAsStream(Serializable id, Object entity) throws InterruptedException {
  LuceneWork work = createUpdateWork( id, entity );
  sfHolder.getBatchBackend().enqueueAsyncWork( work );
}

@Test
public void testInfoStream() throws IOException {
  //Enable trace level on the magic category:
  Logger.getLogger( LuceneLogCategories.INFOSTREAM_LOGGER_CATEGORY.getName() ).setLevel( Level.TRACE );
  AbstractWorkspaceImpl dvdsWorkspace = sfHolder.extractWorkspace( dvdTestType );
  AbstractWorkspaceImpl booksWorkspace = sfHolder.extractWorkspace( bookTestType );
  IndexWriter dvdsIndexWriter = dvdsWorkspace.getIndexWriter();
  IndexWriter booksIndexWriter = booksWorkspace.getIndexWriter();
  try {
    Assert.assertFalse( dvdsIndexWriter.getConfig().getInfoStream().isEnabled( "IW" ) );
    Assert.assertTrue( booksIndexWriter.getConfig().getInfoStream().isEnabled( "IW" ) );
  }
  finally {
    booksIndexWriter.close();
    dvdsIndexWriter.close();
  }
}

private void flush(Class<?> clazz) {
  sfHolder.getBatchBackend().flush( IndexedTypeSets.fromClass( clazz ) );
}

  @Override
  public ExtendedSearchIntegrator getUninitializedSearchIntegrator() {
    return searchFactoryHolder.getSearchFactory();
  };
}

@Test
public void testScheduledCommits() throws Exception {
  writeData( NUMBER_ENTITIES );
  AbstractWorkspaceImpl workspace = sfAsyncExclusiveIndex.extractWorkspace( testType );
  CommitPolicy commitPolicy = workspace.getCommitPolicy();
  assertTrue( commitPolicy instanceof ScheduledCommitPolicy );
  ScheduledCommitPolicy scheduledCommitPolicy = (ScheduledCommitPolicy) commitPolicy;
  ScheduledThreadPoolExecutor scheduledExecutor = (ScheduledThreadPoolExecutor) scheduledCommitPolicy.getScheduledExecutorService();
  POLLER.pollAssertion( () -> assertTaskExecuted( scheduledExecutor, 1 ) );
}

public AbstractWorkspaceImpl extractWorkspace(IndexedTypeIdentifier indexedType) {
  DirectoryBasedIndexManager indexManager = (DirectoryBasedIndexManager) extractIndexManager( indexedType );
  WorkspaceHolder backend = indexManager.getWorkspaceHolder();
  return backend.getIndexResources().getWorkspace();
}

  @Override
  public ExtendedSearchIntegrator getUninitializedSearchIntegrator() {
    return searchFactoryHolder.getSearchFactory();
  };
}

public BatchBackend getBatchBackend() {
  if ( batchBackend == null ) {
    batchBackend = new DefaultBatchBackend( getSearchFactory(), null );
  }
  return batchBackend;
}

private TestExceptionHandler getErrorHandler() {
  ExtendedSearchIntegrator searchFactory = sfHolder.getSearchFactory();
  ErrorHandler errorHandler = searchFactory.getErrorHandler();
  assertThat( errorHandler ).isInstanceOf( TestExceptionHandler.class );
  return (TestExceptionHandler) errorHandler;
}

private void assertThatFilterExists(String filterName) {
  FilterDef filterDefinition = sfHolder.getSearchFactory().getFilterDefinition( filterName );
  assertThat( filterDefinition ).isNotNull();
  assertThat( filterDefinition.getImpl() ).isEqualTo( RoleFilterFactory.class );
}

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 ServiceReference<LuceneWorkSerializer> extractSerializer() {
  return searchFactoryHolder.getSearchFactory()
      .getServiceManager()
      .requestReference( LuceneWorkSerializer.class );
}

@Test
public void testPropertiesIndexing() throws InterruptedException {
  SearchIntegrator integrator = sfHolder.getSearchFactory();
  ThreadPoolExecutor threadPool = Executors.newFixedThreadPool( THREAD_NUMBER, "ReadWriteParallelismTest" );
  for ( int i = 0; i < THREAD_NUMBER; i++ ) {
    threadPool.execute( new Task( integrator, i ) );
  }
  threadPool.shutdown();
  //Time to warmup only:
  threadPool.awaitTermination( WARM_UP_SECONDS, TimeUnit.SECONDS );
  System.out.println( "Warmup complete. Start measuring now.." );
  //Start measuring:
  cyclesCompleted.set( 0 );
  long startMeasurementTime = System.nanoTime();
  threadPool.awaitTermination( FULL_RUN_SECONDS, TimeUnit.SECONDS );
  int doneCycles = cyclesCompleted.get();
  long endMeasurementTime = System.nanoTime();
  Assert.assertFalse( "Some failure happened in Task execution", failures.get() );
  long totalTime = endMeasurementTime - startMeasurementTime;
  long millisecondsElapsedTime = TimeUnit.MILLISECONDS.convert( totalTime, TimeUnit.NANOSECONDS );
  System.out.println( "Completed " + doneCycles + " in " + millisecondsElapsedTime + " milliseconds" );
  running.set( false );
}

@Test
public void testNumRangeQuery() {
  ExtendedSearchIntegrator integrator = this.factoryHolder.getSearchFactory();
  List<SingularTermDeletionQuery> numQueries = this.buildNumQueries();
  List<Integer> expectedCount = this.expectedCount();
  assertEquals( expectedCount.size(), numQueries.size() );
  for ( int i = 0; i < numQueries.size(); ++i ) {
    try {
      this.testForQuery( Book.class, integrator, numQueries.get( i ), expectedCount.get( i ) );
    }
    catch (Throwable e) {
      System.out.println( "ERROR: " + numQueries.get( i ) + ". expected was: " + expectedCount.get( i ) );
      throw e;
    }
  }
}