import org.codelibs.fess.suggest.concurrent.Deferred;
import org.opensearch.client.Client;

public abstract class RequestBuilder<Req extends Request<Res>, Res extends Response> {
    protected Client client;
    protected Req request;

    public RequestBuilder(final Client client, final Req request) {
        this.client = client;
        this.request = request;
    }

        requestBuilder.header("Content-Length", contentLength.toString())
        requestBuilder.removeHeader("Transfer-Encoding")
      } else {
        requestBuilder.header("Transfer-Encoding", "chunked")
        requestBuilder.removeHeader("Content-Length")
      }
    }

    if (userRequest.header("Host") == null) {
      requestBuilder.header("Host", userRequest.url.toHostHeader())
    }

    public void create() {
        RequestConfig.Builder requestBuilder = RequestConfig.custom();
        requestBuilder = requestBuilder.setConnectTimeout(10000);
        requestBuilder = requestBuilder.setConnectionRequestTimeout(10000).setSocketTimeout(5000);
        HttpClient httpClient = HttpClientBuilder.create()
            .setDefaultRequestConfig(requestBuilder.build()).build();

        Queue<String> queue = getUrls();

        requestBuilder.method("GET", null)
      } else {
        val requestBody = if (maintainBody) userResponse.request.body else null
        requestBuilder.method(method, requestBody)
      }
      if (!maintainBody) {
        requestBuilder.removeHeader("Transfer-Encoding")
        requestBuilder.removeHeader("Content-Length")
        requestBuilder.removeHeader("Content-Type")
      }
    }

 * governing permissions and limitations under the License.
 */
package org.codelibs.fess.suggest.request.popularwords;

import org.codelibs.fess.suggest.request.RequestBuilder;
import org.opensearch.client.Client;

public class PopularWordsRequestBuilder extends RequestBuilder<PopularWordsRequest, PopularWordsResponse> {
    public PopularWordsRequestBuilder(final Client client) {
        super(client, new PopularWordsRequest());
    }

import org.codelibs.fess.suggest.converter.ReadingConverter;
import org.codelibs.fess.suggest.normalizer.Normalizer;
import org.codelibs.fess.suggest.request.RequestBuilder;
import org.opensearch.client.Client;

public class SuggestRequestBuilder extends RequestBuilder<SuggestRequest, SuggestResponse> {
    public SuggestRequestBuilder(final Client client, final ReadingConverter readingConverter, final Normalizer normalizer) {

            searchEngineClient.scrollSearch(fessConfig.getIndexDocumentUpdateIndex(), requestBuilder -> {
                requestBuilder.setQuery(queryBuilder).setSize((int) numFound);
                if (fields != null) {
                    requestBuilder.setFetchSource(fields, null);
                }
                return true;
            }, entity -> {

        final GetRequestBuilder requestBuilder = client.prepareGet(index, id);
        if (condition.build(requestBuilder)) {
            response = requestBuilder.execute().actionGet(ComponentUtil.getFessConfig().getIndexSearchTimeout());
        }
        final long execTime = systemHelper.getCurrentTimeAsLong() - startTime;

        return searchResult.build(requestBuilder, execTime, OptionalEntity.ofNullable(response, () -> {}));

  }

  @Test
  fun invalidScheme() {
    val requestBuilder = Request.Builder()
    assertFailsWith<IllegalArgumentException> {
      requestBuilder.url("ftp://hostname/path")
    }.also { expected ->
      assertThat(expected.message).isEqualTo("Expected URL scheme 'http' or 'https' but was 'ftp'")
    }
  }

  @Test
  fun invalidPort() {
    val requestBuilder = Request.Builder()

    server.enqueue(MockResponse(body = "Page 2"))
    val requestBuilder =
      Request.Builder()
        .url(server.url("/page1"))
    if (method == "POST") {
      requestBuilder.post("ABCD".toRequestBody(null))
    } else {
      requestBuilder.method(method, null)
    }
    val response = getResponse(requestBuilder.build())
    val responseString = readAscii(response.body.byteStream(), Int.MAX_VALUE)