Package org.assertj.core.api

Class AbstractCompletableFutureAssert<SELF extends AbstractCompletableFutureAssert<SELF,RESULT>,RESULT>

java.lang.Object

org.assertj.core.api.AbstractAssert<SELF,CompletableFuture<RESULT>>

org.assertj.core.api.AbstractCompletableFutureAssert<SELF,RESULT>

Type Parameters:

RESULT - type of the value contained in the CompletableFuture.

All Implemented Interfaces:

Assert<SELF,CompletableFuture<RESULT>>, Descriptable<SELF>, ExtensionPoints<SELF,CompletableFuture<RESULT>>

Direct Known Subclasses:

CompletableFutureAssert

public abstract class AbstractCompletableFutureAssert<SELF extends AbstractCompletableFutureAssert<SELF,RESULT>,RESULT>
extends AbstractAssert<SELF,CompletableFuture<RESULT>>

Assertions for CompletableFuture.

Field Summary

Fields inherited from class org.assertj.core.api.AbstractAssert

actual, assertionErrorCreator, conditions, info, myself, objects, throwUnsupportedExceptionOnEquals

Constructor Summary

Constructors

Modifier	Constructor	Description
protected	AbstractCompletableFutureAssert(CompletableFuture<RESULT> actual, Class<?> selfType)

Method Summary

Modifier and Type	Method	Description
SELF	hasFailed()	Verifies that the CompletableFuture has completed exceptionally but has not been cancelled, this assertion is equivalent to:
AbstractThrowableAssert<?,? extends Throwable>	hasFailedWithThrowableThat()	Verifies that the CompletableFuture has completed exceptionally and returns a Throwable assertion object allowing to check the Throwable that has caused the future to fail.
SELF	hasNotFailed()	Verifies that the CompletableFuture has not failed i.e: incomplete, completed or cancelled. This is different from isNotCompletedExceptionally() as a cancelled future has not failed but is completed exceptionally.
SELF	isCancelled()	Verifies that the CompletableFuture is cancelled.
SELF	isCompleted()	Verifies that the CompletableFuture is completed normally (i.e.done but not completed exceptionally) or cancelled).
SELF	isCompletedExceptionally()	Verifies that the CompletableFuture is completed exceptionally.
SELF	isCompletedWithValue(RESULT expected)	Verifies that the CompletableFuture is completed normally with the expected result.
SELF	isCompletedWithValueMatching(Predicate<? super RESULT> predicate)	Verifies that the CompletableFuture is completed normally with a result matching the predicate.
SELF	isCompletedWithValueMatching(Predicate<? super RESULT> predicate, String description)	Verifies that the CompletableFuture is completed normally with a result matching the predicate, the String parameter is used in the error message.
private SELF	isCompletedWithValueMatching(Predicate<? super RESULT> predicate, PredicateDescription description)
SELF	isDone()	Verifies that the CompletableFuture is done i.e.
SELF	isNotCancelled()	Verifies that the CompletableFuture is not cancelled.
SELF	isNotCompleted()	Verifies that the CompletableFuture is not completed normally (i.e.
SELF	isNotCompletedExceptionally()	Verifies that the CompletableFuture is not completed exceptionally.
SELF	isNotDone()	Verifies that the CompletableFuture is not done.
ObjectAssert<RESULT>	succeedsWithin(long timeout, TimeUnit unit)	Waits if necessary for at most the given time for this future to complete, and then returns its result for futher assertions.
<ASSERT extends AbstractAssert<?,?>> ASSERT	succeedsWithin(long timeout, TimeUnit unit, InstanceOfAssertFactory<RESULT,ASSERT> assertFactory)	Waits if necessary for at most the given time for this future to complete, the InstanceOfAssertFactory parameter is used to return assertions specific to the the future's result type.
ObjectAssert<RESULT>	succeedsWithin(Duration timeout)	Waits if necessary for at most the given time for this future to complete, and then returns its result for futher assertions.
<ASSERT extends AbstractAssert<?,?>> ASSERT	succeedsWithin(Duration timeout, InstanceOfAssertFactory<RESULT,ASSERT> assertFactory)	Waits if necessary for at most the given time for this future to complete, the InstanceOfAssertFactory parameter is used to return assertions specific to the the future's result type.

Methods inherited from class org.assertj.core.api.AbstractAssert

asInstanceOf, asList, assertionError, asString, describedAs, descriptionText, doesNotHave, doesNotHaveSameClassAs, equals, failWithMessage, getWritableAssertionInfo, has, hashCode, hasSameClassAs, hasSameHashCodeAs, hasToString, inBinary, inHexadecimal, is, isEqualTo, isExactlyInstanceOf, isIn, isIn, isInstanceOf, isInstanceOfAny, isInstanceOfSatisfying, isNot, isNotEqualTo, isNotExactlyInstanceOf, isNotIn, isNotIn, isNotInstanceOf, isNotInstanceOfAny, isNotNull, isNotOfAnyClassIn, isNotSameAs, isNull, isOfAnyClassIn, isSameAs, matches, matches, newListAssertInstance, overridingErrorMessage, satisfies, satisfies, satisfiesAnyOf, satisfiesAnyOf, setCustomRepresentation, throwAssertionError, usingComparator, usingComparator, usingDefaultComparator, usingRecursiveComparison, usingRecursiveComparison, withAssertionState, withFailMessage, withRepresentation, withThreadDumpOnError

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface org.assertj.core.api.Descriptable

as, as, describedAs

Constructor Detail

AbstractCompletableFutureAssert

protected AbstractCompletableFutureAssert(CompletableFuture<RESULT> actual,
                                          Class<?> selfType)

Method Detail

isDone

public SELF isDone()

Verifies that the CompletableFuture is done i.e. completed normally, exceptionally, or via cancellation.

Assertion will pass :

 assertThat(CompletableFuture.completedFuture("something")).isDone();

Assertion will fail :

 assertThat(new CompletableFuture()).isDone();

Returns:

this assertion object.

See Also:

CompletableFuture.isDone()

isNotDone

public SELF isNotDone()

Verifies that the CompletableFuture is not done.

Assertion will pass :

 assertThat(new CompletableFuture()).isNotDone();

Assertion will fail :

 assertThat(CompletableFuture.completedFuture("something")).isNotDone();

Returns:

this assertion object.

See Also:

CompletableFuture.isDone()

isCompletedExceptionally

public SELF isCompletedExceptionally()

Verifies that the CompletableFuture is completed exceptionally. Possible causes include cancellation, explicit invocation of completeExceptionally, and abrupt termination of a CompletionStage action.

If you only want to check that actual future is completed exceptionally but not cancelled, use hasFailed() or hasFailedWithThrowableThat().

Assertion will pass :

 CompletableFuture future = new CompletableFuture();
 future.completeExceptionally(new RuntimeException());
 assertThat(future).isCompletedExceptionally();

Assertion will fail :

 assertThat(CompletableFuture.completedFuture("something")).isCompletedExceptionally();

Returns:

this assertion object.

See Also:

CompletableFuture.isCompletedExceptionally()

isNotCompletedExceptionally

public SELF isNotCompletedExceptionally()

Verifies that the CompletableFuture is not completed exceptionally.

Assertion will pass :

 assertThat(CompletableFuture.completedFuture("something")).isNotCompletedExceptionally();

Assertion will fail :

 CompletableFuture future = new CompletableFuture();
 future.completeExceptionally(new RuntimeException());
 assertThat(future).isNotCompletedExceptionally();

Returns:

this assertion object.

See Also:

CompletableFuture.isCompletedExceptionally()

isCancelled

public SELF isCancelled()

Verifies that the CompletableFuture is cancelled.

Assertion will pass :

 CompletableFuture future = new CompletableFuture();
 future.cancel(true);
 assertThat(future).isCancelled();

Assertion will fail :

 assertThat(new CompletableFuture()).isCancelled();

Returns:

this assertion object.

See Also:

CompletableFuture.isCancelled()

isNotCancelled

public SELF isNotCancelled()

Verifies that the CompletableFuture is not cancelled.

Assertion will pass :

 assertThat(new CompletableFuture()).isNotCancelled();

Assertion will fail :

 CompletableFuture future = new CompletableFuture();
 future.cancel(true);
 assertThat(future).isNotCancelled();

Returns:

this assertion object.

See Also:

CompletableFuture.isCancelled()

isCompleted

public SELF isCompleted()

Verifies that the CompletableFuture is completed normally (i.e.done but not completed exceptionally) or cancelled).

Assertion will pass :

 assertThat(CompletableFuture.completedFuture("something")).isCompleted();

Assertion will fail :

 assertThat(new CompletableFuture()).isCompleted();

Returns:

this assertion object.

isNotCompleted

public SELF isNotCompleted()

Verifies that the CompletableFuture is not completed normally (i.e. incomplete, failed or cancelled).

Assertion will pass :

 assertThat(new CompletableFuture()).isNotCompleted();

Assertion will fail :

 assertThat(CompletableFuture.completedFuture("something")).isNotCompleted();

Returns:

this assertion object.

isCompletedWithValue

public SELF isCompletedWithValue(RESULT expected)

Verifies that the CompletableFuture is completed normally with the expected result.

Assertion will pass :

 assertThat(CompletableFuture.completedFuture("something"))
           .isCompletedWithValue("something");

Assertion will fail :

 assertThat(CompletableFuture.completedFuture("something"))
           .isCompletedWithValue("something else");

Parameters:

expected - the expected result value of the CompletableFuture.

Returns:

this assertion object.

isCompletedWithValueMatching

public SELF isCompletedWithValueMatching(Predicate<? super RESULT> predicate)

Verifies that the CompletableFuture is completed normally with a result matching the predicate.

Assertion will pass :

 assertThat(CompletableFuture.completedFuture("something"))
           .isCompletedWithValueMatching(result -> result.equals("something"));

Assertion will fail :

 assertThat(CompletableFuture.completedFuture("something"))
           .isCompletedWithValueMatching(result -> result.equals("something else"));

Parameters:

predicate - the Predicate to apply.

Returns:

this assertion object.

isCompletedWithValueMatching

public SELF isCompletedWithValueMatching(Predicate<? super RESULT> predicate,
                                         String description)

Verifies that the CompletableFuture is completed normally with a result matching the predicate, the String parameter is used in the error message.

Assertion will pass :

 assertThat(CompletableFuture.completedFuture("something"))
           .isCompletedWithValueMatching(result -> result != null, "expected not null");

Assertion will fail :

 assertThat(CompletableFuture.completedFuture("something"))
           .isCompletedWithValueMatching(result -> result == null, "expected null");

Error message is:

 Expecting:
   <"something">
 to match 'expected null' predicate.

Parameters:

predicate - the Predicate to apply on the resulting value.

description - the Predicate description.

Returns:

this assertion object.

isCompletedWithValueMatching

private SELF isCompletedWithValueMatching(Predicate<? super RESULT> predicate,
                                          PredicateDescription description)

hasFailed

public SELF hasFailed()

Verifies that the CompletableFuture has completed exceptionally but has not been cancelled, this assertion is equivalent to:

 assertThat(future).isCompletedExceptionally()
                   .isNotCancelled();

Assertion will pass :

 CompletableFuture future = new CompletableFuture();
 future.completeExceptionally(new RuntimeException());
 assertThat(future).hasFailed();

Assertion will fail :

 CompletableFuture future = new CompletableFuture();
 future.cancel(true);
 assertThat(future).hasFailed();

Returns:

this assertion object.

hasNotFailed

public SELF hasNotFailed()

Verifies that the CompletableFuture has not failed i.e: incomplete, completed or cancelled.
This is different from isNotCompletedExceptionally() as a cancelled future has not failed but is completed exceptionally.

Assertion will pass :

 CompletableFuture future = new CompletableFuture();
 future.cancel(true);
 assertThat(future).hasNotFailed();

Assertion will fail :

 CompletableFuture future = new CompletableFuture();
 future.completeExceptionally(new RuntimeException());
 assertThat(future).hasNotFailed();

Returns:

this assertion object.

succeedsWithin

public ObjectAssert<RESULT> succeedsWithin(Duration timeout)

Waits if necessary for at most the given time for this future to complete, and then returns its result for futher assertions.

If the future's result is not available for any reason an assertion error is thrown.

To get assertions for the future result's type use succeedsWithin(Duration, InstanceOfAssertFactory) instead.

Examples:

 CompletableFuture<String> future = CompletableFuture.completedFuture("ook!");
 Duration timeout = Duration.ofMillis(100);

 // assertion succeeds
 assertThat(future).succeedsWithin(timeout)
                   .isEqualTo("ook!");

 // fails assuming the future is not done after the given timeout
 CompletableFuture<String> future = ... ; // future too long to complete
 assertThat(future).succeedsWithin(timeout);

 // fails as the future is cancelled
 CompletableFuture future = new CompletableFuture();
 future.cancel(false);
 assertThat(future).succeedsWithin(timeout);

Parameters:

timeout - the maximum time to wait

Returns:

a new assertion object on the the future's result.

Throws:

AssertionError - if the actual CompletableFuture is null.

AssertionError - if the actual CompletableFuture does not succeed within the given timeout.

succeedsWithin

public ObjectAssert<RESULT> succeedsWithin(long timeout,
                                           TimeUnit unit)

Waits if necessary for at most the given time for this future to complete, and then returns its result for futher assertions.

If the future's result is not available for any reason an assertion error is thrown.

To get assertions for the future result's type use succeedsWithin(long, TimeUnit, InstanceOfAssertFactory) instead.

Examples:

 CompletableFuture<String> future = CompletableFuture.completedFuture("ook!");

 // assertion succeeds
 assertThat(future).succeedsWithin(100, TimeUnit.MILLISECONDS)
                   .isEqualTo("ook!");

 // fails assuming the future is not done after the given timeout
 CompletableFuture<String> future = ... ; // future too long to complete
 assertThat(future).succeedsWithin(100, TimeUnit.MILLISECONDS);

 // fails as the future is cancelled
 CompletableFuture future = new CompletableFuture();
 future.cancel(false);
 assertThat(future).succeedsWithin(100, TimeUnit.MILLISECONDS);

Parameters:

timeout - the maximum time to wait

unit - the time unit of the timeout argument

Returns:

a new assertion object on the the future's result.

Throws:

AssertionError - if the actual CompletableFuture is null.

AssertionError - if the actual CompletableFuture does not succeed within the given timeout.

succeedsWithin

public <ASSERT extends AbstractAssert<?,?>> ASSERT succeedsWithin(Duration timeout,
                                                                        InstanceOfAssertFactory<RESULT,ASSERT> assertFactory)

Waits if necessary for at most the given time for this future to complete, the InstanceOfAssertFactory parameter is used to return assertions specific to the the future's result type.

If the future's result is not available for any reason an assertion error is thrown.

Examples:

 CompletableFuture<String> future = CompletableFuture.completedFuture("ook!");
 Duration timeout = Duration.ofMillis(100);

 // assertion succeeds
 // using asInstanceOf is recommanded to get assertions for the future result's type
 assertThat(future).succeedsWithin(timeout, InstanceOfAssertFactories.STRING)
                   .contains("ok");

 // assertion fails if the narrowed type for assertions is incompatible with the future's result type.
 assertThat(future).succeedsWithin(timeout, InstanceOfAssertFactories.DATE)
                   .isToday();

Type Parameters:

ASSERT - the type of the resulting Assert

Parameters:

timeout - the maximum time to wait

assertFactory - the factory which verifies the type and creates the new Assert

Returns:

a new narrowed Assert instance for assertions chaining on the value of the CompletableFuture

Throws:

AssertionError - if the actual CompletableFuture is null.

IllegalStateException - if the actual CompletableFuture does not succeed within the given timeout.

succeedsWithin

public <ASSERT extends AbstractAssert<?,?>> ASSERT succeedsWithin(long timeout,
                                                                        TimeUnit unit,
                                                                        InstanceOfAssertFactory<RESULT,ASSERT> assertFactory)

Waits if necessary for at most the given time for this future to complete, the InstanceOfAssertFactory parameter is used to return assertions specific to the the future's result type.

If the future's result is not available for any reason an assertion error is thrown.

Examples:

 CompletableFuture<String> future = CompletableFuture.completedFuture("ook!");

 // assertion succeeds
 // using asInstanceOf is recommanded to get assertions for the future result's type
 assertThat(future).succeedsWithin(100, TimeUnit.MILLISECONDS, InstanceOfAssertFactories.STRING)
                   .contains("ok");

 // assertion  fails if the narrowed type for assertions is incompatible with the future's result type.
 assertThat(future).succeedsWithin(100, TimeUnit.MILLISECONDS, InstanceOfAssertFactories.DATE)
                   .isToday();

Type Parameters:

ASSERT - the type of the resulting Assert

Parameters:

timeout - the maximum time to wait

unit - the time unit of the timeout argument

assertFactory - the factory which verifies the type and creates the new Assert

Returns:

a new narrowed Assert instance for assertions chaining on the value of the CompletableFuture

Throws:

AssertionError - if the actual CompletableFuture is null.

AssertionError - if the actual CompletableFuture does not succeed within the given timeout.

hasFailedWithThrowableThat

public AbstractThrowableAssert<?,? extends Throwable> hasFailedWithThrowableThat()

Verifies that the CompletableFuture has completed exceptionally and returns a Throwable assertion object allowing to check the Throwable that has caused the future to fail.

Assertion will pass :

 CompletableFuture future = new CompletableFuture();
 future.completeExceptionally(new RuntimeException("boom!"));

 assertThat(future).hasFailedWithThrowableThat().isInstanceOf(RuntimeException.class);
                                                .hasMessage("boom!"); 

Assertion will fail :

 CompletableFuture future = new CompletableFuture();
 future.completeExceptionally(new RuntimeException());

 assertThat(future).hasFailedWithThrowableThat().isInstanceOf(IllegalArgumentException.class);
 

Returns:

an exception assertion object.