Package com.hazelcast.jet.pipeline.test

Class Assertions

  • public final class Assertions
extends java.lang.Object
    Various assertions which can be used to assert items passing through the pipeline for correctness. Each assertion also returns the stage it is attached to so the assertions could be used in-line.

    The assertions in this class are to be used together with the apply() operator on the pipeline. For assertions that can be used directly as sinks, see AssertionSinks.

    Since:
    Jet 3.2

    • Method Detail

      • assertOrdered

        @Nonnull
public static <T> FunctionEx<BatchStage<T>,​BatchStage<T>> assertOrdered​(@Nullable
                                                                              java.lang.String message,
                                                                              @Nonnull
                                                                              java.util.Collection<? extends T> expected)
        Asserts that the previous stage emitted the exact sequence of expected items and nothing else. If the assertion fails, the job will fail with an AssertionError with the given message.

        Example: 

        
 p.readFrom(TestSources.items(1, 2, 3, 4))
  .apply(Assertions.assertOrdered("unexpected values", Arrays.asList(1, 2, 3, 4)))
  .writeTo(Sinks.logger());
        Note: Since Jet jobs are distributed, input from multiple upstream processors is merged in a non-deterministic way. Therefore this assertion is recommended only for testing of non-distributed sources.

      • assertOrdered

        @Nonnull
public static <T> FunctionEx<BatchStage<T>,​BatchStage<T>> assertOrdered​(@Nonnull
                                                                              java.util.Collection<? extends T> expected)
        Asserts that the previous stage emitted the exact sequence of expected items and nothing else. If the assertion fails, the job will fail with an AssertionError.

        Example: 

        
 p.readFrom(TestSources.items(1, 2, 3, 4))
  .apply(Assertions.assertOrderedArrays.asList(1, 2, 3, 4)))
  .writeTo(Sinks.logger());
        Note: Since Jet jobs are distributed, input from multiple upstream processors is merged in a non-deterministic way. Therefore this assertion is recommended only for testing of non-distributed sources.

      • assertAnyOrder

        @Nonnull
public static <T> FunctionEx<BatchStage<T>,​BatchStage<T>> assertAnyOrder​(@Nullable
                                                                               java.lang.String message,
                                                                               @Nonnull
                                                                               java.util.Collection<? extends T> expected)
        Asserts that the previous stage emitted the expected items in any order, but nothing else. If the assertion fails, the job will fail with an AssertionError with the given message.

        Example: 

        
 p.readFrom(TestSources.items(4, 3, 2, 1))
  .apply(Assertions.assertAnyOrder("unexpected values", Arrays.asList(1, 2, 3, 4)))
  .writeTo(Sinks.logger())

      • assertAnyOrder

        @Nonnull
public static <T> FunctionEx<BatchStage<T>,​BatchStage<T>> assertAnyOrder​(@Nonnull
                                                                               java.util.Collection<? extends T> expected)
        Asserts that the previous stage emitted the expected items in any order, but nothing else. If the assertion fails, the job will fail with an AssertionError.

        Example: 

        
 p.readFrom(TestSources.items(4, 3, 2, 1))
  .apply(Assertions.assertAnyOrder(Arrays.asList(1, 2, 3, 4)))
  .writeTo(Sinks.logger())

      • assertContains

        @Nonnull
public static <T> FunctionEx<BatchStage<T>,​BatchStage<T>> assertContains​(@Nullable
                                                                               java.lang.String message,
                                                                               @Nonnull
                                                                               java.util.Collection<? extends T> expected)
        Asserts that the previous stage emitted all of the given items in any order. If the assertion fails, the job will fail with an AssertionError with the given message.

        Example: 

        
 p.readFrom(TestSources.items(4, 3, 2, 1))
  .apply(Assertions.assertAnyOrder(Arrays.asList(1, 3)))
  .writeTo(Sinks.logger())

      • assertContains

        @Nonnull
public static <T> FunctionEx<BatchStage<T>,​BatchStage<T>> assertContains​(@Nonnull
                                                                               java.util.Collection<? extends T> expected)
        Asserts that the previous stage emitted all of the given items in any order. If the assertion fails, the job will fail with a AssertionError with the given message.

        Example: 

        
 p.readFrom(TestSources.items(4, 3, 2, 1))
  .apply(Assertions.assertContains(Arrays.asList(1, 3)))
  .writeTo(Sinks.logger())

      • assertCollected

        @Nonnull
public static <T> FunctionEx<BatchStage<T>,​BatchStage<T>> assertCollected​(@Nonnull
                                                                                ConsumerEx<? super java.util.List<T>> assertFn)
        Collects all the received items in a list and once the upstream stage is completed, it executes the assertion supplied by assertFn. If no items were collected, it will be called with empty list.

        Example: 

        
 p.readFrom(TestSources.items(1, 2, 3, 4))
  .apply(Assertions.assertCollected(items ->
          assertTrue("expected minimum of 4 items", items.size() >= 4)))
  .writeTo(Sinks.logger())
        Note: This assertion is not usable in streaming jobs. For the streaming equivalent see assertCollectedEventually(int, com.hazelcast.function.ConsumerEx<? super java.util.List<T>>).

      • assertCollectedEventually

        @Nonnull
public static <T> FunctionEx<StreamStage<T>,​StreamStage<T>> assertCollectedEventually​(int timeout,
                                                                                            @Nonnull
                                                                                            ConsumerEx<? super java.util.List<T>> assertFn)
        Collects all the received items into a list and runs the assertFn every time a new item is received. An AssertionError thrown from the assertFn will be ignored until timeoutSeconds have passed, after which the last AssertionError will be rethrown. If assertFn throws any other exception, it will be rethrown immediately.

        When assertFn completes without any error, the sink will throw an AssertionCompletedException to indicate success. Exception is used to terminate the job so that you can join() it.

        Example: 

        
 p.readFrom(TestSources.itemStream(10))
  .withoutTimestamps()
  .apply(assertCollectedEventually(5, c -> assertTrue("did not receive at least 20 items", c.size() > 20)));
        To use this assertion in a test, you need to catch the thrown exception and validate that it's of the expected type as follows: 
        
 try {
     jetInstance.newJob(p).join();
     Assert.fail("Job should have completed with an AssertionCompletedException, " +
             "but completed normally");
 } catch (CompletionException e) {
     String errorMsg = e.getCause().getMessage();
     Assert.assertTrue(
             "Job was expected to complete with AssertionCompletedException, but completed with: " + e.getCause(),
             errorMsg.contains(AssertionCompletedException.class.getName())
     );
 }
        Note: This assertions requires that there are no other assertions in the job as this one can complete the job before the other ones succeeded.