io.github.avivcarmis.javared.test

Class RedTestContext

java.lang.Object

io.github.avivcarmis.javared.test.RedTestContext

public class RedTestContext
extends Object

The context of an asynchronous test. The test context is responsible for:

• Forking the test, allowing the flow test method to return without finishing the test, to enable waiting for async operations to finish. Each fork represents a single async operation that must be marked as finished or failed for the test to end.
• Assertions - since assertions may be performed on callbacks of any async operation, on any thread, assertion errors will be thrown, be JUnit won't be there to catch them. For that end, the RedTestContext instance exposes all of JUnit Assert interface, so that assertions can be made from any context, and still influence test results.
• Late scheduling - since scheduling late tasks and assertions is a common async test practice, the context instance introduces a simple utility scheduling method available at scheduleTask(long, TimeUnit, Runnable).
• Timing assertions - allowing simple and intuitive interface to validate whether certain periods of times passed or didn't pass from various points of the execution

Note that all the context forks must be made before the test method returns. See more at fork()

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
class	RedTestContext.Assertions Exposes JUnit Assert interface, wraps each assertion method with a call to assertion(EmptyCallback)
static class	RedTestContext.Fork A fork of a RedTestContext see fork()
class	RedTestContext.TimingValidator A Timing tester for a certain RedTestContext May be used to validate expected periods of time to pass or not pass, from the moment of it's creation.

Field Summary

Fields

Modifier and Type	Field and Description
RedTestContext.Assertions	assertions The context assertion interface

Method Summary

Modifier and Type	Method and Description
void	fail() Fails the test.
void	fail(String message) Fails the test.
void	fail(Throwable throwable) Fails the test.
RedTestContext.Fork	fork() Forks the test, and returns the fork instance.
boolean	isTestActive() In some cases, in a late callback of an async operation, it may be reasonable to validate whether or not the test is still active, or completed.
void	scheduleTask(long delayMillis, Runnable runnable) Schedules a late runnable to be executed with a given delay of milliseconds.
void	scheduleTask(long delay, TimeUnit unit, Runnable runnable) Schedules a late runnable to be executed.
RedTestContext.TimingValidator	timingValidator() A RedTestContext provides a method for validating timing executions.

Methods inherited from class java.lang.Object

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

Field Detail

assertions

public final RedTestContext.Assertions assertions

The context assertion interface

Method Detail

fork

public RedTestContext.Fork fork()

Forks the test, and returns the fork instance. The returned instance must be held and completed, for the test to successful complete. NOTE that all the context forks must be made before the test method returns. If, for example, we want to perform an async DB call, and when it's done, and only then, we want to perform another one. Then in such a case we want to fork the context twice at the beginning of the test method (or any other time before it returns), and NOT to perform the second fork after the first one is completed.

Returns:

a fork instance

fail

public void fail(Throwable throwable)

Fails the test.

Parameters:

throwable - cause

fail

public void fail(String message)

Fails the test.

Parameters:

message - reason

fail

public void fail()

Fails the test.

scheduleTask

public void scheduleTask(long delay,
                         TimeUnit unit,
                         Runnable runnable)

Schedules a late runnable to be executed.

Parameters:

delay - the delay of the execution to apply

unit - the time unit the of given delay

runnable - the runnable task to execute

scheduleTask

public void scheduleTask(long delayMillis,
                         Runnable runnable)

Schedules a late runnable to be executed with a given delay of milliseconds.

Parameters:

delayMillis - the delay of the execution to apply in milliseconds

runnable - the runnable task to execute

timingValidator

public RedTestContext.TimingValidator timingValidator()

A RedTestContext provides a method for validating timing executions. A RedTestContext.TimingValidator may be created at a certain point at time, and later, this RedTestContext.TimingValidator instance may be used to validate certain period of time has passed or not passed since it's creation.

Returns:

a new instance of RedTestContext.TimingValidator

isTestActive

public boolean isTestActive()

In some cases, in a late callback of an async operation, it may be reasonable to validate whether or not the test is still active, or completed. For example, you can create a fork, and then schedule to complete it in 10ms, and schedule another callback to run in 100ms. The second callback will get executed, but the test will already be finished at this point.

Returns:

whether or not the test is still pending results