public void ForkChildren()
{
var a = Helpers.BuildActivity();
var f = new ForkBlock(a, 1);
var wi = new WorkItem(Helpers.Integer(), Helpers.Integer(), 0, WorkflowType.Fork, Helpers.String())
{
InputId = Helpers.Integer()
};
_navigator.Find(wi.WorkflowPath).Returns(f);
_dataStore.SplitAndGetIds(wi.InputId.Value).Returns(new[] {1, 2});
wi.Id = Helpers.Integer();
var items = _workItemBuilder.BuildChildren(wi).ToArray();
var item1 = items[0];
var item2 = items[1];
Assert.Equal(2, items.Count());
Assert.Equal(wi.JobId, item1.JobId);
Assert.Equal(wi.Id, item1.ParentId);
Assert.Equal(0, item1.Order);
Assert.Equal(1, item1.InputId);
Assert.Equal(WorkflowType.Activity, item1.Type);
Assert.Equal(wi.JobId, item2.JobId);
Assert.Equal(wi.Id, item2.ParentId);
Assert.Equal(1, item2.Order);
Assert.Equal(2, item2.InputId);
Assert.Equal(WorkflowType.Activity, item2.Type);
_navigator.Received(2).Path(a);
}
public void Test()
{
var a1 = Helpers.BuildActivity();
var a2 = Helpers.BuildActivity();
var a3 = Helpers.BuildActivity();
var a4 = Helpers.BuildActivity();
var a5 = Helpers.BuildActivity();
var c1 = new SequenceBlock(new[] {a1});
var f = new ForkBlock(a2, 1);
var p = new ParallelBlock(new[] {a4, a5}, 1);
var c2 = new SequenceBlock(new WorkflowBlock[] {f, c1, a3, p});
var navigator = new WorkflowPathNavigator(c2);
Assert.Equal("Sequence[0].Sequence[1].Activity[0]", navigator.Path(a1));
Assert.Equal("Sequence[0].Fork[0].Activity[0]", navigator.Path(a2));
Assert.Equal("Sequence[0].Activity[2]", navigator.Path(a3));
Assert.Equal("Sequence[0].Sequence[1]", navigator.Path(c1));
Assert.Equal("Sequence[0].Fork[0]", navigator.Path(f));
Assert.Equal("Sequence[0]", navigator.Path(c2));
Assert.Equal("Sequence[0].Parallel[3]", navigator.Path(p));
Assert.Equal("Sequence[0].Parallel[3].Activity[0]", navigator.Path(a4));
Assert.Equal("Sequence[0].Parallel[3].Activity[1]", navigator.Path(a5));
Assert.Equal(a1, navigator.Find("Sequence[0].Sequence[1].Activity[0]"));
Assert.Equal(a2, navigator.Find("Sequence[0].Fork[0].Activity[0]"));
Assert.Equal(a3, navigator.Find("Sequence[0].Activity[2]"));
Assert.Equal(c1, navigator.Find("Sequence[0].Sequence[1]"));
Assert.Equal(f, navigator.Find("Sequence[0].Fork[0]"));
Assert.Equal(c2, navigator.Find("Sequence[0]"));
Assert.Equal(p, navigator.Find("Sequence[0].Parallel[3]"));
Assert.Equal(a4, navigator.Find("Sequence[0].Parallel[3].Activity[0]"));
Assert.Equal(a5, navigator.Find("Sequence[0].Parallel[3].Activity[1]"));
}
public async Task TestFork()
{
Func<int, int> twice = x => 2*x;
var activity = new ActivityBlock(twice);
var fork = new ForkBlock(activity, 2);
var workflow = new Workflow<int[], IEnumerable<int>>("test", fork);
var output = await WorkflowRunner.Run(workflow, new[] {1, 2, 3});
//int[] would work but not recommended
Assert.Equal(new[] {2, 4, 6}, output);
}
public void MapConstruction()
{
Func<int, int> pow = x => x*x;
var map = new ForkBlock(new ActivityBlock(pow), 2);
Assert.Equal(WorkflowType.Fork, map.Type);
Assert.Equal(2, map.MaxWorkers);
Assert.Equal(new[] {typeof (int)}, map.InputTypes);
Assert.Equal(typeof (IEnumerable<int>), map.OutputType);
// test method with signature void(void)
map = new ForkBlock(new ActivityBlock(new Action(delegate { })), 1);
Assert.Equal(typeof (void), map.OutputType);
}
public async Task TestLargeChunckOfFork()
{
Func<int, int> identity = x => x;
var activity = new ActivityBlock(identity);
var fork = new ForkBlock(activity, 1);
var workflow = new Workflow<IEnumerable<int>, IEnumerable<int>>("test", fork);
var input = Enumerable.Repeat(1, 1000).ToArray();
var output = await WorkflowRunner.Run(workflow, input);
//int[] would work but not recommended
Assert.Equal(input, output);
}
public async Task TestChainedFork()
{
Func<int, int> identity = x => x;
var activity = new ActivityBlock(identity);
var fork = new ForkBlock(new ForkBlock(new ForkBlock(activity, 1), 1), 1);
var workflow = new Workflow<int[][][], IEnumerable<IEnumerable<IEnumerable<int>>>>("test", fork);
var output =
await
WorkflowRunner.Run(workflow, new[] {new[] {new[] {1}}});
Assert.Equal(new[] {1}, output.SelectMany(_ => _).SelectMany(_ => _));
}
