open-telemetry
/
opentelemetry-java
mirror of https://github.com/open-telemetry/opentelemetry-java.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Replace all assertions with AssetJ's assertThat (#2042) 

* Replace all assertions with AssetJ's assertThat

Remove uses of JUnit 4 and JUnit 5 assert* where a functional equivalent exists in AssertJ. JUnit 5's assertThrows remains.

Fixes #1994

* fixup! Replace all assertions with AssetJ's assertThat
This commit is contained in:
Marius Volkhart 2020-11-07 23:48:00 +01:00 committed by GitHub
parent 1512a53704
commit 3e31fd91aa
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
26 changed files with 329 additions and 361 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
api/src/test/java/io/opentelemetry/api/OpenTelemetryTest.java
View File

@ -7,7 +7,6 @@ package io.opentelemetry.api;
import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.assertThrows; import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import io.opentelemetry.api.metrics.BatchRecorder; import io.opentelemetry.api.metrics.BatchRecorder;
import io.opentelemetry.api.metrics.DoubleCounter; import io.opentelemetry.api.metrics.DoubleCounter;
@ -77,10 +76,12 @@ class OpenTelemetryTest {
FirstTracerProviderFactory.class, FirstTracerProviderFactory.class,
SecondTracerProviderFactory.class); SecondTracerProviderFactory.class);
try { try {
assertTrue( assertThat(
(OpenTelemetry.getGlobalTracerProvider().get("") instanceof FirstTracerProviderFactory) (OpenTelemetry.getGlobalTracerProvider().get("")
|| (OpenTelemetry.getGlobalTracerProvider().get("") instanceof FirstTracerProviderFactory)
instanceof SecondTracerProviderFactory)); || (OpenTelemetry.getGlobalTracerProvider().get("")
instanceof SecondTracerProviderFactory))
.isTrue();
} finally { } finally {
serviceFile.delete(); serviceFile.delete();
} }
@ -117,9 +118,10 @@ class OpenTelemetryTest {
FirstMeterProviderFactory.class, FirstMeterProviderFactory.class,
SecondMeterProviderFactory.class); SecondMeterProviderFactory.class);
try { try {
assertTrue( assertThat(
(OpenTelemetry.getGlobalMeterProvider() instanceof FirstMeterProviderFactory) (OpenTelemetry.getGlobalMeterProvider() instanceof FirstMeterProviderFactory)
|| (OpenTelemetry.getGlobalMeterProvider() instanceof SecondMeterProviderFactory)); || (OpenTelemetry.getGlobalMeterProvider() instanceof SecondMeterProviderFactory))
.isTrue();
assertThat(OpenTelemetry.getGlobalMeterProvider()) assertThat(OpenTelemetry.getGlobalMeterProvider())
.isEqualTo(OpenTelemetry.getGlobalMeterProvider()); .isEqualTo(OpenTelemetry.getGlobalMeterProvider());
} finally { } finally {

12
exporters/jaeger-thrift/src/test/java/io/opentelemetry/exporter/jaeger/thrift/AdapterTest.java
View File

@ -15,8 +15,6 @@ import static io.opentelemetry.api.common.AttributeKey.stringArrayKey;
import static io.opentelemetry.api.common.AttributeKey.stringKey; import static io.opentelemetry.api.common.AttributeKey.stringKey;
import static java.util.concurrent.TimeUnit.MILLISECONDS; import static java.util.concurrent.TimeUnit.MILLISECONDS;
import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import io.jaegertracing.thriftjava.Log; import io.jaegertracing.thriftjava.Log;
import io.jaegertracing.thriftjava.SpanRef; import io.jaegertracing.thriftjava.SpanRef;
@ -64,7 +62,7 @@ class AdapterTest {
List<io.jaegertracing.thriftjava.Span> jaegerSpans = Adapter.toJaeger(spans); List<io.jaegertracing.thriftjava.Span> jaegerSpans = Adapter.toJaeger(spans);
// the span contents are checked somewhere else // the span contents are checked somewhere else
assertEquals(1, jaegerSpans.size()); assertThat(jaegerSpans).hasSize(1);
} }
@Test @Test
@ -114,7 +112,7 @@ class AdapterTest {
Collection<Log> logs = Adapter.toJaegerLogs(Collections.singletonList(eventsData)); Collection<Log> logs = Adapter.toJaegerLogs(Collections.singletonList(eventsData));
// verify // verify
assertEquals(1, logs.size()); assertThat(logs).hasSize(1);
} }
@Test @Test
@ -126,7 +124,7 @@ class AdapterTest {
Log log = Adapter.toJaegerLog(event); Log log = Adapter.toJaegerLog(event);
// verify // verify
assertEquals(2, log.getFieldsSize()); assertThat(log.getFieldsSize()).isEqualTo(2);
assertThat(getValue(log.getFields(), Adapter.KEY_LOG_EVENT).getVStr()) assertThat(getValue(log.getFields(), Adapter.KEY_LOG_EVENT).getVStr())
.isEqualTo("the log message"); .isEqualTo("the log message");
@ -180,7 +178,7 @@ class AdapterTest {
Collection<SpanRef> spanRefs = Adapter.toSpanRefs(Collections.singletonList(link)); Collection<SpanRef> spanRefs = Adapter.toSpanRefs(Collections.singletonList(link));
// verify // verify
assertEquals(1, spanRefs.size()); // the actual span ref is tested in another test assertThat(spanRefs).hasSize(1); // the actual span ref is tested in another test
} }
@Test @Test
@ -216,7 +214,7 @@ class AdapterTest {
.setTotalRecordedLinks(0) .setTotalRecordedLinks(0)
.build(); .build();
assertNotNull(Adapter.toJaeger(span)); assertThat(Adapter.toJaeger(span)).isNotNull();
} }
@Test @Test

136
exporters/jaeger/src/test/java/io/opentelemetry/exporter/jaeger/AdapterTest.java
View File

@ -13,10 +13,7 @@ import static io.opentelemetry.api.common.AttributeKey.longArrayKey;
import static io.opentelemetry.api.common.AttributeKey.longKey; import static io.opentelemetry.api.common.AttributeKey.longKey;
import static io.opentelemetry.api.common.AttributeKey.stringArrayKey; import static io.opentelemetry.api.common.AttributeKey.stringArrayKey;
import static io.opentelemetry.api.common.AttributeKey.stringKey; import static io.opentelemetry.api.common.AttributeKey.stringKey;
import static org.junit.jupiter.api.Assertions.assertEquals; import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import com.google.protobuf.util.Durations; import com.google.protobuf.util.Durations;
import com.google.protobuf.util.Timestamps; import com.google.protobuf.util.Timestamps;
@ -62,7 +59,7 @@ class AdapterTest {
Collection<Model.Span> jaegerSpans = Adapter.toJaeger(spans); Collection<Model.Span> jaegerSpans = Adapter.toJaeger(spans);
// the span contents are checked somewhere else // the span contents are checked somewhere else
assertEquals(1, jaegerSpans.size()); assertThat(jaegerSpans).hasSize(1);
} }
@Test @Test
@ -75,34 +72,35 @@ class AdapterTest {
// test // test
Model.Span jaegerSpan = Adapter.toJaeger(span); Model.Span jaegerSpan = Adapter.toJaeger(span);
assertEquals(TraceProtoUtils.toProtoTraceId(span.getTraceId()), jaegerSpan.getTraceId()); assertThat(jaegerSpan.getTraceId())
assertEquals(TraceProtoUtils.toProtoSpanId(span.getSpanId()), jaegerSpan.getSpanId()); .isEqualTo(TraceProtoUtils.toProtoTraceId(span.getTraceId()));
assertEquals("GET /api/endpoint", jaegerSpan.getOperationName()); assertThat(jaegerSpan.getSpanId()).isEqualTo(TraceProtoUtils.toProtoSpanId(span.getSpanId()));
assertEquals(Timestamps.fromMillis(startMs), jaegerSpan.getStartTime()); assertThat(jaegerSpan.getOperationName()).isEqualTo("GET /api/endpoint");
assertEquals(duration, Durations.toMillis(jaegerSpan.getDuration())); assertThat(jaegerSpan.getStartTime()).isEqualTo(Timestamps.fromMillis(startMs));
assertThat(Durations.toMillis(jaegerSpan.getDuration())).isEqualTo(duration);
assertEquals(5, jaegerSpan.getTagsCount()); assertThat(jaegerSpan.getTagsCount()).isEqualTo(5);
Model.KeyValue keyValue = getValue(jaegerSpan.getTagsList(), Adapter.KEY_SPAN_KIND); Model.KeyValue keyValue = getValue(jaegerSpan.getTagsList(), Adapter.KEY_SPAN_KIND);
assertNotNull(keyValue); assertThat(keyValue).isNotNull();
assertEquals("server", keyValue.getVStr()); assertThat(keyValue.getVStr()).isEqualTo("server");
keyValue = getValue(jaegerSpan.getTagsList(), Adapter.KEY_SPAN_STATUS_CODE); keyValue = getValue(jaegerSpan.getTagsList(), Adapter.KEY_SPAN_STATUS_CODE);
assertNotNull(keyValue); assertThat(keyValue).isNotNull();
assertEquals(0, keyValue.getVInt64()); assertThat(keyValue.getVInt64()).isEqualTo(0);
assertEquals(Model.ValueType.INT64, keyValue.getVType()); assertThat(keyValue.getVType()).isEqualTo(Model.ValueType.INT64);
keyValue = getValue(jaegerSpan.getTagsList(), Adapter.KEY_SPAN_STATUS_MESSAGE); keyValue = getValue(jaegerSpan.getTagsList(), Adapter.KEY_SPAN_STATUS_MESSAGE);
assertNotNull(keyValue); assertThat(keyValue).isNotNull();
assertEquals("", keyValue.getVStr()); assertThat(keyValue.getVStr()).isEmpty();
assertEquals(1, jaegerSpan.getLogsCount()); assertThat(jaegerSpan.getLogsCount()).isEqualTo(1);
Model.Log log = jaegerSpan.getLogs(0); Model.Log log = jaegerSpan.getLogs(0);
keyValue = getValue(log.getFieldsList(), Adapter.KEY_LOG_EVENT); keyValue = getValue(log.getFieldsList(), Adapter.KEY_LOG_EVENT);
assertNotNull(keyValue); assertThat(keyValue).isNotNull();
assertEquals("the log message", keyValue.getVStr()); assertThat(keyValue.getVStr()).isEqualTo("the log message");
keyValue = getValue(log.getFieldsList(), "foo"); keyValue = getValue(log.getFieldsList(), "foo");
assertNotNull(keyValue); assertThat(keyValue).isNotNull();
assertEquals("bar", keyValue.getVStr()); assertThat(keyValue.getVStr()).isEqualTo("bar");
assertEquals(2, jaegerSpan.getReferencesCount()); assertThat(jaegerSpan.getReferencesCount()).isEqualTo(2);
assertHasFollowsFrom(jaegerSpan); assertHasFollowsFrom(jaegerSpan);
assertHasParent(jaegerSpan); assertHasParent(jaegerSpan);
@ -117,7 +115,7 @@ class AdapterTest {
Collection<Model.Log> logs = Adapter.toJaegerLogs(Collections.singletonList(eventsData)); Collection<Model.Log> logs = Adapter.toJaegerLogs(Collections.singletonList(eventsData));
// verify // verify
assertEquals(1, logs.size()); assertThat(logs).hasSize(1);
} }
@Test @Test
@ -129,23 +127,23 @@ class AdapterTest {
Model.Log log = Adapter.toJaegerLog(event); Model.Log log = Adapter.toJaegerLog(event);
// verify // verify
assertEquals(2, log.getFieldsCount()); assertThat(log.getFieldsCount()).isEqualTo(2);
Model.KeyValue keyValue = getValue(log.getFieldsList(), Adapter.KEY_LOG_EVENT); Model.KeyValue keyValue = getValue(log.getFieldsList(), Adapter.KEY_LOG_EVENT);
assertNotNull(keyValue); assertThat(keyValue).isNotNull();
assertEquals("the log message", keyValue.getVStr()); assertThat(keyValue.getVStr()).isEqualTo("the log message");
keyValue = getValue(log.getFieldsList(), "foo"); keyValue = getValue(log.getFieldsList(), "foo");
assertNotNull(keyValue); assertThat(keyValue).isNotNull();
assertEquals("bar", keyValue.getVStr()); assertThat(keyValue.getVStr()).isEqualTo("bar");
keyValue = getValue(log.getFieldsList(), Adapter.KEY_EVENT_DROPPED_ATTRIBUTES_COUNT); keyValue = getValue(log.getFieldsList(), Adapter.KEY_EVENT_DROPPED_ATTRIBUTES_COUNT);
assertNull(keyValue); assertThat(keyValue).isNull();
// verify dropped_attributes_count // verify dropped_attributes_count
event = getTimedEvent(3); event = getTimedEvent(3);
log = Adapter.toJaegerLog(event); log = Adapter.toJaegerLog(event);
keyValue = getValue(log.getFieldsList(), Adapter.KEY_EVENT_DROPPED_ATTRIBUTES_COUNT); keyValue = getValue(log.getFieldsList(), Adapter.KEY_EVENT_DROPPED_ATTRIBUTES_COUNT);
assertNotNull(keyValue); assertThat(keyValue).isNotNull();
assertEquals(2, keyValue.getVInt64()); assertThat(keyValue.getVInt64()).isEqualTo(2);
} }
@Test @Test
@ -165,27 +163,27 @@ class AdapterTest {
Adapter.toKeyValue(stringArrayKey("valueArrayS"), Arrays.asList("foobar", "barfoo")); Adapter.toKeyValue(stringArrayKey("valueArrayS"), Arrays.asList("foobar", "barfoo"));
// verify // verify
assertTrue(kvB.getVBool()); assertThat(kvB.getVBool()).isTrue();
assertEquals(Model.ValueType.BOOL, kvB.getVType()); assertThat(kvB.getVType()).isEqualTo(Model.ValueType.BOOL);
assertEquals(1., kvD.getVFloat64(), 0); assertThat(kvD.getVFloat64()).isEqualTo(1.);
assertEquals(Model.ValueType.FLOAT64, kvD.getVType()); assertThat(kvD.getVType()).isEqualTo(Model.ValueType.FLOAT64);
assertEquals(2, kvI.getVInt64()); assertThat(kvI.getVInt64()).isEqualTo(2);
assertEquals(Model.ValueType.INT64, kvI.getVType()); assertThat(kvI.getVType()).isEqualTo(Model.ValueType.INT64);
assertEquals("foobar", kvS.getVStr()); assertThat(kvS.getVStr()).isEqualTo("foobar");
assertEquals("foobar", kvS.getVStrBytes().toStringUtf8()); assertThat(kvS.getVStrBytes().toStringUtf8()).isEqualTo("foobar");
assertEquals(Model.ValueType.STRING, kvS.getVType()); assertThat(kvS.getVType()).isEqualTo(Model.ValueType.STRING);
assertEquals("[true,false]", kvArrayB.getVStr()); assertThat(kvArrayB.getVStr()).isEqualTo("[true,false]");
assertEquals("[true,false]", kvArrayB.getVStrBytes().toStringUtf8()); assertThat(kvArrayB.getVStrBytes().toStringUtf8()).isEqualTo("[true,false]");
assertEquals(Model.ValueType.STRING, kvArrayB.getVType()); assertThat(kvArrayB.getVType()).isEqualTo(Model.ValueType.STRING);
assertEquals("[1.2345,6.789]", kvArrayD.getVStr()); assertThat(kvArrayD.getVStr()).isEqualTo("[1.2345,6.789]");
assertEquals("[1.2345,6.789]", kvArrayD.getVStrBytes().toStringUtf8()); assertThat(kvArrayD.getVStrBytes().toStringUtf8()).isEqualTo("[1.2345,6.789]");
assertEquals(Model.ValueType.STRING, kvArrayD.getVType()); assertThat(kvArrayD.getVType()).isEqualTo(Model.ValueType.STRING);
assertEquals("[12345,67890]", kvArrayI.getVStr()); assertThat(kvArrayI.getVStr()).isEqualTo("[12345,67890]");
assertEquals("[12345,67890]", kvArrayI.getVStrBytes().toStringUtf8()); assertThat(kvArrayI.getVStrBytes().toStringUtf8()).isEqualTo("[12345,67890]");
assertEquals(Model.ValueType.STRING, kvArrayI.getVType()); assertThat(kvArrayI.getVType()).isEqualTo(Model.ValueType.STRING);
assertEquals("[\"foobar\",\"barfoo\"]", kvArrayS.getVStr()); assertThat(kvArrayS.getVStr()).isEqualTo("[\"foobar\",\"barfoo\"]");
assertEquals("[\"foobar\",\"barfoo\"]", kvArrayS.getVStrBytes().toStringUtf8()); assertThat(kvArrayS.getVStrBytes().toStringUtf8()).isEqualTo("[\"foobar\",\"barfoo\"]");
assertEquals(Model.ValueType.STRING, kvArrayS.getVType()); assertThat(kvArrayS.getVType()).isEqualTo(Model.ValueType.STRING);
} }
@Test @Test
@ -198,7 +196,7 @@ class AdapterTest {
Collection<Model.SpanRef> spanRefs = Adapter.toSpanRefs(Collections.singletonList(link)); Collection<Model.SpanRef> spanRefs = Adapter.toSpanRefs(Collections.singletonList(link));
// verify // verify
assertEquals(1, spanRefs.size()); // the actual span ref is tested in another test assertThat(spanRefs).hasSize(1); // the actual span ref is tested in another test
} }
@Test @Test
@ -210,9 +208,9 @@ class AdapterTest {
Model.SpanRef spanRef = Adapter.toSpanRef(link); Model.SpanRef spanRef = Adapter.toSpanRef(link);
// verify // verify
assertEquals(TraceProtoUtils.toProtoSpanId(SPAN_ID), spanRef.getSpanId()); assertThat(spanRef.getSpanId()).isEqualTo(TraceProtoUtils.toProtoSpanId(SPAN_ID));
assertEquals(TraceProtoUtils.toProtoTraceId(TRACE_ID), spanRef.getTraceId()); assertThat(spanRef.getTraceId()).isEqualTo(TraceProtoUtils.toProtoTraceId(TRACE_ID));
assertEquals(Model.SpanRefType.FOLLOWS_FROM, spanRef.getRefType()); assertThat(spanRef.getRefType()).isEqualTo(Model.SpanRefType.FOLLOWS_FROM);
} }
@Test @Test
@ -233,7 +231,7 @@ class AdapterTest {
.setTotalRecordedLinks(0) .setTotalRecordedLinks(0)
.build(); .build();
assertNotNull(Adapter.toJaeger(span)); assertThat(Adapter.toJaeger(span)).isNotNull();
} }
@Test @Test
@ -263,11 +261,11 @@ class AdapterTest {
Model.Span jaegerSpan = Adapter.toJaeger(span); Model.Span jaegerSpan = Adapter.toJaeger(span);
Model.KeyValue errorType = getValue(jaegerSpan.getTagsList(), "error.type"); Model.KeyValue errorType = getValue(jaegerSpan.getTagsList(), "error.type");
assertNotNull(errorType); assertThat(errorType).isNotNull();
assertEquals(this.getClass().getName(), errorType.getVStr()); assertThat(errorType.getVStr()).isEqualTo(this.getClass().getName());
Model.KeyValue error = getValue(jaegerSpan.getTagsList(), "error"); Model.KeyValue error = getValue(jaegerSpan.getTagsList(), "error");
assertNotNull(error); assertThat(error).isNotNull();
assertTrue(error.getVBool()); assertThat(error.getVBool()).isTrue();
} }
private static Event getTimedEvent() { private static Event getTimedEvent() {
@ -326,23 +324,23 @@ class AdapterTest {
boolean found = false; boolean found = false;
for (Model.SpanRef spanRef : jaegerSpan.getReferencesList()) { for (Model.SpanRef spanRef : jaegerSpan.getReferencesList()) {
if (Model.SpanRefType.FOLLOWS_FROM.equals(spanRef.getRefType())) { if (Model.SpanRefType.FOLLOWS_FROM.equals(spanRef.getRefType())) {
assertEquals(TraceProtoUtils.toProtoTraceId(LINK_TRACE_ID), spanRef.getTraceId()); assertThat(spanRef.getTraceId()).isEqualTo(TraceProtoUtils.toProtoTraceId(LINK_TRACE_ID));
assertEquals(TraceProtoUtils.toProtoSpanId(LINK_SPAN_ID), spanRef.getSpanId()); assertThat(spanRef.getSpanId()).isEqualTo(TraceProtoUtils.toProtoSpanId(LINK_SPAN_ID));
found = true; found = true;
} }
} }
assertTrue(found, "Should have found the follows-from reference"); assertThat(found).withFailMessage("Should have found the follows-from reference").isTrue();
} }
private static void assertHasParent(Model.Span jaegerSpan) { private static void assertHasParent(Model.Span jaegerSpan) {
boolean found = false; boolean found = false;
for (Model.SpanRef spanRef : jaegerSpan.getReferencesList()) { for (Model.SpanRef spanRef : jaegerSpan.getReferencesList()) {
if (Model.SpanRefType.CHILD_OF.equals(spanRef.getRefType())) { if (Model.SpanRefType.CHILD_OF.equals(spanRef.getRefType())) {
assertEquals(TraceProtoUtils.toProtoTraceId(TRACE_ID), spanRef.getTraceId()); assertThat(spanRef.getTraceId()).isEqualTo(TraceProtoUtils.toProtoTraceId(TRACE_ID));
assertEquals(TraceProtoUtils.toProtoSpanId(PARENT_SPAN_ID), spanRef.getSpanId()); assertThat(spanRef.getSpanId()).isEqualTo(TraceProtoUtils.toProtoSpanId(PARENT_SPAN_ID));
found = true; found = true;
} }
} }
assertTrue(found, "Should have found the parent reference"); assertThat(found).withFailMessage("Should have found the parent reference").isTrue();
} }
} }

91
exporters/jaeger/src/test/java/io/opentelemetry/exporter/jaeger/JaegerGrpcSpanExporterTest.java
View File

@ -6,8 +6,6 @@
package io.opentelemetry.exporter.jaeger; package io.opentelemetry.exporter.jaeger;
import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.jupiter.api.Assertions.fail; import static org.junit.jupiter.api.Assertions.fail;
import static org.mockito.AdditionalAnswers.delegatesTo; import static org.mockito.AdditionalAnswers.delegatesTo;
import static org.mockito.Mockito.mock; import static org.mockito.Mockito.mock;
@ -120,14 +118,14 @@ class JaegerGrpcSpanExporterTest {
verify(service).postSpans(requestCaptor.capture(), ArgumentMatchers.any()); verify(service).postSpans(requestCaptor.capture(), ArgumentMatchers.any());
Model.Batch batch = requestCaptor.getValue().getBatch(); Model.Batch batch = requestCaptor.getValue().getBatch();
assertEquals("GET /api/endpoint", batch.getSpans(0).getOperationName()); assertThat(batch.getSpans(0).getOperationName()).isEqualTo("GET /api/endpoint");
assertEquals(TraceProtoUtils.toProtoSpanId(SPAN_ID), batch.getSpans(0).getSpanId()); assertThat(batch.getSpans(0).getSpanId()).isEqualTo(TraceProtoUtils.toProtoSpanId(SPAN_ID));
assertEquals( assertThat(
"resource-attr-value", getTagValue(batch.getProcess().getTagsList(), "resource-attr-key")
getTagValue(batch.getProcess().getTagsList(), "resource-attr-key") .orElseThrow(() -> new AssertionError("resource-attr-key not found"))
.orElseThrow(() -> new AssertionError("resource-attr-key not found")) .getVStr())
.getVStr()); .isEqualTo("resource-attr-value");
verifyBatch(batch); verifyBatch(batch);
} }
@ -188,7 +186,7 @@ class JaegerGrpcSpanExporterTest {
verify(service, times(2)).postSpans(requestCaptor.capture(), ArgumentMatchers.any()); verify(service, times(2)).postSpans(requestCaptor.capture(), ArgumentMatchers.any());
List<Collector.PostSpansRequest> requests = requestCaptor.getAllValues(); List<Collector.PostSpansRequest> requests = requestCaptor.getAllValues();
assertEquals(2, requests.size()); assertThat(requests).hasSize(2);
for (Collector.PostSpansRequest request : requests) { for (Collector.PostSpansRequest request : requests) {
Model.Batch batch = request.getBatch(); Model.Batch batch = request.getBatch();
@ -199,14 +197,15 @@ class JaegerGrpcSpanExporterTest {
Optional<Model.KeyValue> processTag2 = Optional<Model.KeyValue> processTag2 =
getTagValue(batch.getProcess().getTagsList(), "resource-attr-key-2"); getTagValue(batch.getProcess().getTagsList(), "resource-attr-key-2");
if (processTag.isPresent()) { if (processTag.isPresent()) {
assertFalse(processTag2.isPresent()); assertThat(processTag2.isPresent()).isFalse();
assertEquals("GET /api/endpoint/1", batch.getSpans(0).getOperationName()); assertThat(batch.getSpans(0).getOperationName()).isEqualTo("GET /api/endpoint/1");
assertEquals(TraceProtoUtils.toProtoSpanId(SPAN_ID), batch.getSpans(0).getSpanId()); assertThat(batch.getSpans(0).getSpanId()).isEqualTo(TraceProtoUtils.toProtoSpanId(SPAN_ID));
assertEquals("resource-attr-value-1", processTag.get().getVStr()); assertThat(processTag.get().getVStr()).isEqualTo("resource-attr-value-1");
} else if (processTag2.isPresent()) { } else if (processTag2.isPresent()) {
assertEquals("GET /api/endpoint/2", batch.getSpans(0).getOperationName()); assertThat(batch.getSpans(0).getOperationName()).isEqualTo("GET /api/endpoint/2");
assertEquals(TraceProtoUtils.toProtoSpanId(SPAN_ID_2), batch.getSpans(0).getSpanId()); assertThat(batch.getSpans(0).getSpanId())
assertEquals("resource-attr-value-2", processTag2.get().getVStr()); .isEqualTo(TraceProtoUtils.toProtoSpanId(SPAN_ID_2));
assertThat(processTag2.get().getVStr()).isEqualTo("resource-attr-value-2");
} else { } else {
fail("No process tag resource-attr-key-1 or resource-attr-key-2"); fail("No process tag resource-attr-key-1 or resource-attr-key-2");
} }
@ -214,40 +213,40 @@ class JaegerGrpcSpanExporterTest {
} }
private static void verifyBatch(Model.Batch batch) throws Exception { private static void verifyBatch(Model.Batch batch) throws Exception {
assertEquals(1, batch.getSpansCount()); assertThat(batch.getSpansCount()).isEqualTo(1);
assertEquals(TraceProtoUtils.toProtoTraceId(TRACE_ID), batch.getSpans(0).getTraceId()); assertThat(batch.getSpans(0).getTraceId()).isEqualTo(TraceProtoUtils.toProtoTraceId(TRACE_ID));
assertEquals("test", batch.getProcess().getServiceName()); assertThat(batch.getProcess().getServiceName()).isEqualTo("test");
assertEquals(4, batch.getProcess().getTagsCount()); assertThat(batch.getProcess().getTagsCount()).isEqualTo(4);
assertEquals( assertThat(
"io.opentelemetry.auto", getSpanTagValue(batch.getSpans(0), "otel.library.name")
getSpanTagValue(batch.getSpans(0), "otel.library.name") .orElseThrow(() -> new AssertionError("otel.library.name not found"))
.orElseThrow(() -> new AssertionError("otel.library.name not found")) .getVStr())
.getVStr()); .isEqualTo("io.opentelemetry.auto");
assertEquals( assertThat(
"1.0.0", getSpanTagValue(batch.getSpans(0), "otel.library.version")
getSpanTagValue(batch.getSpans(0), "otel.library.version") .orElseThrow(() -> new AssertionError("otel.library.version not found"))
.orElseThrow(() -> new AssertionError("otel.library.version not found")) .getVStr())
.getVStr()); .isEqualTo("1.0.0");
assertEquals( assertThat(
InetAddress.getLocalHost().getHostAddress(), getTagValue(batch.getProcess().getTagsList(), "ip")
getTagValue(batch.getProcess().getTagsList(), "ip") .orElseThrow(() -> new AssertionError("ip not found"))
.orElseThrow(() -> new AssertionError("ip not found")) .getVStr())
.getVStr()); .isEqualTo(InetAddress.getLocalHost().getHostAddress());
assertEquals( assertThat(
InetAddress.getLocalHost().getHostName(), getTagValue(batch.getProcess().getTagsList(), "hostname")
getTagValue(batch.getProcess().getTagsList(), "hostname") .orElseThrow(() -> new AssertionError("hostname not found"))
.orElseThrow(() -> new AssertionError("hostname not found")) .getVStr())
.getVStr()); .isEqualTo(InetAddress.getLocalHost().getHostName());
assertEquals( assertThat(
"opentelemetry-java", getTagValue(batch.getProcess().getTagsList(), "jaeger.version")
getTagValue(batch.getProcess().getTagsList(), "jaeger.version") .orElseThrow(() -> new AssertionError("jaeger.version not found"))
.orElseThrow(() -> new AssertionError("jaeger.version not found")) .getVStr())
.getVStr()); .isEqualTo("opentelemetry-java");
} }
private static Optional<Model.KeyValue> getSpanTagValue(Model.Span span, String tagKey) { private static Optional<Model.KeyValue> getSpanTagValue(Model.Span span, String tagKey) {

6
opentracing-shim/src/test/java/io/opentelemetry/opentracingshim/OpenTracingShimTest.java
View File

@ -5,7 +5,7 @@
package io.opentelemetry.opentracingshim; package io.opentelemetry.opentracingshim;
import static org.junit.jupiter.api.Assertions.assertEquals; import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock; import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when; import static org.mockito.Mockito.when;
@ -19,7 +19,7 @@ class OpenTracingShimTest {
@Test @Test
void createTracerShim_default() { void createTracerShim_default() {
TracerShim tracerShim = (TracerShim) OpenTracingShim.createTracerShim(); TracerShim tracerShim = (TracerShim) OpenTracingShim.createTracerShim();
assertEquals(OpenTelemetry.getGlobalTracer("opentracingshim"), tracerShim.tracer()); assertThat(tracerShim.tracer()).isEqualTo(OpenTelemetry.getGlobalTracer("opentracingshim"));
} }
@Test @Test
@ -30,6 +30,6 @@ class OpenTracingShimTest {
when(openTelemetry.getPropagators()).thenReturn(mock(ContextPropagators.class)); when(openTelemetry.getPropagators()).thenReturn(mock(ContextPropagators.class));
TracerShim tracerShim = (TracerShim) OpenTracingShim.createTracerShim(openTelemetry); TracerShim tracerShim = (TracerShim) OpenTracingShim.createTracerShim(openTelemetry);
assertEquals(sdk.get("opentracingshim"), tracerShim.tracer()); assertThat(tracerShim.tracer()).isEqualTo(sdk.get("opentracingshim"));
} }
} }

19
opentracing-shim/src/test/java/io/opentelemetry/opentracingshim/SpanBuilderShimTest.java
View File

@ -6,8 +6,7 @@
package io.opentelemetry.opentracingshim; package io.opentelemetry.opentracingshim;
import static io.opentelemetry.opentracingshim.TestUtils.getBaggageMap; import static io.opentelemetry.opentracingshim.TestUtils.getBaggageMap;
import static org.junit.jupiter.api.Assertions.assertEquals; import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.assertFalse;
import io.opentelemetry.api.OpenTelemetry; import io.opentelemetry.api.OpenTelemetry;
import io.opentelemetry.api.trace.Tracer; import io.opentelemetry.api.trace.Tracer;
@ -32,10 +31,9 @@ class SpanBuilderShimTest {
SpanShim childSpan = SpanShim childSpan =
(SpanShim) new SpanBuilderShim(telemetryInfo, SPAN_NAME).asChildOf(parentSpan).start(); (SpanShim) new SpanBuilderShim(telemetryInfo, SPAN_NAME).asChildOf(parentSpan).start();
try { try {
assertEquals(childSpan.getBaggageItem("key1"), "value1"); assertThat("value1").isEqualTo(childSpan.getBaggageItem("key1"));
assertEquals( assertThat(getBaggageMap(parentSpan.context().baggageItems()))
getBaggageMap(childSpan.context().baggageItems()), .isEqualTo(getBaggageMap(childSpan.context().baggageItems()));
getBaggageMap(parentSpan.context().baggageItems()));
} finally { } finally {
childSpan.finish(); childSpan.finish();
} }
@ -54,10 +52,9 @@ class SpanBuilderShimTest {
(SpanShim) (SpanShim)
new SpanBuilderShim(telemetryInfo, SPAN_NAME).asChildOf(parentSpan.context()).start(); new SpanBuilderShim(telemetryInfo, SPAN_NAME).asChildOf(parentSpan.context()).start();
try { try {
assertEquals(childSpan.getBaggageItem("key1"), "value1"); assertThat("value1").isEqualTo(childSpan.getBaggageItem("key1"));
assertEquals( assertThat(getBaggageMap(parentSpan.context().baggageItems()))
getBaggageMap(childSpan.context().baggageItems()), .isEqualTo(getBaggageMap(childSpan.context().baggageItems()));
getBaggageMap(parentSpan.context().baggageItems()));
} finally { } finally {
childSpan.finish(); childSpan.finish();
} }
@ -75,7 +72,7 @@ class SpanBuilderShimTest {
SpanShim childSpan = SpanShim childSpan =
(SpanShim) new SpanBuilderShim(telemetryInfo, SPAN_NAME).asChildOf(parentSpan).start(); (SpanShim) new SpanBuilderShim(telemetryInfo, SPAN_NAME).asChildOf(parentSpan).start();
try { try {
assertFalse(childSpan.context().baggageItems().iterator().hasNext()); assertThat(childSpan.context().baggageItems().iterator().hasNext()).isFalse();
} finally { } finally {
childSpan.finish(); childSpan.finish();
} }

45
opentracing-shim/src/test/java/io/opentelemetry/opentracingshim/SpanShimTest.java
View File

@ -6,11 +6,7 @@
package io.opentelemetry.opentracingshim; package io.opentelemetry.opentracingshim;
import static io.opentelemetry.opentracingshim.TestUtils.getBaggageMap; import static io.opentelemetry.opentracingshim.TestUtils.getBaggageMap;
import static org.junit.jupiter.api.Assertions.assertEquals; import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import io.opentelemetry.api.OpenTelemetry; import io.opentelemetry.api.OpenTelemetry;
import io.opentelemetry.api.trace.Span; import io.opentelemetry.api.trace.Span;
@ -46,11 +42,13 @@ class SpanShimTest {
SpanShim spanShim = new SpanShim(telemetryInfo, span); SpanShim spanShim = new SpanShim(telemetryInfo, span);
SpanContextShim contextShim = (SpanContextShim) spanShim.context(); SpanContextShim contextShim = (SpanContextShim) spanShim.context();
assertNotNull(contextShim); assertThat(contextShim).isNotNull();
assertEquals(contextShim.getSpanContext(), span.getSpanContext()); assertThat(span.getSpanContext()).isEqualTo(contextShim.getSpanContext());
assertEquals(contextShim.toTraceId(), span.getSpanContext().getTraceIdAsHexString().toString()); assertThat(span.getSpanContext().getTraceIdAsHexString().toString())
assertEquals(contextShim.toSpanId(), span.getSpanContext().getSpanIdAsHexString().toString()); .isEqualTo(contextShim.toTraceId());
assertFalse(contextShim.baggageItems().iterator().hasNext()); assertThat(span.getSpanContext().getSpanIdAsHexString().toString())
.isEqualTo(contextShim.toSpanId());
assertThat(contextShim.baggageItems().iterator().hasNext()).isFalse();
} }
@Test @Test
@ -59,15 +57,15 @@ class SpanShimTest {
spanShim.setBaggageItem("key1", "value1"); spanShim.setBaggageItem("key1", "value1");
spanShim.setBaggageItem("key2", "value2"); spanShim.setBaggageItem("key2", "value2");
assertEquals(spanShim.getBaggageItem("key1"), "value1"); assertThat("value1").isEqualTo(spanShim.getBaggageItem("key1"));
assertEquals(spanShim.getBaggageItem("key2"), "value2"); assertThat("value2").isEqualTo(spanShim.getBaggageItem("key2"));
SpanContextShim contextShim = (SpanContextShim) spanShim.context(); SpanContextShim contextShim = (SpanContextShim) spanShim.context();
assertNotNull(contextShim); assertThat(contextShim).isNotNull();
Map<String, String> baggageMap = getBaggageMap(contextShim.baggageItems()); Map<String, String> baggageMap = getBaggageMap(contextShim.baggageItems());
assertEquals(2, baggageMap.size()); assertThat(baggageMap.size()).isEqualTo(2);
assertEquals(baggageMap.get("key1"), "value1"); assertThat("value1").isEqualTo(baggageMap.get("key1"));
assertEquals(baggageMap.get("key2"), "value2"); assertThat("value2").isEqualTo(baggageMap.get("key2"));
} }
@Test @Test
@ -77,9 +75,9 @@ class SpanShimTest {
spanShim.setBaggageItem("key1", "value1"); spanShim.setBaggageItem("key1", "value1");
SpanContextShim contextShim2 = (SpanContextShim) spanShim.context(); SpanContextShim contextShim2 = (SpanContextShim) spanShim.context();
assertNotEquals(contextShim1, contextShim2); assertThat(contextShim2).isNotEqualTo(contextShim1);
assertFalse(contextShim1.baggageItems().iterator().hasNext()); /* original, empty */ assertThat(contextShim1.baggageItems().iterator().hasNext()).isFalse(); /* original, empty */
assertTrue(contextShim2.baggageItems().iterator().hasNext()); /* updated, with values */ assertThat(contextShim2.baggageItems().iterator()).hasNext(); /* updated, with values */
} }
@Test @Test
@ -91,10 +89,9 @@ class SpanShimTest {
* referring to the same Span.*/ * referring to the same Span.*/
SpanShim spanShim2 = new SpanShim(telemetryInfo, span); SpanShim spanShim2 = new SpanShim(telemetryInfo, span);
spanShim2.setBaggageItem("key1", "value2"); spanShim2.setBaggageItem("key1", "value2");
assertEquals(spanShim1.getBaggageItem("key1"), "value2"); assertThat(spanShim1.getBaggageItem("key1")).isEqualTo("value2");
assertEquals(spanShim2.getBaggageItem("key1"), "value2"); assertThat(spanShim2.getBaggageItem("key1")).isEqualTo("value2");
assertEquals( assertThat(getBaggageMap(spanShim2.context().baggageItems()))
getBaggageMap(spanShim1.context().baggageItems()), .isEqualTo(getBaggageMap(spanShim1.context().baggageItems()));
getBaggageMap(spanShim2.context().baggageItems()));
} }
} }

31
opentracing-shim/src/test/java/io/opentelemetry/opentracingshim/TracerShimTest.java
View File

@ -6,9 +6,6 @@
package io.opentelemetry.opentracingshim; package io.opentelemetry.opentracingshim;
import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNull;
import io.opentelemetry.api.OpenTelemetry; import io.opentelemetry.api.OpenTelemetry;
import io.opentracing.Scope; import io.opentracing.Scope;
@ -42,10 +39,10 @@ class TracerShimTest {
@Test @Test
void defaultTracer() { void defaultTracer() {
assertNotNull(tracerShim.buildSpan("one")); assertThat(tracerShim.buildSpan("one")).isNotNull();
assertNotNull(tracerShim.scopeManager()); assertThat(tracerShim.scopeManager()).isNotNull();
assertNull(tracerShim.activeSpan()); assertThat(tracerShim.activeSpan()).isNull();
assertNull(tracerShim.scopeManager().activeSpan()); assertThat(tracerShim.scopeManager().activeSpan()).isNull();
} }
@Test @Test
@ -53,32 +50,32 @@ class TracerShimTest {
Span otSpan = tracerShim.buildSpan("one").start(); Span otSpan = tracerShim.buildSpan("one").start();
io.opentelemetry.api.trace.Span span = ((SpanShim) otSpan).getSpan(); io.opentelemetry.api.trace.Span span = ((SpanShim) otSpan).getSpan();
assertNull(tracerShim.activeSpan()); assertThat(tracerShim.activeSpan()).isNull();
assertNull(tracerShim.scopeManager().activeSpan()); assertThat(tracerShim.scopeManager().activeSpan()).isNull();
try (Scope scope = tracerShim.activateSpan(otSpan)) { try (Scope scope = tracerShim.activateSpan(otSpan)) {
assertNotNull(tracerShim.activeSpan()); assertThat(tracerShim.activeSpan()).isNotNull();
assertNotNull(tracerShim.scopeManager().activeSpan()); assertThat(tracerShim.scopeManager().activeSpan()).isNotNull();
assertEquals(span, ((SpanShim) tracerShim.activeSpan()).getSpan()); assertThat(((SpanShim) tracerShim.activeSpan()).getSpan()).isEqualTo(span);
assertEquals(span, ((SpanShim) tracerShim.scopeManager().activeSpan()).getSpan()); assertThat(((SpanShim) tracerShim.scopeManager().activeSpan()).getSpan()).isEqualTo(span);
} }
assertNull(tracerShim.activeSpan()); assertThat(tracerShim.activeSpan()).isNull();
assertNull(tracerShim.scopeManager().activeSpan()); assertThat(tracerShim.scopeManager().activeSpan()).isNull();
} }
@Test @Test
void extract_nullContext() { void extract_nullContext() {
SpanContext result = SpanContext result =
tracerShim.extract(Format.Builtin.TEXT_MAP, new TextMapAdapter(Collections.emptyMap())); tracerShim.extract(Format.Builtin.TEXT_MAP, new TextMapAdapter(Collections.emptyMap()));
assertNull(result); assertThat(result).isNull();
} }
@Test @Test
void inject_nullContext() { void inject_nullContext() {
Map<String, String> map = new HashMap<>(); Map<String, String> map = new HashMap<>();
tracerShim.inject(null, Format.Builtin.TEXT_MAP, new TextMapAdapter(map)); tracerShim.inject(null, Format.Builtin.TEXT_MAP, new TextMapAdapter(map));
assertEquals(0, map.size()); assertThat(map).isEmpty();
} }
@Test @Test

12
opentracing-shim/src/test/java/io/opentelemetry/opentracingshim/testbed/OpenTelemetryInteroperabilityTest.java
View File

@ -5,9 +5,7 @@
package io.opentelemetry.opentracingshim.testbed; package io.opentelemetry.opentracingshim.testbed;
import static org.assertj.core.api.AssertionsForClassTypes.assertThat; import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNull;
import io.opentelemetry.opentracingshim.OpenTracingShim; import io.opentelemetry.opentracingshim.OpenTracingShim;
import io.opentelemetry.sdk.testing.junit5.OpenTelemetryExtension; import io.opentelemetry.sdk.testing.junit5.OpenTelemetryExtension;
@ -38,10 +36,10 @@ class OpenTelemetryInteroperabilityTest {
otSpan.finish(); otSpan.finish();
} }
assertThat(io.opentelemetry.api.trace.Span.current().getSpanContext().isValid()).isFalse(); assertThat(io.opentelemetry.api.trace.Span.current().getSpanContext().isValid()).isFalse();
assertNull(otTracer.activeSpan()); assertThat(otTracer.activeSpan()).isNull();
List<SpanData> finishedSpans = otelTesting.getSpans(); List<SpanData> finishedSpans = otelTesting.getSpans();
assertEquals(2, finishedSpans.size()); assertThat(finishedSpans).hasSize(2);
TestUtils.assertSameTrace(finishedSpans); TestUtils.assertSameTrace(finishedSpans);
} }
@ -55,10 +53,10 @@ class OpenTelemetryInteroperabilityTest {
} }
assertThat(io.opentelemetry.api.trace.Span.current().getSpanContext().isValid()).isFalse(); assertThat(io.opentelemetry.api.trace.Span.current().getSpanContext().isValid()).isFalse();
assertNull(otTracer.activeSpan()); assertThat(otTracer.activeSpan()).isNull();
List<SpanData> finishedSpans = otelTesting.getSpans(); List<SpanData> finishedSpans = otelTesting.getSpans();
assertEquals(2, finishedSpans.size()); assertThat(finishedSpans).hasSize(2);
TestUtils.assertSameTrace(finishedSpans); TestUtils.assertSameTrace(finishedSpans);
} }
} }

10
opentracing-shim/src/test/java/io/opentelemetry/opentracingshim/testbed/TestUtils.java
View File

@ -5,8 +5,7 @@
package io.opentelemetry.opentracingshim.testbed; package io.opentelemetry.opentracingshim.testbed;
import static org.junit.Assert.assertEquals; import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertTrue;
import io.opentelemetry.api.common.AttributeKey; import io.opentelemetry.api.common.AttributeKey;
import io.opentelemetry.api.trace.Span.Kind; import io.opentelemetry.api.trace.Span.Kind;
@ -133,9 +132,10 @@ public final class TestUtils {
public static void assertSameTrace(List<SpanData> spans) { public static void assertSameTrace(List<SpanData> spans) {
for (int i = 0; i < spans.size() - 1; i++) { for (int i = 0; i < spans.size() - 1; i++) {
// TODO - Include nanos in this comparison. // TODO - Include nanos in this comparison.
assertTrue(spans.get(spans.size() - 1).getEndEpochNanos() >= spans.get(i).getEndEpochNanos()); assertThat(spans.get(i).getEndEpochNanos())
assertEquals(spans.get(spans.size() - 1).getTraceId(), spans.get(i).getTraceId()); .isLessThanOrEqualTo(spans.get(spans.size() - 1).getEndEpochNanos());
assertEquals(spans.get(spans.size() - 1).getSpanId(), spans.get(i).getParentSpanId()); assertThat(spans.get(i).getTraceId()).isEqualTo(spans.get(spans.size() - 1).getTraceId());
assertThat(spans.get(i).getParentSpanId()).isEqualTo(spans.get(spans.size() - 1).getSpanId());
} }
} }
} }

29
opentracing-shim/src/test/java/io/opentelemetry/opentracingshim/testbed/activespanreplacement/ActiveSpanReplacementTest.java
View File

@ -5,16 +5,14 @@
package io.opentelemetry.opentracingshim.testbed.activespanreplacement; package io.opentelemetry.opentracingshim.testbed.activespanreplacement;
import static io.opentelemetry.api.trace.SpanId.isValid;
import static io.opentelemetry.opentracingshim.testbed.TestUtils.finishedSpansSize; import static io.opentelemetry.opentracingshim.testbed.TestUtils.finishedSpansSize;
import static io.opentelemetry.opentracingshim.testbed.TestUtils.sleep; import static io.opentelemetry.opentracingshim.testbed.TestUtils.sleep;
import static java.util.concurrent.TimeUnit.SECONDS;
import static org.assertj.core.api.Assertions.assertThat;
import static org.awaitility.Awaitility.await; import static org.awaitility.Awaitility.await;
import static org.hamcrest.core.IsEqual.equalTo; import static org.hamcrest.core.IsEqual.equalTo;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotEquals;
import static org.junit.jupiter.api.Assertions.assertNull;
import io.opentelemetry.api.trace.SpanId;
import io.opentelemetry.opentracingshim.OpenTracingShim; import io.opentelemetry.opentracingshim.OpenTracingShim;
import io.opentelemetry.sdk.testing.junit5.OpenTelemetryExtension; import io.opentelemetry.sdk.testing.junit5.OpenTelemetryExtension;
import io.opentelemetry.sdk.trace.data.SpanData; import io.opentelemetry.sdk.trace.data.SpanData;
@ -24,7 +22,6 @@ import io.opentracing.Tracer;
import java.util.List; import java.util.List;
import java.util.concurrent.ExecutorService; import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors; import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import org.junit.jupiter.api.Test; import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.RegisterExtension; import org.junit.jupiter.api.extension.RegisterExtension;
@ -45,23 +42,23 @@ class ActiveSpanReplacementTest {
submitAnotherTask(span); submitAnotherTask(span);
} }
await().atMost(15, TimeUnit.SECONDS).until(finishedSpansSize(otelTesting), equalTo(3)); await().atMost(15, SECONDS).until(finishedSpansSize(otelTesting), equalTo(3));
List<SpanData> spans = otelTesting.getSpans(); List<SpanData> spans = otelTesting.getSpans();
assertEquals(3, spans.size()); assertThat(spans).hasSize(3);
assertEquals("initial", spans.get(0).getName()); // Isolated task assertThat(spans.get(0).getName()).isEqualTo("initial"); // Isolated task
assertEquals("subtask", spans.get(1).getName()); assertThat(spans.get(1).getName()).isEqualTo("subtask");
assertEquals("task", spans.get(2).getName()); assertThat(spans.get(2).getName()).isEqualTo("task");
// task/subtask are part of the same trace, and subtask is a child of task // task/subtask are part of the same trace, and subtask is a child of task
assertEquals(spans.get(1).getTraceId(), spans.get(2).getTraceId()); assertThat(spans.get(2).getTraceId()).isEqualTo(spans.get(1).getTraceId());
assertEquals(spans.get(2).getSpanId(), spans.get(1).getParentSpanId()); assertThat(spans.get(1).getParentSpanId()).isEqualTo(spans.get(2).getSpanId());
// initial task is not related in any way to those two tasks // initial task is not related in any way to those two tasks
assertNotEquals(spans.get(0).getTraceId(), spans.get(1).getTraceId()); assertThat(spans.get(1).getTraceId()).isNotEqualTo(spans.get(0).getTraceId());
assertFalse(SpanId.isValid(spans.get(0).getParentSpanId())); assertThat(isValid(spans.get(0).getParentSpanId())).isFalse();
assertNull(tracer.scopeManager().activeSpan()); assertThat(tracer.scopeManager().activeSpan()).isNull();
} }
private void submitAnotherTask(final Span initialSpan) { private void submitAnotherTask(final Span initialSpan) {

8
opentracing-shim/src/test/java/io/opentelemetry/opentracingshim/testbed/baggagehandling/BaggageHandlingTest.java
View File

@ -5,7 +5,7 @@
package io.opentelemetry.opentracingshim.testbed.baggagehandling; package io.opentelemetry.opentracingshim.testbed.baggagehandling;
import static org.junit.jupiter.api.Assertions.assertEquals; import static org.assertj.core.api.Assertions.assertThat;
import io.opentelemetry.opentracingshim.OpenTracingShim; import io.opentelemetry.opentracingshim.OpenTracingShim;
import io.opentelemetry.sdk.testing.junit5.OpenTelemetryExtension; import io.opentelemetry.sdk.testing.junit5.OpenTelemetryExtension;
@ -55,8 +55,8 @@ public final class BaggageHandlingTest {
/* Single call, no need to use await() */ /* Single call, no need to use await() */
f.get(5, TimeUnit.SECONDS); f.get(5, TimeUnit.SECONDS);
assertEquals(2, otelTesting.getSpans().size()); assertThat(otelTesting.getSpans()).hasSize(2);
assertEquals(span.getBaggageItem("key1"), "value2"); assertThat("value2").isEqualTo(span.getBaggageItem("key1"));
assertEquals(span.getBaggageItem("newkey"), "newvalue"); assertThat("newvalue").isEqualTo(span.getBaggageItem("newkey"));
} }
} }

13
opentracing-shim/src/test/java/io/opentelemetry/opentracingshim/testbed/clientserver/TestClientServerTest.java
View File

@ -7,10 +7,9 @@ package io.opentelemetry.opentracingshim.testbed.clientserver;
import static io.opentelemetry.opentracingshim.testbed.TestUtils.finishedSpansSize; import static io.opentelemetry.opentracingshim.testbed.TestUtils.finishedSpansSize;
import static io.opentelemetry.opentracingshim.testbed.TestUtils.sortByStartTime; import static io.opentelemetry.opentracingshim.testbed.TestUtils.sortByStartTime;
import static org.assertj.core.api.Assertions.assertThat;
import static org.awaitility.Awaitility.await; import static org.awaitility.Awaitility.await;
import static org.hamcrest.core.IsEqual.equalTo; import static org.hamcrest.core.IsEqual.equalTo;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNull;
import io.opentelemetry.api.trace.Span.Kind; import io.opentelemetry.api.trace.Span.Kind;
import io.opentelemetry.opentracingshim.OpenTracingShim; import io.opentelemetry.opentracingshim.OpenTracingShim;
@ -53,13 +52,13 @@ class TestClientServerTest {
await().atMost(15, TimeUnit.SECONDS).until(finishedSpansSize(otelTesting), equalTo(2)); await().atMost(15, TimeUnit.SECONDS).until(finishedSpansSize(otelTesting), equalTo(2));
List<SpanData> finished = otelTesting.getSpans(); List<SpanData> finished = otelTesting.getSpans();
assertEquals(2, finished.size()); assertThat(finished).hasSize(2);
finished = sortByStartTime(finished); finished = sortByStartTime(finished);
assertEquals(finished.get(0).getTraceId(), finished.get(1).getTraceId()); assertThat(finished.get(1).getTraceId()).isEqualTo(finished.get(0).getTraceId());
assertEquals(Kind.CLIENT, finished.get(0).getKind()); assertThat(finished.get(0).getKind()).isEqualTo(Kind.CLIENT);
assertEquals(Kind.SERVER, finished.get(1).getKind()); assertThat(finished.get(1).getKind()).isEqualTo(Kind.SERVER);
assertNull(tracer.scopeManager().activeSpan()); assertThat(tracer.scopeManager().activeSpan()).isNull();
} }
} }

44
opentracing-shim/src/test/java/io/opentelemetry/opentracingshim/testbed/concurrentcommonrequesthandler/HandlerTest.java
View File

@ -7,11 +7,7 @@ package io.opentelemetry.opentracingshim.testbed.concurrentcommonrequesthandler;
import static io.opentelemetry.opentracingshim.testbed.TestUtils.getOneByName; import static io.opentelemetry.opentracingshim.testbed.TestUtils.getOneByName;
import static io.opentelemetry.opentracingshim.testbed.TestUtils.sortByStartTime; import static io.opentelemetry.opentracingshim.testbed.TestUtils.sortByStartTime;
import static org.junit.jupiter.api.Assertions.assertEquals; import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNull;
import io.opentelemetry.api.trace.Span.Kind; import io.opentelemetry.api.trace.Span.Kind;
import io.opentelemetry.api.trace.SpanId; import io.opentelemetry.api.trace.SpanId;
@ -44,21 +40,21 @@ class HandlerTest {
Future<String> responseFuture = client.send("message"); Future<String> responseFuture = client.send("message");
Future<String> responseFuture2 = client.send("message2"); Future<String> responseFuture2 = client.send("message2");
assertEquals("message:response", responseFuture.get(15, TimeUnit.SECONDS)); assertThat(responseFuture.get(15, TimeUnit.SECONDS)).isEqualTo("message:response");
assertEquals("message2:response", responseFuture2.get(15, TimeUnit.SECONDS)); assertThat(responseFuture2.get(15, TimeUnit.SECONDS)).isEqualTo("message2:response");
List<SpanData> finished = otelTesting.getSpans(); List<SpanData> finished = otelTesting.getSpans();
assertEquals(2, finished.size()); assertThat(finished).hasSize(2);
for (SpanData spanData : finished) { for (SpanData spanData : finished) {
assertEquals(Kind.CLIENT, spanData.getKind()); assertThat(spanData.getKind()).isEqualTo(Kind.CLIENT);
} }
assertNotEquals(finished.get(0).getTraceId(), finished.get(1).getTraceId()); assertThat(finished.get(1).getTraceId()).isNotEqualTo(finished.get(0).getTraceId());
assertFalse(SpanId.isValid(finished.get(0).getParentSpanId())); assertThat(SpanId.isValid(finished.get(0).getParentSpanId())).isFalse();
assertFalse(SpanId.isValid(finished.get(1).getParentSpanId())); assertThat(SpanId.isValid(finished.get(1).getParentSpanId())).isFalse();
assertNull(tracer.scopeManager().activeSpan()); assertThat(tracer.scopeManager().activeSpan()).isNull();
} }
/** Active parent is not picked up by child. */ /** Active parent is not picked up by child. */
@ -67,23 +63,23 @@ class HandlerTest {
Span parentSpan = tracer.buildSpan("parent").start(); Span parentSpan = tracer.buildSpan("parent").start();
try (Scope parentScope = tracer.activateSpan(parentSpan)) { try (Scope parentScope = tracer.activateSpan(parentSpan)) {
String response = client.send("no_parent").get(15, TimeUnit.SECONDS); String response = client.send("no_parent").get(15, TimeUnit.SECONDS);
assertEquals("no_parent:response", response); assertThat(response).isEqualTo("no_parent:response");
} finally { } finally {
parentSpan.finish(); parentSpan.finish();
} }
List<SpanData> finished = otelTesting.getSpans(); List<SpanData> finished = otelTesting.getSpans();
assertEquals(2, finished.size()); assertThat(finished).hasSize(2);
SpanData child = getOneByName(finished, RequestHandler.OPERATION_NAME); SpanData child = getOneByName(finished, RequestHandler.OPERATION_NAME);
assertNotNull(child); assertThat(child).isNotNull();
SpanData parent = getOneByName(finished, "parent"); SpanData parent = getOneByName(finished, "parent");
assertNotNull(parent); assertThat(parent).isNotNull();
// Here check that there is no parent-child relation although it should be because child is // Here check that there is no parent-child relation although it should be because child is
// created when parent is active // created when parent is active
assertNotEquals(parent.getSpanId(), child.getParentSpanId()); assertThat(child.getParentSpanId()).isNotEqualTo(parent.getSpanId());
} }
/** /**
@ -98,27 +94,27 @@ class HandlerTest {
try (Scope parentScope = tracer.activateSpan(parentSpan)) { try (Scope parentScope = tracer.activateSpan(parentSpan)) {
client = new Client(new RequestHandler(tracer, parentSpan.context())); client = new Client(new RequestHandler(tracer, parentSpan.context()));
String response = client.send("correct_parent").get(15, TimeUnit.SECONDS); String response = client.send("correct_parent").get(15, TimeUnit.SECONDS);
assertEquals("correct_parent:response", response); assertThat(response).isEqualTo("correct_parent:response");
} finally { } finally {
parentSpan.finish(); parentSpan.finish();
} }
// Send second request, now there is no active parent, but it will be set, ups // Send second request, now there is no active parent, but it will be set, ups
String response = client.send("wrong_parent").get(15, TimeUnit.SECONDS); String response = client.send("wrong_parent").get(15, TimeUnit.SECONDS);
assertEquals("wrong_parent:response", response); assertThat(response).isEqualTo("wrong_parent:response");
List<SpanData> finished = otelTesting.getSpans(); List<SpanData> finished = otelTesting.getSpans();
assertEquals(3, finished.size()); assertThat(finished).hasSize(3);
finished = sortByStartTime(finished); finished = sortByStartTime(finished);
SpanData parent = getOneByName(finished, "parent"); SpanData parent = getOneByName(finished, "parent");
assertNotNull(parent); assertThat(parent).isNotNull();
// now there is parent/child relation between first and second span: // now there is parent/child relation between first and second span:
assertEquals(parent.getSpanId(), finished.get(1).getParentSpanId()); assertThat(finished.get(1).getParentSpanId()).isEqualTo(parent.getSpanId());
// third span should not have parent, but it has, damn it // third span should not have parent, but it has, damn it
assertEquals(parent.getSpanId(), finished.get(2).getParentSpanId()); assertThat(finished.get(2).getParentSpanId()).isEqualTo(parent.getSpanId());
} }
} }

27
opentracing-shim/src/test/java/io/opentelemetry/opentracingshim/testbed/errorreporting/ErrorReportingTest.java
View File

@ -6,10 +6,9 @@
package io.opentelemetry.opentracingshim.testbed.errorreporting; package io.opentelemetry.opentracingshim.testbed.errorreporting;
import static io.opentelemetry.opentracingshim.testbed.TestUtils.finishedSpansSize; import static io.opentelemetry.opentracingshim.testbed.TestUtils.finishedSpansSize;
import static org.assertj.core.api.Assertions.assertThat;
import static org.awaitility.Awaitility.await; import static org.awaitility.Awaitility.await;
import static org.hamcrest.core.IsEqual.equalTo; import static org.hamcrest.core.IsEqual.equalTo;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNull;
import io.opentelemetry.api.trace.StatusCode; import io.opentelemetry.api.trace.StatusCode;
import io.opentelemetry.opentracingshim.OpenTracingShim; import io.opentelemetry.opentracingshim.OpenTracingShim;
@ -50,11 +49,11 @@ public final class ErrorReportingTest {
span.finish(); span.finish();
} }
assertNull(tracer.scopeManager().activeSpan()); assertThat(tracer.scopeManager().activeSpan()).isNull();
List<SpanData> spans = otelTesting.getSpans(); List<SpanData> spans = otelTesting.getSpans();
assertEquals(spans.size(), 1); assertThat(spans).hasSize(1);
assertEquals(spans.get(0).getStatus().getCanonicalCode(), StatusCode.ERROR); assertThat(StatusCode.ERROR).isEqualTo(spans.get(0).getStatus().getCanonicalCode());
} }
/* Error handling in a callback capturing/activating the Span */ /* Error handling in a callback capturing/activating the Span */
@ -75,8 +74,8 @@ public final class ErrorReportingTest {
await().atMost(5, TimeUnit.SECONDS).until(finishedSpansSize(otelTesting), equalTo(1)); await().atMost(5, TimeUnit.SECONDS).until(finishedSpansSize(otelTesting), equalTo(1));
List<SpanData> spans = otelTesting.getSpans(); List<SpanData> spans = otelTesting.getSpans();
assertEquals(spans.size(), 1); assertThat(spans).hasSize(1);
assertEquals(spans.get(0).getStatus().getCanonicalCode(), StatusCode.ERROR); assertThat(StatusCode.ERROR).isEqualTo(spans.get(0).getStatus().getCanonicalCode());
} }
/* Error handling for a max-retries task (such as url fetching). /* Error handling for a max-retries task (such as url fetching).
@ -103,15 +102,15 @@ public final class ErrorReportingTest {
Tags.ERROR.set(span, true); // Could not fetch anything. Tags.ERROR.set(span, true); // Could not fetch anything.
span.finish(); span.finish();
assertNull(tracer.scopeManager().activeSpan()); assertThat(tracer.scopeManager().activeSpan()).isNull();
List<SpanData> spans = otelTesting.getSpans(); List<SpanData> spans = otelTesting.getSpans();
assertEquals(spans.size(), 1); assertThat(spans).hasSize(1);
assertEquals(spans.get(0).getStatus().getCanonicalCode(), StatusCode.ERROR); assertThat(StatusCode.ERROR).isEqualTo(spans.get(0).getStatus().getCanonicalCode());
List<Event> events = spans.get(0).getEvents(); List<Event> events = spans.get(0).getEvents();
assertEquals(events.size(), maxRetries); assertThat(events).hasSize(maxRetries);
assertEquals(events.get(0).getName(), Tags.ERROR.getKey()); assertThat(Tags.ERROR.getKey()).isEqualTo(events.get(0).getName());
/* TODO: Handle actual objects being passed to log/events. */ /* TODO: Handle actual objects being passed to log/events. */
/*assertNotNull(events.get(0).getEvent().getAttributes().get(Fields.ERROR_OBJECT));*/ /*assertNotNull(events.get(0).getEvent().getAttributes().get(Fields.ERROR_OBJECT));*/
} }
@ -141,8 +140,8 @@ public final class ErrorReportingTest {
await().atMost(5, TimeUnit.SECONDS).until(finishedSpansSize(otelTesting), equalTo(1)); await().atMost(5, TimeUnit.SECONDS).until(finishedSpansSize(otelTesting), equalTo(1));
List<SpanData> spans = otelTesting.getSpans(); List<SpanData> spans = otelTesting.getSpans();
assertEquals(spans.size(), 1); assertThat(spans).hasSize(1);
assertEquals(spans.get(0).getStatus().getCanonicalCode(), StatusCode.ERROR); assertThat(StatusCode.ERROR).isEqualTo(spans.get(0).getStatus().getCanonicalCode());
} }
static class ScopedRunnable implements Runnable { static class ScopedRunnable implements Runnable {

15
opentracing-shim/src/test/java/io/opentelemetry/opentracingshim/testbed/latespanfinish/LateSpanFinishTest.java
View File

@ -7,9 +7,7 @@ package io.opentelemetry.opentracingshim.testbed.latespanfinish;
import static io.opentelemetry.opentracingshim.testbed.TestUtils.assertSameTrace; import static io.opentelemetry.opentracingshim.testbed.TestUtils.assertSameTrace;
import static io.opentelemetry.opentracingshim.testbed.TestUtils.sleep; import static io.opentelemetry.opentracingshim.testbed.TestUtils.sleep;
import static org.junit.jupiter.api.Assertions.assertEquals; import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import io.opentelemetry.opentracingshim.OpenTracingShim; import io.opentelemetry.opentracingshim.OpenTracingShim;
import io.opentelemetry.sdk.testing.junit5.OpenTelemetryExtension; import io.opentelemetry.sdk.testing.junit5.OpenTelemetryExtension;
@ -47,14 +45,15 @@ public final class LateSpanFinishTest {
// Children finish order is not guaranteed, but parent should finish *last*. // Children finish order is not guaranteed, but parent should finish *last*.
List<SpanData> spans = otelTesting.getSpans(); List<SpanData> spans = otelTesting.getSpans();
assertEquals(3, spans.size()); assertThat(spans).hasSize(3);
assertTrue(spans.get(0).getName().startsWith("task")); assertThat(spans.get(0).getName()).startsWith("task");
assertTrue(spans.get(1).getName().startsWith("task")); assertThat(spans.get(0).getName()).startsWith("task");
assertEquals("parent", spans.get(2).getName()); assertThat(spans.get(1).getName()).startsWith("task");
assertThat(spans.get(2).getName()).isEqualTo("parent");
assertSameTrace(spans); assertSameTrace(spans);
assertNull(tracer.scopeManager().activeSpan()); assertThat(tracer.scopeManager().activeSpan()).isNull();
} }
/* /*

13
opentracing-shim/src/test/java/io/opentelemetry/opentracingshim/testbed/listenerperrequest/ListenerTest.java
View File

@ -5,10 +5,9 @@
package io.opentelemetry.opentracingshim.testbed.listenerperrequest; package io.opentelemetry.opentracingshim.testbed.listenerperrequest;
import static org.junit.jupiter.api.Assertions.assertEquals; import static io.opentelemetry.api.trace.Span.Kind.CLIENT;
import static org.junit.jupiter.api.Assertions.assertNull; import static org.assertj.core.api.Assertions.assertThat;
import io.opentelemetry.api.trace.Span;
import io.opentelemetry.opentracingshim.OpenTracingShim; import io.opentelemetry.opentracingshim.OpenTracingShim;
import io.opentelemetry.sdk.testing.junit5.OpenTelemetryExtension; import io.opentelemetry.sdk.testing.junit5.OpenTelemetryExtension;
import io.opentelemetry.sdk.trace.data.SpanData; import io.opentelemetry.sdk.trace.data.SpanData;
@ -28,12 +27,12 @@ class ListenerTest {
void test() throws Exception { void test() throws Exception {
Client client = new Client(tracer); Client client = new Client(tracer);
Object response = client.send("message").get(); Object response = client.send("message").get();
assertEquals("message:response", response); assertThat(response).isEqualTo("message:response");
List<SpanData> finished = otelTesting.getSpans(); List<SpanData> finished = otelTesting.getSpans();
assertEquals(1, finished.size()); assertThat(finished).hasSize(1);
assertEquals(finished.get(0).getKind(), Span.Kind.CLIENT); assertThat(CLIENT).isEqualTo(finished.get(0).getKind());
assertNull(tracer.scopeManager().activeSpan()); assertThat(tracer.scopeManager().activeSpan()).isNull();
} }
} }

13
opentracing-shim/src/test/java/io/opentelemetry/opentracingshim/testbed/multiplecallbacks/MultipleCallbacksTest.java
View File

@ -6,10 +6,9 @@
package io.opentelemetry.opentracingshim.testbed.multiplecallbacks; package io.opentelemetry.opentracingshim.testbed.multiplecallbacks;
import static io.opentelemetry.opentracingshim.testbed.TestUtils.finishedSpansSize; import static io.opentelemetry.opentracingshim.testbed.TestUtils.finishedSpansSize;
import static org.assertj.core.api.Assertions.assertThat;
import static org.awaitility.Awaitility.await; import static org.awaitility.Awaitility.await;
import static org.hamcrest.core.IsEqual.equalTo; import static org.hamcrest.core.IsEqual.equalTo;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNull;
import io.opentelemetry.opentracingshim.OpenTracingShim; import io.opentelemetry.opentracingshim.OpenTracingShim;
import io.opentelemetry.sdk.testing.junit5.OpenTelemetryExtension; import io.opentelemetry.sdk.testing.junit5.OpenTelemetryExtension;
@ -54,15 +53,15 @@ class MultipleCallbacksTest {
await().atMost(15, TimeUnit.SECONDS).until(finishedSpansSize(otelTesting), equalTo(4)); await().atMost(15, TimeUnit.SECONDS).until(finishedSpansSize(otelTesting), equalTo(4));
List<SpanData> spans = otelTesting.getSpans(); List<SpanData> spans = otelTesting.getSpans();
assertEquals(4, spans.size()); assertThat(spans).hasSize(4);
assertEquals("parent", spans.get(0).getName()); assertThat(spans.get(0).getName()).isEqualTo("parent");
SpanData parentSpan = spans.get(0); SpanData parentSpan = spans.get(0);
for (int i = 1; i < 4; i++) { for (int i = 1; i < 4; i++) {
assertEquals(parentSpan.getTraceId(), spans.get(i).getTraceId()); assertThat(spans.get(i).getTraceId()).isEqualTo(parentSpan.getTraceId());
assertEquals(parentSpan.getSpanId(), spans.get(i).getParentSpanId()); assertThat(spans.get(i).getParentSpanId()).isEqualTo(parentSpan.getSpanId());
} }
assertNull(tracer.scopeManager().activeSpan()); assertThat(tracer.scopeManager().activeSpan()).isNull();
} }
} }

14
opentracing-shim/src/test/java/io/opentelemetry/opentracingshim/testbed/nestedcallbacks/NestedCallbacksTest.java
View File

@ -7,10 +7,9 @@ package io.opentelemetry.opentracingshim.testbed.nestedcallbacks;
import static io.opentelemetry.api.common.AttributeKey.stringKey; import static io.opentelemetry.api.common.AttributeKey.stringKey;
import static io.opentelemetry.opentracingshim.testbed.TestUtils.finishedSpansSize; import static io.opentelemetry.opentracingshim.testbed.TestUtils.finishedSpansSize;
import static org.assertj.core.api.Assertions.assertThat;
import static org.awaitility.Awaitility.await; import static org.awaitility.Awaitility.await;
import static org.hamcrest.core.IsEqual.equalTo; import static org.hamcrest.core.IsEqual.equalTo;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNull;
import io.opentelemetry.api.common.ReadableAttributes; import io.opentelemetry.api.common.ReadableAttributes;
import io.opentelemetry.opentracingshim.OpenTracingShim; import io.opentelemetry.opentracingshim.OpenTracingShim;
@ -43,16 +42,17 @@ public final class NestedCallbacksTest {
await().atMost(15, TimeUnit.SECONDS).until(finishedSpansSize(otelTesting), equalTo(1)); await().atMost(15, TimeUnit.SECONDS).until(finishedSpansSize(otelTesting), equalTo(1));
List<SpanData> spans = otelTesting.getSpans(); List<SpanData> spans = otelTesting.getSpans();
assertEquals(1, spans.size()); assertThat(spans).hasSize(1);
assertEquals("one", spans.get(0).getName()); assertThat(spans.get(0).getName()).isEqualTo("one");
ReadableAttributes attrs = spans.get(0).getAttributes(); ReadableAttributes attrs = spans.get(0).getAttributes();
assertEquals(3, attrs.size()); assertThat(attrs.size()).isEqualTo(3);
for (int i = 1; i <= 3; i++) { for (int i = 1; i <= 3; i++) {
assertEquals(Integer.toString(i), spans.get(0).getAttributes().get(stringKey("key" + i))); assertThat(spans.get(0).getAttributes().get(stringKey("key" + i)))
.isEqualTo(Integer.toString(i));
} }
assertNull(tracer.scopeManager().activeSpan()); assertThat(tracer.scopeManager().activeSpan()).isNull();
} }
private void submitCallbacks(final Span span) { private void submitCallbacks(final Span span) {

10
opentracing-shim/src/test/java/io/opentelemetry/opentracingshim/testbed/statelesscommonrequesthandler/HandlerTest.java
View File

@ -5,7 +5,7 @@
package io.opentelemetry.opentracingshim.testbed.statelesscommonrequesthandler; package io.opentelemetry.opentracingshim.testbed.statelesscommonrequesthandler;
import static org.junit.jupiter.api.Assertions.assertEquals; import static org.assertj.core.api.Assertions.assertThat;
import io.opentelemetry.opentracingshim.OpenTracingShim; import io.opentelemetry.opentracingshim.OpenTracingShim;
import io.opentelemetry.sdk.testing.junit5.OpenTelemetryExtension; import io.opentelemetry.sdk.testing.junit5.OpenTelemetryExtension;
@ -34,11 +34,11 @@ public final class HandlerTest {
Future<String> responseFuture2 = client.send("message2"); Future<String> responseFuture2 = client.send("message2");
Future<String> responseFuture3 = client.send("message3"); Future<String> responseFuture3 = client.send("message3");
assertEquals("message3:response", responseFuture3.get(5, TimeUnit.SECONDS)); assertThat(responseFuture3.get(5, TimeUnit.SECONDS)).isEqualTo("message3:response");
assertEquals("message2:response", responseFuture2.get(5, TimeUnit.SECONDS)); assertThat(responseFuture2.get(5, TimeUnit.SECONDS)).isEqualTo("message2:response");
assertEquals("message:response", responseFuture.get(5, TimeUnit.SECONDS)); assertThat(responseFuture.get(5, TimeUnit.SECONDS)).isEqualTo("message:response");
List<SpanData> finished = otelTesting.getSpans(); List<SpanData> finished = otelTesting.getSpans();
assertEquals(3, finished.size()); assertThat(finished).hasSize(3);
} }
} }

83
sdk-extensions/jaeger-remote-sampler/src/test/java/io/opentelemetry/sdk/extension/trace/jaeger/sampler/RateLimiterTest.java
View File

@ -5,9 +5,7 @@
package io.opentelemetry.sdk.extension.trace.jaeger.sampler; package io.opentelemetry.sdk.extension.trace.jaeger.sampler;
import static org.junit.jupiter.api.Assertions.assertEquals; import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
import io.opentelemetry.sdk.common.Clock; import io.opentelemetry.sdk.common.Clock;
import java.util.ArrayList; import java.util.ArrayList;
@ -48,31 +46,31 @@ class RateLimiterTest {
long currentTime = TimeUnit.MICROSECONDS.toNanos(100); long currentTime = TimeUnit.MICROSECONDS.toNanos(100);
clock.timeNanos = currentTime; clock.timeNanos = currentTime;
assertTrue(limiter.checkCredit(1.0)); assertThat(limiter.checkCredit(1.0)).isTrue();
assertTrue(limiter.checkCredit(1.0)); assertThat(limiter.checkCredit(1.0)).isTrue();
assertFalse(limiter.checkCredit(1.0)); assertThat(limiter.checkCredit(1.0)).isFalse();
// move time 250ms forward, not enough credits to pay for 1.0 item // move time 250ms forward, not enough credits to pay for 1.0 item
currentTime += TimeUnit.MILLISECONDS.toNanos(250); currentTime += TimeUnit.MILLISECONDS.toNanos(250);
clock.timeNanos = currentTime; clock.timeNanos = currentTime;
assertFalse(limiter.checkCredit(1.0)); assertThat(limiter.checkCredit(1.0)).isFalse();
// move time 500ms forward, now enough credits to pay for 1.0 item // move time 500ms forward, now enough credits to pay for 1.0 item
currentTime += TimeUnit.MILLISECONDS.toNanos(500); currentTime += TimeUnit.MILLISECONDS.toNanos(500);
clock.timeNanos = currentTime; clock.timeNanos = currentTime;
assertTrue(limiter.checkCredit(1.0)); assertThat(limiter.checkCredit(1.0)).isTrue();
assertFalse(limiter.checkCredit(1.0)); assertThat(limiter.checkCredit(1.0)).isFalse();
// move time 5s forward, enough to accumulate credits for 10 messages, but it should still be // move time 5s forward, enough to accumulate credits for 10 messages, but it should still be
// capped at 2 // capped at 2
currentTime += TimeUnit.MILLISECONDS.toNanos(5000); currentTime += TimeUnit.MILLISECONDS.toNanos(5000);
clock.timeNanos = currentTime; clock.timeNanos = currentTime;
assertTrue(limiter.checkCredit(1.0)); assertThat(limiter.checkCredit(1.0)).isTrue();
assertTrue(limiter.checkCredit(1.0)); assertThat(limiter.checkCredit(1.0)).isTrue();
assertFalse(limiter.checkCredit(1.0)); assertThat(limiter.checkCredit(1.0)).isFalse();
assertFalse(limiter.checkCredit(1.0)); assertThat(limiter.checkCredit(1.0)).isFalse();
assertFalse(limiter.checkCredit(1.0)); assertThat(limiter.checkCredit(1.0)).isFalse();
} }
@Test @Test
@ -82,31 +80,31 @@ class RateLimiterTest {
long currentTime = TimeUnit.MICROSECONDS.toNanos(100); long currentTime = TimeUnit.MICROSECONDS.toNanos(100);
clock.timeNanos = currentTime; clock.timeNanos = currentTime;
assertTrue(limiter.checkCredit(0.25)); assertThat(limiter.checkCredit(0.25)).isTrue();
assertTrue(limiter.checkCredit(0.25)); assertThat(limiter.checkCredit(0.25)).isTrue();
assertFalse(limiter.checkCredit(0.25)); assertThat(limiter.checkCredit(0.25)).isFalse();
// move time 250ms forward, not enough credits to pay for 1.0 item // move time 250ms forward, not enough credits to pay for 1.0 item
currentTime += TimeUnit.MILLISECONDS.toNanos(250); currentTime += TimeUnit.MILLISECONDS.toNanos(250);
clock.timeNanos = currentTime; clock.timeNanos = currentTime;
assertFalse(limiter.checkCredit(0.25)); assertThat(limiter.checkCredit(0.25)).isFalse();
// move time 500ms forward, now enough credits to pay for 1.0 item // move time 500ms forward, now enough credits to pay for 1.0 item
currentTime += TimeUnit.MILLISECONDS.toNanos(500); currentTime += TimeUnit.MILLISECONDS.toNanos(500);
clock.timeNanos = currentTime; clock.timeNanos = currentTime;
assertTrue(limiter.checkCredit(0.25)); assertThat(limiter.checkCredit(0.25)).isTrue();
assertFalse(limiter.checkCredit(0.25)); assertThat(limiter.checkCredit(0.25)).isFalse();
// move time 5s forward, enough to accumulate credits for 10 messages, but it should still be // move time 5s forward, enough to accumulate credits for 10 messages, but it should still be
// capped at 2 // capped at 2
currentTime += TimeUnit.MILLISECONDS.toNanos(5000); currentTime += TimeUnit.MILLISECONDS.toNanos(5000);
clock.timeNanos = currentTime; clock.timeNanos = currentTime;
assertTrue(limiter.checkCredit(0.25)); assertThat(limiter.checkCredit(0.25)).isTrue();
assertTrue(limiter.checkCredit(0.25)); assertThat(limiter.checkCredit(0.25)).isTrue();
assertFalse(limiter.checkCredit(0.25)); assertThat(limiter.checkCredit(0.25)).isFalse();
assertFalse(limiter.checkCredit(0.25)); assertThat(limiter.checkCredit(0.25)).isFalse();
assertFalse(limiter.checkCredit(0.25)); assertThat(limiter.checkCredit(0.25)).isFalse();
} }
@Test @Test
@ -116,16 +114,16 @@ class RateLimiterTest {
long currentTime = TimeUnit.MICROSECONDS.toNanos(100); long currentTime = TimeUnit.MICROSECONDS.toNanos(100);
clock.timeNanos = currentTime; clock.timeNanos = currentTime;
assertTrue(limiter.checkCredit(1.0)); assertThat(limiter.checkCredit(1.0)).isTrue();
assertFalse(limiter.checkCredit(1.0)); assertThat(limiter.checkCredit(1.0)).isFalse();
// move time 20s forward, enough to accumulate credits for 2 messages, but it should still be // move time 20s forward, enough to accumulate credits for 2 messages, but it should still be
// capped at 1 // capped at 1
currentTime += TimeUnit.MILLISECONDS.toNanos(20000); currentTime += TimeUnit.MILLISECONDS.toNanos(20000);
clock.timeNanos = currentTime; clock.timeNanos = currentTime;
assertTrue(limiter.checkCredit(1.0)); assertThat(limiter.checkCredit(1.0)).isTrue();
assertFalse(limiter.checkCredit(1.0)); assertThat(limiter.checkCredit(1.0)).isFalse();
} }
/** /**
@ -138,25 +136,25 @@ class RateLimiterTest {
clock.timeNanos = TimeUnit.MILLISECONDS.toNanos(-1_000_000); clock.timeNanos = TimeUnit.MILLISECONDS.toNanos(-1_000_000);
RateLimiter limiter = new RateLimiter(1000, 100, clock); RateLimiter limiter = new RateLimiter(1000, 100, clock);
assertTrue(limiter.checkCredit(100)); // consume initial (max) balance assertThat(limiter.checkCredit(100)).isTrue(); // consume initial (max) balance
assertFalse(limiter.checkCredit(1)); assertThat(limiter.checkCredit(1)).isFalse();
clock.timeNanos += TimeUnit.MILLISECONDS.toNanos(49); // add 49 credits clock.timeNanos += TimeUnit.MILLISECONDS.toNanos(49); // add 49 credits
assertFalse(limiter.checkCredit(50)); assertThat(limiter.checkCredit(50)).isFalse();
clock.timeNanos += TimeUnit.MILLISECONDS.toNanos(1); // add one credit clock.timeNanos += TimeUnit.MILLISECONDS.toNanos(1); // add one credit
assertTrue(limiter.checkCredit(50)); // consume accrued balance assertThat(limiter.checkCredit(50)).isTrue(); // consume accrued balance
assertFalse(limiter.checkCredit(1)); assertThat(limiter.checkCredit(1)).isFalse();
clock.timeNanos += clock.timeNanos +=
TimeUnit.MILLISECONDS.toNanos(1_000_000); // add a lot of credits (max out balance) TimeUnit.MILLISECONDS.toNanos(1_000_000); // add a lot of credits (max out balance)
assertTrue(limiter.checkCredit(1)); // take one credit assertThat(limiter.checkCredit(1)).isTrue(); // take one credit
clock.timeNanos += clock.timeNanos +=
TimeUnit.MILLISECONDS.toNanos(1_000_000); // add a lot of credits (max out balance) TimeUnit.MILLISECONDS.toNanos(1_000_000); // add a lot of credits (max out balance)
assertFalse(limiter.checkCredit(101)); // can't consume more than max balance assertThat(limiter.checkCredit(101)).isFalse(); // can't consume more than max balance
assertTrue(limiter.checkCredit(100)); // consume max balance assertThat(limiter.checkCredit(100)).isTrue(); // consume max balance
assertFalse(limiter.checkCredit(1)); assertThat(limiter.checkCredit(1)).isFalse();
} }
/** Validates concurrent credit check correctness. */ /** Validates concurrent credit check correctness. */
@ -186,10 +184,9 @@ class RateLimiterTest {
} }
executorService.shutdown(); executorService.shutdown();
executorService.awaitTermination(1, TimeUnit.SECONDS); executorService.awaitTermination(1, TimeUnit.SECONDS);
assertEquals( assertThat(count.get())
numWorkers * creditsPerWorker, .withFailMessage("Exactly the allocated number of credits must be consumed")
count.get(), .isEqualTo(numWorkers * creditsPerWorker);
"Exactly the allocated number of credits must be consumed"); assertThat(limiter.checkCredit(1)).isFalse();
assertFalse(limiter.checkCredit(1));
} }
} }

12
sdk-extensions/jaeger-remote-sampler/src/test/java/io/opentelemetry/sdk/extension/trace/jaeger/sampler/RateLimitingSamplerTest.java
View File

@ -6,7 +6,6 @@
package io.opentelemetry.sdk.extension.trace.jaeger.sampler; package io.opentelemetry.sdk.extension.trace.jaeger.sampler;
import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.assertEquals;
import io.opentelemetry.api.common.Attributes; import io.opentelemetry.api.common.Attributes;
import io.opentelemetry.api.trace.Span; import io.opentelemetry.api.trace.Span;
@ -88,16 +87,15 @@ class RateLimitingSamplerTest {
Collections.emptyList()) Collections.emptyList())
.getDecision()) .getDecision())
.isEqualTo(SamplingResult.Decision.DROP); .isEqualTo(SamplingResult.Decision.DROP);
assertEquals(2, samplingResult.getAttributes().size()); assertThat(samplingResult.getAttributes().size()).isEqualTo(2);
assertEquals(1d, samplingResult.getAttributes().get(RateLimitingSampler.SAMPLER_PARAM)); assertThat(samplingResult.getAttributes().get(RateLimitingSampler.SAMPLER_PARAM)).isEqualTo(1d);
assertEquals( assertThat(samplingResult.getAttributes().get(RateLimitingSampler.SAMPLER_TYPE))
RateLimitingSampler.TYPE, .isEqualTo(RateLimitingSampler.TYPE);
samplingResult.getAttributes().get(RateLimitingSampler.SAMPLER_TYPE));
} }
@Test @Test
void description() { void description() {
RateLimitingSampler sampler = new RateLimitingSampler(15); RateLimitingSampler sampler = new RateLimitingSampler(15);
assertEquals("RateLimitingSampler{15.00}", sampler.getDescription()); assertThat(sampler.getDescription()).isEqualTo("RateLimitingSampler{15.00}");
} }
} }

7
sdk/tracing/src/test/java/io/opentelemetry/sdk/trace/SpanBuilderSdkTest.java
View File

@ -15,7 +15,6 @@ import static io.opentelemetry.api.common.AttributeKey.stringArrayKey;
import static io.opentelemetry.api.common.AttributeKey.stringKey; import static io.opentelemetry.api.common.AttributeKey.stringKey;
import static java.util.Collections.emptyList; import static java.util.Collections.emptyList;
import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertThrows; import static org.junit.jupiter.api.Assertions.assertThrows;
import io.opentelemetry.api.common.AttributeKey; import io.opentelemetry.api.common.AttributeKey;
@ -41,6 +40,7 @@ import java.util.List;
import javax.annotation.Nullable; import javax.annotation.Nullable;
import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test; import org.junit.jupiter.api.Test;
import org.mockito.ArgumentMatchers;
import org.mockito.Mockito; import org.mockito.Mockito;
/** Unit tests for {@link SpanBuilderSdk}. */ /** Unit tests for {@link SpanBuilderSdk}. */
@ -783,10 +783,11 @@ class SpanBuilderSdkTest {
tracerSdk.spanBuilder(SPAN_NAME).setParent(parentContext).startSpan(); tracerSdk.spanBuilder(SPAN_NAME).setParent(parentContext).startSpan();
try { try {
Mockito.verify(mockedSpanProcessor) Mockito.verify(mockedSpanProcessor)
.onStart(Mockito.same(parentContext), Mockito.same((ReadWriteSpan) span)); .onStart(
ArgumentMatchers.same(parentContext), ArgumentMatchers.same((ReadWriteSpan) span));
assertThat(span.getSpanContext().getTraceIdAsHexString()) assertThat(span.getSpanContext().getTraceIdAsHexString())
.isNotEqualTo(parent.getSpanContext().getTraceIdAsHexString()); .isNotEqualTo(parent.getSpanContext().getTraceIdAsHexString());
assertFalse(SpanId.isValid(span.toSpanData().getParentSpanId())); assertThat(SpanId.isValid(span.toSpanData().getParentSpanId())).isFalse();
} finally { } finally {
span.end(); span.end();
} }

3
sdk/tracing/src/test/java/io/opentelemetry/sdk/trace/testbed/clientserver/TestClientServerTest.java
View File

@ -8,7 +8,6 @@ package io.opentelemetry.sdk.trace.testbed.clientserver;
import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThat;
import static org.awaitility.Awaitility.await; import static org.awaitility.Awaitility.await;
import static org.hamcrest.core.IsEqual.equalTo; import static org.hamcrest.core.IsEqual.equalTo;
import static org.junit.jupiter.api.Assertions.assertEquals;
import io.opentelemetry.api.trace.Span; import io.opentelemetry.api.trace.Span;
import io.opentelemetry.api.trace.Span.Kind; import io.opentelemetry.api.trace.Span.Kind;
@ -56,7 +55,7 @@ class TestClientServerTest {
.until(TestUtils.finishedSpansSize(otelTesting), equalTo(2)); .until(TestUtils.finishedSpansSize(otelTesting), equalTo(2));
List<SpanData> finished = otelTesting.getSpans(); List<SpanData> finished = otelTesting.getSpans();
assertEquals(2, finished.size()); assertThat(finished).hasSize(2);
finished = TestUtils.sortByStartTime(finished); finished = TestUtils.sortByStartTime(finished);
assertThat(finished.get(0).getTraceId()).isEqualTo(finished.get(1).getTraceId()); assertThat(finished.get(0).getTraceId()).isEqualTo(finished.get(1).getTraceId());

9
sdk/tracing/src/test/java/io/opentelemetry/sdk/trace/testbed/errorreporting/ErrorReportingTest.java
View File

@ -8,7 +8,6 @@ package io.opentelemetry.sdk.trace.testbed.errorreporting;
import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThat;
import static org.awaitility.Awaitility.await; import static org.awaitility.Awaitility.await;
import static org.hamcrest.core.IsEqual.equalTo; import static org.hamcrest.core.IsEqual.equalTo;
import static org.junit.jupiter.api.Assertions.assertEquals;
import io.opentelemetry.api.trace.Span; import io.opentelemetry.api.trace.Span;
import io.opentelemetry.api.trace.StatusCode; import io.opentelemetry.api.trace.StatusCode;
@ -103,8 +102,8 @@ public final class ErrorReportingTest {
assertThat(spans.get(0).getStatus().getCanonicalCode()).isEqualTo(StatusCode.ERROR); assertThat(spans.get(0).getStatus().getCanonicalCode()).isEqualTo(StatusCode.ERROR);
List<Event> events = spans.get(0).getEvents(); List<Event> events = spans.get(0).getEvents();
assertEquals(events.size(), maxRetries); assertThat(events).hasSize(maxRetries);
assertEquals(events.get(0).getName(), "error"); assertThat("error").isEqualTo(events.get(0).getName());
} }
/* Error handling for a mocked layer automatically capturing/activating /* Error handling for a mocked layer automatically capturing/activating
@ -131,8 +130,8 @@ public final class ErrorReportingTest {
await().atMost(5, TimeUnit.SECONDS).until(TestUtils.finishedSpansSize(otelTesting), equalTo(1)); await().atMost(5, TimeUnit.SECONDS).until(TestUtils.finishedSpansSize(otelTesting), equalTo(1));
List<SpanData> spans = otelTesting.getSpans(); List<SpanData> spans = otelTesting.getSpans();
assertEquals(spans.size(), 1); assertThat(spans).hasSize(1);
assertEquals(spans.get(0).getStatus().getCanonicalCode(), StatusCode.ERROR); assertThat(StatusCode.ERROR).isEqualTo(spans.get(0).getStatus().getCanonicalCode());
} }
private static class ScopedRunnable implements Runnable { private static class ScopedRunnable implements Runnable {

10
sdk/tracing/src/test/java/io/opentelemetry/sdk/trace/testbed/statelesscommonrequesthandler/HandlerTest.java
View File

@ -5,7 +5,7 @@
package io.opentelemetry.sdk.trace.testbed.statelesscommonrequesthandler; package io.opentelemetry.sdk.trace.testbed.statelesscommonrequesthandler;
import static org.junit.jupiter.api.Assertions.assertEquals; import static org.assertj.core.api.Assertions.assertThat;
import io.opentelemetry.api.trace.Tracer; import io.opentelemetry.api.trace.Tracer;
import io.opentelemetry.sdk.testing.junit5.OpenTelemetryExtension; import io.opentelemetry.sdk.testing.junit5.OpenTelemetryExtension;
@ -35,11 +35,11 @@ public final class HandlerTest {
Future<String> responseFuture2 = client.send("message2"); Future<String> responseFuture2 = client.send("message2");
Future<String> responseFuture3 = client.send("message3"); Future<String> responseFuture3 = client.send("message3");
assertEquals("message3:response", responseFuture3.get(5, TimeUnit.SECONDS)); assertThat(responseFuture3.get(5, TimeUnit.SECONDS)).isEqualTo("message3:response");
assertEquals("message2:response", responseFuture2.get(5, TimeUnit.SECONDS)); assertThat(responseFuture2.get(5, TimeUnit.SECONDS)).isEqualTo("message2:response");
assertEquals("message:response", responseFuture.get(5, TimeUnit.SECONDS)); assertThat(responseFuture.get(5, TimeUnit.SECONDS)).isEqualTo("message:response");
List<SpanData> finished = otelTesting.getSpans(); List<SpanData> finished = otelTesting.getSpans();
assertEquals(3, finished.size()); assertThat(finished).hasSize(3);
} }
} }