beam-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From k...@apache.org
Subject [1/2] beam git commit: Captures assertion site and message in PAssert
Date Wed, 11 Jan 2017 05:56:57 GMT
Repository: beam
Updated Branches:
  refs/heads/master 055f452c0 -> 51820cbe0


Captures assertion site and message in PAssert

This makes PAssert failures quite a bit easier to debug.
Example message after this commit:

java.lang.AssertionError: Some message

	at org.apache.beam.sdk.testing.PAssert$PAssertionSite.capture(PAssert.java:384)
	at org.apache.beam.sdk.testing.PAssert.that(PAssert.java:279)
	at org.apache.beam.sdk.transforms.SplittableDoFnTest.testPairWithIndexWindowedTimestamped(SplittableDoFnTest.java:234)
	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
        ...
Caused by: java.lang.AssertionError:
Expected: iterable over [<TimestampedValue(KV{z, 0}, 2017-01-10T00:38:28.000Z)>, <TimestampedValue(KV{bb,
0}, 2017-01-10T00:38:29.000Z)>, <TimestampedValue(KV{bb, 1}, 2017-01-10T00:38:29.000Z)>,
<TimestampedValue(KV{ccccc, 0}, 2017-01-10T00:38:30.000Z)>, <TimestampedValue(KV{ccccc,
1}, 2017-01-10T00:38:30.000Z)>, <TimestampedValue(KV{ccccc, 2}, 2017-01-10T00:38:30.000Z)>,
<TimestampedValue(KV{ccccc, 3}, 2017-01-10T00:38:30.000Z)>, <TimestampedValue(KV{ccccc,
4}, 2017-01-10T00:38:30.000Z)>] in any order
     but: Not matched: <TimestampedValue(KV{a, 0}, 2017-01-10T00:38:28.000Z)>
	at org.hamcrest.MatcherAssert.assertThat(MatcherAssert.java:20)
	at org.junit.Assert.assertThat(Assert.java:956)
	at org.junit.Assert.assertThat(Assert.java:923)
	at org.apache.beam.sdk.testing.PAssert$AssertContainsInAnyOrder.apply(PAssert.java:1270)
	at org.apache.beam.sdk.testing.PAssert$AssertContainsInAnyOrder.apply(PAssert.java:1)
        ...

(as opposed to, basically, just the "Caused by" part)


Project: http://git-wip-us.apache.org/repos/asf/beam/repo
Commit: http://git-wip-us.apache.org/repos/asf/beam/commit/c62611c7
Tree: http://git-wip-us.apache.org/repos/asf/beam/tree/c62611c7
Diff: http://git-wip-us.apache.org/repos/asf/beam/diff/c62611c7

Branch: refs/heads/master
Commit: c62611c73ab0f9a5769f3ee9b28b11e917628f78
Parents: b81bd25
Author: Eugene Kirpichov <kirpichov@google.com>
Authored: Mon Jan 9 16:38:50 2017 -0800
Committer: Kenneth Knowles <klk@google.com>
Committed: Tue Jan 10 21:45:21 2017 -0800

----------------------------------------------------------------------
 .../org/apache/beam/sdk/testing/PAssert.java    | 163 +++++++++++++++----
 .../apache/beam/sdk/testing/PAssertTest.java    |  44 +++++
 2 files changed, 174 insertions(+), 33 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/beam/blob/c62611c7/sdks/java/core/src/main/java/org/apache/beam/sdk/testing/PAssert.java
----------------------------------------------------------------------
diff --git a/sdks/java/core/src/main/java/org/apache/beam/sdk/testing/PAssert.java b/sdks/java/core/src/main/java/org/apache/beam/sdk/testing/PAssert.java
index b57f4a9..89d6fea 100644
--- a/sdks/java/core/src/main/java/org/apache/beam/sdk/testing/PAssert.java
+++ b/sdks/java/core/src/main/java/org/apache/beam/sdk/testing/PAssert.java
@@ -275,8 +275,13 @@ public class PAssert {
   /**
    * Constructs an {@link IterableAssert} for the elements of the provided {@link PCollection}.
    */
+  public static <T> IterableAssert<T> that(String message, PCollection<T>
actual) {
+    return new PCollectionContentsAssert<>(PAssertionSite.capture(message), actual);
+  }
+
+  /** @see #that(String, PCollection) */
   public static <T> IterableAssert<T> that(PCollection<T> actual) {
-    return new PCollectionContentsAssert<>(actual);
+    return that("", actual);
   }
 
   /**
@@ -284,7 +289,7 @@ public class PAssert {
    * must contain a single {@code Iterable<T>} value.
    */
   public static <T> IterableAssert<T> thatSingletonIterable(
-      PCollection<? extends Iterable<T>> actual) {
+      String message, PCollection<? extends Iterable<T>> actual) {
 
     try {
     } catch (NoSuchElementException | IllegalArgumentException exc) {
@@ -297,15 +302,29 @@ public class PAssert {
     @SuppressWarnings("unchecked") // Safe covariant cast
     PCollection<Iterable<T>> actualIterables = (PCollection<Iterable<T>>)
actual;
 
-    return new PCollectionSingletonIterableAssert<>(actualIterables);
+    return new PCollectionSingletonIterableAssert<>(
+        PAssertionSite.capture(message), actualIterables);
   }
 
-  /**
-   * Constructs a {@link SingletonAssert} for the value of the provided
-   * {@code PCollection PCollection<T>}, which must be a singleton.
-   */
+  /** @see #thatSingletonIterable(String, PCollection)  */
+  public static <T> IterableAssert<T> thatSingletonIterable(
+      PCollection<? extends Iterable<T>> actual) {
+    return thatSingletonIterable("", actual);
+  }
+
+    /**
+     * Constructs a {@link SingletonAssert} for the value of the provided
+     * {@code PCollection PCollection<T>}, which must be a singleton.
+     */
+  public static <T> SingletonAssert<T> thatSingleton(String message, PCollection<T>
actual) {
+    return new PCollectionViewAssert<>(
+        PAssertionSite.capture(message),
+        actual, View.<T>asSingleton(), actual.getCoder());
+  }
+
+  /** @see #thatSingleton(String, PCollection) */
   public static <T> SingletonAssert<T> thatSingleton(PCollection<T> actual)
{
-    return new PCollectionViewAssert<>(actual, View.<T>asSingleton(), actual.getCoder());
+    return thatSingleton("", actual);
   }
 
   /**
@@ -315,48 +334,90 @@ public class PAssert {
    * {@code Coder<K, V>}.
    */
   public static <K, V> SingletonAssert<Map<K, Iterable<V>>> thatMultimap(
+      String message,
       PCollection<KV<K, V>> actual) {
     @SuppressWarnings("unchecked")
     KvCoder<K, V> kvCoder = (KvCoder<K, V>) actual.getCoder();
     return new PCollectionViewAssert<>(
+        PAssertionSite.capture(message),
         actual,
         View.<K, V>asMultimap(),
         MapCoder.of(kvCoder.getKeyCoder(), IterableCoder.of(kvCoder.getValueCoder())));
   }
 
+  /** @see #thatMultimap(String, PCollection) */
+  public static <K, V> SingletonAssert<Map<K, Iterable<V>>> thatMultimap(
+      PCollection<KV<K, V>> actual) {
+    return thatMultimap("", actual);
+  }
+
   /**
    * Constructs a {@link SingletonAssert} for the value of the provided {@link PCollection},
which
    * must have at most one value per key.
    *
-   * <p>Note that the actual value must be coded by a {@link KvCoder}, not just any
-   * {@code Coder<K, V>}.
+   * <p>Note that the actual value must be coded by a {@link KvCoder}, not just any
{@code Coder<K,
+   * V>}.
    */
-  public static <K, V> SingletonAssert<Map<K, V>> thatMap(PCollection<KV<K,
V>> actual) {
+  public static <K, V> SingletonAssert<Map<K, V>> thatMap(
+      String message, PCollection<KV<K, V>> actual) {
     @SuppressWarnings("unchecked")
     KvCoder<K, V> kvCoder = (KvCoder<K, V>) actual.getCoder();
     return new PCollectionViewAssert<>(
-        actual, View.<K, V>asMap(), MapCoder.of(kvCoder.getKeyCoder(), kvCoder.getValueCoder()));
+        PAssertionSite.capture(message),
+        actual,
+        View.<K, V>asMap(),
+        MapCoder.of(kvCoder.getKeyCoder(), kvCoder.getValueCoder()));
+  }
+
+  /** @see #thatMap(String, PCollection) */
+  public static <K, V> SingletonAssert<Map<K, V>> thatMap(PCollection<KV<K,
V>> actual) {
+    return thatMap("", actual);
   }
 
   ////////////////////////////////////////////////////////////
 
+  private static class PAssertionSite implements Serializable {
+    private final String message;
+    private final StackTraceElement[] creationStackTrace;
+
+    static PAssertionSite capture(String message) {
+      return new PAssertionSite(message, new Throwable().getStackTrace());
+    }
+
+    PAssertionSite(String message, StackTraceElement[] creationStackTrace) {
+      this.message = message;
+      this.creationStackTrace = creationStackTrace;
+    }
+
+    public AssertionError wrap(Throwable t) {
+      AssertionError res =
+          new AssertionError(
+              message.isEmpty() ? t.getMessage() : (message + ": " + t.getMessage()), t);
+      res.setStackTrace(creationStackTrace);
+      return res;
+    }
+  }
+
   /**
    * An {@link IterableAssert} about the contents of a {@link PCollection}. This does not
require
    * the runner to support side inputs.
    */
   private static class PCollectionContentsAssert<T> implements IterableAssert<T>
{
+    private final PAssertionSite site;
     private final PCollection<T> actual;
     private final AssertionWindows rewindowingStrategy;
     private final SimpleFunction<Iterable<ValueInSingleWindow<T>>, Iterable<T>>
paneExtractor;
 
-    public PCollectionContentsAssert(PCollection<T> actual) {
-      this(actual, IntoGlobalWindow.<T>of(), PaneExtractors.<T>allPanes());
+    public PCollectionContentsAssert(PAssertionSite site, PCollection<T> actual) {
+      this(site, actual, IntoGlobalWindow.<T>of(), PaneExtractors.<T>allPanes());
     }
 
     public PCollectionContentsAssert(
+        PAssertionSite site,
         PCollection<T> actual,
         AssertionWindows rewindowingStrategy,
         SimpleFunction<Iterable<ValueInSingleWindow<T>>, Iterable<T>>
paneExtractor) {
+      this.site = site;
       this.actual = actual;
       this.rewindowingStrategy = rewindowingStrategy;
       this.paneExtractor = paneExtractor;
@@ -394,7 +455,7 @@ public class PAssert {
       Coder<BoundedWindow> windowCoder =
           (Coder) actual.getWindowingStrategy().getWindowFn().windowCoder();
       return new PCollectionContentsAssert<>(
-          actual, IntoStaticWindows.<T>of(windowCoder, window), paneExtractor);
+          site, actual, IntoStaticWindows.<T>of(windowCoder, window), paneExtractor);
     }
 
     /**
@@ -429,7 +490,7 @@ public class PAssert {
         SerializableFunction<Iterable<T>, Void> checkerFn) {
       actual.apply(
           nextAssertionName(),
-          new GroupThenAssert<>(checkerFn, rewindowingStrategy, paneExtractor));
+          new GroupThenAssert<>(site, checkerFn, rewindowingStrategy, paneExtractor));
       return this;
     }
 
@@ -471,7 +532,7 @@ public class PAssert {
           (SerializableFunction) new MatcherCheckerFn<>(matcher);
       actual.apply(
           "PAssert$" + (assertCount++),
-          new GroupThenAssert<>(checkerFn, rewindowingStrategy, paneExtractor));
+          new GroupThenAssert<>(site, checkerFn, rewindowingStrategy, paneExtractor));
       return this;
     }
 
@@ -518,21 +579,26 @@ public class PAssert {
    * This does not require the runner to support side inputs.
    */
   private static class PCollectionSingletonIterableAssert<T> implements IterableAssert<T>
{
+    private final PAssertionSite site;
     private final PCollection<Iterable<T>> actual;
     private final Coder<T> elementCoder;
     private final AssertionWindows rewindowingStrategy;
     private final SimpleFunction<Iterable<ValueInSingleWindow<Iterable<T>>>,
Iterable<Iterable<T>>>
         paneExtractor;
 
-    public PCollectionSingletonIterableAssert(PCollection<Iterable<T>> actual)
{
-      this(actual, IntoGlobalWindow.<Iterable<T>>of(), PaneExtractors.<Iterable<T>>onlyPane());
+    public PCollectionSingletonIterableAssert(
+        PAssertionSite site, PCollection<Iterable<T>> actual) {
+      this(
+          site, actual, IntoGlobalWindow.<Iterable<T>>of(), PaneExtractors.<Iterable<T>>onlyPane());
     }
 
     public PCollectionSingletonIterableAssert(
+        PAssertionSite site,
         PCollection<Iterable<T>> actual,
         AssertionWindows rewindowingStrategy,
         SimpleFunction<Iterable<ValueInSingleWindow<Iterable<T>>>, Iterable<Iterable<T>>>
             paneExtractor) {
+      this.site = site;
       this.actual = actual;
 
       @SuppressWarnings("unchecked")
@@ -576,7 +642,7 @@ public class PAssert {
       Coder<BoundedWindow> windowCoder =
           (Coder) actual.getWindowingStrategy().getWindowFn().windowCoder();
       return new PCollectionSingletonIterableAssert<>(
-          actual, IntoStaticWindows.<Iterable<T>>of(windowCoder, window), paneExtractor);
+          site, actual, IntoStaticWindows.<Iterable<T>>of(windowCoder, window),
paneExtractor);
     }
 
     @Override
@@ -600,7 +666,7 @@ public class PAssert {
         SerializableFunction<Iterable<T>, Void> checkerFn) {
       actual.apply(
           "PAssert$" + (assertCount++),
-          new GroupThenAssertForSingleton<>(checkerFn, rewindowingStrategy, paneExtractor));
+          new GroupThenAssertForSingleton<>(site, checkerFn, rewindowingStrategy, paneExtractor));
       return this;
     }
 
@@ -617,6 +683,7 @@ public class PAssert {
    * of type {@code ViewT}. This requires side input support from the runner.
    */
   private static class PCollectionViewAssert<ElemT, ViewT> implements SingletonAssert<ViewT>
{
+    private final PAssertionSite site;
     private final PCollection<ElemT> actual;
     private final PTransform<PCollection<ElemT>, PCollectionView<ViewT>>
view;
     private final AssertionWindows rewindowActuals;
@@ -625,18 +692,27 @@ public class PAssert {
     private final Coder<ViewT> coder;
 
     protected PCollectionViewAssert(
+        PAssertionSite site,
         PCollection<ElemT> actual,
         PTransform<PCollection<ElemT>, PCollectionView<ViewT>> view,
         Coder<ViewT> coder) {
-      this(actual, view, IntoGlobalWindow.<ElemT>of(), PaneExtractors.<ElemT>onlyPane(),
coder);
+      this(
+          site,
+          actual,
+          view,
+          IntoGlobalWindow.<ElemT>of(),
+          PaneExtractors.<ElemT>onlyPane(),
+          coder);
     }
 
     private PCollectionViewAssert(
+        PAssertionSite site,
         PCollection<ElemT> actual,
         PTransform<PCollection<ElemT>, PCollectionView<ViewT>> view,
         AssertionWindows rewindowActuals,
         SimpleFunction<Iterable<ValueInSingleWindow<ElemT>>, Iterable<ElemT>>
paneExtractor,
         Coder<ViewT> coder) {
+      this.site = site;
       this.actual = actual;
       this.view = view;
       this.rewindowActuals = rewindowActuals;
@@ -663,6 +739,7 @@ public class PAssert {
         BoundedWindow window,
         SimpleFunction<Iterable<ValueInSingleWindow<ElemT>>, Iterable<ElemT>>
paneExtractor) {
       return new PCollectionViewAssert<>(
+          site,
           actual,
           view,
           IntoStaticWindows.of(
@@ -689,6 +766,7 @@ public class PAssert {
           .apply(
               "PAssert$" + (assertCount++),
               new OneSideInputAssert<ViewT>(
+                  site,
                   CreateActual.from(actual, rewindowActuals, paneExtractor, view),
                   rewindowActuals.<Integer>windowDummy(),
                   checkerFn));
@@ -911,14 +989,17 @@ public class PAssert {
    */
   public static class GroupThenAssert<T> extends PTransform<PCollection<T>,
PDone>
       implements Serializable {
+    private final PAssertionSite site;
     private final SerializableFunction<Iterable<T>, Void> checkerFn;
     private final AssertionWindows rewindowingStrategy;
     private final SimpleFunction<Iterable<ValueInSingleWindow<T>>, Iterable<T>>
paneExtractor;
 
     private GroupThenAssert(
+        PAssertionSite site,
         SerializableFunction<Iterable<T>, Void> checkerFn,
         AssertionWindows rewindowingStrategy,
         SimpleFunction<Iterable<ValueInSingleWindow<T>>, Iterable<T>>
paneExtractor) {
+      this.site = site;
       this.checkerFn = checkerFn;
       this.rewindowingStrategy = rewindowingStrategy;
       this.paneExtractor = paneExtractor;
@@ -930,7 +1011,7 @@ public class PAssert {
           .apply("GroupGlobally", new GroupGlobally<T>(rewindowingStrategy))
           .apply("GetPane", MapElements.via(paneExtractor))
           .setCoder(IterableCoder.of(input.getCoder()))
-          .apply("RunChecks", ParDo.of(new GroupedValuesCheckerDoFn<>(checkerFn)));
+          .apply("RunChecks", ParDo.of(new GroupedValuesCheckerDoFn<>(site, checkerFn)));
 
       return PDone.in(input.getPipeline());
     }
@@ -942,16 +1023,19 @@ public class PAssert {
    */
   public static class GroupThenAssertForSingleton<T>
       extends PTransform<PCollection<Iterable<T>>, PDone> implements Serializable
{
+    private final PAssertionSite site;
     private final SerializableFunction<Iterable<T>, Void> checkerFn;
     private final AssertionWindows rewindowingStrategy;
     private final SimpleFunction<Iterable<ValueInSingleWindow<Iterable<T>>>,
Iterable<Iterable<T>>>
         paneExtractor;
 
     private GroupThenAssertForSingleton(
+        PAssertionSite site,
         SerializableFunction<Iterable<T>, Void> checkerFn,
         AssertionWindows rewindowingStrategy,
         SimpleFunction<Iterable<ValueInSingleWindow<Iterable<T>>>, Iterable<Iterable<T>>>
             paneExtractor) {
+      this.site = site;
       this.checkerFn = checkerFn;
       this.rewindowingStrategy = rewindowingStrategy;
       this.paneExtractor = paneExtractor;
@@ -963,7 +1047,7 @@ public class PAssert {
           .apply("GroupGlobally", new GroupGlobally<Iterable<T>>(rewindowingStrategy))
           .apply("GetPane", MapElements.via(paneExtractor))
           .setCoder(IterableCoder.of(input.getCoder()))
-          .apply("RunChecks", ParDo.of(new SingletonCheckerDoFn<>(checkerFn)));
+          .apply("RunChecks", ParDo.of(new SingletonCheckerDoFn<>(site, checkerFn)));
 
       return PDone.in(input.getPipeline());
     }
@@ -981,14 +1065,17 @@ public class PAssert {
    */
   public static class OneSideInputAssert<ActualT> extends PTransform<PBegin, PDone>
       implements Serializable {
+    private final PAssertionSite site;
     private final transient PTransform<PBegin, PCollectionView<ActualT>> createActual;
     private final transient PTransform<PCollection<Integer>, PCollection<Integer>>
windowToken;
     private final SerializableFunction<ActualT, Void> checkerFn;
 
     private OneSideInputAssert(
+        PAssertionSite site,
         PTransform<PBegin, PCollectionView<ActualT>> createActual,
         PTransform<PCollection<Integer>, PCollection<Integer>> windowToken,
         SerializableFunction<ActualT, Void> checkerFn) {
+      this.site = site;
       this.createActual = createActual;
       this.windowToken = windowToken;
       this.checkerFn = checkerFn;
@@ -1003,7 +1090,7 @@ public class PAssert {
           .apply("WindowToken", windowToken)
           .apply(
               "RunChecks",
-              ParDo.withSideInputs(actual).of(new SideInputCheckerDoFn<>(checkerFn,
actual)));
+              ParDo.withSideInputs(actual).of(new SideInputCheckerDoFn<>(site, checkerFn,
actual)));
 
       return PDone.in(input.getPipeline());
     }
@@ -1017,6 +1104,7 @@ public class PAssert {
    * null values.
    */
   private static class SideInputCheckerDoFn<ActualT> extends DoFn<Integer, Void>
{
+    private final PAssertionSite site;
     private final SerializableFunction<ActualT, Void> checkerFn;
     private final Aggregator<Integer, Integer> success =
         createAggregator(SUCCESS_COUNTER, Sum.ofIntegers());
@@ -1025,7 +1113,10 @@ public class PAssert {
     private final PCollectionView<ActualT> actual;
 
     private SideInputCheckerDoFn(
-        SerializableFunction<ActualT, Void> checkerFn, PCollectionView<ActualT>
actual) {
+        PAssertionSite site,
+        SerializableFunction<ActualT, Void> checkerFn,
+        PCollectionView<ActualT> actual) {
+      this.site = site;
       this.checkerFn = checkerFn;
       this.actual = actual;
     }
@@ -1034,7 +1125,7 @@ public class PAssert {
     public void processElement(ProcessContext c) {
       try {
         ActualT actualContents = c.sideInput(actual);
-        doChecks(actualContents, checkerFn, success, failure);
+        doChecks(site, actualContents, checkerFn, success, failure);
       } catch (Throwable t) {
         // Suppress exception in streaming
         if (!c.getPipelineOptions().as(StreamingOptions.class).isStreaming()) {
@@ -1052,19 +1143,22 @@ public class PAssert {
    * <p>The singleton property is presumed, not enforced.
    */
   private static class GroupedValuesCheckerDoFn<ActualT> extends DoFn<ActualT, Void>
{
+    private final PAssertionSite site;
     private final SerializableFunction<ActualT, Void> checkerFn;
     private final Aggregator<Integer, Integer> success =
         createAggregator(SUCCESS_COUNTER, Sum.ofIntegers());
     private final Aggregator<Integer, Integer> failure =
         createAggregator(FAILURE_COUNTER, Sum.ofIntegers());
 
-    private GroupedValuesCheckerDoFn(SerializableFunction<ActualT, Void> checkerFn)
{
+    private GroupedValuesCheckerDoFn(
+        PAssertionSite site, SerializableFunction<ActualT, Void> checkerFn) {
+      this.site = site;
       this.checkerFn = checkerFn;
     }
 
     @ProcessElement
     public void processElement(ProcessContext c) {
-      doChecks(c.element(), checkerFn, success, failure);
+      doChecks(site, c.element(), checkerFn, success, failure);
     }
   }
 
@@ -1077,24 +1171,28 @@ public class PAssert {
    * each input element must be a singleton iterable, or this will fail.
    */
   private static class SingletonCheckerDoFn<ActualT> extends DoFn<Iterable<ActualT>,
Void> {
+    private final PAssertionSite site;
     private final SerializableFunction<ActualT, Void> checkerFn;
     private final Aggregator<Integer, Integer> success =
         createAggregator(SUCCESS_COUNTER, Sum.ofIntegers());
     private final Aggregator<Integer, Integer> failure =
         createAggregator(FAILURE_COUNTER, Sum.ofIntegers());
 
-    private SingletonCheckerDoFn(SerializableFunction<ActualT, Void> checkerFn) {
+    private SingletonCheckerDoFn(
+        PAssertionSite site, SerializableFunction<ActualT, Void> checkerFn) {
+      this.site = site;
       this.checkerFn = checkerFn;
     }
 
     @ProcessElement
     public void processElement(ProcessContext c) {
       ActualT actualContents = Iterables.getOnlyElement(c.element());
-      doChecks(actualContents, checkerFn, success, failure);
+      doChecks(site, actualContents, checkerFn, success, failure);
     }
   }
 
   private static <ActualT> void doChecks(
+      PAssertionSite site,
       ActualT actualContents,
       SerializableFunction<ActualT, Void> checkerFn,
       Aggregator<Integer, Integer> successAggregator,
@@ -1103,9 +1201,8 @@ public class PAssert {
       checkerFn.apply(actualContents);
       successAggregator.addValue(1);
     } catch (Throwable t) {
-      LOG.error("PAssert failed expectations.", t);
       failureAggregator.addValue(1);
-      throw t;
+      throw site.wrap(t);
     }
   }
 

http://git-wip-us.apache.org/repos/asf/beam/blob/c62611c7/sdks/java/core/src/test/java/org/apache/beam/sdk/testing/PAssertTest.java
----------------------------------------------------------------------
diff --git a/sdks/java/core/src/test/java/org/apache/beam/sdk/testing/PAssertTest.java b/sdks/java/core/src/test/java/org/apache/beam/sdk/testing/PAssertTest.java
index 1997bbe..e09f54b 100644
--- a/sdks/java/core/src/test/java/org/apache/beam/sdk/testing/PAssertTest.java
+++ b/sdks/java/core/src/test/java/org/apache/beam/sdk/testing/PAssertTest.java
@@ -24,6 +24,7 @@ import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
 
 import com.fasterxml.jackson.annotation.JsonCreator;
+import com.google.common.base.Throwables;
 import com.google.common.collect.Iterables;
 import java.io.IOException;
 import java.io.InputStream;
@@ -392,6 +393,49 @@ public class PAssertTest implements Serializable {
     assertThat(thrown.getMessage(), containsString("Expected: iterable over [] in any order"));
   }
 
+  @Test
+  @Category(RunnableOnService.class)
+  public void testAssertionSiteIsCapturedWithMessage() throws Exception {
+    PCollection<Long> vals = pipeline.apply(CountingInput.upTo(5L));
+    assertThatCollectionIsEmptyWithMessage(vals);
+
+    Throwable thrown = runExpectingAssertionFailure(pipeline);
+
+    assertThat(
+        thrown.getMessage(),
+        containsString("Should be empty"));
+    assertThat(
+        thrown.getMessage(),
+        containsString("Expected: iterable over [] in any order"));
+    String stacktrace = Throwables.getStackTraceAsString(thrown);
+    assertThat(stacktrace, containsString("testAssertionSiteIsCapturedWithMessage"));
+    assertThat(stacktrace, containsString("assertThatCollectionIsEmptyWithMessage"));
+  }
+
+  @Test
+  @Category(RunnableOnService.class)
+  public void testAssertionSiteIsCapturedWithoutMessage() throws Exception {
+    PCollection<Long> vals = pipeline.apply(CountingInput.upTo(5L));
+    assertThatCollectionIsEmptyWithoutMessage(vals);
+
+    Throwable thrown = runExpectingAssertionFailure(pipeline);
+
+    assertThat(
+        thrown.getMessage(),
+        containsString("Expected: iterable over [] in any order"));
+    String stacktrace = Throwables.getStackTraceAsString(thrown);
+    assertThat(stacktrace, containsString("testAssertionSiteIsCapturedWithoutMessage"));
+    assertThat(stacktrace, containsString("assertThatCollectionIsEmptyWithoutMessage"));
+  }
+
+  private static void assertThatCollectionIsEmptyWithMessage(PCollection<Long> vals)
{
+    PAssert.that("Should be empty", vals).empty();
+  }
+
+  private static void assertThatCollectionIsEmptyWithoutMessage(PCollection<Long> vals)
{
+    PAssert.that(vals).empty();
+  }
+
   private static Throwable runExpectingAssertionFailure(Pipeline pipeline) {
     // We cannot use thrown.expect(AssertionError.class) because the AssertionError
     // is first caught by JUnit and causes a test failure.


Mime
View raw message