TestSubscriberJsonIntegration

java.lang.Object
- com.hcl.domino.keep.testhelper.TestSubscriberJsonIntegration

All Implemented Interfaces:

io.reactivex.Emitter<io.vertx.core.json.JsonObject>, io.reactivex.ObservableEmitter<io.vertx.core.json.JsonObject>, io.reactivex.Observer<io.vertx.core.json.JsonObject>
```
public class TestSubscriberJsonIntegration
extends java.lang.Object
implements io.reactivex.ObservableEmitter<io.vertx.core.json.JsonObject>, io.reactivex.Observer<io.vertx.core.json.JsonObject>
```
Helper class as subscriber to the request methods allows to specify what behavior is expected by fluently add properties to the constructor e.g.
```
java TestSubscriberJson sub = new TestSubscriberJson()
.expectFailure()
.errorClass(SomeError.class)
.errorMessage(String message)
.expectedOnNextCount(42)
.minimumOnNextCount(3)
.maximumOnNextCount(100)
.expectEmpty(true)
.failOnAdditionalFieldsInActual(true)
.addfieldToExist("SomeName")
.setIgnoreMissingFieldsInActual(false);
```
When you specify an exact number, maximum and minimum don’t make sense, but will still get reported. Class takes a VertxTestContext as parameter to allow for asynchronous testing. Implemented only for JsonObjects

Constructor Summary

Constructors
Constructor and Description

TestSubscriberJsonIntegration(io.vertx.junit5.VertxTestContext context)
Constructor with test context

Constructors
Constructor and Description
`TestSubscriberJsonIntegration(io.vertx.junit5.VertxTestContext context)` Constructor with test context

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`TestSubscriberJsonIntegration`	`addExpectedValue(io.vertx.core.json.JsonObject expected)` Add an expected entry onto a queue, expectation is a strict sequence in return
`TestSubscriberJsonIntegration`	`addExpectedValues(java.util.Collection<io.vertx.core.json.JsonObject> expected)` Add an expected entries onto a queue, expectation is a strict sequence in return
`TestSubscriberJsonIntegration`	`addExpectedValues(io.vertx.core.json.JsonArray expected)` Add an expected entries onto a queue, expectation is a strict sequence in return
`TestSubscriberJsonIntegration`	`addfieldsToExist(java.util.Collection<java.lang.String> fieldNames)` Checks for the existence of a set of fields in JSON without checking type or content, Just the bare existence
`TestSubscriberJsonIntegration`	`addfieldToExist(java.lang.String fieldName)` Checks for the existence of a field in JSON without checking type or content, Just the bare existence
`void`	`close()` Close connection to check if results are OK
`TestSubscriberJsonIntegration`	`errorClass(java.lang.Class<? extends java.lang.Throwable> errorClass)` Specify what class of error to expect, we use ExceptionClasses extensively if not null, _expectFailure is set too
`TestSubscriberJsonIntegration`	`errorMessage(java.lang.String errorMessage)` We can look for a very specific error message
`TestSubscriberJsonIntegration`	`expectedOnNextCount(int expectedOnNextCount)` Sets the exact number of returned items we expect default is -1 = no expectations
`TestSubscriberJsonIntegration`	`expectEmpty(boolean expectEmpty)` When set to true, an empty {} is acceptable in JSON default is false
`TestSubscriberJsonIntegration`	`expectFailure(boolean expectFailure)` Specify if we expect the listener to succeed
`TestSubscriberJsonIntegration`	`failOnAdditionalFieldsInActual(boolean failOnAdditionalFieldsInActual)` If we compare Json elements, actual might have more elements than expected, if we need to ensure that, we can set this property to true, default is false, additional fields get ignored
`int`	`getDataCount()`
`io.vertx.core.json.JsonObject`	`getResult(int pos)` Return one result
`io.vertx.core.json.JsonArray`	`getResults()` Array with results, might be empty, never null
`TestSubscriberJsonIntegration`	`ignoreMissingFieldsInActual(boolean ignoreMissingFieldsInActual)` By default missing fields in actual throw an error, setting this to true will only compared fields found.
`boolean`	`isDisposed()`
`TestSubscriberJsonIntegration`	`maximumOnNextCount(int maximumOnNextCount)` Sets the maximum of returned items we expect, default is -1 = no expectations
`TestSubscriberJsonIntegration`	`minimumOnNextCount(int minimumOnNextCount)` Sets the minimum of returned items we expect, default is -1 = no expectations
`void`	`onComplete()`
`void`	`onError(java.lang.Throwable error)`
`void`	`onNext(io.vertx.core.json.JsonObject actual)`
`void`	`onSubscribe(io.reactivex.disposables.Disposable d1)`
`io.reactivex.ObservableEmitter<io.vertx.core.json.JsonObject>`	`serialize()`
`TestSubscriberJsonIntegration`	`setAdditionalTests(java.lang.String errorMessage, java.util.function.Predicate<io.vertx.core.json.JsonObject> additionalTests)` Callback to hook additional tests into the onNext phase of the Subscriber
`void`	`setCancellable(io.reactivex.functions.Cancellable c)`
`void`	`setDisposable(io.reactivex.disposables.Disposable d)`
`boolean`	`tryOnError(java.lang.Throwable t)`

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

- Constructor Detail
  - TestSubscriberJsonIntegration
```
public TestSubscriberJsonIntegration(io.vertx.junit5.VertxTestContext context)
```
    Constructor with test context
    
    Parameters:
    
    context - TestContext for async operations
- Method Detail
  - addExpectedValue
```
public TestSubscriberJsonIntegration addExpectedValue(@Nonnull
                                                      io.vertx.core.json.JsonObject expected)
```
    Add an expected entry onto a queue, expectation is a strict sequence in return
    Parameters:
    expected -
    
    expected value
    Returns:
    
    fluent
  - addExpectedValues
```
public TestSubscriberJsonIntegration addExpectedValues(@Nonnull
                                                       java.util.Collection<io.vertx.core.json.JsonObject> expected)
```
    Add an expected entries onto a queue, expectation is a strict sequence in return
    Parameters:
    expected -
    
    expected values
    Returns:
    
    fluent
  - addExpectedValues
```
public TestSubscriberJsonIntegration addExpectedValues(@Nonnull
                                                       io.vertx.core.json.JsonArray expected)
```
    Add an expected entries onto a queue, expectation is a strict sequence in return
    Parameters:
    expected -
    
    expected values
    Returns:
    
    fluent
  - addfieldsToExist
```
public TestSubscriberJsonIntegration addfieldsToExist(java.util.Collection<java.lang.String> fieldNames)
```
    Checks for the existence of a set of fields in JSON without checking type or content, Just the bare existence
    Parameters:
    fieldNames -
    
    Collection of field names that needs to exist
    Returns:
    
    fluent
  - addfieldToExist
```
public TestSubscriberJsonIntegration addfieldToExist(java.lang.String fieldName)
```
    Checks for the existence of a field in JSON without checking type or content, Just the bare existence
    Parameters:
    fieldName -
    
    name of a field that needs to exist
    Returns:
    
    fluent
  - close
```
public void close()
```
    Close connection to check if results are OK
  - errorClass
```
public TestSubscriberJsonIntegration errorClass(java.lang.Class<? extends java.lang.Throwable> errorClass)
```
    Specify what class of error to expect, we use ExceptionClasses extensively if not null, _expectFailure is set too
    
    Parameters:
    
    errorClass -
    
    Returns:
    
    fluent
  - errorMessage
```
public TestSubscriberJsonIntegration errorMessage(java.lang.String errorMessage)
```
    We can look for a very specific error message
    
    Parameters:
    
    errorMessage - Expected error message as String
    
    Returns:
    
    fluent
  - expectedOnNextCount
```
public TestSubscriberJsonIntegration expectedOnNextCount(int expectedOnNextCount)
```
    Sets the exact number of returned items we expect default is -1 = no expectations
    
    Parameters:
    
    expectedOnNextCount -
    
    Returns:
    
    fluent
  - expectEmpty
```
public TestSubscriberJsonIntegration expectEmpty(boolean expectEmpty)
```
    When set to true, an empty {} is acceptable in JSON default is false
    
    Parameters:
    
    expectEmpty - true = accept {}, false = complaint
    
    Returns:
    
    fluent
  - expectFailure
```
public TestSubscriberJsonIntegration expectFailure(boolean expectFailure)
```
    Specify if we expect the listener to succeed
    
    Parameters:
    
    expectFailure - true if we expect onError but not onNext
    
    Returns:
    
    fluent
  - failOnAdditionalFieldsInActual
```
public TestSubscriberJsonIntegration failOnAdditionalFieldsInActual(boolean failOnAdditionalFieldsInActual)
```
    If we compare Json elements, actual might have more elements than expected, if we need to ensure that, we can set this property to true, default is false, additional fields get ignored
    
    Parameters:
    
    failOnAdditionalFieldsInActual - true for no extra fields, false for ignore extra fields
    
    Returns:
    
    fluent
  - getDataCount
```
public int getDataCount()
```
    Returns:
    
    the onNextCount
  - getResult
```
public io.vertx.core.json.JsonObject getResult(int pos)
```
    Return one result
    
    Parameters:
    
    pos - Position starting with 0
    
    Returns:
    
    one JsonObject or null if out of position
  - getResults
```
public io.vertx.core.json.JsonArray getResults()
```
    Array with results, might be empty, never null
    
    Returns:
    
    JsonArray with all results
  - ignoreMissingFieldsInActual
```
public TestSubscriberJsonIntegration ignoreMissingFieldsInActual(boolean ignoreMissingFieldsInActual)
```
    By default missing fields in actual throw an error, setting this to true will only compared fields found. Default = false
    
    Parameters:
    
    ignoreMissingFieldsInActual - true: only fields in actual are compared, false throws and error
    
    Returns:
    
    fluent
  - isDisposed
```
public boolean isDisposed()
```
    Specified by:
    
    isDisposed in interface io.reactivex.ObservableEmitter<io.vertx.core.json.JsonObject>
  - maximumOnNextCount
```
public TestSubscriberJsonIntegration maximumOnNextCount(int maximumOnNextCount)
```
    Sets the maximum of returned items we expect, default is -1 = no expectations
    
    Parameters:
    
    maximumOnNextCount -
    
    Returns:
    
    fluent
  - minimumOnNextCount
```
public TestSubscriberJsonIntegration minimumOnNextCount(int minimumOnNextCount)
```
    Sets the minimum of returned items we expect, default is -1 = no expectations
    
    Parameters:
    
    minimumOnNextCount -
    
    Returns:
    
    fluent
  - onComplete
```
public void onComplete()
```
    Specified by:
    
    onComplete in interface io.reactivex.Emitter<io.vertx.core.json.JsonObject>
    
    Specified by:
    
    onComplete in interface io.reactivex.Observer<io.vertx.core.json.JsonObject>
  - onError
```
public void onError(java.lang.Throwable error)
```
    Specified by:
    
    onError in interface io.reactivex.Emitter<io.vertx.core.json.JsonObject>
    
    Specified by:
    
    onError in interface io.reactivex.Observer<io.vertx.core.json.JsonObject>
  - onNext
```
public void onNext(io.vertx.core.json.JsonObject actual)
```
    Specified by:
    
    onNext in interface io.reactivex.Emitter<io.vertx.core.json.JsonObject>
    
    Specified by:
    
    onNext in interface io.reactivex.Observer<io.vertx.core.json.JsonObject>
  - onSubscribe
```
public void onSubscribe(io.reactivex.disposables.Disposable d1)
```
    Specified by:
    
    onSubscribe in interface io.reactivex.Observer<io.vertx.core.json.JsonObject>
  - serialize
```
public io.reactivex.ObservableEmitter<io.vertx.core.json.JsonObject> serialize()
```
    Specified by:
    
    serialize in interface io.reactivex.ObservableEmitter<io.vertx.core.json.JsonObject>
  - setAdditionalTests
```
public TestSubscriberJsonIntegration setAdditionalTests(java.lang.String errorMessage,
                                                        java.util.function.Predicate<io.vertx.core.json.JsonObject> additionalTests)
```
    Callback to hook additional tests into the onNext phase of the Subscriber
    Parameters:
    errorMessage -
    
    The message for the failed test
    additionalTests - additional tests and assertions to run
    
    Returns:
    
    fluent
  - setCancellable
```
public void setCancellable(io.reactivex.functions.Cancellable c)
```
    Specified by:
    
    setCancellable in interface io.reactivex.ObservableEmitter<io.vertx.core.json.JsonObject>
  - setDisposable
```
public void setDisposable(io.reactivex.disposables.Disposable d)
```
    Specified by:
    
    setDisposable in interface io.reactivex.ObservableEmitter<io.vertx.core.json.JsonObject>
  - tryOnError
```
public boolean tryOnError(java.lang.Throwable t)
```
    Specified by:
    
    tryOnError in interface io.reactivex.ObservableEmitter<io.vertx.core.json.JsonObject>

Class TestSubscriberJsonIntegration

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

TestSubscriberJsonIntegration

Method Detail

addExpectedValue

addExpectedValues

addExpectedValues

addfieldsToExist

addfieldToExist

close

errorClass

errorMessage

expectedOnNextCount

expectEmpty

expectFailure

failOnAdditionalFieldsInActual

getDataCount

getResult

getResults

ignoreMissingFieldsInActual

isDisposed

maximumOnNextCount

minimumOnNextCount

onComplete

onError

onNext

onSubscribe

serialize

setAdditionalTests

setCancellable

setDisposable

tryOnError