public void ReturnsNextIfAllContinuationsInGroupedIsComplete()
        {
            var continuation = new Continuation
            {
                Type = ContinuationType.Parallel,
                Children = new[] {new Continuation {Status = JobStatus.Completed}},
                Next = new Continuation()
            };

            var pending = continuation.PendingContinuations();

            Assert.Equal(continuation.Next, pending.Single());
        }
        public void ReturnsNextIfAnyFailedContinuationHasCompletedRecoverableContinuation()
        {
            var continuation = new Continuation
            {
                Type = ContinuationType.Parallel,
                Children = new[]
                {
                    new Continuation {Status = JobStatus.Poisoned}
                },
                ContinueAfterHandlingFailure = true,
                OnAnyFailed = new Continuation {Status = JobStatus.Completed},
                Next = new Continuation()
            };

            var pending = continuation.PendingContinuations();

            Assert.Equal(continuation.Next, pending.Single());
        }
        public void ReturnsAllIncompleteContinuationsInGrouped()
        {
            var created = new Continuation { Status = JobStatus.Created };
            var ready = new Continuation { Status = JobStatus.Ready };
            var completed = new Continuation {Status = JobStatus.Completed};
            var poisoned = new Continuation {Status = JobStatus.Poisoned};

            var continuation = new Continuation
            {
                Type = ContinuationType.Parallel,
                Children = new[] {created, completed, poisoned, ready}
            };

            var pending = continuation.PendingContinuations().ToArray();

            Assert.Contains(created, pending);
            Assert.Contains(ready, pending);
            Assert.DoesNotContain(completed, pending);
            Assert.DoesNotContain(poisoned, pending);
        }
        public void ShouldReturnNextInSequence()
        {
            var continuation = new Continuation
            {
                Type = ContinuationType.Sequence,
                Children = new[]
                {
                    new Continuation {Status = JobStatus.Completed},
                    new Continuation {Status = JobStatus.Created},
                    new Continuation {Status = JobStatus.Created}
                }
            };

            var pending = continuation.PendingContinuations();

            Assert.Equal(continuation.Children.ElementAt(1), pending.Single());
        }
        public void ShouldReturnAnyFailedHandlerWhenAnyItemFailsInSequence()
        {
            var continuation = new Continuation
            {
                Type = ContinuationType.Sequence,
                Children = new[]
                {
                    new Continuation {Status = JobStatus.Completed},
                    new Continuation {Status = JobStatus.Poisoned},
                    new Continuation {Status = JobStatus.Created}
                },
                OnAnyFailed = new Continuation()
            };

            var pending = continuation.PendingContinuations();

            Assert.Equal(continuation.OnAnyFailed, pending.Single());
        }
        public void ShouldReturnAnyFailedContinuationIfAnyContinuationInGroupIsFailed()
        {
            var continuation = new Continuation
            {
                Type = ContinuationType.Parallel,
                Children = new[]
                {
                    new Continuation {Status = JobStatus.Poisoned}
                },
                OnAnyFailed = new Continuation()
            };

            var pending = continuation.PendingContinuations();

            Assert.Equal(continuation.OnAnyFailed, pending.Single());
        }
        public void ShouldReturnAnyFailedContinuationIfAllContinuationsInGroupIsFailed()
        {
            var continuation = new Continuation
            {
                Type = ContinuationType.Parallel,
                Children = new[]
                {
                    new Continuation {Status = JobStatus.Poisoned},
                    new Continuation {Status = JobStatus.Poisoned}
                },
                OnAnyFailed = new Continuation(),
                OnAllFailed = new Continuation()
            };

            var pending = continuation.PendingContinuations();

            Assert.Contains(continuation.OnAnyFailed, pending);
        }
        public void ShouldNotReturnNextInSequenceIfCurrentIsFailed()
        {
            var continuation = new Continuation
            {
                Type = ContinuationType.Sequence,
                Children = new[]
                {
                    new Continuation {Status = JobStatus.Completed},
                    new Continuation {Status = JobStatus.Poisoned},
                    new Continuation {Status = JobStatus.Created}
                }
            };

            var pending = continuation.PendingContinuations();

            Assert.Empty(pending);
        }
        public void ShouldNotReturnNextIfSingleContinuationIsFailed()
        {
            var continuation = new Continuation {Status = JobStatus.Poisoned, Next = new Continuation()};

            var pending = continuation.PendingContinuations();

            Assert.Empty(pending);
        }
        public void ShouldNotReturnNextIfSingleContinuationIsCreated()
        {
            var continuation = new Continuation {Next = new Continuation()};

            var pending = continuation.PendingContinuations();

            Assert.Equal(continuation, pending.Single());
        }
        public void ShouldNotReturnNextIfAnyContinuationInGroupIsFailed()
        {
            var continuation = new Continuation
            {
                Type = ContinuationType.Parallel,
                Children = new[]
                {
                    new Continuation {Status = JobStatus.Completed},
                    new Continuation {Status = JobStatus.Poisoned}
                },
                Next = new Continuation()
            };

            var pending = continuation.PendingContinuations();

            Assert.Empty(pending);
        }
        public void ShouldNotReturnNextIfAllChilrenAreNotComplete()
        {
            var continuation = new Continuation
            {
                Children = new[]
                {
                    new Continuation()
                },
                Next = new Continuation()
            };

            var pending = continuation.PendingContinuations();

            Assert.DoesNotContain(continuation.Next, pending);
        }
        public void ShouldNotReturnAllFailedContinuationIfAllContinuationsInGroupIsNotFailed()
        {
            var continuation = new Continuation
            {
                Children = new[]
                {
                    new Continuation {Status = JobStatus.Completed},
                    new Continuation {Status = JobStatus.Poisoned}
                },
                OnAllFailed = new Continuation()
            };

            var pending = continuation.PendingContinuations();

            Assert.DoesNotContain(continuation.OnAllFailed, pending);
        }
        public void ReturnsSingleIncompleteContinuation(JobStatus incompleteStatus)
        {
            var continuation = new Continuation {Status = incompleteStatus};

            var pending = continuation.PendingContinuations();

            Assert.Equal(continuation, pending.Single());
        }
        public void ReturnsOnFailedContinuationIfSingleContinuationIsFailed()
        {
            var continuation = new Continuation {Status = JobStatus.Poisoned, OnAllFailed = new Continuation()};

            var pending = continuation.PendingContinuations();

            Assert.Equal(continuation.OnAllFailed, pending.Single());
        }
        public void ReturnsNextIfSingleContinuationIsCompleted()
        {
            var continuation = new Continuation {Status = JobStatus.Completed, Next = new Continuation()};

            var pending = continuation.PendingContinuations();

            Assert.Equal(continuation.Next, pending.Single());
        }