private void _runSearch(
      final String query,
      final QueryType type,
      final User searcher,
      final int numberOfIssues,
      final String resolutionId)
      throws SearchException {
    final LuceneSearchProvider luceneSearchProvider = getSearchProvider();

    // Create a search request
    final JqlClauseBuilder jqlQuery =
        JqlQueryBuilder.newBuilder().where().defaultAnd().resolution(resolutionId);

    switch (type) {
      case COMMENT:
        jqlQuery.comment(query);
        break;
      case ISSUE:
        jqlQuery.summary(query);
        break;
    }
    final SearchResults issues =
        luceneSearchProvider.search(jqlQuery.buildQuery(), searcher, new PagerFilter(-1));
    assertNotNull(issues);
    assertEquals(query, numberOfIssues, issues.getTotal());
  }
  public void testNullQuery() throws SearchException {
    final LuceneSearchProvider luceneSearchProvider = getSearchProvider();

    // Create a search request
    final SearchResults issues = luceneSearchProvider.search(null, bob, new PagerFilter(-1));
    assertNotNull(issues);
    assertEquals(0, issues.getTotal());
  }
  public void testHitCounter() throws SearchException {
    final LuceneSearchProvider luceneSearchProvider = getSearchProvider();

    // Create a search request
    final QueryImpl query =
        new QueryImpl(
            new TerminalClauseImpl(
                "resolution", Operator.EQUALS, new SingleValueOperand(resolutionId)));

    final long issueCount = luceneSearchProvider.searchCount(query, bob);
    assertEquals(3, issueCount);
  }
  public void testStandardQuery() throws SearchException {
    final LuceneSearchProvider luceneSearchProvider = getSearchProvider();

    // Create a search request
    final QueryImpl query =
        new QueryImpl(
            new TerminalClauseImpl(
                "resolution", Operator.EQUALS, new SingleValueOperand(resolutionId)));

    final SearchResults issues = luceneSearchProvider.search(query, bob, new PagerFilter(-1));
    assertNotNull(issues);
    assertEquals(3, issues.getTotal());
  }
  public void testComplexQueryWithSummaryAndComments() throws SearchException {
    final LuceneSearchProvider luceneSearchProvider = getSearchProvider();

    // Create a search request
    JqlClauseBuilder jqlQuery =
        JqlQueryBuilder.newBuilder()
            .where()
            .resolution(resolutionId)
            .and()
            .sub()
            .comment(SUMMARY_BODY)
            .or()
            .summary(SUMMARY_BODY)
            .endsub();

    final SearchResults issues =
        luceneSearchProvider.search(jqlQuery.buildQuery(), bob, new PagerFilter(-1));
    assertNotNull(issues);
    assertEquals(2, issues.getTotal());
  }
  public void testStandardHitCollectorSearch() throws SearchException {
    final LuceneSearchProvider luceneSearchProvider = getSearchProvider();

    // Create a search request
    final QueryImpl query =
        new QueryImpl(
            new TerminalClauseImpl(
                "resolution", Operator.EQUALS, new SingleValueOperand(resolutionId)));

    final Set<String> results = new LinkedHashSet<String>();
    // create a PrefixFieldableHitCollector that searches for summaries starting with "Summ"
    luceneSearchProvider.search(
        query,
        bob,
        new PrefixFieldableHitCollector(
            ComponentManager.getComponentInstanceOfType(IssueIndexManager.class).getIssueSearcher(),
            "summary",
            "Summ",
            results));
    assertEquals(1, results.size());
    assertEquals(SUMMARY_BODY, results.iterator().next());
  }
  public void testSearchAndSortForPagerConstraints() throws SearchException, IOException {
    final LuceneSearchProvider luceneSearchProvider = getSearchProvider();

    // Create a search request
    Query jqlQuery =
        JqlQueryBuilder.newBuilder()
            .where()
            .resolution(resolutionId)
            .and()
            .summary(SUMMARY_BODY)
            .buildQuery();

    final MyDocumentHitCollector hitCollector = new MyDocumentHitCollector(null);

    // Test that we limit the results with a max on the filter
    luceneSearchProvider.searchAndSort(jqlQuery, bob, hitCollector, new PagerFilter(1));
    assertEquals(1, hitCollector.count);
    hitCollector.clearCount();

    // Test that we bring them all back with a max of 2
    luceneSearchProvider.searchAndSort(jqlQuery, bob, hitCollector, new PagerFilter(2));
    assertEquals(2, hitCollector.count);
    hitCollector.clearCount();

    // Test the start and end
    final PagerFilter filter = new PagerFilter(2);
    filter.setStart(1);
    luceneSearchProvider.searchAndSort(jqlQuery, bob, hitCollector, filter);
    assertEquals(1, hitCollector.count);
    hitCollector.clearCount();

    // Bring them all back
    luceneSearchProvider.searchAndSort(
        jqlQuery, bob, hitCollector, PagerFilter.getUnlimitedFilter());
    assertEquals(2, hitCollector.count);
  }