TestSupport (hazelcast-jet-root 0.5 API)

java.lang.Object
- com.hazelcast.jet.core.test.TestSupport

```
public final class TestSupport
extends Object
```
A utility to test processors. It will initialize the processor instance, pass input items to it and assert the outbox contents.
The test process does the following:
- initializes the processor by calling Processor.init()
- does snapshot or snapshot+restore (optional, see below)
- calls Processor.process(0, inbox). The inbox always contains one item from input parameter
- every time the inbox gets empty does snapshot or snapshot+restore
- optionally calls Processor.complete() until it returns true or calls it until specified timeout elapses (for streaming sources)
- does snapshot or snapshot+restore each time the complete() method returned false and made a progress
The optional snapshot+restore test procedure:
- saveToSnapshot() is called. If we are not doing restore, this is the last step.
- new processor instance is created, from now on only this instance will be used
- snapshot is restored using restoreFromSnapshot()
- finishSnapshotRestore() is called
For each call to any processing method the progress is asserted (optional). The processor must do at least one of these:
- take something from inbox
- put something to outbox
- for boolean-returning methods, returning true is considered as making progress
Outbox rejection
A 1-capacity outbox will be provided, which will additionally be full in every other call to process(). This will test the edge case: the process() method is called even when the outbox is full to give the processor a chance to process the inbox. The snapshot bucket will also have capacity of 1.
Cooperative processors
For cooperative processors, time spent in each call to processing method must not exceed cooperativeTimeout(long).
Not-covered cases
This class does not cover these cases:
- Testing of processors which distinguish input or output edges by ordinal
- Checking that the state of a stateful processor is empty at the end (you can do that yourself afterwards with the last instance returned from your supplier).
- This utility never calls Processor.tryProcess().
Example usage
This will test one of the jet-provided processors:
```
 TestSupport.verifyProcessor(Processors.map((String s) -> s.toUpperCase()))
            .disableCompleteCall()             // enabled by default
            .disableLogging()                  // enabled by default
            .disableProgressAssertion()        // enabled by default
            .disableSnapshots()                // enabled by default
            .cooperativeTimeout(<timeoutInMs>) // default is 1000
            .outputChecker(<function>)         // default is `Objects::equal`
            .input(asList("foo", "bar"))       // default is `emptyList()`
            .expectOutput(asList("FOO", "BAR"));
 
```

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`TestSupport`	`cooperativeTimeout(long timeout)` If `timeout > 0`, the test will fail if any call to processing method in a cooperative processor exceeds this timeout.
`TestSupport`	`disableCompleteCall()` Disables calling `complete()` method during the test.
`TestSupport`	`disableLogging()` Disables logging of input and output objects.
`TestSupport`	`disableProgressAssertion()` Disables checking of progress of processing methods (see `class javadoc` for information on what is "progress").
`TestSupport`	`disableRunUntilCompleted(long timeoutMillis)` If the timeout > 0, the `complete()` method is called repeatedly until the timeout elapses.
`TestSupport`	`disableSnapshots()` Disable snapshot save and restore before first item and after each `process()` and `complete()` call.
`static <T> void`	`drainOutbox(Queue<T> outboxBucket, Collection<? super T> target, boolean logItems)` Move all items from the outbox to the `target` list and make the outbox available to accept more items.
`void`	`expectOutput(List<?> expectedOutput)` Sets the expected output and runs the test.
`TestSupport`	`input(List<?> input)` Sets the input objects for processor.
`TestSupport`	`outputChecker(java.util.function.BiPredicate<? super List<?>,? super List<?>> outputChecker)` Predicate to compare expected and actual output.
`static java.util.function.Supplier<Processor>`	`supplierFrom(ProcessorMetaSupplier supplier)` Wraps the provided `ProcessorMetaSupplier` with a `Supplier<Processor>` that returns processors obtained from it.
`static java.util.function.Supplier<Processor>`	`supplierFrom(ProcessorSupplier supplier)` Wraps the provided `ProcessorSupplier` with a `Supplier<Processor>` that returns processors obtained from it.
`static TestSupport`	`verifyProcessor(Processor processor)`
`static TestSupport`	`verifyProcessor(ProcessorMetaSupplier supplier)`
`static TestSupport`	`verifyProcessor(ProcessorSupplier supplier)`
`static TestSupport`	`verifyProcessor(java.util.function.Supplier<Processor> supplier)`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Method Detail
  - verifyProcessor
```
public static TestSupport verifyProcessor(Processor processor)
```
    Parameters:
    
    processor - a processor instance to test. disableSnapshots() will be set to false, because can't have new instance after each restore.
  - verifyProcessor
```
public static TestSupport verifyProcessor(@Nonnull
                                          java.util.function.Supplier<Processor> supplier)
```
    Parameters:
    
    supplier - a processor supplier create processor instances
  - verifyProcessor
```
public static TestSupport verifyProcessor(@Nonnull
                                          ProcessorSupplier supplier)
```
    Parameters:
    
    supplier - a processor supplier create processor instances
  - verifyProcessor
```
public static TestSupport verifyProcessor(@Nonnull
                                          ProcessorMetaSupplier supplier)
```
    Parameters:
    
    supplier - a processor supplier create processor instances
  - input
```
public TestSupport input(@Nonnull
                         List<?> input)
```
    Sets the input objects for processor.
    Defaults to empty list.
    
    Returns:
    
    this instance for fluent API.
  - expectOutput
```
public void expectOutput(@Nonnull
                         List<?> expectedOutput)
```
    Sets the expected output and runs the test.
    
    Throws:
    
    AssertionError - If some assertion does not hold.
  - disableProgressAssertion
```
public TestSupport disableProgressAssertion()
```
    Disables checking of progress of processing methods (see class javadoc for information on what is "progress").
    
    Returns:
    
    this instance for fluent API.
  - disableRunUntilCompleted
```
public TestSupport disableRunUntilCompleted(long timeoutMillis)
```
    If the timeout > 0, the complete() method is called repeatedly until the timeout elapses. After that, the output is compared using output checker. The complete() method is also not allowed to return true in this case. This setting is useful for testing of streaming sources.
    If the timeout is <= 0 (the default), complete() method is called until it returns true, after which the output is checked.
    Has no effect if complete() call is disabled.
    
    Parameters:
    
    timeoutMillis - how long to wait until outputs match
    
    Returns:
    
    this instance for fluent API.
  - disableSnapshots
```
public TestSupport disableSnapshots()
```
    Disable snapshot save and restore before first item and after each process() and complete() call.
    
    Returns:
    
    this instance for fluent API.
  - disableLogging
```
public TestSupport disableLogging()
```
    Disables logging of input and output objects. Normally they are logged as they are processed to standard output.
    
    Returns:
    
    this instance for fluent API.
  - disableCompleteCall
```
public TestSupport disableCompleteCall()
```
    Disables calling complete() method during the test. Suitable for testing of streaming processors to make sure that the flushing code in complete() method is not executed.
    
    Returns:
    
    this instance for fluent API.
  - cooperativeTimeout
```
public TestSupport cooperativeTimeout(long timeout)
```
    If timeout > 0, the test will fail if any call to processing method in a cooperative processor exceeds this timeout. Has no effect for non-cooperative processors.
    Default value is COOPERATIVE_TIME_LIMIT_MS_FAIL ms. Useful to set to 0 during debugging.
    
    Returns:
    
    this instance for fluent API.
  - outputChecker
```
public TestSupport outputChecker(@Nonnull
                                 java.util.function.BiPredicate<? super List<?>,? super List<?>> outputChecker)
```
    Predicate to compare expected and actual output.
    Defaults to Objects::equals
    
    Returns:
    
    this instance for fluent API.
  - drainOutbox
```
public static <T> void drainOutbox(Queue<T> outboxBucket,
                                   Collection<? super T> target,
                                   boolean logItems)
```
    Move all items from the outbox to the target list and make the outbox available to accept more items.
    
    Parameters:
    
    outboxBucket - the queue from Outbox to drain
    
    target - target list
    
    logItems - whether to log drained items to System.out
  - supplierFrom
```
public static java.util.function.Supplier<Processor> supplierFrom(ProcessorSupplier supplier)
```
    Wraps the provided ProcessorSupplier with a Supplier<Processor> that returns processors obtained from it.
  - supplierFrom
```
public static java.util.function.Supplier<Processor> supplierFrom(ProcessorMetaSupplier supplier)
```
    Wraps the provided ProcessorMetaSupplier with a Supplier<Processor> that returns processors obtained from it.

Class TestSupport

Outbox rejection

Cooperative processors

Not-covered cases

Example usage

Method Summary

Methods inherited from class java.lang.Object

Method Detail

verifyProcessor

verifyProcessor

verifyProcessor

verifyProcessor

input

expectOutput

disableProgressAssertion

disableRunUntilCompleted

disableSnapshots

disableLogging

disableCompleteCall

cooperativeTimeout

outputChecker

drainOutbox

supplierFrom

supplierFrom