Validating SignalStorageExporter

Author: LikeTheSalad

disk-buffering/src/test/java/io/opentelemetry/contrib/disk/buffering/exporters/SignalStorageExporterTest.java

@@ -0,0 +1,130 @@
+package io.opentelemetry.contrib.disk.buffering.exporters;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.anyCollection;
+import static org.mockito.Mockito.clearInvocations;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.when;
+
+import io.opentelemetry.contrib.disk.buffering.SignalType;
+import io.opentelemetry.contrib.disk.buffering.storage.SignalStorage;
+import io.opentelemetry.contrib.disk.buffering.storage.result.WriteResult;
+import io.opentelemetry.sdk.common.CompletableResultCode;
+import io.opentelemetry.sdk.trace.data.SpanData;
+import java.time.Duration;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+import javax.annotation.Nonnull;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+@ExtendWith(MockitoExtension.class)
+class SignalStorageExporterTest {
+  @Mock private ExporterCallback callback;
+
+  @Test
+  void verifyExportToStorage_success() {
+    SignalStorage.Span storage = new TestSpanStorage();
+    SignalType signalType = SignalType.SPAN;
+    SignalStorageExporter<SpanData> storageExporter =
+        new SignalStorageExporter<>(storage, callback, Duration.ofSeconds(1), signalType);
+    SpanData item1 = mock();
+    SpanData item2 = mock();
+    SpanData item3 = mock();
+
+    CompletableResultCode resultCode = storageExporter.exportToStorage(Arrays.asList(item1, item2));
+
+    assertThat(resultCode.isSuccess()).isTrue();
+    verify(callback).onExportSuccess(signalType);
+    verifyNoMoreInteractions(callback);
+
+    // Adding more items
+    clearInvocations(callback);
+    resultCode = storageExporter.exportToStorage(Collections.singletonList(item3));
+
+    assertThat(resultCode.isSuccess()).isTrue();
+    verify(callback).onExportSuccess(signalType);
+    verifyNoMoreInteractions(callback);
+
+    // Checking items
+    List<SpanData> storedItems = new ArrayList<>();
+    for (Collection<SpanData> collection : storage) {
+      storedItems.addAll(collection);
+    }
+    assertThat(storedItems).containsExactly(item1, item2, item3);
+  }
+
+  @SuppressWarnings("ThrowableNotThrown")
+  @Test
+  void verifyExportToStorage_failure() {
+    SignalStorage.Span storage = mock();
+    SignalType signalType = SignalType.SPAN;
+    SignalStorageExporter<SpanData> storageExporter =
+        new SignalStorageExporter<>(storage, callback, Duration.ofSeconds(1), signalType);
+    SpanData item1 = mock();
+
+    // Without exception
+    when(storage.write(anyCollection()))
+        .thenReturn(CompletableFuture.completedFuture(WriteResult.create(false, null)));
+
+    CompletableResultCode resultCode =
+        storageExporter.exportToStorage(Collections.singletonList(item1));
+
+    assertThat(resultCode.isSuccess()).isFalse();
+    assertThat(resultCode.getFailureThrowable()).isNull();
+    verify(callback).onExportError(signalType, null);
+    verifyNoMoreInteractions(callback);
+
+    // With exception
+    clearInvocations(callback);
+    Exception exception = new Exception();
+    when(storage.write(anyCollection()))
+        .thenReturn(CompletableFuture.completedFuture(WriteResult.create(false, exception)));
+
+    resultCode = storageExporter.exportToStorage(Collections.singletonList(item1));
+
+    assertThat(resultCode.isSuccess()).isFalse();
+    assertThat(resultCode.getFailureThrowable()).isEqualTo(exception);
+    verify(callback).onExportError(signalType, exception);
+    verifyNoMoreInteractions(callback);
+  }
+
+  private static class TestSpanStorage implements SignalStorage.Span {
+    private final List<Collection<SpanData>> storedItems = new ArrayList<>();
+
+    @Override
+    public CompletableFuture<WriteResult> write(Collection<SpanData> items) {
+      storedItems.add(items);
+      return getSuccessfulFuture();
+    }
+
+    @Override
+    public CompletableFuture<WriteResult> clear() {
+      storedItems.clear();
+      return getSuccessfulFuture();
+    }
+
+    @Override
+    public void close() {}
+
+    @Nonnull
+    @Override
+    public Iterator<Collection<SpanData>> iterator() {
+      return storedItems.iterator();
+    }
+
+    @Nonnull
+    private static CompletableFuture<WriteResult> getSuccessfulFuture() {
+      return CompletableFuture.completedFuture(WriteResult.create(true, null));
+    }
+  }
+}