public void TransformPhaseGetsAllDocuments()
            {
                // Given
                TestDocument a1 = new TestDocument("a1");
                TestDocument b1 = new TestDocument("b1");
                TestDocument b2 = new TestDocument("b2");
                TestDocument c1 = new TestDocument("c1");
                TestDocument d1 = new TestDocument("d1");
                TestDocument d2 = new TestDocument("d2");
                ConcurrentDictionary <string, PhaseResult[]> phaseResults =
                    new ConcurrentDictionary <string, PhaseResult[]>(StringComparer.OrdinalIgnoreCase);
                IPipelineCollection pipelines = new TestPipelineCollection();
                PipelinePhase       phaseA    =
                    GetPipelineAndPhase("A", Phase.Transform, pipelines, phaseResults, new[] { a1 });
                PipelinePhase phaseB =
                    GetPipelineAndPhase("B", Phase.Transform, pipelines, phaseResults, new[] { b1, b2 }, phaseA);
                PipelinePhase phaseC =
                    GetPipelineAndPhase("C", Phase.Transform, pipelines, phaseResults, new[] { c1 }, phaseB);
                PipelinePhase phaseD =
                    GetPipelineAndPhase("D", Phase.Transform, pipelines, phaseResults, new[] { d1, d2 });
                ProcessPhaseOutputs documentCollection = new ProcessPhaseOutputs(phaseResults, phaseC, pipelines);

                // When
                IDocument[] result = documentCollection.ToArray();

                // Then
                result.ShouldBe(new[] { a1, b1, b2, c1, d1, d2 }, true);
            }
            public void ThrowsForNonDependentPipelineDuringProcessPhase()
            {
                // Given
                TestDocument a1 = new TestDocument("a1");
                TestDocument b1 = new TestDocument("b1");
                TestDocument b2 = new TestDocument("b2");
                TestDocument c1 = new TestDocument("c1");
                TestDocument d1 = new TestDocument("d1");
                TestDocument d2 = new TestDocument("d2");
                ConcurrentDictionary <string, PhaseResult[]> phaseResults =
                    new ConcurrentDictionary <string, PhaseResult[]>(StringComparer.OrdinalIgnoreCase);
                IPipelineCollection pipelines = new TestPipelineCollection();
                PipelinePhase       phaseA    =
                    GetPipelineAndPhase("A", Phase.Process, pipelines, phaseResults, new[] { a1 });
                PipelinePhase phaseB =
                    GetPipelineAndPhase("B", Phase.Process, pipelines, phaseResults, new[] { b1, b2 }, phaseA);
                PipelinePhase phaseC =
                    GetPipelineAndPhase("C", Phase.Process, pipelines, phaseResults, new[] { c1 }, phaseB);
                PipelinePhase phaseD =
                    GetPipelineAndPhase("D", Phase.Process, pipelines, phaseResults, new[] { d1, d2 });
                ProcessPhaseOutputs documentCollection = new ProcessPhaseOutputs(phaseResults, phaseC, pipelines);

                // When, Then
                Should.Throw <InvalidOperationException>(() => documentCollection.FromPipeline("D"));
            }
            public void DoesNotThrowForCurrentPipelineDuringTransform()
            {
                // Given
                ConcurrentDictionary <string, PhaseResult[]> phaseResults =
                    new ConcurrentDictionary <string, PhaseResult[]>(StringComparer.OrdinalIgnoreCase);
                IPipelineCollection pipelines          = new TestPipelineCollection();
                PipelinePhase       phase              = GetPipelineAndPhase("A", Phase.Transform, pipelines, phaseResults, Array.Empty <IDocument>());
                ProcessPhaseOutputs documentCollection = new ProcessPhaseOutputs(phaseResults, phase, pipelines);

                // When, Then
                Should.NotThrow(() => documentCollection.FromPipeline("A"));
            }
            public void ThrowsForCurrentPipelineDuringProcess()
            {
                // Given
                ConcurrentDictionary <string, PhaseResult[]> phaseResults =
                    new ConcurrentDictionary <string, PhaseResult[]>(StringComparer.OrdinalIgnoreCase);
                IPipelineCollection pipelines          = new TestPipelineCollection();
                PipelinePhase       phase              = GetPipelineAndPhase("A", Phase.Process, pipelines, phaseResults, Array.Empty <IDocument>());
                ProcessPhaseOutputs documentCollection = new ProcessPhaseOutputs(phaseResults, phase, pipelines);

                // When, Then
                Should.Throw <InvalidOperationException>(() => documentCollection.FromPipeline("A"));
            }
            public void ThrowsIfInputPhase()
            {
                // Given
                ConcurrentDictionary <string, PhaseResult[]> documents =
                    new ConcurrentDictionary <string, PhaseResult[]>(StringComparer.OrdinalIgnoreCase);
                IPipelineCollection pipelines = new TestPipelineCollection();
                PipelinePhase       phase     = GetPipelineAndPhase("A", Phase.Input, pipelines, documents, Array.Empty <IDocument>());

                phase.Pipeline.Isolated = true;
                ProcessPhaseOutputs documentCollection = new ProcessPhaseOutputs(documents, phase, pipelines);

                // When, Then
                Should.Throw <InvalidOperationException>(() => documentCollection.ToArray());
            }