PromiseTest.java

/*                        __    __  __  __    __  ___
 *                       \  \  /  /    \  \  /  /  __/
 *                        \  \/  /  /\  \  \/  /  /
 *                         \____/__/  \__\____/__/.ɪᴏ
 * ᶜᵒᵖʸʳᶦᵍʰᵗ ᵇʸ ᵛᵃᵛʳ ⁻ ˡᶦᶜᵉⁿˢᵉᵈ ᵘⁿᵈᵉʳ ᵗʰᵉ ᵃᵖᵃᶜʰᵉ ˡᶦᶜᵉⁿˢᵉ ᵛᵉʳˢᶦᵒⁿ ᵗʷᵒ ᵈᵒᵗ ᶻᵉʳᵒ
 */
package io.vavr.concurrent;

import io.vavr.control.Try;
import org.junit.Test;

import static io.vavr.concurrent.Concurrent.zZz;
import static org.assertj.core.api.Assertions.assertThat;

public class PromiseTest {

    @Test
    public void shouldReturnExecutorService() {
        final Promise<Integer> promise = Promise.successful(42);
        assertThat(promise.executorService()).isNotNull();
    }

    @Test
    public void shouldReturnSuccessfulPromise() {
        final Promise<Integer> promise = Promise.successful(42);
        assertThat(promise.isCompleted()).isTrue();
        assertThat(promise.future().isSuccess()).isTrue();
    }

    @Test
    public void shouldReturnFailedPromise() {
        final Promise<Integer> promise = Promise.failed(new RuntimeException());
        assertThat(promise.isCompleted()).isTrue();
        assertThat(promise.future().isFailure()).isTrue();
    }

    @Test
    public void shouldReturnPromiseFromTry() {
        final Promise<Integer> promise = Promise.fromTry(Try.of(() -> 42));
        assertThat(promise.isCompleted()).isTrue();
        assertThat(promise.future().isSuccess()).isTrue();
    }

    @Test(expected = IllegalStateException.class)
    public void shouldFailWhenCompleteAgain() {
        Promise.successful(42).complete(Try.success(0));
    }

    @Test
    public void shouldTrySuccess() {
        final Promise<Integer> promise = Promise.make();
        assertThat(promise.trySuccess(42)).isTrue();
        assertThat(promise.trySuccess(42)).isFalse();
        assertThat(promise.future().get()).isEqualTo(42);
    }

    @Test
    public void shouldTryFailure() {
        final Promise<Integer> promise = Promise.make();
        assertThat(promise.tryFailure(new RuntimeException())).isTrue();
        assertThat(promise.tryFailure(new RuntimeException())).isFalse();
        assertThat(promise.future().isFailure()).isTrue();
    }

    @Test
    public void shouldConvertToString() {
        assertThat(Promise.successful("vavr").toString().contains("vavr")).isTrue();
    }

    @Test
    public void shouldCompletePromiseWithItsOwnFuture() {
        final Promise<String> promise = Promise.make(ExecutorServices.trivialExecutorService());
        promise.completeWith(promise.future());
        assertThat(promise.isCompleted()).isFalse();
        assertThat(promise.success("ok").isCompleted()).isTrue();
    }

    @Test
    public void shouldMediateProducerConsumerViaPromise() {

        final String product = "Coffee";

        class Context {

            String produceSomething() {
                Concurrent.zZz();
                System.out.println("Making " + product);
                return product;
            }

            void continueDoingSomethingUnrelated() {
                System.out.println("Unreleated stuff");
            }

            void startDoingSomething() {
                System.out.println("Something else");
            }
        }

        final Context ctx = new Context();
        final Promise<String> producerResult = Promise.make();
        final Promise<String> consumerResult = Promise.make();

        // producer
        Future.run(() -> {
            producerResult.success(ctx.produceSomething());
            ctx.continueDoingSomethingUnrelated();
        });

        // consumer
        Future.run(() -> {
            ctx.startDoingSomething();
            consumerResult.completeWith(producerResult.future());
        });

        final String actual = consumerResult.future().get();
        assertThat(actual).isEqualTo(product);
    }
}