Add some javadocs

Author: ST-DDT

tests/src/test/java/net/devh/boot/grpc/test/util/FutureAssertions.java

@@ -23,32 +23,65 @@
 import static org.junit.jupiter.api.Assertions.fail;
 
 import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
 import java.util.function.Function;
 import java.util.function.UnaryOperator;
 
-import com.google.common.util.concurrent.ListenableFuture;
-
+/**
+ * Assertions related to {@link Future}s.
+ */
 public final class FutureAssertions {
 
-    public static <T> void assertFutureEquals(final T expected, final ListenableFuture<T> future,
+    /**
+     * Asserts that the {@link Future} returns the expected result.
+     *
+     * @param <T> The type of the future content.
+     * @param expected The expected content.
+     * @param future The future to check for the expected content.
+     * @param timeout The maximum time to wait for the result.
+     * @param timeoutUnit The time unit of the {@code timeout} argument.
+     */
+    public static <T> void assertFutureEquals(final T expected, final Future<T> future,
             final int timeout, final TimeUnit timeoutUnit) {
         assertFutureEquals(expected, future, UnaryOperator.identity(), timeout, timeoutUnit);
     }
 
-    public static <T, R> void assertFutureEquals(final T expected, final ListenableFuture<R> future,
+    /**
+     * Asserts that the {@link Future} returns the expected result.
+     *
+     * @param <T> The type of the unwrapped/expected content.
+     * @param <R> The type of the future content.
+     * @param expected The expected content.
+     * @param future The future to check for the expected content.
+     * @param unwrapper The function used to extract the content.
+     * @param timeout The maximum time to wait for the result.
+     * @param timeoutUnit The time unit of the {@code timeout} argument.
+     */
+    public static <T, R> void assertFutureEquals(final T expected, final Future<R> future,
             final Function<R, T> unwrapper, final int timeout, final TimeUnit timeoutUnit) {
         try {
             assertEquals(expected, unwrapper.apply(future.get(timeout, timeoutUnit)));
         } catch (InterruptedException | ExecutionException | TimeoutException e) {
-            fail(e);
+            fail("Unexpected error while trying to get the result", e);
         }
     }
 
+    /**
+     * Asserts that the given {@link Future} fails with an {@link ExecutionException} caused by the given exception
+     * type.
+     *
+     * @param <T> The type of the causing exception.
+     * @param expectedType The expected type of the causing exception.
+     * @param future The future expected to throw.
+     * @param timeout The maximum time to wait for the result.
+     * @param timeoutUnit The time unit of the {@code timeout} argument.
+     * @return The causing exception.
+     */
     @SuppressWarnings("unchecked")
     public static <T extends Exception> T assertFutureThrows(final Class<T> expectedType,
-            final ListenableFuture<?> future, final int timeout, final TimeUnit timeoutUnit) {
+            final Future<?> future, final int timeout, final TimeUnit timeoutUnit) {
         final Throwable cause =
                 assertThrows(ExecutionException.class, () -> future.get(timeout, timeoutUnit)).getCause();
         final Class<? extends Throwable> causeClass = cause.getClass();

tests/src/test/java/net/devh/boot/grpc/test/util/GrpcAssertions.java

@@ -22,50 +22,110 @@
 import static org.junit.Assert.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
 import java.util.concurrent.TimeUnit;
 import java.util.function.Function;
 import java.util.function.UnaryOperator;
 
+import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.function.Executable;
 
-import com.google.common.util.concurrent.ListenableFuture;
-
 import io.grpc.Status;
 import io.grpc.StatusRuntimeException;
 import io.grpc.internal.testing.StreamRecorder;
 
+/**
+ * Assertions related to gRPC client calls.
+ */
 public final class GrpcAssertions {
 
+    /**
+     * Asserts that the first value in the {@link StreamRecorder} equals the expected value.
+     *
+     * @param <T> The type of the observer's content.
+     * @param expected The expected content.
+     * @param responseObserver The observer to check for the expected content.
+     * @param timeout The maximum time to wait for the result.
+     * @param timeoutUnit The time unit of the {@code timeout} argument.
+     */
     public static <T> void assertFutureFirstEquals(final T expected, final StreamRecorder<T> responseObserver,
             final int timeout, final TimeUnit timeoutUnit) {
         assertFutureFirstEquals(expected, responseObserver, UnaryOperator.identity(), timeout, timeoutUnit);
     }
 
+    /**
+     * Asserts that the first value in the {@link StreamRecorder} equals the expected value.
+     *
+     * @param <T> The type of the unwrapped/expected content.
+     * @param <R> The type of the observer's content.
+     * @param expected The expected content.
+     * @param responseObserver The observer to check for the expected content.
+     * @param unwrapper The function used to extract the content.
+     * @param timeout The maximum time to wait for the result.
+     * @param timeoutUnit The time unit of the {@code timeout} argument.
+     */
     public static <T, R> void assertFutureFirstEquals(final T expected, final StreamRecorder<R> responseObserver,
             final Function<R, T> unwrapper, final int timeout, final TimeUnit timeoutUnit) {
         assertFutureEquals(expected, responseObserver.firstValue(), unwrapper, timeout, timeoutUnit);
     }
 
-    public static Status assertThrowsStatus(final Status.Code code, final Executable executable) {
+    /**
+     * Assert that the given {@link Executable} throws a {@link StatusRuntimeException} with the expected status code.
+     *
+     * @param expectedCode The expected status code.
+     * @param executable The executable to run.
+     * @return The status contained in the exception.
+     * @see Assertions#assertThrows(Class, Executable)
+     */
+    public static Status assertThrowsStatus(final Status.Code expectedCode, final Executable executable) {
         final StatusRuntimeException exception = assertThrows(StatusRuntimeException.class, executable);
-        return assertStatus(code, exception);
+        return assertStatus(expectedCode, exception);
     }
 
-    public static Status assertFutureThrowsStatus(final Status.Code code, final StreamRecorder<?> recorder,
+    /**
+     * Asserts that the given {@link StreamRecorder} throws an {@link ExecutionException} caused by a
+     * {@link StatusRuntimeException} with the expected status code.
+     *
+     * @param expectedCode The expected status code.
+     * @param recorder The recorder expected to throw.
+     * @param timeout The maximum time to wait for the result.
+     * @param timeoutUnit The time unit of the {@code timeout} argument.
+     * @return The status contained in the exception.
+     * @see #assertFutureThrowsStatus(io.grpc.Status.Code, Future, int, TimeUnit)
+     */
+    public static Status assertFutureThrowsStatus(final Status.Code expectedCode, final StreamRecorder<?> recorder,
             final int timeout, final TimeUnit timeoutUnit) {
-        return assertFutureThrowsStatus(code, recorder.firstValue(), timeout, timeoutUnit);
+        return assertFutureThrowsStatus(expectedCode, recorder.firstValue(), timeout, timeoutUnit);
     }
 
-    public static Status assertFutureThrowsStatus(final Status.Code code, final ListenableFuture<?> future,
+    /**
+     * Asserts that the given {@link Future} throws an {@link ExecutionException} caused by a
+     * {@link StatusRuntimeException} with the expected status code.
+     *
+     * @param expectedCode The expected status code.
+     * @param future The future expected to throw.
+     * @param timeout The maximum time to wait for the result.
+     * @param timeoutUnit The time unit of the {@code timeout} argument.
+     * @return The status contained in the exception.
+     */
+    public static Status assertFutureThrowsStatus(final Status.Code expectedCode, final Future<?> future,
             final int timeout, final TimeUnit timeoutUnit) {
         final StatusRuntimeException exception =
                 assertFutureThrows(StatusRuntimeException.class, future, timeout, timeoutUnit);
-        return assertStatus(code, exception);
+        return assertStatus(expectedCode, exception);
     }
 
-    public static Status assertStatus(final Status.Code code, final StatusRuntimeException exception) {
+    /**
+     * Asserts that the given {@link StatusRuntimeException} uses the expected status code.
+     *
+     * @param expectedCode The expected status code.
+     * @param exception The exception to check for the status code.
+     * @return The status contained in the exception.
+     */
+    public static Status assertStatus(final Status.Code expectedCode, final StatusRuntimeException exception) {
         final Status status = exception.getStatus();
-        assertEquals(code, status.getCode());
+        assertEquals(expectedCode, status.getCode());
         return status;
     }