Migrate apache-httpclient-4.3 tests to Java. (#5774)

* Migrate apache-httpclient-4.3 tests to Java.

* Spot

instrumentation/apache-httpasyncclient-4.1/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/apachehttpasyncclient/ApacheHttpAsyncClientTest.java

@@ -14,7 +14,6 @@ import io.opentelemetry.semconv.trace.attributes.SemanticAttributes;
 import java.io.IOException;
 import java.io.UncheckedIOException;
 import java.net.URI;
-import java.time.Duration;
 import java.util.HashSet;
 import java.util.Map;
 import java.util.Set;
@@ -39,13 +38,14 @@ class ApacheHttpAsyncClientTest {
   @RegisterExtension
   static final InstrumentationExtension testing = HttpClientInstrumentationExtension.forAgent();
 
-  // TODO(anuraaga): AbstractHttpClientTest should provide timeout values statically
   private final RequestConfig requestConfig =
-      RequestConfig.custom().setConnectTimeout((int) Duration.ofSeconds(5).toMillis()).build();
+      RequestConfig.custom()
+          .setConnectTimeout((int) AbstractHttpClientTest.CONNECTION_TIMEOUT.toMillis())
+          .build();
 
   private final RequestConfig requestWithReadTimeoutConfig =
       RequestConfig.copy(requestConfig)
-          .setSocketTimeout((int) Duration.ofSeconds(2).toMillis())
+          .setSocketTimeout((int) AbstractHttpClientTest.READ_TIMEOUT.toMillis())
           .build();
 
   private final CloseableHttpAsyncClient client =

instrumentation/apache-httpclient/apache-httpclient-4.3/library/src/test/groovy/io/opentelemetry/instrumentation/apachehttpclient/v4_3/ApacheClientHostAbsoluteUriRequestContextTest.groovy

@@ -1,25 +0,0 @@
-/*
- * Copyright The OpenTelemetry Authors
- * SPDX-License-Identifier: Apache-2.0
- */
-
-package io.opentelemetry.instrumentation.apachehttpclient.v4_3
-
-import io.opentelemetry.instrumentation.test.LibraryTestTrait
-import org.apache.http.client.config.RequestConfig
-import org.apache.http.impl.client.CloseableHttpClient
-
-class ApacheClientHostAbsoluteUriRequestContextTest extends AbstractApacheClientHostAbsoluteUriRequestContextTest implements LibraryTestTrait {
-  @Override
-  protected CloseableHttpClient createClient(boolean readTimeout) {
-    def builder = ApacheHttpClientTelemetry.create(openTelemetry).newHttpClientBuilder()
-    def requestConfigBuilder = RequestConfig.custom()
-      .setMaxRedirects(maxRedirects())
-      .setConnectTimeout(CONNECT_TIMEOUT_MS)
-    if (readTimeout) {
-      requestConfigBuilder.setSocketTimeout(READ_TIMEOUT_MS)
-    }
-    builder.defaultRequestConfig = requestConfigBuilder.build()
-    return builder.build()
-  }
-}

instrumentation/apache-httpclient/apache-httpclient-4.3/library/src/test/groovy/io/opentelemetry/instrumentation/apachehttpclient/v4_3/ApacheClientHostAbsoluteUriRequestTest.groovy

@@ -1,25 +0,0 @@
-/*
- * Copyright The OpenTelemetry Authors
- * SPDX-License-Identifier: Apache-2.0
- */
-
-package io.opentelemetry.instrumentation.apachehttpclient.v4_3
-
-import io.opentelemetry.instrumentation.test.LibraryTestTrait
-import org.apache.http.client.config.RequestConfig
-import org.apache.http.impl.client.CloseableHttpClient
-
-class ApacheClientHostAbsoluteUriRequestTest extends AbstractApacheClientHostAbsoluteUriRequestTest implements LibraryTestTrait {
-  @Override
-  protected CloseableHttpClient createClient(boolean readTimeout) {
-    def builder = ApacheHttpClientTelemetry.create(openTelemetry).newHttpClientBuilder()
-    def requestConfigBuilder = RequestConfig.custom()
-      .setMaxRedirects(maxRedirects())
-      .setConnectTimeout(CONNECT_TIMEOUT_MS)
-    if (readTimeout) {
-      requestConfigBuilder.setSocketTimeout(READ_TIMEOUT_MS)
-    }
-    builder.defaultRequestConfig = requestConfigBuilder.build()
-    return builder.build()
-  }
-}

instrumentation/apache-httpclient/apache-httpclient-4.3/library/src/test/groovy/io/opentelemetry/instrumentation/apachehttpclient/v4_3/ApacheClientHostRequestContextTest.groovy

@@ -1,25 +0,0 @@
-/*
- * Copyright The OpenTelemetry Authors
- * SPDX-License-Identifier: Apache-2.0
- */
-
-package io.opentelemetry.instrumentation.apachehttpclient.v4_3
-
-import io.opentelemetry.instrumentation.test.LibraryTestTrait
-import org.apache.http.client.config.RequestConfig
-import org.apache.http.impl.client.CloseableHttpClient
-
-class ApacheClientHostRequestContextTest extends AbstractApacheClientHostRequestContextTest implements LibraryTestTrait {
-  @Override
-  protected CloseableHttpClient createClient(boolean readTimeout) {
-    def builder = ApacheHttpClientTelemetry.create(openTelemetry).newHttpClientBuilder()
-    def requestConfigBuilder = RequestConfig.custom()
-      .setMaxRedirects(maxRedirects())
-      .setConnectTimeout(CONNECT_TIMEOUT_MS)
-    if (readTimeout) {
-      requestConfigBuilder.setSocketTimeout(READ_TIMEOUT_MS)
-    }
-    builder.defaultRequestConfig = requestConfigBuilder.build()
-    return builder.build()
-  }
-}

instrumentation/apache-httpclient/apache-httpclient-4.3/library/src/test/groovy/io/opentelemetry/instrumentation/apachehttpclient/v4_3/ApacheClientHostRequestTest.groovy

@@ -1,25 +0,0 @@
-/*
- * Copyright The OpenTelemetry Authors
- * SPDX-License-Identifier: Apache-2.0
- */
-
-package io.opentelemetry.instrumentation.apachehttpclient.v4_3
-
-import io.opentelemetry.instrumentation.test.LibraryTestTrait
-import org.apache.http.client.config.RequestConfig
-import org.apache.http.impl.client.CloseableHttpClient
-
-class ApacheClientHostRequestTest extends AbstractApacheClientHostRequestTest implements LibraryTestTrait {
-  @Override
-  protected CloseableHttpClient createClient(boolean readTimeout) {
-    def builder = ApacheHttpClientTelemetry.create(openTelemetry).newHttpClientBuilder()
-    def requestConfigBuilder = RequestConfig.custom()
-      .setMaxRedirects(maxRedirects())
-      .setConnectTimeout(CONNECT_TIMEOUT_MS)
-    if (readTimeout) {
-      requestConfigBuilder.setSocketTimeout(READ_TIMEOUT_MS)
-    }
-    builder.defaultRequestConfig = requestConfigBuilder.build()
-    return builder.build()
-  }
-}

instrumentation/apache-httpclient/apache-httpclient-4.3/library/src/test/groovy/io/opentelemetry/instrumentation/apachehttpclient/v4_3/ApacheClientUriRequestContextTest.groovy

@@ -1,25 +0,0 @@
-/*
- * Copyright The OpenTelemetry Authors
- * SPDX-License-Identifier: Apache-2.0
- */
-
-package io.opentelemetry.instrumentation.apachehttpclient.v4_3
-
-import io.opentelemetry.instrumentation.test.LibraryTestTrait
-import org.apache.http.client.config.RequestConfig
-import org.apache.http.impl.client.CloseableHttpClient
-
-class ApacheClientUriRequestContextTest extends AbstractApacheClientUriRequestContextTest implements LibraryTestTrait {
-  @Override
-  protected CloseableHttpClient createClient(boolean readTimeout) {
-    def builder = ApacheHttpClientTelemetry.create(openTelemetry).newHttpClientBuilder()
-    def requestConfigBuilder = RequestConfig.custom()
-      .setMaxRedirects(maxRedirects())
-      .setConnectTimeout(CONNECT_TIMEOUT_MS)
-    if (readTimeout) {
-      requestConfigBuilder.setSocketTimeout(READ_TIMEOUT_MS)
-    }
-    builder.defaultRequestConfig = requestConfigBuilder.build()
-    return builder.build()
-  }
-}

instrumentation/apache-httpclient/apache-httpclient-4.3/library/src/test/groovy/io/opentelemetry/instrumentation/apachehttpclient/v4_3/ApacheClientUriRequestTest.groovy

@@ -1,25 +0,0 @@
-/*
- * Copyright The OpenTelemetry Authors
- * SPDX-License-Identifier: Apache-2.0
- */
-
-package io.opentelemetry.instrumentation.apachehttpclient.v4_3
-
-import io.opentelemetry.instrumentation.test.LibraryTestTrait
-import org.apache.http.client.config.RequestConfig
-import org.apache.http.impl.client.CloseableHttpClient
-
-class ApacheClientUriRequestTest extends AbstractApacheClientUriRequestTest implements LibraryTestTrait {
-  @Override
-  protected CloseableHttpClient createClient(boolean readTimeout) {
-    def builder = ApacheHttpClientTelemetry.create(openTelemetry).newHttpClientBuilder()
-    def requestConfigBuilder = RequestConfig.custom()
-      .setMaxRedirects(maxRedirects())
-      .setConnectTimeout(CONNECT_TIMEOUT_MS)
-    if (readTimeout) {
-      requestConfigBuilder.setSocketTimeout(READ_TIMEOUT_MS)
-    }
-    builder.defaultRequestConfig = requestConfigBuilder.build()
-    return builder.build()
-  }
-}

instrumentation/apache-httpclient/apache-httpclient-4.3/library/src/test/java/io/opentelemetry/instrumentation/apachehttpclient/v4_3/ApacheHttpClientTest.java

@@ -0,0 +1,40 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.instrumentation.apachehttpclient.v4_3;
+
+import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension;
+import io.opentelemetry.instrumentation.testing.junit.http.AbstractHttpClientTest;
+import io.opentelemetry.instrumentation.testing.junit.http.HttpClientInstrumentationExtension;
+import org.apache.http.client.config.RequestConfig;
+import org.apache.http.impl.client.CloseableHttpClient;
+import org.apache.http.impl.client.HttpClientBuilder;
+import org.junit.jupiter.api.extension.RegisterExtension;
+
+class ApacheHttpClientTest extends AbstractApacheHttpClientTest {
+
+  @RegisterExtension
+  static final InstrumentationExtension testing = HttpClientInstrumentationExtension.forLibrary();
+
+  @Override
+  protected InstrumentationExtension testing() {
+    return testing;
+  }
+
+  @Override
+  protected CloseableHttpClient createClient(boolean readTimeout) {
+    HttpClientBuilder builder =
+        ApacheHttpClientTelemetry.create(testing.getOpenTelemetry()).newHttpClientBuilder();
+    RequestConfig.Builder requestConfigBuilder =
+        RequestConfig.custom()
+            .setMaxRedirects(2)
+            .setConnectTimeout((int) AbstractHttpClientTest.CONNECTION_TIMEOUT.toMillis());
+    if (readTimeout) {
+      requestConfigBuilder.setSocketTimeout((int) AbstractHttpClientTest.READ_TIMEOUT.toMillis());
+    }
+    builder.setDefaultRequestConfig(requestConfigBuilder.build());
+    return builder.build();
+  }
+}

instrumentation/apache-httpclient/apache-httpclient-4.3/testing/build.gradle.kts

@@ -7,7 +7,5 @@ dependencies {
 
   api("org.apache.httpcomponents:httpclient:4.3")
 
-  implementation("org.apache.groovy:groovy")
   implementation("io.opentelemetry:opentelemetry-api")
-  implementation("org.spockframework:spock-core")
 }

instrumentation/apache-httpclient/apache-httpclient-4.3/testing/src/main/groovy/io/opentelemetry/instrumentation/apachehttpclient/v4_3/ApacheHttpClientTest.groovy

@@ -1,232 +0,0 @@
-/*
- * Copyright The OpenTelemetry Authors
- * SPDX-License-Identifier: Apache-2.0
- */
-
-package io.opentelemetry.instrumentation.apachehttpclient.v4_3
-
-import io.opentelemetry.api.common.AttributeKey
-import io.opentelemetry.instrumentation.test.base.HttpClientTest
-import io.opentelemetry.instrumentation.testing.junit.http.AbstractHttpClientTest
-import io.opentelemetry.semconv.trace.attributes.SemanticAttributes
-import org.apache.http.HttpHost
-import org.apache.http.HttpRequest
-import org.apache.http.HttpResponse
-import org.apache.http.impl.client.CloseableHttpClient
-import org.apache.http.message.BasicHeader
-import org.apache.http.message.BasicHttpRequest
-import org.apache.http.protocol.BasicHttpContext
-import spock.lang.Shared
-
-import java.util.function.Consumer
-
-abstract class ApacheHttpClientTest<T extends HttpRequest> extends HttpClientTest<T> {
-
-  abstract protected CloseableHttpClient createClient(boolean readTimeout)
-
-  @Override
-  String userAgent() {
-    return "apachehttpclient"
-  }
-
-  @Override
-  Integer responseCodeOnRedirectError() {
-    return 302
-  }
-
-  @Override
-  boolean testReadTimeout() {
-    true
-  }
-
-  @Shared
-  CloseableHttpClient client = createClient(false)
-
-  @Shared
-  CloseableHttpClient clientWithReadTimeout = createClient(true)
-
-  CloseableHttpClient getClient(URI uri) {
-    if (uri.toString().contains("/read-timeout")) {
-      return clientWithReadTimeout
-    }
-    return client
-  }
-
-  @Override
-  T buildRequest(String method, URI uri, Map<String, String> headers) {
-    def request = createRequest(method, uri)
-    request.addHeader("user-agent", userAgent())
-    headers.entrySet().each {
-      request.setHeader(new BasicHeader(it.key, it.value))
-    }
-    return request
-  }
-
-  @Override
-  Set<AttributeKey<?>> httpAttributes(URI uri) {
-    Set<AttributeKey<?>> extra = [
-      SemanticAttributes.HTTP_SCHEME,
-      SemanticAttributes.HTTP_TARGET
-    ]
-    super.httpAttributes(uri) + extra
-  }
-
-  // compilation fails with @Override annotation on this method (groovy quirk?)
-  int sendRequest(T request, String method, URI uri, Map<String, String> headers) {
-    def response = executeRequest(request, uri)
-    response.entity?.content?.close() // Make sure the connection is closed.
-    return response.statusLine.statusCode
-  }
-
-  // compilation fails with @Override annotation on this method (groovy quirk?)
-  void sendRequestWithCallback(T request, String method, URI uri, Map<String, String> headers, AbstractHttpClientTest.RequestResult requestResult) {
-    try {
-      executeRequestWithCallback(request, uri) {
-        it.entity?.content?.close() // Make sure the connection is closed.
-        requestResult.complete(it.statusLine.statusCode)
-      }
-    } catch (Throwable throwable) {
-      requestResult.complete(throwable)
-    }
-  }
-
-  abstract T createRequest(String method, URI uri)
-
-  abstract HttpResponse executeRequest(T request, URI uri)
-
-  abstract void executeRequestWithCallback(T request, URI uri, Consumer<HttpResponse> callback)
-
-  static String fullPathFromURI(URI uri) {
-    StringBuilder builder = new StringBuilder()
-    if (uri.getPath() != null) {
-      builder.append(uri.getPath())
-    }
-
-    if (uri.getQuery() != null) {
-      builder.append('?')
-      builder.append(uri.getQuery())
-    }
-
-    if (uri.getFragment() != null) {
-      builder.append('#')
-      builder.append(uri.getFragment())
-    }
-    return builder.toString()
-  }
-}
-
-abstract class AbstractApacheClientHostRequestTest extends ApacheHttpClientTest<BasicHttpRequest> {
-  @Override
-  BasicHttpRequest createRequest(String method, URI uri) {
-    // also testing with an absolute path below
-    return new BasicHttpRequest(method, fullPathFromURI(uri))
-  }
-
-  @Override
-  HttpResponse executeRequest(BasicHttpRequest request, URI uri) {
-    return getClient(uri).execute(new HttpHost(uri.getHost(), uri.getPort(), uri.getScheme()), request)
-  }
-
-  @Override
-  void executeRequestWithCallback(BasicHttpRequest request, URI uri, Consumer<HttpResponse> callback) {
-    getClient(uri).execute(new HttpHost(uri.getHost(), uri.getPort(), uri.getScheme()), request) {
-      callback.accept(it)
-    }
-  }
-}
-
-abstract class AbstractApacheClientHostAbsoluteUriRequestTest extends ApacheHttpClientTest<BasicHttpRequest> {
-  @Override
-  BasicHttpRequest createRequest(String method, URI uri) {
-    return new BasicHttpRequest(method, uri.toString())
-  }
-
-  @Override
-  HttpResponse executeRequest(BasicHttpRequest request, URI uri) {
-    return getClient(uri).execute(new HttpHost(uri.getHost(), uri.getPort(), uri.getScheme()), request)
-  }
-
-  @Override
-  void executeRequestWithCallback(BasicHttpRequest request, URI uri, Consumer<HttpResponse> callback) {
-    getClient(uri).execute(new HttpHost(uri.getHost(), uri.getPort(), uri.getScheme()), request) {
-      callback.accept(it)
-    }
-  }
-}
-
-abstract class AbstractApacheClientHostRequestContextTest extends ApacheHttpClientTest<BasicHttpRequest> {
-  @Override
-  BasicHttpRequest createRequest(String method, URI uri) {
-    // also testing with an absolute path below
-    return new BasicHttpRequest(method, fullPathFromURI(uri))
-  }
-
-  @Override
-  HttpResponse executeRequest(BasicHttpRequest request, URI uri) {
-    return getClient(uri).execute(new HttpHost(uri.getHost(), uri.getPort(), uri.getScheme()), request, new BasicHttpContext())
-  }
-
-  @Override
-  void executeRequestWithCallback(BasicHttpRequest request, URI uri, Consumer<HttpResponse> callback) {
-    getClient(uri).execute(new HttpHost(uri.getHost(), uri.getPort(), uri.getScheme()), request, {
-      callback.accept(it)
-    }, new BasicHttpContext())
-  }
-}
-
-abstract class AbstractApacheClientHostAbsoluteUriRequestContextTest extends ApacheHttpClientTest<BasicHttpRequest> {
-  @Override
-  BasicHttpRequest createRequest(String method, URI uri) {
-    return new BasicHttpRequest(method, uri.toString())
-  }
-
-  @Override
-  HttpResponse executeRequest(BasicHttpRequest request, URI uri) {
-    return getClient(uri).execute(new HttpHost(uri.getHost(), uri.getPort(), uri.getScheme()), request, new BasicHttpContext())
-  }
-
-  @Override
-  void executeRequestWithCallback(BasicHttpRequest request, URI uri, Consumer<HttpResponse> callback) {
-    getClient(uri).execute(new HttpHost(uri.getHost(), uri.getPort(), uri.getScheme()), request, {
-      callback.accept(it)
-    }, new BasicHttpContext())
-  }
-}
-
-abstract class AbstractApacheClientUriRequestTest extends ApacheHttpClientTest<HttpUriRequest> {
-  @Override
-  HttpUriRequest createRequest(String method, URI uri) {
-    return new HttpUriRequest(method, uri)
-  }
-
-  @Override
-  HttpResponse executeRequest(HttpUriRequest request, URI uri) {
-    return getClient(uri).execute(request)
-  }
-
-  @Override
-  void executeRequestWithCallback(HttpUriRequest request, URI uri, Consumer<HttpResponse> callback) {
-    getClient(uri).execute(request) {
-      callback.accept(it)
-    }
-  }
-}
-
-abstract class AbstractApacheClientUriRequestContextTest extends ApacheHttpClientTest<HttpUriRequest> {
-  @Override
-  HttpUriRequest createRequest(String method, URI uri) {
-    return new HttpUriRequest(method, uri)
-  }
-
-  @Override
-  HttpResponse executeRequest(HttpUriRequest request, URI uri) {
-    return getClient(uri).execute(request, new BasicHttpContext())
-  }
-
-  @Override
-  void executeRequestWithCallback(HttpUriRequest request, URI uri, Consumer<HttpResponse> callback) {
-    getClient(uri).execute(request, {
-      callback.accept(it)
-    }, new BasicHttpContext())
-  }
-}

instrumentation/apache-httpclient/apache-httpclient-4.3/testing/src/main/groovy/io/opentelemetry/instrumentation/apachehttpclient/v4_3/HttpUriRequest.groovy

@@ -1,23 +0,0 @@
-/*
- * Copyright The OpenTelemetry Authors
- * SPDX-License-Identifier: Apache-2.0
- */
-
-package io.opentelemetry.instrumentation.apachehttpclient.v4_3
-
-import org.apache.http.client.methods.HttpRequestBase
-
-class HttpUriRequest extends HttpRequestBase {
-
-  private final String methodName
-
-  HttpUriRequest(final String methodName, final URI uri) {
-    this.methodName = methodName
-    setURI(uri)
-  }
-
-  @Override
-  String getMethod() {
-    return methodName
-  }
-}

instrumentation/apache-httpclient/apache-httpclient-4.3/testing/src/main/java/io/opentelemetry/instrumentation/apachehttpclient/v4_3/AbstractApacheHttpClientTest.java

@@ -0,0 +1,369 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.instrumentation.apachehttpclient.v4_3;
+
+import io.opentelemetry.api.common.AttributeKey;
+import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension;
+import io.opentelemetry.instrumentation.testing.junit.http.AbstractHttpClientTest;
+import io.opentelemetry.instrumentation.testing.junit.http.HttpClientTestOptions;
+import io.opentelemetry.semconv.trace.attributes.SemanticAttributes;
+import java.io.IOException;
+import java.io.UncheckedIOException;
+import java.net.URI;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+import org.apache.http.HttpHost;
+import org.apache.http.HttpRequest;
+import org.apache.http.HttpResponse;
+import org.apache.http.client.ResponseHandler;
+import org.apache.http.impl.client.CloseableHttpClient;
+import org.apache.http.message.BasicHeader;
+import org.apache.http.message.BasicHttpRequest;
+import org.apache.http.protocol.BasicHttpContext;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.TestInstance;
+
+@TestInstance(TestInstance.Lifecycle.PER_CLASS)
+public abstract class AbstractApacheHttpClientTest {
+
+  protected abstract InstrumentationExtension testing();
+
+  protected abstract CloseableHttpClient createClient(boolean readTimeout);
+
+  private CloseableHttpClient client;
+  private CloseableHttpClient clientWithReadTimeout;
+
+  @BeforeAll
+  void setUp() {
+    client = createClient(false);
+    clientWithReadTimeout = createClient(true);
+  }
+
+  @AfterAll
+  void tearDown() throws Exception {
+    client.close();
+    clientWithReadTimeout.close();
+  }
+
+  CloseableHttpClient getClient(URI uri) {
+    if (uri.toString().contains("/read-timeout")) {
+      return clientWithReadTimeout;
+    }
+    return client;
+  }
+
+  @Nested
+  class ApacheClientHostRequestTest extends AbstractHttpClientTest<BasicHttpRequest> {
+
+    @Override
+    protected BasicHttpRequest buildRequest(String method, URI uri, Map<String, String> headers) {
+      // also testing with an absolute path below
+      return configureRequest(new BasicHttpRequest(method, fullPathFromUri(uri)), headers);
+    }
+
+    @Override
+    protected int sendRequest(
+        BasicHttpRequest request, String method, URI uri, Map<String, String> headers)
+        throws Exception {
+      return getResponseCode(
+          getClient(uri)
+              .execute(new HttpHost(uri.getHost(), uri.getPort(), uri.getScheme()), request));
+    }
+
+    @Override
+    protected void sendRequestWithCallback(
+        BasicHttpRequest request,
+        String method,
+        URI uri,
+        Map<String, String> headers,
+        RequestResult requestResult) {
+      try {
+        getClient(uri)
+            .execute(
+                new HttpHost(uri.getHost(), uri.getPort(), uri.getScheme()),
+                request,
+                responseCallback(requestResult));
+      } catch (Throwable t) {
+        requestResult.complete(t);
+      }
+    }
+
+    @Override
+    protected void configure(HttpClientTestOptions options) {
+      configureTest(options);
+    }
+  }
+
+  @Nested
+  class ApacheClientHostRequestContextTest extends AbstractHttpClientTest<BasicHttpRequest> {
+
+    @Override
+    protected BasicHttpRequest buildRequest(String method, URI uri, Map<String, String> headers) {
+      // also testing with an absolute path below
+      return configureRequest(new BasicHttpRequest(method, fullPathFromUri(uri)), headers);
+    }
+
+    @Override
+    protected int sendRequest(
+        BasicHttpRequest request, String method, URI uri, Map<String, String> headers)
+        throws Exception {
+      return getResponseCode(
+          getClient(uri)
+              .execute(
+                  new HttpHost(uri.getHost(), uri.getPort(), uri.getScheme()),
+                  request,
+                  new BasicHttpContext()));
+    }
+
+    @Override
+    protected void sendRequestWithCallback(
+        BasicHttpRequest request,
+        String method,
+        URI uri,
+        Map<String, String> headers,
+        RequestResult requestResult) {
+      try {
+        getClient(uri)
+            .execute(
+                new HttpHost(uri.getHost(), uri.getPort(), uri.getScheme()),
+                request,
+                responseCallback(requestResult),
+                new BasicHttpContext());
+      } catch (Throwable t) {
+        requestResult.complete(t);
+      }
+    }
+
+    @Override
+    protected void configure(HttpClientTestOptions options) {
+      configureTest(options);
+    }
+  }
+
+  @Nested
+  class ApacheClientHostAbsoluteUriRequestTest extends AbstractHttpClientTest<BasicHttpRequest> {
+
+    @Override
+    protected BasicHttpRequest buildRequest(String method, URI uri, Map<String, String> headers) {
+      return configureRequest(new BasicHttpRequest(method, uri.toString()), headers);
+    }
+
+    @Override
+    protected int sendRequest(
+        BasicHttpRequest request, String method, URI uri, Map<String, String> headers)
+        throws Exception {
+      return getResponseCode(
+          getClient(uri)
+              .execute(new HttpHost(uri.getHost(), uri.getPort(), uri.getScheme()), request));
+    }
+
+    @Override
+    protected void sendRequestWithCallback(
+        BasicHttpRequest request,
+        String method,
+        URI uri,
+        Map<String, String> headers,
+        RequestResult requestResult) {
+      try {
+        getClient(uri)
+            .execute(
+                new HttpHost(uri.getHost(), uri.getPort(), uri.getScheme()),
+                request,
+                responseCallback(requestResult));
+      } catch (Throwable t) {
+        requestResult.complete(t);
+      }
+    }
+
+    @Override
+    protected void configure(HttpClientTestOptions options) {
+      configureTest(options);
+    }
+  }
+
+  @Nested
+  class ApacheClientHostAbsoluteUriRequestContextTest
+      extends AbstractHttpClientTest<BasicHttpRequest> {
+
+    @Override
+    protected BasicHttpRequest buildRequest(String method, URI uri, Map<String, String> headers) {
+      return configureRequest(new BasicHttpRequest(method, uri.toString()), headers);
+    }
+
+    @Override
+    protected int sendRequest(
+        BasicHttpRequest request, String method, URI uri, Map<String, String> headers)
+        throws Exception {
+      return getResponseCode(
+          getClient(uri)
+              .execute(
+                  new HttpHost(uri.getHost(), uri.getPort(), uri.getScheme()),
+                  request,
+                  new BasicHttpContext()));
+    }
+
+    @Override
+    protected void sendRequestWithCallback(
+        BasicHttpRequest request,
+        String method,
+        URI uri,
+        Map<String, String> headers,
+        RequestResult requestResult) {
+      try {
+        getClient(uri)
+            .execute(
+                new HttpHost(uri.getHost(), uri.getPort(), uri.getScheme()),
+                request,
+                responseCallback(requestResult),
+                new BasicHttpContext());
+      } catch (Throwable t) {
+        requestResult.complete(t);
+      }
+    }
+
+    @Override
+    protected void configure(HttpClientTestOptions options) {
+      configureTest(options);
+    }
+  }
+
+  @Nested
+  class ApacheClientUriRequestTest extends AbstractHttpClientTest<HttpUriRequest> {
+
+    @Override
+    protected HttpUriRequest buildRequest(String method, URI uri, Map<String, String> headers) {
+      // also testing with an absolute path below
+      return configureRequest(new HttpUriRequest(method, uri), headers);
+    }
+
+    @Override
+    protected int sendRequest(
+        HttpUriRequest request, String method, URI uri, Map<String, String> headers)
+        throws Exception {
+      return getResponseCode(getClient(uri).execute(request));
+    }
+
+    @Override
+    protected void sendRequestWithCallback(
+        HttpUriRequest request,
+        String method,
+        URI uri,
+        Map<String, String> headers,
+        RequestResult requestResult) {
+      try {
+        getClient(uri).execute(request, responseCallback(requestResult));
+      } catch (Throwable t) {
+        requestResult.complete(t);
+      }
+    }
+
+    @Override
+    protected void configure(HttpClientTestOptions options) {
+      configureTest(options);
+    }
+  }
+
+  @Nested
+  class ApacheClientUriRequestContextTest extends AbstractHttpClientTest<HttpUriRequest> {
+
+    @Override
+    protected HttpUriRequest buildRequest(String method, URI uri, Map<String, String> headers) {
+      // also testing with an absolute path below
+      return configureRequest(new HttpUriRequest(method, uri), headers);
+    }
+
+    @Override
+    protected int sendRequest(
+        HttpUriRequest request, String method, URI uri, Map<String, String> headers)
+        throws Exception {
+      return getResponseCode(getClient(uri).execute(request, new BasicHttpContext()));
+    }
+
+    @Override
+    protected void sendRequestWithCallback(
+        HttpUriRequest request,
+        String method,
+        URI uri,
+        Map<String, String> headers,
+        RequestResult requestResult) {
+      try {
+        getClient(uri).execute(request, responseCallback(requestResult), new BasicHttpContext());
+      } catch (Throwable t) {
+        requestResult.complete(t);
+      }
+    }
+
+    @Override
+    protected void configure(HttpClientTestOptions options) {
+      configureTest(options);
+    }
+  }
+
+  static <T extends HttpRequest> T configureRequest(T request, Map<String, String> headers) {
+    request.addHeader("user-agent", "apachehttpclient");
+    headers.forEach((key, value) -> request.setHeader(new BasicHeader(key, value)));
+    return request;
+  }
+
+  static int getResponseCode(HttpResponse response) {
+    try {
+      if (response.getEntity() != null && response.getEntity().getContent() != null) {
+        response.getEntity().getContent().close();
+      }
+    } catch (IOException e) {
+      throw new UncheckedIOException(e);
+    }
+    return response.getStatusLine().getStatusCode();
+  }
+
+  static ResponseHandler<HttpResponse> responseCallback(
+      AbstractHttpClientTest.RequestResult requestResult) {
+    return response -> {
+      try {
+        requestResult.complete(getResponseCode(response));
+      } catch (Throwable t) {
+        requestResult.complete(t);
+        return response;
+      }
+      return response;
+    };
+  }
+
+  static void configureTest(HttpClientTestOptions options) {
+    options.setUserAgent("apachehttpclient");
+    options.setResponseCodeOnRedirectError(302);
+    options.enableTestReadTimeout();
+    options.setHttpAttributes(
+        endpoint -> {
+          Set<AttributeKey<?>> attributes =
+              new HashSet<>(HttpClientTestOptions.DEFAULT_HTTP_ATTRIBUTES);
+          attributes.add(SemanticAttributes.HTTP_SCHEME);
+          attributes.add(SemanticAttributes.HTTP_TARGET);
+          return attributes;
+        });
+  }
+
+  static String fullPathFromUri(URI uri) {
+    StringBuilder builder = new StringBuilder();
+    if (uri.getPath() != null) {
+      builder.append(uri.getPath());
+    }
+
+    if (uri.getQuery() != null) {
+      builder.append('?');
+      builder.append(uri.getQuery());
+    }
+
+    if (uri.getFragment() != null) {
+      builder.append('#');
+      builder.append(uri.getFragment());
+    }
+    return builder.toString();
+  }
+}

instrumentation/apache-httpclient/apache-httpclient-4.3/testing/src/main/java/io/opentelemetry/instrumentation/apachehttpclient/v4_3/HttpUriRequest.java

@@ -0,0 +1,24 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.instrumentation.apachehttpclient.v4_3;
+
+import java.net.URI;
+import org.apache.http.client.methods.HttpRequestBase;
+
+final class HttpUriRequest extends HttpRequestBase {
+
+  private final String methodName;
+
+  HttpUriRequest(String methodName, URI uri) {
+    this.methodName = methodName;
+    setURI(uri);
+  }
+
+  @Override
+  public String getMethod() {
+    return methodName;
+  }
+}

testing-common/src/main/java/io/opentelemetry/instrumentation/testing/junit/http/AbstractHttpClientTest.java

@@ -50,6 +50,7 @@ import org.junit.jupiter.params.provider.ValueSource;
 public abstract class AbstractHttpClientTest<REQUEST> {
   public static final Duration CONNECTION_TIMEOUT = Duration.ofSeconds(5);
   public static final Duration READ_TIMEOUT = Duration.ofSeconds(2);
+
   static final String BASIC_AUTH_KEY = "custom-authorization-header";
   static final String BASIC_AUTH_VAL = "plain text auth token";