public void Pipeline_Execute_Throws_Wrong_Output_Length()
{
MockPipeline pipeline = TestPipelines.CreateMockProcessor1Pipeline();
ProcessorResult errorResult = null;
// Override the OnExecute to return a ProcessorResult
// which contains the wrong
((MockProcessor1)pipeline.Processors[1]).OnExecuteCalled =
i =>
{
ProcessorResult pr = new ProcessorResult <string>()
{
};
pr.Output = new object[] { "string1", "string2" };
return(pr as ProcessorResult <string>);
};
pipeline.OnErrorCalled = r => errorResult = r;
// The final pipeline result should reflect that error status
ProcessorResult result = pipeline.Execute(new object[] { 5 });
Assert.IsNotNull(result, "Failed to get a result");
Assert.AreEqual(ProcessorStatus.Error, result.Status, "Expected failure status");
Assert.IsNotNull(result.Error, "Expected error result");
Assert.AreEqual(typeof(InvalidOperationException), result.Error.GetType(), "Expected InvalidOperationException");
Assert.IsNotNull(errorResult, "Pipeline.OnError should have been called");
}
public void ProcessCallsStep()
{
var pipeline = new MockPipeline();
pipeline.Process(new TestableBundle("~"), new CassetteSettings());
pipeline.DummyStep.ProcessCalled.ShouldBeTrue();
}
public void Pipeline_BindArgumentToPipelineOutput_By_Name()
{
MockProcessor1 processor = new MockProcessor1();
MockPipeline pipeline = new MockPipeline(
new Processor[] { processor },
Enumerable.Empty <ProcessorArgument>(),
new ProcessorArgument[] { new ProcessorArgument("PipelineOutput", typeof(string)) });
BindArgumentsEventArgs eventArgs = null;
ProcessorArgument inArgFromBind = null;
ProcessorArgument outArgFromBind = null;
pipeline.OnBindArgumentsCalled = (outArg, inArg) =>
{
inArgFromBind = inArg;
outArgFromBind = outArg;
};
pipeline.BoundArguments = (s, a) => { eventArgs = a as BindArgumentsEventArgs; };
pipeline.BindArgumentToPipelineOutput(processor.OutArguments[0], "PipelineOutput");
Assert.IsNotNull(eventArgs, "Did not receive OnBoundArguments callback");
Assert.AreSame(pipeline.Processors[1].OutArguments[0], outArgFromBind, "Did not receive correct outArg in OnBind virtual");
Assert.AreSame(pipeline.Processors[2].InArguments[0], inArgFromBind, "Did not receive correct inArg in OnBind virtual");
Assert.IsTrue(pipeline.GetBoundToArguments(pipeline.Processors[1].OutArguments[0]).Contains(pipeline.Processors[2].InArguments[0]),
"Failed to find exit processor in argument in bindings for processor 1");
}
/// <summary>
/// This pipeline has 2 MockProcessor1's in it, both binding their inputs to the pipeline's 'intValue'.
/// The pipeline has 2 outputs, one bound to each processor's.
/// </summary>
/// <returns></returns>
public static MockPipeline CreateDoubleMockProcessor1Pipeline()
{
Processor processor1 = new MockProcessor1();
Processor processor2 = new MockProcessor1();
MockPipeline pipeline = new MockPipeline(
new[] { processor1, processor2 },
new[] { new ProcessorArgument("intValue", typeof(int), new object[0]) },
new[] { new ProcessorArgument("theResult1", typeof(string), new object[0]),
new ProcessorArgument("theResult2", typeof(string), new object[0]) }
);
// Pipeline["intValue"] --> Processor1[0]
pipeline.BindArgumentToPipelineInput("intValue", processor1.InArguments[0]);
// Pipeline["intValue"] --> Processor2[0]
pipeline.BindArgumentToPipelineInput("intValue", processor2.InArguments[0]);
// Processor1[0] --> Pipeline["theResult1"]
pipeline.BindArgumentToPipelineOutput(processor1.OutArguments[0], "theResult1");
// Processor2[0] --> Pipeline["theResult2"]
pipeline.BindArgumentToPipelineOutput(processor2.OutArguments[0], "theResult2");
pipeline.Initialize();
return(pipeline);
}
/// <summary>
/// Creates a Pipeline with a single MockProcessor1 in it, binding its inputs to the pipeline inputs
/// and its outputs to the pipeline outputs.
/// </summary>
/// <returns></returns>
public static MockPipeline CreateMockProcessor1Pipeline()
{
MockPipeline pipeline = CreateMockProcessor1PipelineUninitialized();
pipeline.Initialize();
return(pipeline);
}
public void TestInitialise()
{
_Snapshot = Factory.TakeSnapshot();
_ControllerFinder = MockHelper.FactoryImplementation <IControllerFinder>();
_ControllerTypes = new List <ControllerType>();
_ControllerFinder.Setup(r => r.DiscoverControllers()).Returns(_ControllerTypes);
_RouteFinder = MockHelper.FactoryImplementation <IRouteFinder>();
_Routes = new List <Route>();
_RouteFinder.Setup(r => r.DiscoverRoutes(It.IsAny <IEnumerable <ControllerType> >())).Returns(_Routes);
_RouteMapper = MockHelper.FactoryImplementation <IRouteMapper>();
_FoundRoute = new Route();
_RouteMapper.Setup(r => r.FindRouteForRequest(It.IsAny <IDictionary <string, object> >())).Returns(() => _FoundRoute);
_RouteParameters = new RouteParameters(new string[0], new object[0]);
_RouteMapper.Setup(r => r.BuildRouteParameters(It.IsAny <Route>(), It.IsAny <IDictionary <string, object> >())).Returns(() => _RouteParameters);
_RouteFilter_CanCallRoute = true;
_RouteFilter = MockHelper.FactoryImplementation <IRouteFilter>();
_RouteFilter.Setup(r => r.CanCallRoute(It.IsAny <Route>(), It.IsAny <IDictionary <string, object> >())).Returns(() => _RouteFilter_CanCallRoute);
_RouteCaller = MockHelper.FactoryImplementation <IRouteCaller>();
_RouteOutcome = null;
_RouteCaller.Setup(r => r.CallRoute(It.IsAny <IDictionary <string, object> >(), It.IsAny <Route>(), It.IsAny <RouteParameters>())).Returns(() => _RouteOutcome);
_Responder = MockHelper.FactoryImplementation <IWebApiResponder>();
_Pipeline = new MockPipeline();
_Environment = new MockOwinEnvironment();
_WebApi = Factory.Resolve <IWebApiMiddleware>();
}
public void ProcessCallsCreatePipeline()
{
var pipeline = new MockPipeline();
pipeline.Process(new TestableBundle("~"), new CassetteSettings(""));
pipeline.CreatePipelineCalled.ShouldBeTrue();
}
public void Pipeline_BindArgumentToPipelineOutput_By_Bad_Name_Throws()
{
MockProcessor1 processor = new MockProcessor1();
MockPipeline pipeline = new MockPipeline(
new Processor[] { processor },
Enumerable.Empty <ProcessorArgument>(),
new ProcessorArgument[] { new ProcessorArgument("PipelineOutput", typeof(string)) });
ExceptionAssert.Throws(
typeof(ArgumentException),
"BindArgumentToPipelineOutput should throw with null name",
() => pipeline.BindArgumentToPipelineOutput(processor.OutArguments[0], null),
"pipelineOutputArgumentName"
);
ExceptionAssert.Throws(
typeof(ArgumentException),
"BindArgumentToPipelineOutput should throw with empty name",
() => pipeline.BindArgumentToPipelineOutput(processor.OutArguments[0], string.Empty),
"pipelineOutputArgumentName"
);
ExceptionAssert.Throws(
typeof(ArgumentException),
"BindArgumentToPipelineOutput should throw with whitespace name",
() => pipeline.BindArgumentToPipelineOutput(processor.OutArguments[0], " "),
"pipelineOutputArgumentName"
);
ExceptionAssert.ThrowsInvalidOperation(
"BindArgumentToPipelineInput should throw with non-existent name",
() => pipeline.BindArgumentToPipelineOutput(processor.OutArguments[0], "NotAName")
);
}
public void PipelineContext_OnReadAllInputs_Overridable()
{
MockPipeline pipeline = TestPipelines.CreateMockProcessor1Pipeline();
MockPipelineContext context = pipeline.Context;
bool processorCalled = false;
context.OnReadAllInputsCalled = (inProc, inValues) =>
{
// Inject a '3' into the inputs for proc 1
if (inProc == pipeline.Processors[1])
{
processorCalled = true;
Assert.AreEqual(4, inValues[0], "Expected to see '4' as the pipeline input");
inValues[0] = 3;
}
};
ProcessorResult procResult = pipeline.Execute(new object[] { 4 });
Assert.IsNotNull(procResult.Output, "Expected output array");
Assert.AreEqual(1, procResult.Output.Length, "Output size mismatch");
Assert.AreEqual(3.ToString(), procResult.Output[0], "Pipeline did not use context we injected");
Assert.IsTrue(processorCalled, "Our ReadAllInputs override was not called");
}
public void Pipeline_Bind_OnBinding_OnBind_OnBound_Callbacks()
{
MockProcessor1 processor1 = new MockProcessor1();
MockProcessorEchoString processor2 = new MockProcessorEchoString();
MockPipeline pipeline = new MockPipeline(
new Processor[] { processor1, processor2 },
Enumerable.Empty <ProcessorArgument>(),
Enumerable.Empty <ProcessorArgument>());
BindArgumentsEventArgs bindingEventArgs = null;
BindArgumentsEventArgs boundEventArgs = null;
ProcessorArgument inArgFromBind = null;
ProcessorArgument outArgFromBind = null;
pipeline.OnBindArgumentsCalled = (outArg, inArg) =>
{
inArgFromBind = inArg;
outArgFromBind = outArg;
};
pipeline.BindingArguments = (s, a) => { bindingEventArgs = a as BindArgumentsEventArgs; };
pipeline.BoundArguments = (s, a) => { boundEventArgs = a as BindArgumentsEventArgs; };
pipeline.BindArguments(processor1.OutArguments[0], processor2.InArguments[0]);
Assert.IsNotNull(bindingEventArgs, "Did not receive BindingArguments callback");
Assert.AreSame(processor1.OutArguments[0], bindingEventArgs.OutArgument, "Did not receive correct outArg in BindingArgument callback");
Assert.AreSame(processor2.InArguments[0], bindingEventArgs.InArgument, "Did not receive correct inArg in BindingArgument callback");
Assert.IsNotNull(boundEventArgs, "Did not receive BoundArguments callback");
Assert.AreSame(processor1.OutArguments[0], boundEventArgs.OutArgument, "Did not receive correct outArg in BoundArgument callback");
Assert.AreSame(processor2.InArguments[0], boundEventArgs.InArgument, "Did not receive correct inArg in BoundArgument callback");
Assert.AreSame(processor1.OutArguments[0], outArgFromBind, "Did not receive correct outArg in OnBind virtual");
Assert.AreSame(processor2.InArguments[0], inArgFromBind, "Did not receive correct inArg in OnBind virtual");
}
public void PipelineBuilder_Derived_Pipeline()
{
MockPipelineBuilderOfMockPipeline pb = new MockPipelineBuilderOfMockPipeline();
Processor[] processors = new Processor[0];
ProcessorArgument[] inArgs = new ProcessorArgument[0];
ProcessorArgument[] outArgs = new ProcessorArgument[0];
MockPipeline pipeline = pb.Build(processors, inArgs, outArgs);
}
public void WhenUpdateStep_ThenProcessCallsUpdateAction()
{
var pipeline = new MockPipeline();
pipeline.Update <MockStep>(step => step.Updated = true);
pipeline.Process(new TestableBundle("~"), new CassetteSettings());
pipeline.DummyStep.Updated.ShouldBeTrue();
}
public void WhenRemoveStep_ThenProcessDoesNotCallIt()
{
var pipeline = new MockPipeline();
pipeline.Remove <MockStep>();
pipeline.Process(new TestableBundle("~"), new CassetteSettings());
pipeline.DummyStep.ProcessCalled.ShouldBeFalse();
}
public void PipelineContext_ReadInput_Returns_WriteInput()
{
MockPipeline pipeline = TestPipelines.CreateMockProcessor1Pipeline();
MockPipelineContext context = pipeline.Context;
context.WriteInput(pipeline.Processors[1].InArguments[0], 7);
object value = context.ReadInput(pipeline.Processors[1].InArguments[0]);
Assert.AreEqual(7, value, "Expected processor 1 to have this input value after we wrote it");
}
public void PipelineContext_WriteInput_Throws_If_Null_ProcessorArgument()
{
MockPipeline pipeline = TestPipelines.CreateMockProcessor1Pipeline();
PipelineContext context = new PipelineContext(pipeline);
ExceptionAssert.ThrowsArgumentNull(
"PipelineContext should throw if null processor argument specified",
"inArgument",
() => context.WriteInput(null, new object())
);
}
public void WhenReplaceStep_ThenProcessCallsNewStep()
{
var pipeline = new MockPipeline();
var newStep = new MockStep();
pipeline.Replace <MockStep>(newStep);
pipeline.Process(new TestableBundle("~"), new CassetteSettings());
newStep.ProcessCalled.ShouldBeTrue();
}
public void WhenInsertAfterStep_TheProcessCallsTheNewStep()
{
var pipeline = new MockPipeline();
var newStep = new MockStep();
pipeline.InsertAfter <MockStep>(newStep);
pipeline.Process(new TestableBundle("~"), new CassetteSettings());
newStep.ProcessCalled.ShouldBeTrue();
}
public void PipelineContext_ReadAllInputs_Throws_If_Null_Processor()
{
MockPipeline pipeline = TestPipelines.CreateMockProcessor1Pipeline();
PipelineContext context = new PipelineContext(pipeline);
ExceptionAssert.ThrowsArgumentNull(
"PipelineContext should throw if null processor specified",
"processor",
() => context.ReadAllInputs(null)
);
}
public void WhenReplaceStep_ThenProcessDoesNotCallOldStep()
{
var pipeline = new MockPipeline();
var newStep = new MockStep();
pipeline.Replace <MockStep>(newStep);
pipeline.Process(new TestableBundle("~"), new CassetteSettings(""));
pipeline.DummyStep.ProcessCalled.ShouldBeFalse();
}
public void WhenAppendStep_ThenProcessCallsTheStepLast()
{
var pipeline = new MockPipeline();
var step = new MockStep();
pipeline.Append(step);
pipeline.Process(new TestableBundle("~"), new CassetteSettings());
(step.CallIndex > pipeline.DummyStep.CallIndex).ShouldBeTrue();
}
public void WhenInsertBeforeStep_TheProcessCallsTheNewStepBeforeOriginalStep()
{
var pipeline = new MockPipeline();
var newStep = new MockStep();
pipeline.InsertBefore <MockStep>(newStep);
pipeline.Process(new TestableBundle("~"), new CassetteSettings());
(newStep.CallIndex < pipeline.DummyStep.CallIndex).ShouldBeTrue();
}
public void PipelineContext_ReadInput_Returns_Result_After_Execution()
{
MockPipeline pipeline = TestPipelines.CreateMockProcessor1Pipeline();
MockPipelineContext context = pipeline.Context;
object value = context.ReadInput(pipeline.Processors[1].InArguments[0]);
Assert.IsNull(value, "Expected null prior to execution");
ProcessorResult result = pipeline.Execute(new object[] { 7 });
value = context.ReadInput(pipeline.Processors[1].InArguments[0]);
Assert.AreEqual(7, value, "Expected processor 1 to have this input value after execution");
}
/// <summary>
/// Creates a Pipeline with no actual processor other than binding the pipeline inputs to the
/// pipeline outputs.
/// </summary>
/// <returns></returns>
public static MockPipeline CreateEmptyPipeline()
{
MockPipeline pipeline = new MockPipeline(
new Processor[0],
new[] { new ProcessorArgument("inValue", typeof(string), new object[0]) },
new[] { new ProcessorArgument("outValue", typeof(string), new object[0]) }
);
pipeline.BindArgumentToPipelineInput("inValue", pipeline.Processors[1].InArguments[0]);
pipeline.Initialize();
return(pipeline);
}
public void PipelineContext_WriteInput_Throws_If_Containerless_ProcessorArgument()
{
MockPipeline pipeline = TestPipelines.CreateMockProcessor1Pipeline();
PipelineContext context = new PipelineContext(pipeline);
ExceptionAssert.Throws(
typeof(ArgumentException),
"PipelineContext should throw if processor argument belongs to no collection",
() => context.WriteInput(new ProcessorArgument("foo", typeof(string)), new object()),
"inArgument"
);
}
public void CanChainModifications()
{
var pipeline = new MockPipeline();
var step1 = new MockStep();
var step2 = new MockStep();
pipeline.Append(step1).Append(step2);
pipeline.Process(new TestableBundle("~"), new CassetteSettings());
step1.CallIndex.ShouldEqual(1);
step2.CallIndex.ShouldEqual(2);
}
/// <summary>
/// Creates an uninitialized Pipeline with a single MockProcessor1 in it, binding its inputs to the pipeline inputs
/// and its outputs to the pipeline outputs.
/// </summary>
/// <returns></returns>
public static MockPipeline CreateMockProcessor1PipelineUninitialized()
{
Processor processor = new MockProcessor1();
MockPipeline pipeline = new MockPipeline(
new[] { processor },
new[] { new ProcessorArgument("intValue", typeof(int), new object[0]) },
new[] { new ProcessorArgument("theResult", typeof(string), new object[0]) }
);
pipeline.BindArgumentToPipelineInput("intValue", processor.InArguments[0]);
pipeline.BindArgumentToPipelineOutput(processor.OutArguments[0], "theResult");
return(pipeline);
}
public void PipelineContext_ReadAllInputs_Throws_If_Processor_Not_In_Pipeline()
{
Processor processor = new MockProcessor1();
MockPipeline pipeline = TestPipelines.CreateMockProcessor1Pipeline();
PipelineContext context = new PipelineContext(pipeline);
ExceptionAssert.Throws(
typeof(ArgumentException),
"PipelineContext should throw if processor from different pipeline specified",
() => context.ReadAllInputs(processor),
"processor"
);
}
public void PipelineContext_WriteInput_Throws_If_External_ProcessorArgument()
{
Processor processor = new MockProcessor1();
MockPipeline pipeline = TestPipelines.CreateMockProcessor1Pipeline();
PipelineContext context = new PipelineContext(pipeline);
ExceptionAssert.Throws(
typeof(ArgumentException),
"PipelineContext should throw if processor argument belongs to different pipeline",
() => context.WriteInput(processor.InArguments[0], new object()),
"inArgument"
);
}
public void Pipeline_Executes_With_No_Bindings()
{
MockProcessor1 processor1 = new MockProcessor1();
MockProcessorEchoString processor2 = new MockProcessorEchoString();
MockPipeline pipeline = new MockPipeline(
new Processor[] { processor1, processor2 },
Enumerable.Empty <ProcessorArgument>(),
Enumerable.Empty <ProcessorArgument>());
pipeline.Initialize();
ProcessorResult result = pipeline.Execute(new object[0]);
Assert.IsNotNull(result, "Expected non-null ProcessorResult");
Assert.IsNotNull(result.Output, "Expected non-null output from unbound pipeline");
Assert.AreEqual(0, result.Output.Length, "Expected empty array from unbound pipeline");
Assert.AreEqual(ProcessorStatus.Ok, result.Status, "Expected OK status from pipeline");
}
public void PipelineContext_Can_Redirect_Storage()
{
MockPipeline pipeline = TestPipelines.CreateMockProcessor1Pipeline();
// Create our own special context and redirect to it when pipeline executes
MockPipelineContextWithOwnStore context = new MockPipelineContextWithOwnStore(pipeline);
pipeline.OnCreateContextCalled = () => context;
ProcessorResult procResult = pipeline.Execute(new object[] { 4 });
Assert.IsNotNull(procResult.Output, "Expected output array");
Assert.AreEqual(1, procResult.Output.Length, "Output size mismatch");
Assert.AreEqual(4.ToString(), procResult.Output[0], "Pipeline did produce expected value");
Dictionary <ProcessorArgument, object> cache = context.Cache;
Assert.AreEqual(2, cache.Count, "Expected 2 cached input values");
}
