This fixes the Jaeger integration test and generally cleans it up (#1122)

Before, the Jaeger integration test hand-rolled docker setup which
failed on my machine, distracting from other unrelated change. When
looking at it, I noticed non standard test libraries as well. This
cleans up everything and now works as expected.

3 files changed, 198 insertions, 228 deletions

diff --git a/exporters/trace/jaeger/build.gradle b/exporters/trace/jaeger/build.gradle
index 1e005bed..78a7f42a 100644
--- a/exporters/trace/jaeger/build.gradle
+++ b/exporters/trace/jaeger/build.gradle
@@ -5,13 +5,26 @@ description = 'OpenCensus Trace Jaeger Exporter'
     it.targetCompatibility = 1.6
 }
 
+// Docker tests require JDK 8+
+sourceSets {
+    test {
+        java {
+            if (!JavaVersion.current().isJava8Compatible()) {
+                exclude '**/JaegerExporterHandlerIntegrationTest.java'
+            }
+        }
+    }
+}
+
 dependencies {
     compile project(':opencensus-api'),
             libraries.jaeger_reporter
 
-    testCompile 'org.hamcrest:hamcrest-junit:2.0.0.0'
-    testCompile 'com.google.http-client:google-http-client-gson:1.23.0'
-    testCompile project(':opencensus-api')
+    testCompile project(':opencensus-api'),
+                'org.testcontainers:testcontainers:1.7.0',
+                'com.google.http-client:google-http-client-gson:1.23.0'
+
+    // Unless linked to impl, spans will be blank and not exported during integration tests.
     testRuntime project(':opencensus-impl')
 
     signature "org.codehaus.mojo.signature:java16:+@signature"
diff --git a/exporters/trace/jaeger/src/test/java/io/opencensus/exporter/trace/jaeger/JaegerExporterHandlerIntegrationTest.java b/exporters/trace/jaeger/src/test/java/io/opencensus/exporter/trace/jaeger/JaegerExporterHandlerIntegrationTest.java
index 1ebf9327..9d492aa5 100644
--- a/exporters/trace/jaeger/src/test/java/io/opencensus/exporter/trace/jaeger/JaegerExporterHandlerIntegrationTest.java
+++ b/exporters/trace/jaeger/src/test/java/io/opencensus/exporter/trace/jaeger/JaegerExporterHandlerIntegrationTest.java
@@ -16,17 +16,11 @@
 
 package io.opencensus.exporter.trace.jaeger;
 
+import static com.google.common.truth.Truth.assertThat;
+import static com.google.common.truth.Truth.assertWithMessage;
 import static java.lang.String.format;
 import static java.lang.System.currentTimeMillis;
 import static java.util.concurrent.TimeUnit.MILLISECONDS;
-import static org.hamcrest.Matchers.greaterThanOrEqualTo;
-import static org.hamcrest.Matchers.is;
-import static org.hamcrest.Matchers.lessThanOrEqualTo;
-import static org.hamcrest.Matchers.matchesPattern;
-import static org.hamcrest.Matchers.not;
-import static org.hamcrest.Matchers.nullValue;
-import static org.junit.Assert.assertThat;
-import static org.junit.Assume.assumeThat;
 
 import com.google.api.client.http.GenericUrl;
 import com.google.api.client.http.HttpRequest;
@@ -46,219 +40,186 @@ import io.opencensus.trace.Tracer;
 import io.opencensus.trace.Tracing;
 import io.opencensus.trace.samplers.Samplers;
 import java.io.IOException;
-import java.net.ConnectException;
-import java.net.SocketException;
 import java.util.Random;
-import java.util.logging.Level;
-import java.util.logging.Logger;
+import org.junit.AfterClass;
+import org.junit.AssumptionViolatedException;
+import org.junit.Before;
+import org.junit.BeforeClass;
 import org.junit.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.testcontainers.containers.GenericContainer;
+import org.testcontainers.containers.wait.strategy.HttpWaitStrategy;
 
 public class JaegerExporterHandlerIntegrationTest {
-  private static final String JAEGER_HOST = "127.0.0.1";
-  private static final int OK = 200;
+  private static final String JAEGER_IMAGE = "jaegertracing/all-in-one:1.3";
+  private static final int JAEGER_HTTP_PORT = 16686;
+  private static final int JAEGER_HTTP_PORT_THRIFT = 14268;
   private static final String SERVICE_NAME = "test";
   private static final String SPAN_NAME = "my.org/ProcessVideo";
   private static final String START_PROCESSING_VIDEO = "Start processing video.";
   private static final String FINISHED_PROCESSING_VIDEO = "Finished processing video.";
 
   private static final Logger logger =
-      Logger.getLogger(JaegerExporterHandlerIntegrationTest.class.getName());
-  private static final Tracer tracer = Tracing.getTracer();
+      LoggerFactory.getLogger(JaegerExporterHandlerIntegrationTest.class);
 
   private HttpRequestFactory httpRequestFactory = new NetHttpTransport().createRequestFactory();
 
-  @Test(timeout = 30000)
-  public void exportToJaeger() throws InterruptedException, IOException {
-    assumeThat("docker is installed and running", isDockerInstalledAndRunning(), is(true));
-
-    final Process jaeger =
-        Runtime.getRuntime()
-            .exec(
-                "docker run --rm "
-                    + "-e COLLECTOR_ZIPKIN_HTTP_PORT=9411 -p5775:5775/udp -p6831:6831/udp "
-                    + "-p6832:6832/udp -p5778:5778 -p16686:16686 -p14268:14268 -p9411:9411 "
-                    + "jaegertracing/all-in-one:1.2.0");
-    waitForJaegerToStart(format("http://%s:16686", JAEGER_HOST));
-    final long startTimeInMillis = currentTimeMillis();
+  private static GenericContainer<?> container;
 
+  /** Starts a docker container optionally. For example, skips if Docker is unavailable. */
+  @SuppressWarnings("rawtypes")
+  @BeforeClass
+  public static void startContainer() {
     try {
-      SpanBuilder spanBuilder =
-          tracer.spanBuilder(SPAN_NAME).setRecordEvents(true).setSampler(Samplers.alwaysSample());
-      JaegerTraceExporter.createAndRegister(
-          format("http://%s:14268/api/traces", JAEGER_HOST), SERVICE_NAME);
-
-      final int spanDurationInMillis = new Random().nextInt(10) + 1;
-
-      final Scope scopedSpan = spanBuilder.startScopedSpan();
-      try {
-        tracer.getCurrentSpan().addAnnotation(START_PROCESSING_VIDEO);
-        Thread.sleep(spanDurationInMillis); // Fake work.
-        tracer.getCurrentSpan().putAttribute("foo", AttributeValue.stringAttributeValue("bar"));
-        tracer.getCurrentSpan().addAnnotation(FINISHED_PROCESSING_VIDEO);
-      } catch (Exception e) {
-        tracer.getCurrentSpan().addAnnotation("Exception thrown when processing video.");
-        tracer.getCurrentSpan().setStatus(Status.UNKNOWN);
-        logger.severe(e.getMessage());
-      } finally {
-        scopedSpan.close();
-      }
-
-      logger.info("Wait longer than the reporting duration...");
-      // Wait for a duration longer than reporting duration (5s) to ensure spans are exported.
-      long timeWaitingForSpansToBeExportedInMillis = 5100L;
-      Thread.sleep(timeWaitingForSpansToBeExportedInMillis);
-      JaegerTraceExporter.unregister();
-      final long endTimeInMillis = currentTimeMillis();
-
-      // Get traces recorded by Jaeger:
-      final HttpRequest request =
-          httpRequestFactory.buildGetRequest(
-              new GenericUrl(
-                  format(
-                      "http://%s:16686/api/traces?end=%d&limit=20&lookback=1m&maxDuration&minDuration&service=%s",
-                      JAEGER_HOST, MILLISECONDS.toMicros(currentTimeMillis()), SERVICE_NAME)));
-      final HttpResponse response = request.execute();
-      final String body = response.parseAsString();
-      assertThat("Response was: " + body, response.getStatusCode(), is(OK));
-
-      final JsonObject result = new JsonParser().parse(body).getAsJsonObject();
-      // Pretty-print for debugging purposes:
-      logger.log(Level.FINE, new GsonBuilder().setPrettyPrinting().create().toJson(result));
-
-      assertThat(result, is(not(nullValue())));
-      assertThat(result.get("total").getAsInt(), is(0));
-      assertThat(result.get("limit").getAsInt(), is(0));
-      assertThat(result.get("offset").getAsInt(), is(0));
-      assertThat(result.get("errors").getAsJsonNull(), is(JsonNull.INSTANCE));
-      final JsonArray data = result.get("data").getAsJsonArray();
-      assertThat(data, is(not(nullValue())));
-      assertThat(data.size(), is(1));
-      final JsonObject trace = data.get(0).getAsJsonObject();
-      assertThat(trace, is(not(nullValue())));
-      assertThat(trace.get("traceID").getAsString(), matchesPattern("[a-z0-9]{1,32}"));
-
-      final JsonArray spans = trace.get("spans").getAsJsonArray();
-      assertThat(spans, is(not(nullValue())));
-      assertThat(spans.size(), is(1));
-
-      final JsonObject span = spans.get(0).getAsJsonObject();
-      assertThat(span, is(not(nullValue())));
-      assertThat(span.get("traceID").getAsString(), matchesPattern("[a-z0-9]{1,32}"));
-      assertThat(span.get("spanID").getAsString(), matchesPattern("[a-z0-9]{1,16}"));
-      assertThat(span.get("flags").getAsInt(), is(1));
-      assertThat(span.get("operationName").getAsString(), is(SPAN_NAME));
-      assertThat(span.get("references").getAsJsonArray().size(), is(0));
-      assertThat(
-          span.get("startTime").getAsLong(),
-          is(greaterThanOrEqualTo(MILLISECONDS.toMicros(startTimeInMillis))));
-      assertThat(
-          span.get("startTime").getAsLong(),
-          is(lessThanOrEqualTo(MILLISECONDS.toMicros(endTimeInMillis))));
-      assertThat(
-          span.get("duration").getAsLong(),
-          is(greaterThanOrEqualTo(MILLISECONDS.toMicros(spanDurationInMillis))));
-      assertThat(
-          span.get("duration").getAsLong(),
-          is(
-              lessThanOrEqualTo(
-                  MILLISECONDS.toMicros(
-                      spanDurationInMillis + timeWaitingForSpansToBeExportedInMillis))));
-
-      final JsonArray tags = span.get("tags").getAsJsonArray();
-      assertThat(tags.size(), is(1));
-      final JsonObject tag = tags.get(0).getAsJsonObject();
-      assertThat(tag.get("key").getAsString(), is("foo"));
-      assertThat(tag.get("type").getAsString(), is("string"));
-      assertThat(tag.get("value").getAsString(), is("bar"));
+      container =
+          new GenericContainer(JAEGER_IMAGE)
+              .withExposedPorts(JAEGER_HTTP_PORT, JAEGER_HTTP_PORT_THRIFT)
+              .waitingFor(new HttpWaitStrategy());
+      container.start();
+    } catch (RuntimeException e) {
+      throw new AssumptionViolatedException("could not start docker container", e);
+    }
+  }
 
-      final JsonArray logs = span.get("logs").getAsJsonArray();
-      assertThat(logs.size(), is(2));
+  @AfterClass
+  public static void stopContainer() {
+    if (container != null) {
+      container.stop();
+    }
+  }
 
-      final JsonObject log1 = logs.get(0).getAsJsonObject();
-      final long ts1 = log1.get("timestamp").getAsLong();
-      assertThat(ts1, is(greaterThanOrEqualTo(MILLISECONDS.toMicros(startTimeInMillis))));
-      assertThat(ts1, is(lessThanOrEqualTo(MILLISECONDS.toMicros(endTimeInMillis))));
-      final JsonArray fields1 = log1.get("fields").getAsJsonArray();
-      assertThat(fields1.size(), is(1));
-      final JsonObject field1 = fields1.get(0).getAsJsonObject();
-      assertThat(field1.get("key").getAsString(), is("description"));
-      assertThat(field1.get("type").getAsString(), is("string"));
-      assertThat(field1.get("value").getAsString(), is(START_PROCESSING_VIDEO));
+  @Before
+  public void before() {
+    JaegerTraceExporter.createAndRegister(thriftTracesEndpoint(), SERVICE_NAME);
+  }
 
-      final JsonObject log2 = logs.get(1).getAsJsonObject();
-      final long ts2 = log2.get("timestamp").getAsLong();
-      assertThat(ts2, is(greaterThanOrEqualTo(MILLISECONDS.toMicros(startTimeInMillis))));
-      assertThat(ts2, is(lessThanOrEqualTo(MILLISECONDS.toMicros(endTimeInMillis))));
-      assertThat(ts2, is(greaterThanOrEqualTo(ts1)));
-      final JsonArray fields2 = log2.get("fields").getAsJsonArray();
-      assertThat(fields2.size(), is(1));
-      final JsonObject field2 = fields2.get(0).getAsJsonObject();
-      assertThat(field2.get("key").getAsString(), is("description"));
-      assertThat(field2.get("type").getAsString(), is("string"));
-      assertThat(field2.get("value").getAsString(), is(FINISHED_PROCESSING_VIDEO));
+  @Test
+  public void exportToJaeger() throws InterruptedException, IOException {
+    Tracer tracer = Tracing.getTracer();
+    final long startTimeInMillis = currentTimeMillis();
 
-      assertThat(span.get("processID").getAsString(), is("p1"));
-      assertThat(span.get("warnings").getAsJsonNull(), is(JsonNull.INSTANCE));
+    SpanBuilder spanBuilder =
+        tracer.spanBuilder(SPAN_NAME).setRecordEvents(true).setSampler(Samplers.alwaysSample());
+    int spanDurationInMillis = new Random().nextInt(10) + 1;
 
-      final JsonObject processes = trace.get("processes").getAsJsonObject();
-      assertThat(processes.size(), is(1));
-      final JsonObject p1 = processes.get("p1").getAsJsonObject();
-      assertThat(p1.get("serviceName").getAsString(), is(SERVICE_NAME));
-      assertThat(p1.get("tags").getAsJsonArray().size(), is(0));
-      assertThat(trace.get("warnings").getAsJsonNull(), is(JsonNull.INSTANCE));
+    Scope scopedSpan = spanBuilder.startScopedSpan();
+    try {
+      tracer.getCurrentSpan().addAnnotation(START_PROCESSING_VIDEO);
+      Thread.sleep(spanDurationInMillis); // Fake work.
+      tracer.getCurrentSpan().putAttribute("foo", AttributeValue.stringAttributeValue("bar"));
+      tracer.getCurrentSpan().addAnnotation(FINISHED_PROCESSING_VIDEO);
+    } catch (Exception e) {
+      tracer.getCurrentSpan().addAnnotation("Exception thrown when processing video.");
+      tracer.getCurrentSpan().setStatus(Status.UNKNOWN);
+      logger.error(e.getMessage());
     } finally {
-      jaeger.destroy();
+      scopedSpan.close();
     }
-  }
 
-  private static boolean isDockerInstalledAndRunning() {
-    final String command = "docker version";
-    try {
-      return Runtime.getRuntime().exec(command).waitFor() == 0;
-    } catch (IOException e) {
-      logger.log(
-          Level.WARNING,
-          format("Failed to run '%s' to find if docker is installed and running", command),
-          e);
-    } catch (InterruptedException e) {
-      logger.log(
-          Level.WARNING,
-          format(
-              "Interrupted '%s' while trying to find if docker is installed and running", command),
-          e);
-    }
-    return false;
+    logger.info("Wait longer than the reporting duration...");
+    // Wait for a duration longer than reporting duration (5s) to ensure spans are exported.
+    long timeWaitingForSpansToBeExportedInMillis = 5100L;
+    Thread.sleep(timeWaitingForSpansToBeExportedInMillis);
+    JaegerTraceExporter.unregister();
+    final long endTimeInMillis = currentTimeMillis();
+
+    // Get traces recorded by Jaeger:
+    HttpRequest request =
+        httpRequestFactory.buildGetRequest(new GenericUrl(tracesForServiceEndpoint(SERVICE_NAME)));
+    HttpResponse response = request.execute();
+    String body = response.parseAsString();
+    assertWithMessage("Response was: " + body).that(response.getStatusCode()).isEqualTo(200);
+
+    JsonObject result = new JsonParser().parse(body).getAsJsonObject();
+    // Pretty-print for debugging purposes:
+    logger.debug(new GsonBuilder().setPrettyPrinting().create().toJson(result));
+
+    assertThat(result).isNotNull();
+    assertThat(result.get("total").getAsInt()).isEqualTo(0);
+    assertThat(result.get("limit").getAsInt()).isEqualTo(0);
+    assertThat(result.get("offset").getAsInt()).isEqualTo(0);
+    assertThat(result.get("errors").getAsJsonNull()).isEqualTo(JsonNull.INSTANCE);
+    JsonArray data = result.get("data").getAsJsonArray();
+    assertThat(data).isNotNull();
+    assertThat(data.size()).isEqualTo(1);
+    JsonObject trace = data.get(0).getAsJsonObject();
+    assertThat(trace).isNotNull();
+    assertThat(trace.get("traceID").getAsString()).matches("[a-z0-9]{1,32}");
+
+    JsonArray spans = trace.get("spans").getAsJsonArray();
+    assertThat(spans).isNotNull();
+    assertThat(spans.size()).isEqualTo(1);
+
+    JsonObject span = spans.get(0).getAsJsonObject();
+    assertThat(span).isNotNull();
+    assertThat(span.get("traceID").getAsString()).matches("[a-z0-9]{1,32}");
+    assertThat(span.get("spanID").getAsString()).matches("[a-z0-9]{1,16}");
+    assertThat(span.get("flags").getAsInt()).isEqualTo(1);
+    assertThat(span.get("operationName").getAsString()).isEqualTo(SPAN_NAME);
+    assertThat(span.get("references").getAsJsonArray()).isEmpty();
+    assertThat(span.get("startTime").getAsLong())
+        .isAtLeast(MILLISECONDS.toMicros(startTimeInMillis));
+    assertThat(span.get("startTime").getAsLong()).isAtMost(MILLISECONDS.toMicros(endTimeInMillis));
+    assertThat(span.get("duration").getAsLong())
+        .isAtLeast(MILLISECONDS.toMicros(spanDurationInMillis));
+    assertThat(span.get("duration").getAsLong())
+        .isAtMost(
+            MILLISECONDS.toMicros(spanDurationInMillis + timeWaitingForSpansToBeExportedInMillis));
+
+    JsonArray tags = span.get("tags").getAsJsonArray();
+    assertThat(tags.size()).isEqualTo(1);
+    JsonObject tag = tags.get(0).getAsJsonObject();
+    assertThat(tag.get("key").getAsString()).isEqualTo("foo");
+    assertThat(tag.get("type").getAsString()).isEqualTo("string");
+    assertThat(tag.get("value").getAsString()).isEqualTo("bar");
+
+    JsonArray logs = span.get("logs").getAsJsonArray();
+    assertThat(logs.size()).isEqualTo(2);
+
+    JsonObject log1 = logs.get(0).getAsJsonObject();
+    long ts1 = log1.get("timestamp").getAsLong();
+    assertThat(ts1).isAtLeast(MILLISECONDS.toMicros(startTimeInMillis));
+    assertThat(ts1).isAtMost(MILLISECONDS.toMicros(endTimeInMillis));
+    JsonArray fields1 = log1.get("fields").getAsJsonArray();
+    assertThat(fields1.size()).isEqualTo(1);
+    JsonObject field1 = fields1.get(0).getAsJsonObject();
+    assertThat(field1.get("key").getAsString()).isEqualTo("description");
+    assertThat(field1.get("type").getAsString()).isEqualTo("string");
+    assertThat(field1.get("value").getAsString()).isEqualTo(START_PROCESSING_VIDEO);
+
+    JsonObject log2 = logs.get(1).getAsJsonObject();
+    long ts2 = log2.get("timestamp").getAsLong();
+    assertThat(ts2).isAtLeast(MILLISECONDS.toMicros(startTimeInMillis));
+    assertThat(ts2).isAtMost(MILLISECONDS.toMicros(endTimeInMillis));
+    assertThat(ts2).isAtLeast(ts1);
+    JsonArray fields2 = log2.get("fields").getAsJsonArray();
+    assertThat(fields2.size()).isEqualTo(1);
+    JsonObject field2 = fields2.get(0).getAsJsonObject();
+    assertThat(field2.get("key").getAsString()).isEqualTo("description");
+    assertThat(field2.get("type").getAsString()).isEqualTo("string");
+    assertThat(field2.get("value").getAsString()).isEqualTo(FINISHED_PROCESSING_VIDEO);
+
+    assertThat(span.get("processID").getAsString()).isEqualTo("p1");
+    assertThat(span.get("warnings").getAsJsonNull()).isEqualTo(JsonNull.INSTANCE);
+
+    JsonObject processes = trace.get("processes").getAsJsonObject();
+    assertThat(processes.size()).isEqualTo(1);
+    JsonObject p1 = processes.get("p1").getAsJsonObject();
+    assertThat(p1.get("serviceName").getAsString()).isEqualTo(SERVICE_NAME);
+    assertThat(p1.get("tags").getAsJsonArray().size()).isEqualTo(0);
+    assertThat(trace.get("warnings").getAsJsonNull()).isEqualTo(JsonNull.INSTANCE);
   }
 
-  private void waitForJaegerToStart(final String url) throws IOException, InterruptedException {
-    logger.log(Level.INFO, "Waiting for Jaeger to be ready...");
-    while (true) { // We rely on the test's timeout to avoid looping forever.
-      try {
-        final HttpRequest request = httpRequestFactory.buildGetRequest(new GenericUrl(url));
-        final HttpResponse response = request.execute();
-        if (response.getStatusCode() == OK) {
-          logger.log(Level.INFO, "Jaeger is now ready.");
-          return;
-        }
-      } catch (ConnectException e) {
-        logger.log(Level.INFO, "Jaeger is not yet ready, waiting a bit...");
-        Thread.sleep(10L);
-      } catch (SocketException e) {
-        if (isRetryableError(e)) {
-          // Jaeger seems to accept connections even though it is not yet ready to handle HTTP
-          // requests.
-          logger.log(Level.INFO, "Jaeger is still not yet ready, waiting a bit more...", e);
-          Thread.sleep(10L);
-        } else {
-          throw e;
-        }
-      }
-    }
+  private static String thriftTracesEndpoint() {
+    return format(
+        "http://%s:%s/api/traces",
+        container.getContainerIpAddress(), container.getMappedPort(JAEGER_HTTP_PORT_THRIFT));
   }
 
-  private static boolean isRetryableError(final SocketException e) {
-    final String message = e.getMessage();
-    return message.contains("Unexpected end of file from server")
-        || message.contains("Connection reset");
+  private static String tracesForServiceEndpoint(String service) {
+    return format(
+        "http://%s:%s/api/traces?service=%s",
+        container.getContainerIpAddress(), container.getMappedPort(JAEGER_HTTP_PORT), service);
   }
 }
diff --git a/exporters/trace/jaeger/src/test/java/io/opencensus/exporter/trace/jaeger/JaegerExporterHandlerTest.java b/exporters/trace/jaeger/src/test/java/io/opencensus/exporter/trace/jaeger/JaegerExporterHandlerTest.java
index bb1acb36..04e9a7a7 100644
--- a/exporters/trace/jaeger/src/test/java/io/opencensus/exporter/trace/jaeger/JaegerExporterHandlerTest.java
+++ b/exporters/trace/jaeger/src/test/java/io/opencensus/exporter/trace/jaeger/JaegerExporterHandlerTest.java
@@ -16,11 +16,9 @@
 
 package io.opencensus.exporter.trace.jaeger;
 
+import static com.google.common.truth.Truth.assertThat;
 import static java.util.Collections.singletonList;
 import static java.util.concurrent.TimeUnit.MILLISECONDS;
-import static org.hamcrest.Matchers.hasItems;
-import static org.hamcrest.Matchers.is;
-import static org.junit.Assert.assertThat;
 import static org.mockito.Matchers.eq;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
@@ -88,47 +86,45 @@ public class JaegerExporterHandlerTest {
     verify(mockSender).send(eq(process), captor.capture());
     List<Span> spans = captor.getValue();
 
-    assertThat(spans.size(), is(1));
+    assertThat(spans.size()).isEqualTo(1);
     Span span = spans.get(0);
 
-    assertThat(span.operationName, is("test"));
-    assertThat(span.spanId, is(256L));
-    assertThat(span.traceIdHigh, is(-72057594037927936L));
-    assertThat(span.traceIdLow, is(1L));
-    assertThat(span.parentSpanId, is(Long.MAX_VALUE));
-    assertThat(span.flags, is(1));
-    assertThat(span.startTime, is(MILLISECONDS.toMicros(startTime)));
-    assertThat(span.duration, is(MILLISECONDS.toMicros(endTime - startTime)));
-
-    assertThat(span.tags.size(), is(3));
-    assertThat(
-        span.tags,
-        hasItems(
+    assertThat(span.operationName).isEqualTo("test");
+    assertThat(span.spanId).isEqualTo(256L);
+    assertThat(span.traceIdHigh).isEqualTo(-72057594037927936L);
+    assertThat(span.traceIdLow).isEqualTo(1L);
+    assertThat(span.parentSpanId).isEqualTo(Long.MAX_VALUE);
+    assertThat(span.flags).isEqualTo(1);
+    assertThat(span.startTime).isEqualTo(MILLISECONDS.toMicros(startTime));
+    assertThat(span.duration).isEqualTo(MILLISECONDS.toMicros(endTime - startTime));
+
+    assertThat(span.tags.size()).isEqualTo(3);
+    assertThat(span.tags)
+        .containsExactly(
             new Tag("BOOL", TagType.BOOL).setVBool(false),
             new Tag("LONG", TagType.LONG).setVLong(Long.MAX_VALUE),
             new Tag("STRING", TagType.STRING)
                 .setVStr(
-                    "Judge of a man by his questions rather than by his answers. -- Voltaire")));
+                    "Judge of a man by his questions rather than by his answers. -- Voltaire"));
 
-    assertThat(span.logs.size(), is(1));
+    assertThat(span.logs.size()).isEqualTo(1);
     Log log = span.logs.get(0);
-    assertThat(log.timestamp, is(1519629872987654L));
-    assertThat(log.fields.size(), is(4));
-    assertThat(
-        log.fields,
-        hasItems(
+    assertThat(log.timestamp).isEqualTo(1519629872987654L);
+    assertThat(log.fields.size()).isEqualTo(4);
+    assertThat(log.fields)
+        .containsExactly(
             new Tag("description", TagType.STRING).setVStr("annotation #1"),
             new Tag("bool", TagType.BOOL).setVBool(true),
             new Tag("long", TagType.LONG).setVLong(1337L),
             new Tag("string", TagType.STRING)
-                .setVStr("Kind words do not cost much. Yet they accomplish much. -- Pascal")));
+                .setVStr("Kind words do not cost much. Yet they accomplish much. -- Pascal"));
 
-    assertThat(span.references.size(), is(1));
+    assertThat(span.references.size()).isEqualTo(1);
     SpanRef reference = span.references.get(0);
-    assertThat(reference.traceIdHigh, is(-1L));
-    assertThat(reference.traceIdLow, is(-256L));
-    assertThat(reference.spanId, is(512L));
-    assertThat(reference.refType, is(SpanRefType.CHILD_OF));
+    assertThat(reference.traceIdHigh).isEqualTo(-1L);
+    assertThat(reference.traceIdLow).isEqualTo(-256L);
+    assertThat(reference.spanId).isEqualTo(512L);
+    assertThat(reference.refType).isEqualTo(SpanRefType.CHILD_OF);
   }
 
   private static SpanContext sampleSpanContext() {