import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TestName;
import org.opensearch.index.query.QueryBuilders;

public class SuggestIndexerTest {
    static Suggester suggester;
    static OpenSearchRunner runner;

    @Rule
    public final TestName testName = new TestName();

    @BeforeClass

     * Deletes documents in an index matching a query.
     *
     * @param index        the index name
     * @param queryBuilder the query to match documents for deletion
     * @return the number of documents deleted
     */
    public long deleteByQuery(final String index, final QueryBuilder queryBuilder) {

        final FessConfig fessConfig = ComponentUtil.getFessConfig();

        // Test with boost = 0.5
        QueryBuilder queryBuilder1 = queryCommand.convertWildcardQuery(queryContext, wildcardQuery, 0.5f);
        assertNotNull(queryBuilder1);

        // Test with boost = 2.0
        QueryBuilder queryBuilder2 = queryCommand.convertWildcardQuery(queryContext, wildcardQuery, 2.0f);
        assertNotNull(queryBuilder2);

        // Test with boost = 0

     * @throws IllegalArgumentException if the query builder type is not supported
     */
    public DefaultQueryBuilder(final QueryBuilder queryBuilder) {
        this.queryBuilder = queryBuilder;
        if (queryBuilder instanceof BoolQueryBuilder) {
            queryType = QueryType.BOOL;
        } else if (queryBuilder instanceof DisMaxQueryBuilder) {
            queryType = QueryType.DISMAX;
        } else {

        QueryContext context = new QueryContext("test", false);
        QueryBuilder result = booleanQueryCommand.convertBooleanQuery(context, booleanQuery, 1.0f);

        assertNull(result);
    }

    // Test convertBooleanQuery with null queryBuilder from processor
    @Test
    public void test_convertBooleanQuery_withNullQueryBuilder() {

        QueryContext context = new QueryContext("*:*", false);
        MatchAllDocsQuery query = new MatchAllDocsQuery();
        float boost = 1.0f;

        QueryBuilder result1 = matchAllQueryCommand.execute(context, query, boost);
        QueryBuilder result2 = matchAllQueryCommand.execute(context, query, boost);

        assertNotNull(result1);
        assertNotNull(result2);

    }

    /**
     * Sets the query builder for filtering documents.
     *
     * @param queryBuilder the query builder to filter documents
     * @return this UpdateLabelJob instance for method chaining
     */
    public UpdateLabelJob query(final QueryBuilder queryBuilder) {
        this.queryBuilder = queryBuilder;
        return this;
    }

import org.codelibs.fess.entity.QueryContext;
import org.codelibs.fess.exception.InvalidQueryException;
import org.junit.jupiter.api.Test;
import org.opensearch.index.query.FuzzyQueryBuilder;
import org.opensearch.index.query.QueryBuilder;

public class FuzzyQueryCommandTest extends QueryTestBase {

    private FuzzyQueryCommand fuzzyQueryCommand;

    @Override
    protected void setUpChild() throws Exception {

    @Override
    public SearchRequestBuilder build(SearchRequestBuilder builder) {
        if (_conditionQuery != null) {
            QueryBuilder queryBuilder = _conditionQuery.getQuery();
            if (queryBuilder != null) {
                builder.setQuery(queryBuilder);
            }
            _conditionQuery.getFieldSortBuilderList().forEach(sort -> {
                builder.addSort(sort);
            });
        }

import org.codelibs.fess.entity.QueryContext;
import org.codelibs.fess.exception.InvalidQueryException;
import org.junit.jupiter.api.Test;
import org.opensearch.index.query.MatchPhraseQueryBuilder;
import org.opensearch.index.query.QueryBuilder;

public class PhraseQueryCommandTest extends QueryTestBase {
    private PhraseQueryCommand queryCommand;

    @Override
    protected void setUpChild() throws Exception {