public void Adding_ShouldExecute_To_Subflow_Applies_To_Subflow_Root()
{
var containerBuilder = new ContainerBuilder();
containerBuilder.RegisterBanzaiNodes(GetType().Assembly, true);
var flowBuilder = new FlowBuilder <object>(new AutofacFlowRegistrar(containerBuilder));
flowBuilder.CreateFlow("TestFlow2")
.AddRoot <PipelineNode <object> >()
.AddChild <ITestNode4>()
.AddChild <ITestNode3>()
.AddChild <ITestNode2>();
flowBuilder.Register();
flowBuilder.CreateFlow("TestFlow1")
.AddRoot <PipelineNode <object> >()
.AddChild <ITestNode2>()
.AddFlow("TestFlow2")
.ForChildFlow("TestFlow2").SetShouldExecute(ctxt => Task.FromResult(1 + 1 == 3));
flowBuilder.Register();
var container = containerBuilder.Build();
var factory = container.Resolve <INodeFactory <object> >();
var flow = (IPipelineNode <object>)factory.BuildFlow("TestFlow1");
var subflowRoot = (IPipelineNode <object>)flow.Children[1];
subflowRoot.ShouldExecuteFunc.Should().NotBeNull();
subflowRoot.ShouldExecuteFunc(new ExecutionContext <object>(new object())).Result.Should().BeFalse();
}
public void Multiple_Flows_Can_Be_Registered()
{
var kernel = new StandardKernel();
kernel.RegisterBanzaiNodes(GetType().Assembly, true);
var flowBuilder = new FlowBuilder <object>(new NinjectFlowRegistrar(kernel));
flowBuilder.CreateFlow("TestFlow2")
.AddRoot <IPipelineNode <object> >()
.AddChild <ITestNode4>()
.AddChild <ITestNode3>()
.AddChild <ITestNode2>();
flowBuilder.Register();
flowBuilder.CreateFlow("TestFlow1")
.AddRoot <IPipelineNode <object> >()
.AddChild <ITestNode2>();
flowBuilder.Register();
var factory = kernel.Get <INodeFactory <object> >();
var flow = factory.BuildFlow("TestFlow1");
flow.Should().NotBeNull();
flow = factory.BuildFlow("TestFlow2");
flow.Should().NotBeNull();
}
public async Task SimpleFlowElementCanExecuteErrorShouldNotExecuteSecondStep()
{
var flow = new FlowBuilder()
.Add(
FlowElementBuilder
.New()
.CanExecute(async(i, _) => CanExecuteResult.Error("error"))
.OnExecute(async(i, _) => throw new Exception("Should not execute step 1"))
.Build()
,
FlowElementBuilder
.New()
.CanExecute(async(i, _) => CanExecuteResult.Continue)
.OnExecute(async(i, _) => throw new Exception("Should not execute step 2"))
.Build()
)
.Build();
var flowResult = await flow.RunAsync(4);
flowResult
.Should()
.BeOfType <FlowErrorResult>()
.Which.ErrorObject
.Should().Be("error");
}
public void ShouldExecute_Is_Added_To_Child_Node()
{
var kernel = new StandardKernel();
kernel.RegisterBanzaiNodes(GetType().Assembly, true);
var flowBuilder = new FlowBuilder <object>(new NinjectFlowRegistrar(kernel));
flowBuilder.CreateFlow("TestFlow1")
.AddRoot <IPipelineNode <object> >()
.AddChild <ITestNode2>()
.ForChild <ITestNode2>()
.SetShouldExecute(ctxt => Task.FromResult(1 + 1 == 3));
flowBuilder.Register();
var factory = kernel.Get <INodeFactory <object> >();
var flow = (IPipelineNode <object>)factory.BuildFlow("TestFlow1");
var subflow = flow.Children[0];
subflow.ShouldExecuteFunc.ShouldNotBeNull();
subflow.ShouldExecuteFunc(new ExecutionContext <object>(new object())).Result.ShouldBeFalse();
}
protected override void Build(FlowBuilder builder)
{
builder.WithDefaultFaultHandler <MyFaultHandler>();
builder.WithDefaultCancellationHandler <MyCancellationHandler>();
builder.WithInitialNode(builder.Activity <ThrowServiceClient>("ThrowService client"));
}
public async Task ExecutePipeSuccess()
{
var element = new Mock <FlowElement>();
element
.Protected()
.Setup <Task <CanExecuteResult> >("OnCanExecuteAsync", ItExpr.IsAny <string>(), ItExpr.IsAny <FlowState>())
.ReturnsAsync(true);
element
.Protected()
.Setup <Task <FlowElementResult> >("OnExecuteAsync", ItExpr.IsAny <string>(), ItExpr.IsAny <FlowState>())
.ReturnsAsync(new FlowSuccessResult()
{
Result = "res"
});
var builder = new FlowBuilder()
.Add(element.Object);
var pipeline = builder.Build();
var result = await pipeline.RunAsync("test");
result.Result.Should().Be("res");
}
public void Multiple_Flows_Can_Be_Registered()
{
var containerBuilder = new ContainerBuilder();
containerBuilder.RegisterBanzaiNodes(GetType().Assembly, true);
var flowBuilder = new FlowBuilder <object>(new AutofacFlowRegistrar(containerBuilder));
flowBuilder.CreateFlow("TestFlow2")
.AddRoot <IPipelineNode <object> >()
.AddChild <ITestNode4>()
.AddChild <ITestNode3>()
.AddChild <ITestNode2>();
flowBuilder.Register();
flowBuilder.CreateFlow("TestFlow1")
.AddRoot <IPipelineNode <object> >()
.AddChild <ITestNode2>();
flowBuilder.Register();
var container = containerBuilder.Build();
var factory = container.Resolve <INodeFactory <object> >();
var flow = factory.BuildFlow("TestFlow1");
flow.ShouldNotBeNull();
flow = factory.BuildFlow("TestFlow2");
flow.ShouldNotBeNull();
}
static void Run()
{
var flow = new FlowBuilder();
flow
.Validate(() => true)
.Condition("StepName", () => expression())
.That()
.If()
.ExecuteInLessThan(5)
.And()
.Return(ConditionState.True)
.Then()
.ReportSuccess()
.Else()
.ReportFailure()
.OnSuccess()
.OnFailure()
.Continiue()
.Retry()
.WarnAndRetry()
.WarnAndContiniue()
.Abord()
.OnException().OfType().Continiue()
.OnException().Any().Abord()
.ValidateThat()
.....
;
}
public void Simple_Flow_Is_Serialized_With_Full_Abbreviations()
{
TypeAbbreviationCache.RegisterFromAssembly(GetType().Assembly, true, false);
var containerBuilder = new ContainerBuilder();
containerBuilder.RegisterBanzaiNodes(GetType().Assembly, true);
var flowBuilder = new FlowBuilder <object>(new AutofacFlowRegistrar(containerBuilder));
flowBuilder.CreateFlow("TestFlow1")
.AddRoot <IPipelineNode <object> >()
.AddChild <ITestNode2>();
var rootComponent = flowBuilder.RootComponent;
var serializer = new JsonComponentSerializer();
var definition = serializer.Serialize(rootComponent);
_testOutputHelper.WriteLine(definition);
definition.Should().NotBeNullOrEmpty();
definition.Should().Contain("Banzai.Serialization.SystemJson.Test");
}
public void Simple_Flow_Contains_All_Nodes()
{
var containerBuilder = new ContainerBuilder();
containerBuilder.RegisterBanzaiNodes(GetType().Assembly, true);
var flowBuilder = new FlowBuilder <object>(new AutofacFlowRegistrar(containerBuilder));
flowBuilder.CreateFlow("TestFlow1")
.AddRoot <PipelineNode <object> >()
.AddChild <ITestNode2>()
.AddChild <IPipelineNode <object> >()
.ForLastChild()
.AddChild <ITestNode4>()
.AddChild <ITestNode3>()
.AddChild <ITestNode2>()
.ForParent()
.AddChild <ITestNode3>();
flowBuilder.Register();
var container = containerBuilder.Build();
var factory = container.Resolve <INodeFactory <object> >();
var flow = (IPipelineNode <object>)factory.BuildFlow("TestFlow1");
flow.ShouldBeType <PipelineNode <object> >();
flow.Children.Count.ShouldEqual(3);
var subflow = (IPipelineNode <object>)flow.Children[1];
subflow.Children.Count.ShouldEqual(3);
subflow.Children[1].ShouldBeType <TestNode3>();
}
public void Simple_Flow_Is_Deserialized()
{
TypeAbbreviationCache.RegisterFromAssembly(GetType().Assembly, failOnCollision: false);
var containerBuilder = new ContainerBuilder();
containerBuilder.RegisterBanzaiNodes(GetType().Assembly, true);
var flowBuilder = new FlowBuilder <object>(new AutofacFlowRegistrar(containerBuilder));
flowBuilder.CreateFlow("TestFlow1")
.AddRoot <IPipelineNode <object> >()
.AddChild <ITestNode2>();
var rootComponent = flowBuilder.RootComponent;
var serializer = new JsonComponentSerializer();
var definition = serializer.Serialize(rootComponent);
var deserializedComponent = serializer.Deserialize <object>(definition);
deserializedComponent.Should().NotBeNull();
deserializedComponent.Children[0].Children.Count.Should().Be(1);
}
public void Simple_Flow_With_ShouldExecuteJavaScript_Is_Deserialized()
{
var containerBuilder = new ContainerBuilder();
containerBuilder.RegisterBanzaiNodes(GetType().Assembly, true);
var flowBuilder = new FlowBuilder <object>(new AutofacFlowRegistrar(containerBuilder));
flowBuilder.CreateFlow("TestFlow1")
.AddRoot <IPipelineNode <object> >()
.AddChild <ITestJsNode>()
.AddChild <ITestNode2>()
.ForChild <ITestJsNode>()
.SetShouldExecuteJavaScript("var x = 1;");
var rootComponent = flowBuilder.RootComponent;
var serializer = new JsonComponentSerializer();
var definition = serializer.Serialize(rootComponent);
FlowComponent <object> deserializedComponent = serializer.Deserialize <object>(definition);
deserializedComponent.ShouldNotBeNull();
var pipelineComponent = deserializedComponent.Children[0];
pipelineComponent.Children.Count.ShouldEqual(2);
var jsNode = pipelineComponent.Children[0];
jsNode.GetShouldExecuteJavaScript().ShouldEqual("var x = 1;");
}
static void Run(){
var flow = new FlowBuilder();
flow
.Validate(() => true)
.Condition("StepName", () => expression())
.That()
.If()
.ExecuteInLessThan(5)
.And()
.Return(ConditionState.True)
.Then()
.ReportSuccess()
.Else()
.ReportFailure()
.OnSuccess()
.OnFailure()
.Continiue()
.Retry()
.WarnAndRetry()
.WarnAndContiniue()
.Abord()
.OnException().OfType().Continiue()
.OnException().Any().Abord()
.ValidateThat()
.....
;
}
public void CheckFlowWithSwitch()
{
// Arrange
var b = new FlowBuilder();
var s = b.SwitchOf <int>();
var a1 = b.DummyActivity();
var a2 = b.DummyActivity();
var a3 = b.DummyActivity();
b.WithInitialNode(s);
s.ConnectCase(0).To(a1);
s.ConnectCase(1).To(a2);
s.ConnectDefaultTo(a3);
var e = b.DummyActivity();
var validator = new ReachabilityValidator();
// Act
validator.Validate(b.CreateFlow());
var result = validator.Result;
// Assert
Assert.That(result.GetErrorsOf(s), Is.Empty);
Assert.That(result.GetErrorsOf(a1), Is.Empty);
Assert.That(result.GetErrorsOf(a2), Is.Empty);
Assert.That(result.GetErrorsOf(a3), Is.Empty);
Assert.That(result.GetErrorsOf(e), Is.Not.Empty);
}
public void Adding_ShouldExecute_To_Subflow_Applies_To_Subflow_Root()
{
var kernel = new StandardKernel();
kernel.RegisterBanzaiNodes(GetType().Assembly, true);
var flowBuilder = new FlowBuilder <object>(new NinjectFlowRegistrar(kernel));
flowBuilder.CreateFlow("TestFlow2")
.AddRoot <PipelineNode <object> >()
.AddChild <ITestNode4>()
.AddChild <ITestNode3>()
.AddChild <ITestNode2>();
flowBuilder.Register();
flowBuilder.CreateFlow("TestFlow1")
.AddRoot <PipelineNode <object> >()
.AddChild <ITestNode2>()
.AddFlow("TestFlow2")
.ForChildFlow("TestFlow2").SetShouldExecuteBlock <ShouldNotExecuteTestBlock>();
flowBuilder.Register();
var factory = kernel.Get <INodeFactory <object> >();
var flow = (IPipelineNode <object>)factory.BuildFlow("TestFlow1");
var subflowRoot = (IPipelineNode <object>)flow.Children[1];
subflowRoot.ShouldExecuteBlock.ShouldNotBeNull();
((IShouldExecuteBlock <object>)subflowRoot.ShouldExecuteBlock).ShouldExecuteAsync(new ExecutionContext <object>(new object())).Result.ShouldBeFalse();
}
public void ShouldExecute_Is_Added_To_Child_Node()
{
var containerBuilder = new ContainerBuilder();
containerBuilder.RegisterBanzaiNodes(GetType().Assembly, true);
var flowBuilder = new FlowBuilder <object>(new AutofacFlowRegistrar(containerBuilder));
flowBuilder.CreateFlow("TestFlow1")
.AddRoot <IPipelineNode <object> >()
.AddChild <ITestNode2>()
.ForChild <ITestNode2>()
.SetShouldExecuteBlock <ShouldNotExecuteTestBlock>();
flowBuilder.Register();
var container = containerBuilder.Build();
var factory = container.Resolve <INodeFactory <object> >();
var flow = (IPipelineNode <object>)factory.BuildFlow("TestFlow1");
var subflow = flow.Children[0];
subflow.ShouldExecuteBlock.ShouldNotBeNull();
((IShouldExecuteBlock <object>)subflow.ShouldExecuteBlock).ShouldExecuteAsync(new ExecutionContext <object>(new object())).Result.ShouldBeFalse();
}
public void Flow_With_ShouldExecuteBlock_Is_Serialized_With_Abbreviations()
{
TypeAbbreviationCache.RegisterFromAssembly(GetType().Assembly, failOnCollision: false);
var containerBuilder = new ContainerBuilder();
containerBuilder.RegisterBanzaiNodes(GetType().Assembly, true);
var flowBuilder = new FlowBuilder <object>(new AutofacFlowRegistrar(containerBuilder));
flowBuilder.CreateFlow("TestFlow1")
.AddRoot <IPipelineNode <object> >().SetShouldExecuteBlock <ShouldNotExecuteTestBlock>()
.AddChild <ITestJsNode>()
.AddChild <ITestNode2>();
var rootComponent = flowBuilder.RootComponent;
var serializer = new JsonComponentSerializer();
var definition = serializer.Serialize(rootComponent);
Console.WriteLine(definition);
definition.ShouldNotBeNull().ShouldNotBeEmpty();
definition.ShouldContain("\"ShouldExecuteBlockType\":\"ShouldNotExecuteTestBlock\"");
}
public void Flow_Is_Built_With_NodeFactory_And_Json_Serializer()
{
Json.Registrar.RegisterAsDefault();
var containerBuilder = new ContainerBuilder();
containerBuilder.RegisterBanzaiNodes(GetType().Assembly, true);
var container = containerBuilder.Build();
var factory = container.Resolve <INodeFactory <object> >();
var flowBuilder = new FlowBuilder <object>(new AutofacFlowRegistrar(containerBuilder));
flowBuilder.CreateFlow("TestFlow1")
.AddRoot <IPipelineNode <object> >()
.AddChild <ITestNode2>();
var component = flowBuilder.RootComponent;
var serialized = SerializerProvider.Serializer.Serialize(component);
var flow = factory.BuildSerializedFlow(serialized);
flow.FlowId.ShouldEqual("TestFlow1");
flow.Id.ShouldEqual("Banzai.Autofac.Test.TestPipelineNode1");
((IMultiNode <object>)flow).Children[0].Id.ShouldEqual("Banzai.Autofac.Test.TestNode2");
}
public void Flow_With_ShouldExecuteBlock_Is_Deserialized()
{
TypeAbbreviationCache.RegisterFromAssembly(GetType().Assembly, failOnCollision: false);
var containerBuilder = new ContainerBuilder();
containerBuilder.RegisterBanzaiNodes(GetType().Assembly, true);
var flowBuilder = new FlowBuilder <object>(new AutofacFlowRegistrar(containerBuilder));
flowBuilder.CreateFlow("TestFlow1")
.AddRoot <IPipelineNode <object> >().SetShouldExecuteBlock <ShouldNotExecuteTestBlock>()
.AddChild <ITestJsNode>()
.AddChild <ITestNode2>();
var rootComponent = flowBuilder.RootComponent;
var serializer = new JsonComponentSerializer();
var definition = serializer.Serialize(rootComponent);
FlowComponent <object> deserializedComponent = serializer.Deserialize <object>(definition);
deserializedComponent.ShouldNotBeNull();
deserializedComponent.Children[0].ShouldExecuteBlockType.ShouldEqual(typeof(ShouldNotExecuteTestBlock));
}
public async Task ExecuteQueryTaskOnEmptyResultReturnError()
{
var factory = new OrmLiteConnectionFactory(":memory:", SqliteDialect.Provider);
var db = await factory.OpenDbConnectionAsync();
db.CreateTable <Person>();
var pipeline = new FlowBuilder()
.Add(
DataFlowElementBuilder.New()
.SetConnection(db)
.Read <Person>()
.Query(args => args.Expression.Where(p => p.Id == (int)args.PipeArgs))
.OnEmptyOrNullRaiseError()
.List()
.Build()
).Build();
var result = await pipeline.RunAsync(2);
result.Should()
.BeOfType <FlowErrorResult>()
.Which.ErrorObject.Should().Be("no results found");
}
public void Simple_Flow_Is_Serialized_With_Full_Abbreviations()
{
TypeAbbreviationCache.Clear();
TypeAbbreviationCache.RegisterFromAssembly(GetType().Assembly, useFullName: true, failOnCollision: false);
var containerBuilder = new ContainerBuilder();
containerBuilder.RegisterBanzaiNodes(GetType().Assembly, true);
var flowBuilder = new FlowBuilder <object>(new AutofacFlowRegistrar(containerBuilder));
flowBuilder.CreateFlow("TestFlow1")
.AddRoot <IPipelineNode <object> >()
.AddChild <ITestJsNode>()
.AddChild <ITestNode2>();
var rootComponent = flowBuilder.RootComponent;
var serializer = new JsonComponentSerializer();
var definition = serializer.Serialize(rootComponent);
Console.WriteLine(definition);
definition.ShouldNotBeNull().ShouldNotBeEmpty();
definition.ShouldContain("Banzai.Json.Test");
}
public async Task FlowDeleteById()
{
var factory = new OrmLiteConnectionFactory(":memory:", SqliteDialect.Provider);
var db = await factory.OpenDbConnectionAsync();
db.CreateTable <Person>();
db.Save(new Person()
{
Name = "Mario"
});
var flow = new FlowBuilder()
.Add(
DataFlowElementBuilder.New()
.SetConnection(db)
.Delete <Person>()
.DeleteById(i => i)
.Build()
).Build();
await flow.RunAsync(1);
var persons = await db.SelectAsync <Person>();
persons.Should().BeEmpty();
}
public async Task PerformanceTest()
{
ServiceProvider = SetupServices();
var flowBuilder = new FlowBuilder <TestContext>();
flowBuilder.Use <IncrementByOneMiddleware>();
flowBuilder.Use <MultiplyByFiveMiddleware>();
flowBuilder.Use <IncrementByOneMiddleware>();
flowBuilder.Use <MultiplyByFiveMiddleware>();
flowBuilder.Use <IncrementByOneMiddleware>();
flowBuilder.Use <MultiplyByFiveMiddleware>();
var flow = flowBuilder.Build();
var context = new TestContext {
N = 0
};
var stopwatch = new Stopwatch();
stopwatch.Start();
for (var i = 0; i < 10000; i++)
{
await flow.InvokeAsync(context, ServiceProvider);
}
stopwatch.Stop();
Assert.Pass($"Total: {stopwatch.ElapsedMilliseconds}, avg: {stopwatch.ElapsedMilliseconds/10000d}");
}
public async Task SimpleFlowElementMapOnError()
{
var flow = new FlowBuilder()
.Add(
FlowElementBuilder
.New()
.CanExecuteContinue()
.OnExecute(async(_, _) => new FlowErrorResult()
{
ErrorObject = "failed"
})
.Build()
.MapOnError(async(_, _, _) => 42)
)
.Build();
var flowResult = await flow.RunAsync(4);
flowResult
.Should()
.BeOfType <FlowSuccessResult>()
.Which.Result
.Should()
.Be(42);
}
public async Task StoppingMiddlewareTest()
{
ServiceProvider = SetupServices();
var flowBuilder = new FlowBuilder <TestContext>();
flowBuilder.Use(typeof(MultiplyByFiveMiddleware));
flowBuilder.Use <StopMiddleware>();
flowBuilder.Use <IncrementByOneMiddleware>();
var flow = flowBuilder.Build();
var context = new TestContext {
N = 5
};
await flow.InvokeAsync(context, ServiceProvider);
Assert.AreEqual(5 * 5, context.N);
VerifyCreated(true, typeof(MultiplyByFiveMiddleware), typeof(StopMiddleware));
VerifyReleased(true, typeof(MultiplyByFiveMiddleware), typeof(StopMiddleware));
VerifyCreated(false, typeof(IncrementByOneMiddleware));
VerifyReleased(false, typeof(IncrementByOneMiddleware));
}
public void Flow_Builder_Is_Hydrated_And_Flow_Built_From_Json_Serializer()
{
Json.Registrar.RegisterAsDefault();
var containerBuilder = new ContainerBuilder();
containerBuilder.RegisterBanzaiNodes(GetType().Assembly, true);
var container = containerBuilder.Build();
var factory = container.Resolve <INodeFactory <object> >();
var flowBuilder = new FlowBuilder <object>(new AutofacFlowRegistrar(containerBuilder));
flowBuilder.CreateFlow("TestFlow1")
.AddRoot <IPipelineNode <object> >()
.AddChild <ITestNode2>();
var serialized = flowBuilder.SerializeRootComponent();
Console.WriteLine(serialized);
var component = flowBuilder.DeserializeAndSetRootComponent(serialized);
var flow = factory.BuildFlow(component);
flow.FlowId.Should().Be("TestFlow1");
flow.Id.Should().Be("Banzai.Autofac.Test.TestPipelineNode1");
((IMultiNode <object>)flow).Children[0].Id.Should().Be("Banzai.Autofac.Test.TestNode2");
}
public void ThrowingMiddlewareTest()
{
ServiceProvider = SetupServices();
var flowBuilder = new FlowBuilder <TestContext>();
flowBuilder.Use <MultiplyByFiveMiddleware>();
flowBuilder.Use <ThrowingMiddleware>();
flowBuilder.Use <IncrementByOneMiddleware>();
var flow = flowBuilder.Build();
var context = new TestContext {
N = 5
};
var exception = Assert.ThrowsAsync <MiddlewareException <TestContext> >(() => flow.InvokeAsync(context, ServiceProvider));
Assert.AreEqual(ServiceProvider.GetService(typeof(ThrowingMiddleware)), exception.Middleware);
Assert.AreSame(context, exception.Context);
Assert.AreEqual(5 * 5, context.N);
VerifyCreated(true, typeof(MultiplyByFiveMiddleware), typeof(ThrowingMiddleware));
VerifyReleased(true, typeof(MultiplyByFiveMiddleware), typeof(ThrowingMiddleware));
VerifyCreated(false, typeof(IncrementByOneMiddleware));
VerifyReleased(false, typeof(IncrementByOneMiddleware));
}
public async Task ShouldExecuteAsync_Is_Added_To_Child_Node()
{
var containerBuilder = new ContainerBuilder();
containerBuilder.RegisterBanzaiNodes(GetType().Assembly, true);
var flowBuilder = new FlowBuilder <object>(new AutofacFlowRegistrar(containerBuilder));
flowBuilder.CreateFlow("TestFlow1")
.AddRoot <IPipelineNode <object> >()
.AddChild <ITestNode2>()
.ForChild <ITestNode2>().SetShouldExecute(ctxt => Task.FromResult(1 + 1 != 2));
flowBuilder.Register();
var container = containerBuilder.Build();
var factory = container.Resolve <INodeFactory <object> >();
var flow = (IPipelineNode <object>)factory.BuildFlow("TestFlow1");
var subflow = flow.Children[0];
subflow.ShouldExecuteFunc.Should().NotBeNull();
(await subflow.ShouldExecuteFunc(new ExecutionContext <object>(new object()))).Should().BeFalse();
}
protected override void Build(FlowBuilder builder)
{
builder.WithDefaultFaultHandler <MyFaultHandler>();
builder.WithDefaultCancellationHandler <MyCancellationHandler>();
var forkJoin = builder.ForkJoin("My fork join node");
var first = forkJoin.Fork <DelayedIncrementActivity>("First fork");
first.Bind(a => a.X).To(A);
var second = forkJoin.Fork <DelayedIncrementActivity>("Second fork");
second.Bind(a => a.X).To(B);
var third = forkJoin.Fork <DelayedIncrementActivity>("Third fork");
third.Bind(a => a.X).To(C);
var sum = builder.Activity <SumActivity>("Sum action");
sum.Bind(x => x.A).ToResultOf(first);
sum.Bind(x => x.B).ToResultOf(second);
sum.Bind(x => x.C).ToResultOf(third);
builder.WithInitialNode(forkJoin);
forkJoin.ConnectTo(sum);
}
public void Simple_Flow_Contains_Subflow()
{
var kernel = new StandardKernel();
kernel.RegisterBanzaiNodes(GetType().Assembly, true);
var flowBuilder = new FlowBuilder <object>(new NinjectFlowRegistrar(kernel));
flowBuilder.CreateFlow("TestFlow2")
.AddRoot <PipelineNode <object> >()
.AddChild <ITestNode4>()
.AddChild <ITestNode3>()
.AddChild <ITestNode2>();
flowBuilder.Register();
flowBuilder.CreateFlow("TestFlow1")
.AddRoot <PipelineNode <object> >()
.AddChild <ITestNode2>()
.AddFlow("TestFlow2");
flowBuilder.Register();
var factory = kernel.Get <INodeFactory <object> >();
var flow = (IPipelineNode <object>)factory.BuildFlow("TestFlow1");
flow.Should().BeOfType <PipelineNode <object> >();
flow.Children.Count.Should().Be(2);
var subflow = (IPipelineNode <object>)flow.Children[1];
subflow.Children.Count.Should().Be(3);
subflow.Children[1].Should().BeOfType <TestNode3>();
}
public void CheckFlowWithBlock()
{
// Arrange
var b = new FlowBuilder();
IFlowNode a = null;
IFlowNode e = null;
var block = b.Block("test", (_, builder) =>
{
a = builder.DummyActivity();
e = builder.DummyActivity();
});
b.WithInitialNode(block);
var validator = new ReachabilityValidator();
// Act
validator.Validate(b.CreateFlow());
var result = validator.Result;
// Assert
Assert.That(result.GetErrorsOf(block), Is.Empty);
Assert.That(result.GetErrorsOf(a), Is.Empty);
Assert.That(result.GetErrorsOf(e), Is.Not.Empty);
}
