change endpoint from enum to regular class (#8325)

Co-authored-by: Trask Stalnaker <trask.stalnaker@gmail.com>

instrumentation/grails-3.0/javaagent/src/test/java/test/GrailsTest.java

@@ -5,9 +5,13 @@
 
 package test;
 
+import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.CAPTURE_HEADERS;
 import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.ERROR;
 import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.EXCEPTION;
+import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.INDEXED_CHILD;
 import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.NOT_FOUND;
+import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.PATH_PARAM;
+import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.QUERY_PARAM;
 import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.REDIRECT;
 import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.assertThat;
 
@@ -103,18 +107,16 @@ public class GrailsTest extends AbstractHttpServerTest<ConfigurableApplicationCo
 
   @Override
   public String expectedHttpRoute(ServerEndpoint endpoint) {
-    switch (endpoint) {
-      case PATH_PARAM:
-        return getContextPath() + "/test/path";
-      case QUERY_PARAM:
-        return getContextPath() + "/test/query";
-      case ERROR:
-        return getContextPath() + "/test/error";
-      case NOT_FOUND:
-        return getContextPath() + "/**";
-      default:
-        return getContextPath() + "/test" + endpoint.getPath();
+    if (PATH_PARAM.equals(endpoint)) {
+      return getContextPath() + "/test/path";
+    } else if (QUERY_PARAM.equals(endpoint)) {
+      return getContextPath() + "/test/query";
+    } else if (ERROR.equals(endpoint)) {
+      return getContextPath() + "/test/error";
+    } else if (NOT_FOUND.equals(endpoint)) {
+      return getContextPath() + "/**";
     }
+    return getContextPath() + "/test" + endpoint.getPath();
   }
 
   ConfigurableApplicationContext startServer(int port) {
@@ -122,20 +124,18 @@ public class GrailsTest extends AbstractHttpServerTest<ConfigurableApplicationCo
   }
 
   private static String getHandlerSpanName(ServerEndpoint endpoint) {
-    switch (endpoint) {
-      case QUERY_PARAM:
-        return "TestController.query";
-      case PATH_PARAM:
-        return "TestController.path";
-      case CAPTURE_HEADERS:
-        return "TestController.captureHeaders";
-      case INDEXED_CHILD:
-        return "TestController.child";
-      case NOT_FOUND:
-        return "ResourceHttpRequestHandler.handleRequest";
-      default:
-        return "TestController." + endpoint.name().toLowerCase(Locale.ROOT);
+    if (QUERY_PARAM.equals(endpoint)) {
+      return "TestController.query";
+    } else if (PATH_PARAM.equals(endpoint)) {
+      return "TestController.path";
+    } else if (CAPTURE_HEADERS.equals(endpoint)) {
+      return "TestController.captureHeaders";
+    } else if (INDEXED_CHILD.equals(endpoint)) {
+      return "TestController.child";
+    } else if (NOT_FOUND.equals(endpoint)) {
+      return "ResourceHttpRequestHandler.handleRequest";
     }
+    return "TestController." + endpoint.name().toLowerCase(Locale.ROOT);
   }
 
   @Override

instrumentation/jetty/jetty-11.0/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/jetty/v11_0/JettyHandlerTest.java

@@ -6,11 +6,14 @@
 package io.opentelemetry.javaagent.instrumentation.jetty.v11_0;
 
 import static io.opentelemetry.instrumentation.testing.junit.http.HttpServerTestOptions.DEFAULT_HTTP_ATTRIBUTES;
+import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.CAPTURE_HEADERS;
 import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.ERROR;
 import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.EXCEPTION;
 import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.INDEXED_CHILD;
 import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.NOT_FOUND;
+import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.QUERY_PARAM;
 import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.REDIRECT;
+import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.SUCCESS;
 import static org.assertj.core.api.Assertions.assertThat;
 
 import com.google.common.collect.Sets;
@@ -119,37 +122,29 @@ public class JettyHandlerTest extends AbstractHttpServerTest<Server> {
   private static HttpServletResponse response(
       Request request, HttpServletResponse response, ServerEndpoint endpoint) throws IOException {
     response.setContentType("text/plain");
-    switch (endpoint) {
-      case SUCCESS:
-        response.setStatus(endpoint.getStatus());
-        response.getWriter().print(endpoint.getBody());
-        break;
-      case QUERY_PARAM:
-        response.setStatus(endpoint.getStatus());
-        response.getWriter().print(request.getQueryString());
-        break;
-      case REDIRECT:
-        response.sendRedirect(endpoint.getBody());
-        break;
-      case ERROR:
-        response.sendError(endpoint.getStatus(), endpoint.getBody());
-        break;
-      case CAPTURE_HEADERS:
-        response.setHeader("X-Test-Response", request.getHeader("X-Test-Request"));
-        response.setStatus(endpoint.getStatus());
-        response.getWriter().print(endpoint.getBody());
-        break;
-      case EXCEPTION:
-        throw new IllegalStateException(endpoint.getBody());
-      case INDEXED_CHILD:
-        INDEXED_CHILD.collectSpanAttributes(name -> request.getParameter(name));
-        response.setStatus(endpoint.getStatus());
-        response.getWriter().print(endpoint.getBody());
-        break;
-      default:
-        response.setStatus(NOT_FOUND.getStatus());
-        response.getWriter().print(NOT_FOUND.getBody());
-        break;
+    if (SUCCESS.equals(endpoint)) {
+      response.setStatus(endpoint.getStatus());
+      response.getWriter().print(endpoint.getBody());
+    } else if (QUERY_PARAM.equals(endpoint)) {
+      response.setStatus(endpoint.getStatus());
+      response.getWriter().print(request.getQueryString());
+    } else if (REDIRECT.equals(endpoint)) {
+      response.sendRedirect(endpoint.getBody());
+    } else if (ERROR.equals(endpoint)) {
+      response.sendError(endpoint.getStatus(), endpoint.getBody());
+    } else if (CAPTURE_HEADERS.equals(endpoint)) {
+      response.setHeader("X-Test-Response", request.getHeader("X-Test-Request"));
+      response.setStatus(endpoint.getStatus());
+      response.getWriter().print(endpoint.getBody());
+    } else if (EXCEPTION.equals(endpoint)) {
+      throw new IllegalStateException(endpoint.getBody());
+    } else if (INDEXED_CHILD.equals(endpoint)) {
+      INDEXED_CHILD.collectSpanAttributes(name -> request.getParameter(name));
+      response.setStatus(endpoint.getStatus());
+      response.getWriter().print(endpoint.getBody());
+    } else {
+      response.setStatus(NOT_FOUND.getStatus());
+      response.getWriter().print(NOT_FOUND.getBody());
     }
     return response;
   }

instrumentation/jetty/jetty-8.0/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/jetty/v8_0/JettyHandlerTest.java

@@ -6,11 +6,14 @@
 package io.opentelemetry.javaagent.instrumentation.jetty.v8_0;
 
 import static io.opentelemetry.instrumentation.testing.junit.http.HttpServerTestOptions.DEFAULT_HTTP_ATTRIBUTES;
+import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.CAPTURE_HEADERS;
 import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.ERROR;
 import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.EXCEPTION;
 import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.INDEXED_CHILD;
 import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.NOT_FOUND;
+import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.QUERY_PARAM;
 import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.REDIRECT;
+import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.SUCCESS;
 import static org.assertj.core.api.Assertions.assertThat;
 
 import com.google.common.collect.Sets;
@@ -119,37 +122,29 @@ public class JettyHandlerTest extends AbstractHttpServerTest<Server> {
   private static HttpServletResponse response(
       Request request, HttpServletResponse response, ServerEndpoint endpoint) throws IOException {
     response.setContentType("text/plain");
-    switch (endpoint) {
-      case SUCCESS:
-        response.setStatus(endpoint.getStatus());
-        response.getWriter().print(endpoint.getBody());
-        break;
-      case QUERY_PARAM:
-        response.setStatus(endpoint.getStatus());
-        response.getWriter().print(request.getQueryString());
-        break;
-      case REDIRECT:
-        response.sendRedirect(endpoint.getBody());
-        break;
-      case ERROR:
-        response.sendError(endpoint.getStatus(), endpoint.getBody());
-        break;
-      case CAPTURE_HEADERS:
-        response.setHeader("X-Test-Response", request.getHeader("X-Test-Request"));
-        response.setStatus(endpoint.getStatus());
-        response.getWriter().print(endpoint.getBody());
-        break;
-      case EXCEPTION:
-        throw new IllegalStateException(endpoint.getBody());
-      case INDEXED_CHILD:
-        INDEXED_CHILD.collectSpanAttributes(name -> request.getParameter(name));
-        response.setStatus(endpoint.getStatus());
-        response.getWriter().print(endpoint.getBody());
-        break;
-      default:
-        response.setStatus(NOT_FOUND.getStatus());
-        response.getWriter().print(NOT_FOUND.getBody());
-        break;
+    if (SUCCESS.equals(endpoint)) {
+      response.setStatus(endpoint.getStatus());
+      response.getWriter().print(endpoint.getBody());
+    } else if (QUERY_PARAM.equals(endpoint)) {
+      response.setStatus(endpoint.getStatus());
+      response.getWriter().print(request.getQueryString());
+    } else if (REDIRECT.equals(endpoint)) {
+      response.sendRedirect(endpoint.getBody());
+    } else if (ERROR.equals(endpoint)) {
+      response.sendError(endpoint.getStatus(), endpoint.getBody());
+    } else if (CAPTURE_HEADERS.equals(endpoint)) {
+      response.setHeader("X-Test-Response", request.getHeader("X-Test-Request"));
+      response.setStatus(endpoint.getStatus());
+      response.getWriter().print(endpoint.getBody());
+    } else if (EXCEPTION.equals(endpoint)) {
+      throw new IllegalStateException(endpoint.getBody());
+    } else if (INDEXED_CHILD.equals(endpoint)) {
+      INDEXED_CHILD.collectSpanAttributes(name -> request.getParameter(name));
+      response.setStatus(endpoint.getStatus());
+      response.getWriter().print(endpoint.getBody());
+    } else {
+      response.setStatus(NOT_FOUND.getStatus());
+      response.getWriter().print(NOT_FOUND.getBody());
     }
     return response;
   }

instrumentation/netty/netty-3.8/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/netty/v3_8/server/Netty38ServerTest.java

@@ -5,7 +5,14 @@
 
 package io.opentelemetry.javaagent.instrumentation.netty.v3_8.server;
 
+import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.CAPTURE_HEADERS;
+import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.ERROR;
+import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.EXCEPTION;
+import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.INDEXED_CHILD;
 import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.NOT_FOUND;
+import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.QUERY_PARAM;
+import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.REDIRECT;
+import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.SUCCESS;
 import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.forPath;
 import static org.jboss.netty.handler.codec.http.HttpHeaders.Names.CONTENT_LENGTH;
 import static org.jboss.netty.handler.codec.http.HttpHeaders.Names.CONTENT_TYPE;
@@ -88,7 +95,7 @@ class Netty38ServerTest extends AbstractHttpServerTest<ServerBootstrap> {
           return attributes;
         });
 
-    options.setExpectedException(new IllegalArgumentException(ServerEndpoint.EXCEPTION.getBody()));
+    options.setExpectedException(new IllegalArgumentException(EXCEPTION.getBody()));
     options.setHasResponseCustomizer(serverEndpoint -> true);
   }
 
@@ -112,66 +119,56 @@ class Netty38ServerTest extends AbstractHttpServerTest<ServerBootstrap> {
                       () -> {
                         HttpResponse response;
                         ChannelBuffer responseContent;
-                        switch (endpoint) {
-                          case SUCCESS:
-                          case ERROR:
-                            responseContent =
-                                ChannelBuffers.copiedBuffer(endpoint.getBody(), CharsetUtil.UTF_8);
-                            response =
-                                new DefaultHttpResponse(
-                                    HTTP_1_1, HttpResponseStatus.valueOf(endpoint.getStatus()));
-                            response.setContent(responseContent);
-                            break;
-                          case INDEXED_CHILD:
-                            responseContent = ChannelBuffers.EMPTY_BUFFER;
-                            endpoint.collectSpanAttributes(
-                                name ->
-                                    new QueryStringDecoder(uri)
-                                        .getParameters().get(name).stream()
-                                            .findFirst()
-                                            .orElse(null));
-                            response =
-                                new DefaultHttpResponse(
-                                    HTTP_1_1, HttpResponseStatus.valueOf(endpoint.getStatus()));
-                            response.setContent(responseContent);
-                            break;
-                          case QUERY_PARAM:
-                            responseContent =
-                                ChannelBuffers.copiedBuffer(uri.getQuery(), CharsetUtil.UTF_8);
-                            response =
-                                new DefaultHttpResponse(
-                                    HTTP_1_1, HttpResponseStatus.valueOf(endpoint.getStatus()));
-                            response.setContent(responseContent);
-                            break;
-                          case REDIRECT:
-                            responseContent = ChannelBuffers.EMPTY_BUFFER;
-                            response =
-                                new DefaultHttpResponse(
-                                    HTTP_1_1, HttpResponseStatus.valueOf(endpoint.getStatus()));
-                            response.setContent(responseContent);
-                            response.headers().set(LOCATION, endpoint.getBody());
-                            break;
-                          case CAPTURE_HEADERS:
-                            responseContent =
-                                ChannelBuffers.copiedBuffer(endpoint.getBody(), CharsetUtil.UTF_8);
-                            response =
-                                new DefaultHttpResponse(
-                                    HTTP_1_1, HttpResponseStatus.valueOf(endpoint.getStatus()));
-                            response
-                                .headers()
-                                .set("X-Test-Response", request.headers().get("X-Test-Request"));
-                            response.setContent(responseContent);
-                            break;
-                          case EXCEPTION:
-                            throw new IllegalArgumentException(endpoint.getBody());
-                          default:
-                            responseContent =
-                                ChannelBuffers.copiedBuffer(NOT_FOUND.getBody(), CharsetUtil.UTF_8);
-                            response =
-                                new DefaultHttpResponse(
-                                    HTTP_1_1, HttpResponseStatus.valueOf(endpoint.getStatus()));
-                            response.setContent(responseContent);
-                            break;
+                        if (SUCCESS.equals(endpoint) || ERROR.equals(endpoint)) {
+                          responseContent =
+                              ChannelBuffers.copiedBuffer(endpoint.getBody(), CharsetUtil.UTF_8);
+                          response =
+                              new DefaultHttpResponse(
+                                  HTTP_1_1, HttpResponseStatus.valueOf(endpoint.getStatus()));
+                          response.setContent(responseContent);
+                        } else if (INDEXED_CHILD.equals(endpoint)) {
+                          responseContent = ChannelBuffers.EMPTY_BUFFER;
+                          endpoint.collectSpanAttributes(
+                              name ->
+                                  new QueryStringDecoder(uri)
+                                      .getParameters().get(name).stream().findFirst().orElse(null));
+                          response =
+                              new DefaultHttpResponse(
+                                  HTTP_1_1, HttpResponseStatus.valueOf(endpoint.getStatus()));
+                          response.setContent(responseContent);
+                        } else if (QUERY_PARAM.equals(endpoint)) {
+                          responseContent =
+                              ChannelBuffers.copiedBuffer(uri.getQuery(), CharsetUtil.UTF_8);
+                          response =
+                              new DefaultHttpResponse(
+                                  HTTP_1_1, HttpResponseStatus.valueOf(endpoint.getStatus()));
+                          response.setContent(responseContent);
+                        } else if (REDIRECT.equals(endpoint)) {
+                          responseContent = ChannelBuffers.EMPTY_BUFFER;
+                          response =
+                              new DefaultHttpResponse(
+                                  HTTP_1_1, HttpResponseStatus.valueOf(endpoint.getStatus()));
+                          response.setContent(responseContent);
+                          response.headers().set(LOCATION, endpoint.getBody());
+                        } else if (CAPTURE_HEADERS.equals(endpoint)) {
+                          responseContent =
+                              ChannelBuffers.copiedBuffer(endpoint.getBody(), CharsetUtil.UTF_8);
+                          response =
+                              new DefaultHttpResponse(
+                                  HTTP_1_1, HttpResponseStatus.valueOf(endpoint.getStatus()));
+                          response
+                              .headers()
+                              .set("X-Test-Response", request.headers().get("X-Test-Request"));
+                          response.setContent(responseContent);
+                        } else if (EXCEPTION.equals(endpoint)) {
+                          throw new IllegalArgumentException(endpoint.getBody());
+                        } else {
+                          responseContent =
+                              ChannelBuffers.copiedBuffer(NOT_FOUND.getBody(), CharsetUtil.UTF_8);
+                          response =
+                              new DefaultHttpResponse(
+                                  HTTP_1_1, HttpResponseStatus.valueOf(endpoint.getStatus()));
+                          response.setContent(responseContent);
                         }
                         response.headers().set(CONTENT_TYPE, "text/plain");
                         if (responseContent != null) {

instrumentation/netty/netty-4.1/testing/src/main/java/io/opentelemetry/instrumentation/netty/v4_1/AbstractNetty41ServerTest.java

@@ -10,7 +10,14 @@ import static io.netty.handler.codec.http.HttpHeaderNames.CONTENT_TYPE;
 import static io.netty.handler.codec.http.HttpResponseStatus.INTERNAL_SERVER_ERROR;
 import static io.netty.handler.codec.http.HttpVersion.HTTP_1_1;
 import static io.opentelemetry.instrumentation.testing.junit.http.HttpServerTestOptions.DEFAULT_HTTP_ATTRIBUTES;
+import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.CAPTURE_HEADERS;
+import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.ERROR;
+import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.EXCEPTION;
+import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.INDEXED_CHILD;
 import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.NOT_FOUND;
+import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.QUERY_PARAM;
+import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.REDIRECT;
+import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.SUCCESS;
 
 import com.google.common.collect.Sets;
 import io.netty.bootstrap.ServerBootstrap;
@@ -106,52 +113,43 @@ public abstract class AbstractNetty41ServerTest extends AbstractHttpServerTest<E
     private static Object handle(HttpRequest request, URI uri, ServerEndpoint endpoint) {
       ByteBuf content;
       FullHttpResponse response;
-      switch (endpoint) {
-        case SUCCESS:
-        case ERROR:
-          content = Unpooled.copiedBuffer(endpoint.getBody(), CharsetUtil.UTF_8);
-          response =
-              new DefaultFullHttpResponse(
-                  HTTP_1_1, HttpResponseStatus.valueOf(endpoint.getStatus()), content);
-          break;
-        case INDEXED_CHILD:
-          content = Unpooled.EMPTY_BUFFER;
-          endpoint.collectSpanAttributes(
-              name ->
-                  new QueryStringDecoder(uri)
-                      .parameters().get(name).stream().findFirst().orElse(""));
-          response =
-              new DefaultFullHttpResponse(
-                  HTTP_1_1, HttpResponseStatus.valueOf(endpoint.getStatus()), content);
-          break;
-        case QUERY_PARAM:
-          content = Unpooled.copiedBuffer(uri.getQuery(), CharsetUtil.UTF_8);
-          response =
-              new DefaultFullHttpResponse(
-                  HTTP_1_1, HttpResponseStatus.valueOf(endpoint.getStatus()), content);
-          break;
-        case REDIRECT:
-          content = Unpooled.EMPTY_BUFFER;
-          response =
-              new DefaultFullHttpResponse(
-                  HTTP_1_1, HttpResponseStatus.valueOf(endpoint.getStatus()), content);
-          response.headers().set(HttpHeaderNames.LOCATION, endpoint.getBody());
-          break;
-        case CAPTURE_HEADERS:
-          content = Unpooled.copiedBuffer(endpoint.getBody(), CharsetUtil.UTF_8);
-          response =
-              new DefaultFullHttpResponse(
-                  HTTP_1_1, HttpResponseStatus.valueOf(endpoint.getStatus()), content);
-          response.headers().set("X-Test-Response", request.headers().get("X-Test-Request"));
-          break;
-        case EXCEPTION:
-          throw new IllegalStateException(endpoint.getBody());
-        default:
-          content = Unpooled.copiedBuffer(NOT_FOUND.getBody(), CharsetUtil.UTF_8);
-          response =
-              new DefaultFullHttpResponse(
-                  HTTP_1_1, HttpResponseStatus.valueOf(NOT_FOUND.getStatus()), content);
-          break;
+      if (SUCCESS.equals(endpoint) || ERROR.equals(endpoint)) {
+        content = Unpooled.copiedBuffer(endpoint.getBody(), CharsetUtil.UTF_8);
+        response =
+            new DefaultFullHttpResponse(
+                HTTP_1_1, HttpResponseStatus.valueOf(endpoint.getStatus()), content);
+      } else if (INDEXED_CHILD.equals(endpoint)) {
+        content = Unpooled.EMPTY_BUFFER;
+        endpoint.collectSpanAttributes(
+            name ->
+                new QueryStringDecoder(uri).parameters().get(name).stream().findFirst().orElse(""));
+        response =
+            new DefaultFullHttpResponse(
+                HTTP_1_1, HttpResponseStatus.valueOf(endpoint.getStatus()), content);
+      } else if (QUERY_PARAM.equals(endpoint)) {
+        content = Unpooled.copiedBuffer(uri.getQuery(), CharsetUtil.UTF_8);
+        response =
+            new DefaultFullHttpResponse(
+                HTTP_1_1, HttpResponseStatus.valueOf(endpoint.getStatus()), content);
+      } else if (REDIRECT.equals(endpoint)) {
+        content = Unpooled.EMPTY_BUFFER;
+        response =
+            new DefaultFullHttpResponse(
+                HTTP_1_1, HttpResponseStatus.valueOf(endpoint.getStatus()), content);
+        response.headers().set(HttpHeaderNames.LOCATION, endpoint.getBody());
+      } else if (CAPTURE_HEADERS.equals(endpoint)) {
+        content = Unpooled.copiedBuffer(endpoint.getBody(), CharsetUtil.UTF_8);
+        response =
+            new DefaultFullHttpResponse(
+                HTTP_1_1, HttpResponseStatus.valueOf(endpoint.getStatus()), content);
+        response.headers().set("X-Test-Response", request.headers().get("X-Test-Request"));
+      } else if (EXCEPTION.equals(endpoint)) {
+        throw new IllegalStateException(endpoint.getBody());
+      } else {
+        content = Unpooled.copiedBuffer(NOT_FOUND.getBody(), CharsetUtil.UTF_8);
+        response =
+            new DefaultFullHttpResponse(
+                HTTP_1_1, HttpResponseStatus.valueOf(NOT_FOUND.getStatus()), content);
       }
       response.headers().set(CONTENT_TYPE, "text/plain");
       response.headers().set(CONTENT_LENGTH, content.readableBytes());

instrumentation/spring/spring-webflux/spring-webflux-5.0/javaagent/src/test/java/server/base/SpringWebFluxServerTest.java

@@ -6,6 +6,9 @@
 package server.base;
 
 import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.EXCEPTION;
+import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.NESTED_PATH;
+import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.NOT_FOUND;
+import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.PATH_PARAM;
 
 import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension;
 import io.opentelemetry.instrumentation.testing.junit.http.AbstractHttpServerTest;
@@ -47,16 +50,14 @@ public abstract class SpringWebFluxServerTest
 
   @Override
   public String expectedHttpRoute(ServerEndpoint endpoint) {
-    switch (endpoint) {
-      case PATH_PARAM:
-        return getContextPath() + "/path/{id}/param";
-      case NOT_FOUND:
-        return "/**";
-      case NESTED_PATH:
-        return "/nestedPath/hello/world";
-      default:
-        return super.expectedHttpRoute(endpoint);
+    if (endpoint.equals(PATH_PARAM)) {
+      return getContextPath() + "/path/{id}/param";
+    } else if (endpoint.equals(NOT_FOUND)) {
+      return "/**";
+    } else if (endpoint.equals(NESTED_PATH)) {
+      return "/nestedPath/hello/world";
     }
+    return super.expectedHttpRoute(endpoint);
   }
 
   @Override

instrumentation/tomcat/tomcat-10.0/javaagent/src/test/groovy/io/opentelemetry/javaagent/instrumentation/tomcat/v10_0/TomcatHandlerTest.groovy

@@ -17,12 +17,24 @@ import org.apache.catalina.core.StandardHost
 import org.apache.catalina.startup.Tomcat
 import org.apache.catalina.valves.ErrorReportValve
 
+import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.AUTH_ERROR
+import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.AUTH_REQUIRED
+import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.CAPTURE_HEADERS
+import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.CAPTURE_PARAMETERS
 import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.ERROR
+import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.EXCEPTION
+import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.INDEXED_CHILD
+import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.LOGIN
 import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.NOT_FOUND
+import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.PATH_PARAM
+import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.QUERY_PARAM
 import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.REDIRECT
+import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.SUCCESS
 
 class TomcatHandlerTest extends HttpServerTest<Tomcat> implements AgentTestTrait {
 
+  private static final List<ServerEndpoint> serverEndpointsList = Arrays.asList(SUCCESS, REDIRECT, ERROR, EXCEPTION, NOT_FOUND, CAPTURE_HEADERS, CAPTURE_PARAMETERS, QUERY_PARAM, PATH_PARAM, AUTH_REQUIRED, LOGIN, AUTH_ERROR, INDEXED_CHILD)
+
   def "Tomcat starts"() {
     expect:
     getServer() != null
@@ -55,7 +67,7 @@ class TomcatHandlerTest extends HttpServerTest<Tomcat> implements AgentTestTrait
     Tomcat.addServlet(ctx, "testServlet", new TestServlet())
 
     // Mapping servlet to /* will result in all requests have a name of just a context.
-    ServerEndpoint.values().toList().stream()
+    serverEndpointsList.stream()
       .filter { it != NOT_FOUND }
       .forEach {
         ctx.addServletMappingDecoded(it.path, "testServlet")

instrumentation/tomcat/tomcat-7.0/javaagent/src/test/groovy/io/opentelemetry/javaagent/instrumentation/tomcat/v7_0/TomcatHandlerTest.groovy

@@ -5,7 +5,6 @@
 
 package io.opentelemetry.javaagent.instrumentation.tomcat.v7_0
 
-
 import io.opentelemetry.instrumentation.test.AgentTestTrait
 import io.opentelemetry.instrumentation.test.asserts.TraceAssert
 import io.opentelemetry.instrumentation.test.base.HttpServerTest
@@ -17,12 +16,24 @@ import org.apache.catalina.core.StandardHost
 import org.apache.catalina.startup.Tomcat
 import org.apache.catalina.valves.ErrorReportValve
 
+import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.AUTH_ERROR
+import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.AUTH_REQUIRED
+import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.CAPTURE_HEADERS
+import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.CAPTURE_PARAMETERS
 import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.ERROR
+import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.EXCEPTION
+import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.INDEXED_CHILD
+import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.LOGIN
 import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.NOT_FOUND
+import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.PATH_PARAM
+import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.QUERY_PARAM
 import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.REDIRECT
+import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.SUCCESS
 
 class TomcatHandlerTest extends HttpServerTest<Tomcat> implements AgentTestTrait {
 
+  private static final List<ServerEndpoint> serverEndpointsList = Arrays.asList(SUCCESS, REDIRECT, ERROR, EXCEPTION, NOT_FOUND, CAPTURE_HEADERS, CAPTURE_PARAMETERS, QUERY_PARAM, PATH_PARAM, AUTH_REQUIRED, LOGIN, AUTH_ERROR, INDEXED_CHILD)
+
   def "Tomcat starts"() {
     expect:
     getServer() != null
@@ -55,7 +66,7 @@ class TomcatHandlerTest extends HttpServerTest<Tomcat> implements AgentTestTrait
     Tomcat.addServlet(ctx, "testServlet", new TestServlet())
 
     // Mapping servlet to /* will result in all requests have a name of just a context.
-    ServerEndpoint.values().toList().stream()
+    serverEndpointsList.stream()
       .filter { it != NOT_FOUND }
       .forEach {
         ctx.addServletMappingDecoded(it.path, "testServlet")

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

@@ -49,6 +49,7 @@ import java.util.Set;
 import java.util.concurrent.CountDownLatch;
 import java.util.function.Consumer;
 import java.util.function.Supplier;
+import java.util.stream.Stream;
 import javax.annotation.Nullable;
 import org.assertj.core.api.AssertAccess;
 import org.awaitility.Awaitility;
@@ -56,7 +57,7 @@ import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.EnumSource;
+import org.junit.jupiter.params.provider.MethodSource;
 import org.junit.jupiter.params.provider.ValueSource;
 
 public abstract class AbstractHttpServerTest<SERVER> extends AbstractHttpServerUsingTest<SERVER> {
@@ -159,9 +160,7 @@ public abstract class AbstractHttpServerTest<SERVER> extends AbstractHttpServerU
   }
 
   @ParameterizedTest
-  @EnumSource(
-      value = ServerEndpoint.class,
-      names = {"SUCCESS", "QUERY_PARAM"})
+  @MethodSource("provideServerEndpoints")
   void requestWithQueryString(ServerEndpoint endpoint) {
     String method = "GET";
     AggregatedHttpRequest request = request(endpoint, method);
@@ -174,6 +173,10 @@ public abstract class AbstractHttpServerTest<SERVER> extends AbstractHttpServerU
     assertTheTraces(1, null, null, spanId, method, endpoint, response);
   }
 
+  private static Stream<ServerEndpoint> provideServerEndpoints() {
+    return Stream.of(ServerEndpoint.SUCCESS, ServerEndpoint.QUERY_PARAM);
+  }
+
   @Test
   void requestWithRedirect() {
     assumeTrue(options.testRedirect);
@@ -671,13 +674,12 @@ public abstract class AbstractHttpServerTest<SERVER> extends AbstractHttpServerU
       return null;
     }
 
-    switch (endpoint) {
-      case NOT_FOUND:
-        return null;
-      case PATH_PARAM:
-        return options.contextPath + "/path/:id/param";
-      default:
-        return endpoint.resolvePath(address).getPath();
+    if (NOT_FOUND.equals(endpoint)) {
+      return null;
+    } else if (PATH_PARAM.equals(endpoint)) {
+      return options.contextPath + "/path/:id/param";
+    } else {
+      return endpoint.resolvePath(address).getPath();
     }
   }
 }

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

@@ -5,6 +5,8 @@
 
 package io.opentelemetry.instrumentation.testing.junit.http;
 
+import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.EXCEPTION;
+
 import com.google.errorprone.annotations.CanIgnoreReturnValue;
 import io.opentelemetry.api.common.AttributeKey;
 import io.opentelemetry.semconv.trace.attributes.SemanticAttributes;
@@ -31,7 +33,7 @@ public final class HttpServerTestOptions {
   Function<ServerEndpoint, String> expectedHttpRoute = unused -> null;
   Function<ServerEndpoint, String> sockPeerAddr = unused -> "127.0.0.1";
   String contextPath = "";
-  Throwable expectedException = new Exception(ServerEndpoint.EXCEPTION.getBody());
+  Throwable expectedException = new Exception(EXCEPTION.body);
 
   Predicate<ServerEndpoint> hasHandlerSpan = unused -> false;
   Predicate<ServerEndpoint> hasResponseSpan = unused -> false;

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

@@ -8,39 +8,54 @@ package io.opentelemetry.instrumentation.testing.junit.http;
 import io.opentelemetry.api.trace.Span;
 import java.net.URI;
 import java.net.URISyntaxException;
-import java.util.Arrays;
+import java.util.HashMap;
 import java.util.Map;
-import java.util.stream.Collectors;
-
-public enum ServerEndpoint {
-  SUCCESS("success", 200, "success"),
-  REDIRECT("redirect", 302, "/redirected"),
-  ERROR("error-status", 500, "controller error"), // "error" is a special path for some frameworks
-  EXCEPTION("exception", 500, "controller exception"),
-  NOT_FOUND("notFound", 404, "not found"),
-  CAPTURE_HEADERS("captureHeaders", 200, "headers captured"),
-  NESTED_PATH(
-      "nestedPath/hello/world",
-      200,
-      "nested path"), // TODO (heya) move it to webflux test module after this has been converted to
-  // a class
-  CAPTURE_PARAMETERS("captureParameters", 200, "parameters captured"),
+
+public class ServerEndpoint {
+  private static final Map<String, ServerEndpoint> PATH_MAP = new HashMap<>();
+  public static final ServerEndpoint SUCCESS =
+      new ServerEndpoint("SUCCESS", "success", 200, "success");
+  public static final ServerEndpoint REDIRECT =
+      new ServerEndpoint("REDIRECT", "redirect", 302, "/redirected");
+  public static final ServerEndpoint ERROR =
+      new ServerEndpoint(
+          "ERROR",
+          "error-status",
+          500,
+          "controller error"); // "error" is a special path for some frameworks
+  public static final ServerEndpoint EXCEPTION =
+      new ServerEndpoint("EXCEPTION", "exception", 500, "controller exception");
+  public static final ServerEndpoint NOT_FOUND =
+      new ServerEndpoint("NOT_FOUND", "notFound", 404, "not found");
+  public static final ServerEndpoint CAPTURE_HEADERS =
+      new ServerEndpoint("CAPTURE_HEADERS", "captureHeaders", 200, "headers captured");
+  // TODO (heya) move it to webflux test module after this has been converted to a class
+  public static final ServerEndpoint NESTED_PATH =
+      new ServerEndpoint("NESTED_PATH", "nestedPath/hello/world", 200, "nested path");
+  public static final ServerEndpoint CAPTURE_PARAMETERS =
+      new ServerEndpoint("CAPTURE_PARAMETERS", "captureParameters", 200, "parameters captured");
 
   // TODO: add tests for the following cases:
-  QUERY_PARAM("query?some=query", 200, "some=query"),
+  public static final ServerEndpoint QUERY_PARAM =
+      new ServerEndpoint("QUERY_PARAM", "query?some=query", 200, "some=query");
   // OkHttp never sends the fragment in the request, so these cases don't work.
   // FRAGMENT_PARAM("fragment#some-fragment", 200, "some-fragment"),
   // QUERY_FRAGMENT_PARAM("query/fragment?some=query#some-fragment", 200,
   // "some=query#some-fragment"),
-  PATH_PARAM("path/123/param", 200, "123"),
-  AUTH_REQUIRED("authRequired", 200, null),
-  LOGIN("login", 302, null),
-  AUTH_ERROR("basicsecured/endpoint", 401, null),
-  INDEXED_CHILD("child", 200, "");
+  public static final ServerEndpoint PATH_PARAM =
+      new ServerEndpoint("PATH_PARAM", "path/123/param", 200, "123");
+  public static final ServerEndpoint AUTH_REQUIRED =
+      new ServerEndpoint("AUTH_REQUIRED", "authRequired", 200, null);
+  public static final ServerEndpoint LOGIN = new ServerEndpoint("LOGIN", "login", 302, null);
+  public static final ServerEndpoint AUTH_ERROR =
+      new ServerEndpoint("AUTH_ERROR", "basicsecured/endpoint", 401, null);
+  public static final ServerEndpoint INDEXED_CHILD =
+      new ServerEndpoint("INDEXED_CHILD", "child", 200, "");
 
   public static final String ID_ATTRIBUTE_NAME = "test.request.id";
   public static final String ID_PARAMETER_NAME = "id";
 
+  private final String name;
   private final URI uriObj;
   private final String path;
   final String query;
@@ -64,13 +79,19 @@ public enum ServerEndpoint {
     return body;
   }
 
-  ServerEndpoint(String uri, int status, String body) {
+  public String name() {
+    return name;
+  }
+
+  ServerEndpoint(String name, String uri, int status, String body) {
+    this.name = name;
     this.uriObj = URI.create(uri);
     this.path = uriObj.getPath();
     this.query = uriObj.getQuery();
     this.fragment = uriObj.getFragment();
     this.status = status;
     this.body = body;
+    PATH_MAP.put(this.getPath(), this);
   }
 
   public String getPath() {
@@ -110,9 +131,6 @@ public enum ServerEndpoint {
     }
   }
 
-  private static final Map<String, ServerEndpoint> PATH_MAP =
-      Arrays.stream(values()).collect(Collectors.toMap(x -> x.getPath(), x -> x));
-
   public static ServerEndpoint forPath(String path) {
     return PATH_MAP.get(path);
   }