test(common): Add testing classes previously taken from core package

Author: lpatino10

common/src/main/java/com/ibm/watson/common/WatsonHttpHeaders.java

@@ -1,6 +1,12 @@
 package com.ibm.watson.common;
 
 public interface WatsonHttpHeaders {
+  /** Allow Watson to collect the payload. */
+  String X_WATSON_LEARNING_OPT_OUT = "X-Watson-Learning-Opt-Out";
+
   /** Header containing analytics info. */
   String X_IBMCLOUD_SDK_ANALYTICS = "X-IBMCloud-SDK-Analytics";
+
+  /** Mark API calls as tests. */
+  String X_WATSON_TEST = "X-Watson-Test";
 }

common/src/test/java/com/ibm/watson/common/RetryRunner.java

@@ -0,0 +1,121 @@
+package com.ibm.watson.common;
+
+import com.ibm.cloud.sdk.core.service.exception.TooManyRequestsException;
+import com.ibm.cloud.sdk.core.service.exception.UnauthorizedException;
+import org.junit.Ignore;
+import org.junit.internal.AssumptionViolatedException;
+import org.junit.internal.runners.model.EachTestNotifier;
+import org.junit.runner.Description;
+import org.junit.runner.notification.RunNotifier;
+import org.junit.runner.notification.StoppedByUserException;
+import org.junit.runners.BlockJUnit4ClassRunner;
+import org.junit.runners.model.FrameworkMethod;
+import org.junit.runners.model.InitializationError;
+import org.junit.runners.model.Statement;
+
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * Junit Runner that retry tests. Useful when tests could fail due to network issues.
+ */
+public class RetryRunner extends BlockJUnit4ClassRunner {
+  private static final Logger LOG = Logger.getLogger(RetryRunner.class.getName());
+
+  private static final int RETRY_COUNT = 3;
+
+  /**
+   * Delay factor when tests are failing.
+   */
+  private static final int RETRY_DELAY_FACTOR = 2000;
+
+  /**
+   * Instantiates a new retry runner.
+   *
+   * @param clazz the class
+   * @throws InitializationError the initialization error
+   */
+  public RetryRunner(Class<?> clazz) throws InitializationError {
+    super(clazz);
+  }
+
+  /*
+   * (non-Javadoc)
+   *
+   * @see org.junit.runners.ParentRunner#run(org.junit.runner.notification.RunNotifier)
+   */
+  @Override
+  public void run(final RunNotifier notifier) {
+    EachTestNotifier testNotifier = new EachTestNotifier(notifier, getDescription());
+    Statement statement = classBlock(notifier);
+    try {
+      statement.evaluate();
+    } catch (AssumptionViolatedException ave) {
+      testNotifier.fireTestIgnored();
+    } catch (StoppedByUserException sbue) {
+      throw sbue;
+    } catch (Throwable t) {
+      LOG.warning("Retry class: " + getDescription().getDisplayName());
+      retry(testNotifier, statement, t, getDescription());
+    }
+  }
+
+  /*
+   * (non-Javadoc)
+   *
+   * @see org.junit.runners.BlockJUnit4ClassRunner#runChild(org.junit.runners.model.FrameworkMethod,
+   * org.junit.runner.notification.RunNotifier)
+   */
+  @Override
+  protected void runChild(final FrameworkMethod method, RunNotifier notifier) {
+    Description description = describeChild(method);
+    if (method.getAnnotation(Ignore.class) != null) {
+      notifier.fireTestIgnored(description);
+    } else {
+      runTest(methodBlock(method), description, notifier);
+    }
+  }
+
+  private void runTest(Statement statement, Description description, RunNotifier notifier) {
+    EachTestNotifier eachNotifier = new EachTestNotifier(notifier, description);
+    eachNotifier.fireTestStarted();
+    try {
+      statement.evaluate();
+    } catch (AssumptionViolatedException e) {
+      eachNotifier.addFailedAssumption(e);
+    } catch (Throwable e) {
+      LOG.warning("Retry test: " + description.getDisplayName());
+      retry(eachNotifier, statement, e, description);
+    } finally {
+      eachNotifier.fireTestFinished();
+    }
+  }
+
+  private void retry(EachTestNotifier notifier, Statement statement, Throwable currentThrowable, Description info) {
+    int failedAttempts = 0;
+    Throwable caughtThrowable = currentThrowable;
+    while (RETRY_COUNT > failedAttempts) {
+      try {
+        LOG.warning("Retry attempt " + (failedAttempts + 1) + " for " + info.getDisplayName());
+        statement.evaluate();
+        return;
+      } catch (UnauthorizedException ue) {
+        LOG.log(Level.WARNING, "Do not retry test failures due to UnauthorizedException", ue);
+        failedAttempts = RETRY_COUNT;
+      } catch (TooManyRequestsException e) {
+        LOG.log(Level.WARNING, "Ignoring test failures due to rate limitation", e);
+        return;
+      } catch (Throwable t) {
+        failedAttempts++;
+        try {
+          // GERMAN: Delay test failures to prevent network/service hiccups
+          Thread.sleep(RETRY_DELAY_FACTOR * failedAttempts);
+        } catch (InterruptedException e) {
+          LOG.log(Level.WARNING, "The thread used by JUnit was interrupted", e);
+        }
+        caughtThrowable = t;
+      }
+    }
+    notifier.addFailure(caughtThrowable);
+  }
+}

common/src/test/java/com/ibm/watson/common/TestUtils.java

@@ -0,0 +1,126 @@
+package com.ibm.watson.common;
+
+import junit.framework.AssertionFailedError;
+import org.junit.Ignore;
+
+import java.beans.BeanInfo;
+import java.beans.Introspector;
+import java.beans.PropertyDescriptor;
+import java.io.IOException;
+import java.io.InputStream;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.Collection;
+
+/**
+ * The Class TestUtils.
+ */
+@Ignore
+public final class TestUtils {
+  /**
+   * Private constructor.
+   */
+  private TestUtils() { }
+
+  /**
+   * Test that a collection is not null or empty.
+   *
+   * @param objs the collection of objects
+   * @throws Exception any exception
+   */
+  @SuppressWarnings("rawtypes")
+  public static void assertIsEmpty(final Collection objs) throws Exception {
+    if ((objs != null) && !objs.isEmpty()) {
+      throw new AssertionFailedError("Collection is empty");
+    }
+  }
+
+  /**
+   * Test that collection iteration does not generate exceptions.
+   *
+   * @param objs the collection of objects
+   * @throws Exception any exception
+   */
+  @SuppressWarnings("rawtypes")
+  public static void assertNoExceptionsOnCollectionIteration(final Collection objs) throws Exception {
+    for (final Object obj : objs) {
+      assertNoExceptionsOnGetters(obj);
+    }
+  }
+
+  /**
+   * Test access to the properties of an object through its accessors.
+   *
+   * @param obj the object to test
+   * @throws Exception any exception
+   */
+  public static void assertNoExceptionsOnGetters(final Object obj) throws Exception {
+
+    final Class<?> clazz = obj.getClass();
+    final BeanInfo beanInfo = Introspector.getBeanInfo(clazz);
+    final PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
+
+    for (final PropertyDescriptor propertyDescriptor : propertyDescriptors) {
+      final Method readMethod = propertyDescriptor.getReadMethod();
+
+      if (readMethod != null) {
+        try {
+          readMethod.invoke(obj, new Object[] { });
+        } catch (final InvocationTargetException e) {
+          final StringBuffer msg = new StringBuffer();
+          msg.append("Failure: " + propertyDescriptor.getName());
+          msg.append(" Exception: " + e.getCause().getClass());
+          msg.append(" Msg: " + e.getCause().getMessage());
+          throw new AssertionFailedError(msg.toString());
+        }
+      }
+    }
+
+  }
+
+  /**
+   * Test that a collection is not null or empty.
+   *
+   * @param objs the collection of objects
+   * @throws Exception any exception
+   */
+  @SuppressWarnings({ "rawtypes" })
+  public static void assertNotEmpty(final Collection objs) throws Exception {
+    if (objs == null) {
+      throw new AssertionFailedError("Collection is null");
+    }
+    if (objs.isEmpty()) {
+      throw new AssertionFailedError("Collection is empty");
+    }
+  }
+
+  /**
+   * Checks if both InputStreams have the same content and length. The streams are closed after reading.
+   *
+   * @param s1 the s1
+   * @param s2 the s2
+   * @return true, if the InputStreams are equal
+   * @throws IOException Signals that an I/O exception has occurred.
+   */
+  public static boolean streamContentEquals(InputStream s1, InputStream s2) throws IOException {
+    try {
+      int b1;
+      int b2;
+
+      do { // read while both stream contents are equal and s1 still has more bytes
+        b1 = s1.read();
+        b2 = s2.read();
+      } while ((b1 == b2) && (b1 != -1));
+
+      // this is true iff both streams are equally long and have the same content
+      return b1 == b2;
+    } finally {
+      try {
+        s1.close();
+        s2.close();
+      } catch (Exception e) {
+        // Exceptions during closing seem to be ok!
+      }
+    }
+  }
+}

common/src/test/java/com/ibm/watson/common/WaitFor.java

@@ -0,0 +1,51 @@
+package com.ibm.watson.common;
+
+import java.util.concurrent.TimeUnit;
+
+/**
+ * Wait for a certain condition to be true or for a timeout to expire.
+ *
+ */
+
+public class WaitFor {
+
+  private WaitFor() {
+
+  }
+
+  /**
+   * Static method used to wait for a specific condition to be satisfied.
+   *
+   * @param condition The condition to check
+   * @param time The maximum time to wait for the condition to become true
+   * @param unit The time unit of the {@code time} argument
+   * @param sleepMs The time to wait between checks
+   *
+   * @return true if the condition was true before the timeout, false if it wasn't.
+   */
+  public static boolean waitFor(Condition condition, long time, TimeUnit unit, long sleepMs) {
+    long waitMs = unit.toMillis(time);
+    long startMs = System.currentTimeMillis();
+    while (System.currentTimeMillis() - startMs < waitMs) {
+      if (condition.isSatisfied()) {
+        return true;
+      }
+      try {
+        Thread.sleep(sleepMs);
+      } catch (InterruptedException e) {
+        throw new RuntimeException("WaitFor aborted", e);
+      }
+    }
+    return false;
+  }
+
+  /**
+   * The Interface Condition.
+   */
+  public interface Condition {
+    /**
+     * @return true/false indicating whether or not the condition has been met.
+     */
+    boolean isSatisfied();
+  }
+}