public async Task HandlesExceptionsThrownImmediatelyByInnerPublisher()
    {
        const int expectedResult   = 42;
        var       exceptionToThrow = new PublishException();
        var       exceptionsThrown = new List <Exception>();

        var innerPublisher = Substitute.For <IResultPublisher>();

        innerPublisher.Publish(Arg.Any <Result <int, int> >())
        .Throws(exceptionToThrow);

        var fireAndForgetPublisher = new FireAndForgetResultPublisher(innerPublisher, ex => { exceptionsThrown.Add(ex); });

        var mock = Substitute.For <IControlCandidate <int, string> >();

        mock.Control().Returns(expectedResult);
        mock.Candidate().Returns(expectedResult);

        using (Swap.Publisher(fireAndForgetPublisher))
        {
            var result = Scientist.Science <int>("myExperiment", experiment =>
            {
                experiment.Use(mock.Control);
                experiment.Try(mock.Candidate);
            });
        }

        await fireAndForgetPublisher.WhenPublished();

        Assert.Equal(new List <Exception> {
            exceptionToThrow
        }, exceptionsThrown);
    }
    public async Task PublishesAsynchronously()
    {
        const int expectedResult     = 42;
        var       pendingPublishTask = new TaskCompletionSource <object>();

        // Create a new publisher that will delay all
        // publishing to account for this test.
        var innerPublisher = Substitute.For <IResultPublisher>();

        innerPublisher.Publish(Arg.Any <Result <int, int> >())
        .Returns(call => pendingPublishTask.Task);

        var fireAndForgetPublisher = new FireAndForgetResultPublisher(innerPublisher, ex => { });

        var mock = Substitute.For <IControlCandidate <int, string> >();

        mock.Control().Returns(expectedResult);
        mock.Candidate().Returns(expectedResult);

        const int count = 10;

        using (Swap.Publisher(fireAndForgetPublisher))
        {
            Parallel.ForEach(
                Enumerable.Repeat(0, count),
                src =>
            {
                var result = Scientist.Science <int>("myExperiment", experiment =>
                {
                    experiment.Use(mock.Control);
                    experiment.Try(mock.Candidate);
                });

                Assert.Equal(expectedResult, result);
            });
        }

        // Make sure that the above science calls are still publishing.
        Task whenPublished = fireAndForgetPublisher.WhenPublished();

        Assert.NotNull(whenPublished);

        // Ensure that the mock was called before the when published task has completed.
        mock.Received(count).Control();
        mock.Received(count).Candidate();

        Assert.False(whenPublished.IsCompleted, "When Published Task completed early.");

        pendingPublishTask.SetResult(null);

        await whenPublished;

        Assert.True(whenPublished.IsCompleted, "When Published Task isn't complete.");
    }
    public async Task PublishesAsynchronously()
    {
        const int expectedResult = 42;
        var pendingPublishTask = new TaskCompletionSource<object>();

        // Create a new publisher that will delay all
        // publishing to account for this test.
        var innerPublisher = Substitute.For<IResultPublisher>();
        innerPublisher.Publish(Arg.Any<Result<int, int>>())
            .Returns(call => pendingPublishTask.Task);

        var fireAndForgetPublisher = new FireAndForgetResultPublisher(innerPublisher, ex => { });

        var mock = Substitute.For<IControlCandidate<int, string>>();
        mock.Control().Returns(expectedResult);
        mock.Candidate().Returns(expectedResult);

        const int count = 10;
        using (Swap.Publisher(fireAndForgetPublisher))
        {
            Parallel.ForEach(
                Enumerable.Repeat(0, count),
                src =>
                {
                    var result = Scientist.Science<int>("myExperiment", experiment =>
                    {
                        experiment.Use(mock.Control);
                        experiment.Try(mock.Candidate);
                    });

                    Assert.Equal(expectedResult, result);
                });
        }

        // Make sure that the above science calls are still publishing.
        Task whenPublished = fireAndForgetPublisher.WhenPublished();
        Assert.NotNull(whenPublished);

        // Ensure that the mock was called before the when published task has completed.
        mock.Received(count).Control();
        mock.Received(count).Candidate();

        Assert.False(whenPublished.IsCompleted, "When Published Task completed early.");

        pendingPublishTask.SetResult(null);

        await whenPublished;

        Assert.True(whenPublished.IsCompleted, "When Published Task isn't complete.");
    }
    public async Task HandlesDelayedExceptionsThrownByInnerPublisher()
    {
        const int expectedResult   = 42;
        var       exceptionToThrow = new PublishException();
        var       exceptionsThrown = new List <Exception>();

        var pendingPublishTask = new TaskCompletionSource <object>();
        var innerPublisher     = Substitute.For <IResultPublisher>();

        innerPublisher.Publish(Arg.Any <Result <int, int> >())
        .Returns(call => pendingPublishTask.Task.ContinueWith(_ => { throw exceptionToThrow; }));

        var fireAndForgetPublisher = new FireAndForgetResultPublisher(innerPublisher, ex => { exceptionsThrown.Add(ex); });

        var mock = Substitute.For <IControlCandidate <int, string> >();

        mock.Control().Returns(expectedResult);
        mock.Candidate().Returns(expectedResult);

        using (Swap.Publisher(fireAndForgetPublisher))
        {
            var result = Scientist.Science <int>("myExperiment", experiment =>
            {
                experiment.Use(mock.Control);
                experiment.Try(mock.Candidate);
            });
        }

        var whenPublished = fireAndForgetPublisher.WhenPublished();

        Assert.False(whenPublished.IsCompleted, "When Published Task completed early.");

        pendingPublishTask.SetResult(null);

        await whenPublished;

        Assert.True(whenPublished.IsCompleted, "When Published Task isn't complete.");

        Assert.Equal(new List <Exception> {
            exceptionToThrow
        }, exceptionsThrown);
    }
    public async Task HandlesDelayedExceptionsThrownByInnerPublisher()
    {
        const int expectedResult = 42;
        var exceptionToThrow = new PublishException();
        var exceptionsThrown = new List<Exception>();

        var pendingPublishTask = new TaskCompletionSource<object>();
        var innerPublisher = Substitute.For<IResultPublisher>();
        innerPublisher.Publish(Arg.Any<Result<int, int>>())
            .Returns(call => pendingPublishTask.Task.ContinueWith(_ => { throw exceptionToThrow; }));

        var fireAndForgetPublisher = new FireAndForgetResultPublisher(innerPublisher, ex => { exceptionsThrown.Add(ex); });

        var mock = Substitute.For<IControlCandidate<int, string>>();
        mock.Control().Returns(expectedResult);
        mock.Candidate().Returns(expectedResult);

        using (Swap.Publisher(fireAndForgetPublisher))
        {
            var result = Scientist.Science<int>("myExperiment", experiment =>
            {
                experiment.Use(mock.Control);
                experiment.Try(mock.Candidate);
            });
        }

        var whenPublished = fireAndForgetPublisher.WhenPublished();

        Assert.False(whenPublished.IsCompleted, "When Published Task completed early.");

        pendingPublishTask.SetResult(null);

        await whenPublished;

        Assert.True(whenPublished.IsCompleted, "When Published Task isn't complete.");

        Assert.Equal(new List<Exception> { exceptionToThrow }, exceptionsThrown);
    }
    public async Task HandlesExceptionsThrownImmediatelyByInnerPublisher()
    {
        const int expectedResult = 42;
        var exceptionToThrow = new PublishException();
        var exceptionsThrown = new List<Exception>();

        var innerPublisher = Substitute.For<IResultPublisher>();
        innerPublisher.Publish(Arg.Any<Result<int, int>>())
            .Throws(exceptionToThrow);

        var fireAndForgetPublisher = new FireAndForgetResultPublisher(innerPublisher, ex => { exceptionsThrown.Add(ex); });

        var mock = Substitute.For<IControlCandidate<int, string>>();
        mock.Control().Returns(expectedResult);
        mock.Candidate().Returns(expectedResult);

        using (Swap.Publisher(fireAndForgetPublisher))
        {
            var result = Scientist.Science<int>("myExperiment", experiment =>
            {
                experiment.Use(mock.Control);
                experiment.Try(mock.Candidate);
            });
        }

        await fireAndForgetPublisher.WhenPublished();

        Assert.Equal(new List<Exception> { exceptionToThrow }, exceptionsThrown);
    }