Migrate dd-trace-ot tests to JUnit 5

dd-trace-ot/build.gradle.kts

@@ -66,6 +66,11 @@ dependencies {
   implementation(project(":dd-trace-ot:correlation-id-injection"))
 
   testImplementation(project(":dd-java-agent:testing"))
+  testImplementation(project(":utils:junit-utils"))
+  testImplementation(libs.bundles.mockito)
+
+  add("ot31CompatibilityTestImplementation", project(":utils:junit-utils"))
+  add("ot33CompatibilityTestImplementation", project(":utils:junit-utils"))
 
   // Kotlin accessors not generated if not coming from plugin
   add("ot33CompatibilityTestImplementation", "io.opentracing:opentracing-api") {

dd-trace-ot/correlation-id-injection/build.gradle.kts

@@ -28,6 +28,7 @@ dependencies {
   testImplementation(libs.guava)
   testImplementation(project(":dd-trace-ot"))
   testImplementation(project(":dd-java-agent:testing"))
+  testImplementation(libs.bundles.mockito)
   testImplementation("org.apache.logging.log4j:log4j-core:$log4j2")
   testImplementation("ch.qos.logback:logback-core:$logback")
 }

dd-trace-ot/correlation-id-injection/src/test/java/CorrelationIdInjectorTest.java

@@ -0,0 +1,80 @@
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import datadog.opentracing.DDTracer;
+import datadog.trace.api.CorrelationIdentifier;
+import datadog.trace.api.GlobalTracer;
+import datadog.trace.test.util.DDJavaSpecification;
+import io.opentracing.Scope;
+import io.opentracing.Span;
+import org.junit.jupiter.api.Test;
+
+abstract class CorrelationIdInjectorTest extends DDJavaSpecification {
+
+  protected String logPattern =
+      "TRACE_ID=%X{"
+          + CorrelationIdentifier.getTraceIdKey()
+          + "} SPAN_ID=%X{"
+          + CorrelationIdentifier.getSpanIdKey()
+          + "} %m";
+
+  @Test
+  void testCorrelationIdInjection() throws Exception {
+    DDTracer tracer = buildTracer();
+    LogJournal journal = buildJournal();
+    TestLogger logger = buildLogger();
+
+    logger.log("Event without context");
+
+    assertEquals("TRACE_ID= SPAN_ID= Event without context", journal.nextLog());
+
+    Span rootSpan = tracer.buildSpan("operation1").start();
+    Scope rootScope = tracer.activateSpan(rootSpan);
+    logger.log("Event with root span context");
+
+    assertEquals(expectedLog("Event with root span context"), journal.nextLog());
+
+    Span childSpan = tracer.buildSpan("operation1").asChildOf(rootSpan).start();
+    Scope childScope = tracer.activateSpan(childSpan);
+    logger.log("Event with child span context");
+
+    assertEquals(expectedLog("Event with child span context"), journal.nextLog());
+
+    childScope.close();
+    childSpan.finish();
+    logger.log("Event with root span context");
+
+    assertEquals(expectedLog("Event with root span context"), journal.nextLog());
+
+    rootScope.close();
+    rootSpan.finish();
+    logger.log("Event without context");
+
+    assertEquals("TRACE_ID= SPAN_ID= Event without context", journal.nextLog());
+
+    tracer.close();
+  }
+
+  private static String expectedLog(String message) {
+    return String.format(
+        "TRACE_ID=%s SPAN_ID=%s %s",
+        CorrelationIdentifier.getTraceId(), CorrelationIdentifier.getSpanId(), message);
+  }
+
+  DDTracer buildTracer() {
+    DDTracer tracer = new DDTracer.DDTracerBuilder().build();
+    GlobalTracer.registerIfAbsent(tracer);
+    return tracer;
+  }
+
+  abstract LogJournal buildJournal();
+
+  abstract TestLogger buildLogger();
+
+  interface LogJournal {
+    String nextLog();
+  }
+
+  interface TestLogger {
+    void log(String message);
+  }
+}

dd-trace-ot/correlation-id-injection/src/test/java/Log4j2CorrelationIdInjectorTest.java

@@ -0,0 +1,70 @@
+import java.util.ArrayList;
+import java.util.List;
+import org.apache.logging.log4j.Level;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.apache.logging.log4j.core.Appender;
+import org.apache.logging.log4j.core.Filter;
+import org.apache.logging.log4j.core.LogEvent;
+import org.apache.logging.log4j.core.LoggerContext;
+import org.apache.logging.log4j.core.appender.AbstractAppender;
+import org.apache.logging.log4j.core.config.Configuration;
+import org.apache.logging.log4j.core.config.LoggerConfig;
+import org.apache.logging.log4j.core.layout.PatternLayout;
+
+class Log4j2CorrelationIdInjectorTest extends CorrelationIdInjectorTest {
+
+  @Override
+  LogJournal buildJournal() {
+    LoggerContext context = LoggerContext.getContext(false);
+    Configuration config = context.getConfiguration();
+
+    TestAppender appender =
+        new TestAppender(PatternLayout.newBuilder().withPattern(logPattern).build());
+    appender.start();
+    config.addAppender(appender);
+    updateLoggers(appender, config);
+    return appender;
+  }
+
+  @Override
+  TestLogger buildLogger() {
+    Logger logger = LogManager.getLogger("TestLogger");
+    return message -> logger.error(message);
+  }
+
+  private static void updateLoggers(Appender appender, Configuration config) {
+    Level level = null;
+    Filter filter = null;
+    for (LoggerConfig loggerConfig : config.getLoggers().values()) {
+      loggerConfig.addAppender(appender, level, filter);
+    }
+    config.getRootLogger().addAppender(appender, level, filter);
+  }
+
+  static class TestAppender extends AbstractAppender
+      implements CorrelationIdInjectorTest.LogJournal {
+    List<String> events;
+    int read;
+
+    protected TestAppender(PatternLayout patternLayout) {
+      super("TestAppender", null, patternLayout, false, null);
+      events = new ArrayList<>();
+      read = 0;
+    }
+
+    @Override
+    public void append(LogEvent event) {
+      String log = ((PatternLayout) getLayout()).toSerializable(event);
+      events.add(log);
+    }
+
+    @Override
+    public String nextLog() {
+      if (events.size() <= read) {
+        return null;
+      }
+      return events.get(read++);
+    }
+  }
+}