public void OrderByOrdersInDescendingOrder()
{
// Given
List<string> content = new List<string>();
Engine engine = new Engine();
engine.CleanOutputFolderOnExecute = false;
engine.Trace.AddListener(new TestTraceListener());
CountModule count = new CountModule("A")
{
AdditionalOutputs = 4
};
CountModule count2 = new CountModule("A")
{
AdditionalOutputs = 2
};
Concat concat = new Concat(count2);
OrderBy orderBy = new OrderBy((d, c) => d.Get<int>("A")).Descending();
Execute gatherData = new Execute((d, c) =>
{
content.Add(d.Content);
return null;
});
engine.Pipelines.Add(count, concat, orderBy, gatherData);
// When
engine.Execute();
// Then
Assert.AreEqual(8, content.Count);
CollectionAssert.AreEqual(new[] { "5", "4", "3", "3", "2", "2", "1", "1" }, content);
}
public void PaginateSetsDocumentsInMetadata()
{
// Given
List<IList<string>> content = new List<IList<string>>();
Engine engine = new Engine();
engine.Trace.AddListener(new TestTraceListener());
CountModule count = new CountModule("A")
{
AdditionalOutputs = 7
};
Paginate paginate = new Paginate(3, count);
Execute gatherData = new Execute((d, c) =>
{
content.Add(d.Get<IList<IDocument>>(Keys.PageDocuments).Select(x => x.Content).ToList());
return null;
});
engine.Pipelines.Add(paginate, gatherData);
// When
engine.Execute();
// Then
Assert.AreEqual(3, content.Count);
CollectionAssert.AreEqual(new[] { "1", "2", "3" }, content[0]);
CollectionAssert.AreEqual(new[] { "4", "5", "6" }, content[1]);
CollectionAssert.AreEqual(new[] { "7", "8" }, content[2]);
}
public void BranchWithPredicateResultsInCorrectCounts()
{
// Given
Engine engine = new Engine();
CountModule a = new CountModule("A")
{
AdditionalOutputs = 1
};
CountModule b = new CountModule("B")
{
AdditionalOutputs = 2
};
CountModule c = new CountModule("C")
{
AdditionalOutputs = 3
};
engine.Pipelines.Add(a, new Branch(b).Where(x => x.Content == "1"), c);
// When
engine.Execute();
// Then
Assert.AreEqual(1, a.ExecuteCount);
Assert.AreEqual(1, b.ExecuteCount);
Assert.AreEqual(1, c.ExecuteCount);
Assert.AreEqual(1, a.InputCount);
Assert.AreEqual(1, b.InputCount);
Assert.AreEqual(2, c.InputCount);
Assert.AreEqual(2, a.OutputCount);
Assert.AreEqual(3, b.OutputCount);
Assert.AreEqual(8, c.OutputCount);
}
public void ResultsInCorrectCounts()
{
// Given
Engine engine = new Engine();
CountModule a = new CountModule("A")
{
AdditionalOutputs = 1
};
CountModule b = new CountModule("B")
{
AdditionalOutputs = 2
};
CountModule c = new CountModule("C")
{
AdditionalOutputs = 3
};
engine.Pipelines.Add(a, new ConcatBranch(b), c);
// When
engine.Execute();
// Then
Assert.AreEqual(1, a.ExecuteCount);
Assert.AreEqual(1, b.ExecuteCount);
Assert.AreEqual(1, c.ExecuteCount);
Assert.AreEqual(1, a.InputCount);
Assert.AreEqual(2, b.InputCount);
Assert.AreEqual(8, c.InputCount);
Assert.AreEqual(2, a.OutputCount);
Assert.AreEqual(6, b.OutputCount);
Assert.AreEqual(32, c.OutputCount);
}
public void BranchResultsInCorrectCounts()
{
// Given
Engine engine = new Engine();
engine.CleanOutputFolderOnExecute = false;
engine.Trace.AddListener(new TestTraceListener());
CountModule a = new CountModule("A")
{
AdditionalOutputs = 1
};
CountModule b = new CountModule("B")
{
AdditionalOutputs = 2
};
CountModule c = new CountModule("C")
{
AdditionalOutputs = 3
};
engine.Pipelines.Add(a, new Branch(b), c);
// When
engine.Execute();
// Then
Assert.AreEqual(1, a.ExecuteCount);
Assert.AreEqual(1, b.ExecuteCount);
Assert.AreEqual(1, c.ExecuteCount);
Assert.AreEqual(1, a.InputCount);
Assert.AreEqual(2, b.InputCount);
Assert.AreEqual(2, c.InputCount);
Assert.AreEqual(2, a.OutputCount);
Assert.AreEqual(6, b.OutputCount);
Assert.AreEqual(8, c.OutputCount);
}
public void WithPredicateResultsInCorrectCounts()
{
// Given
Engine engine = new Engine();
engine.CleanOutputFolderOnExecute = false;
engine.Trace.AddListener(new TestTraceListener());
CountModule a = new CountModule("A")
{
AdditionalOutputs = 1
};
CountModule b = new CountModule("B")
{
AdditionalOutputs = 2
};
CountModule c = new CountModule("C")
{
AdditionalOutputs = 3
};
engine.Pipelines.Add(a, new ConcatBranch(b).Where((x, y) => x.Content == "1"), c);
// When
engine.Execute();
// Then
Assert.AreEqual(1, a.ExecuteCount);
Assert.AreEqual(1, b.ExecuteCount);
Assert.AreEqual(1, c.ExecuteCount);
Assert.AreEqual(1, a.InputCount);
Assert.AreEqual(1, b.InputCount);
Assert.AreEqual(5, c.InputCount);
Assert.AreEqual(2, a.OutputCount);
Assert.AreEqual(3, b.OutputCount);
Assert.AreEqual(20, c.OutputCount);
}
public void PaginateSetsCorrectMetadata()
{
// Given
List<int> currentPage = new List<int>();
List<int> totalPages = new List<int>();
List<bool> hasNextPage = new List<bool>();
List<bool> hasPreviousPage = new List<bool>();
Engine engine = new Engine();
engine.Trace.AddListener(new TestTraceListener());
CountModule count = new CountModule("A")
{
AdditionalOutputs = 7
};
Paginate paginate = new Paginate(3, count);
Execute gatherData = new Execute((d, c) =>
{
currentPage.Add(d.Get<int>(Keys.CurrentPage));
totalPages.Add(d.Get<int>(Keys.TotalPages));
hasNextPage.Add(d.Get<bool>(Keys.HasNextPage));
hasPreviousPage.Add(d.Get<bool>(Keys.HasPreviousPage));
return null;
});
engine.Pipelines.Add(paginate, gatherData);
// When
engine.Execute();
// Then
CollectionAssert.AreEqual(new[] { 1, 2, 3 }, currentPage);
CollectionAssert.AreEqual(new[] { 3, 3, 3 }, totalPages);
CollectionAssert.AreEqual(new[] { true, true, false }, hasNextPage);
CollectionAssert.AreEqual(new[] { false, true, true }, hasPreviousPage);
}
public void SetsDocumentsInMetadata()
{
// Given
List<IList<string>> content = new List<IList<string>>();
Engine engine = new Engine();
CountModule count = new CountModule("A")
{
AdditionalOutputs = 7
};
GroupBy groupBy = new GroupBy((d, c) => d.Get<int>("A")%3, count);
OrderBy orderBy = new OrderBy((d, c) => d.Get<int>(Keys.GroupKey));
Execute gatherData = new Execute((d, c) =>
{
content.Add(d.Get<IList<IDocument>>(Keys.GroupDocuments).Select(x => x.Content).ToList());
return null;
});
engine.Pipelines.Add(groupBy, orderBy, gatherData);
// When
engine.Execute();
// Then
Assert.AreEqual(3, content.Count);
CollectionAssert.AreEquivalent(new[] {"3", "6"}, content[0]);
CollectionAssert.AreEquivalent(new[] {"1", "4", "7"}, content[1]);
CollectionAssert.AreEquivalent(new[] {"2", "5", "8"}, content[2]);
}
public void IfResultsInCorrectCounts()
{
// Given
Engine engine = new Engine();
engine.Trace.AddListener(new TestTraceListener());
CountModule a = new CountModule("A")
{
AdditionalOutputs = 2
};
CountModule b = new CountModule("B")
{
AdditionalOutputs = 2
};
CountModule c = new CountModule("C")
{
AdditionalOutputs = 3
};
engine.Pipelines.Add(a, new If((x, y) => x.Content == "1", b), c);
// When
engine.Execute();
// Then
Assert.AreEqual(1, a.ExecuteCount);
Assert.AreEqual(1, b.ExecuteCount);
Assert.AreEqual(1, c.ExecuteCount);
Assert.AreEqual(1, a.InputCount);
Assert.AreEqual(1, b.InputCount);
Assert.AreEqual(5, c.InputCount);
Assert.AreEqual(3, a.OutputCount);
Assert.AreEqual(3, b.OutputCount);
Assert.AreEqual(20, c.OutputCount);
}
public void ChildModulesAreExecuted()
{
// Given
Engine engine = new Engine();
CountModule a = new CountModule("A")
{
AdditionalOutputs = 1
};
CountModule b = new CountModule("B")
{
AdditionalOutputs = 2
};
CountModule c = new CountModule("C")
{
AdditionalOutputs = 3
};
engine.Pipelines.Add(a, new Core.Modules.Control.ModuleCollection(b, c));
// When
engine.Execute();
// Then
Assert.AreEqual(1, a.ExecuteCount);
Assert.AreEqual(1, b.ExecuteCount);
Assert.AreEqual(1, c.ExecuteCount);
Assert.AreEqual(1, a.InputCount);
Assert.AreEqual(2, b.InputCount);
Assert.AreEqual(6, c.InputCount);
Assert.AreEqual(2, a.OutputCount);
Assert.AreEqual(6, b.OutputCount);
Assert.AreEqual(24, c.OutputCount);
}
public void GroupBySetsCorrectMetadata()
{
// Given
List<int> groupKey = new List<int>();
Engine engine = new Engine();
engine.CleanOutputFolderOnExecute = false;
engine.Trace.AddListener(new TestTraceListener());
CountModule count = new CountModule("A")
{
AdditionalOutputs = 7
};
GroupBy groupBy = new GroupBy((d, c) => d.Get<int>("A") % 3, count);
Execute gatherData = new Execute((d, c) =>
{
groupKey.Add(d.Get<int>(Keys.GroupKey));
return null;
});
engine.Pipelines.Add(groupBy, gatherData);
// When
engine.Execute();
// Then
CollectionAssert.AreEquivalent(new[] { 0, 1, 2 }, groupKey);
}
public void OrderByOrdersDescendingThenByInDescendingOrder()
{
// Given
List<string> content = new List<string>();
Engine engine = new Engine();
engine.Trace.AddListener(new TestTraceListener());
CountModule count = new CountModule("A")
{
AdditionalOutputs = 4
};
CountModule count2 = new CountModule("B")
{
AdditionalOutputs = 1
};
OrderBy orderBy = new OrderBy((d, c) => d.Get<int>("A"))
.Descending()
.ThenBy((d, c) => d.Get<int>("B"))
.Descending();
Execute gatherData = new Execute((d, c) =>
{
content.Add(d.Content);
return null;
});
engine.Pipelines.Add(count, count2, orderBy, gatherData);
// When
engine.Execute();
// Then
Assert.AreEqual(10, content.Count); // (4+1) * (21+1)
CollectionAssert.AreEqual(new[] { "510", "59", "48", "47", "36", "35", "24", "23", "12", "11" }, content);
}
public void ReturnsFalseWhenNotRemoved()
{
// Given
CountModule count = new CountModule("A");
CountModule count2 = new CountModule("B");
ModuleList list = new ModuleList(count2);
// When
bool result = list.Remove(count);
// Then
Assert.That(result, Is.False);
Assert.That(list, Is.EqualTo(new[] { count2 }));
}
public async Task IfElseAndElseResultsInCorrectCounts()
{
// Given
CountModule a = new CountModule("A")
{
AdditionalOutputs = 3,
EnsureInputDocument = true
};
CountModule b = new CountModule("B")
{
AdditionalOutputs = 2
};
CountModule c = new CountModule("C")
{
AdditionalOutputs = 3
};
CountModule d = new CountModule("B")
{
AdditionalOutputs = 2
};
CountModule e = new CountModule("B")
{
AdditionalOutputs = 3
};
// When
await ExecuteAsync(
a,
new ExecuteIf(Config.FromDocument(async doc => await doc.GetStringAsync() == "1"), b)
.ElseIf(Config.FromDocument(async doc => await doc.GetStringAsync() == "3"), c)
.Else(d),
e);
// Then
Assert.AreEqual(1, a.ExecuteCount);
Assert.AreEqual(1, b.ExecuteCount);
Assert.AreEqual(1, c.ExecuteCount);
Assert.AreEqual(1, d.ExecuteCount);
Assert.AreEqual(1, e.ExecuteCount);
Assert.AreEqual(1, a.InputCount);
Assert.AreEqual(1, b.InputCount);
Assert.AreEqual(1, c.InputCount);
Assert.AreEqual(2, d.InputCount);
Assert.AreEqual(13, e.InputCount);
Assert.AreEqual(4, a.OutputCount);
Assert.AreEqual(3, b.OutputCount);
Assert.AreEqual(4, c.OutputCount);
Assert.AreEqual(6, d.OutputCount);
Assert.AreEqual(52, e.OutputCount);
}
public async Task IfElseAndElseResultsInCorrectCounts()
{
// Given
CountModule a = new CountModule("A")
{
AdditionalOutputs = 3,
EnsureInputDocument = true
};
CountModule b = new CountModule("B")
{
AdditionalOutputs = 2
};
CountModule c = new CountModule("C")
{
AdditionalOutputs = 3
};
CountModule d = new CountModule("B")
{
AdditionalOutputs = 2
};
CountModule e = new CountModule("B")
{
AdditionalOutputs = 3
};
// When
await ExecuteAsync(
a,
new ExecuteIf(Config.FromDocument(async doc => await doc.GetContentStringAsync() == "1"), b)
.ElseIf(Config.FromDocument(async doc => await doc.GetContentStringAsync() == "3"), c)
.Else(d),
e);
// Then
a.ExecuteCount.ShouldBe(1);
b.ExecuteCount.ShouldBe(1);
c.ExecuteCount.ShouldBe(1);
d.ExecuteCount.ShouldBe(1);
e.ExecuteCount.ShouldBe(1);
a.InputCount.ShouldBe(1);
b.InputCount.ShouldBe(1);
c.InputCount.ShouldBe(1);
d.InputCount.ShouldBe(2);
e.InputCount.ShouldBe(13);
a.OutputCount.ShouldBe(4);
b.OutputCount.ShouldBe(3);
c.OutputCount.ShouldBe(4);
d.OutputCount.ShouldBe(6);
e.OutputCount.ShouldBe(52);
}
public void DoesNotThrowWhenSettingDuplicateNamedModuleAtSameIndex()
{
// Given
CountModule count = new CountModule("A");
CountModule count2 = new CountModule("B");
ModuleList list = new ModuleList(
new NamedModule("A", count),
new NamedModule("B", count2));
// When
list[1] = new NamedModule("B", count2);
// Then
Assert.That(list, Is.EqualTo(new[] { count, count2 }));
}
public void ReturnsIndexByName()
{
// Given
CountModule count = new CountModule("A");
CountModule count2 = new CountModule("B");
ModuleList list = new ModuleList(
new NamedModule("A", count),
new NamedModule("B", count2));
// When
int index = list.IndexOf("B");
// Then
Assert.That(index, Is.EqualTo(1));
}
public async Task DocumentConfigReturnsDocumentForSingleResultDocument()
{
// Given
TestDocument document = new TestDocument();
CountModule count = new CountModule("A")
{
EnsureInputDocument = true
};
ExecuteConfig execute = new ExecuteConfig(Config.FromDocument((_, __) => document));
// When
IReadOnlyList <TestDocument> result = await ExecuteAsync(count, execute);
// Then
CollectionAssert.AreEquivalent(document, result.Single());
}
public void RemovesModuleByName()
{
// Given
CountModule count = new CountModule("A");
CountModule count2 = new CountModule("B");
ModuleList list = new ModuleList(
new NamedModule("A", count),
new NamedModule("B", count2));
// When
bool result = list.Remove("A");
// Then
Assert.That(result, Is.True);
Assert.That(list, Is.EqualTo(new [] { count2 }));
}
public void ElseIfResultsInCorrectCounts()
{
// Given
Engine engine = new Engine();
engine.Trace.AddListener(new TestTraceListener());
CountModule a = new CountModule("A")
{
AdditionalOutputs = 2
};
CountModule b = new CountModule("B")
{
AdditionalOutputs = 2
};
CountModule c = new CountModule("C")
{
AdditionalOutputs = 3
};
CountModule d = new CountModule("B")
{
AdditionalOutputs = 2
};
engine.Pipelines.Add(
a,
new If((x, y) => x.Content == "1", b)
.ElseIf((x, y) => x.Content == "2", c),
d);
// When
engine.Execute();
// Then
Assert.AreEqual(1, a.ExecuteCount);
Assert.AreEqual(1, b.ExecuteCount);
Assert.AreEqual(1, c.ExecuteCount);
Assert.AreEqual(1, d.ExecuteCount);
Assert.AreEqual(1, a.InputCount);
Assert.AreEqual(1, b.InputCount);
Assert.AreEqual(1, c.InputCount);
Assert.AreEqual(8, d.InputCount);
Assert.AreEqual(3, a.OutputCount);
Assert.AreEqual(3, b.OutputCount);
Assert.AreEqual(4, c.OutputCount);
Assert.AreEqual(24, d.OutputCount);
}
public async Task OmittingCasesAndDefaultResultsInCorrectCounts()
{
// Given
CountModule a = new CountModule("A")
{
AdditionalOutputs = 2,
EnsureInputDocument = true
};
CountModule b = new CountModule("B");
ExecuteSwitch switchModule = new ExecuteSwitch(Config.FromDocument(async x => (object)await x.GetContentStringAsync()));
// When
await ExecuteAsync(a, switchModule, b);
// Then
Assert.AreEqual(3, b.InputCount);
}
public void DisposingPipelineDisposesModules()
{
// Given
Engine engine = new Engine();
DisposableCountModule a = new DisposableCountModule("A");
DisposableCountModule b = new DisposableCountModule("B");
CountModule c = new CountModule("C");
engine.Pipelines.Add("Count", a, new Concat(b, c));
// When
engine.Dispose();
// Then
Assert.IsTrue(a.Disposed);
Assert.IsTrue(b.Disposed);
}
public void ElseResultsInCorrectCounts()
{
// Given
Engine engine = new Engine();
engine.CleanOutputPathOnExecute = false;
CountModule a = new CountModule("A")
{
AdditionalOutputs = 2
};
CountModule b = new CountModule("B")
{
AdditionalOutputs = 2
};
CountModule c = new CountModule("C")
{
AdditionalOutputs = 3
};
CountModule d = new CountModule("B")
{
AdditionalOutputs = 2
};
engine.Pipelines.Add(
a,
new If((x, y) => x.Content == "1", b)
.Else(c),
d);
// When
engine.Execute();
// Then
Assert.AreEqual(1, a.ExecuteCount);
Assert.AreEqual(1, b.ExecuteCount);
Assert.AreEqual(1, c.ExecuteCount);
Assert.AreEqual(1, d.ExecuteCount);
Assert.AreEqual(1, a.InputCount);
Assert.AreEqual(1, b.InputCount);
Assert.AreEqual(2, c.InputCount);
Assert.AreEqual(11, d.InputCount);
Assert.AreEqual(3, a.OutputCount);
Assert.AreEqual(3, b.OutputCount);
Assert.AreEqual(8, c.OutputCount);
Assert.AreEqual(33, d.OutputCount);
}
public void ElseIfResultsInCorrectCounts()
{
// Given
Engine engine = new Engine();
engine.CleanOutputFolderOnExecute = false;
engine.Trace.AddListener(new TestTraceListener());
CountModule a = new CountModule("A")
{
AdditionalOutputs = 2
};
CountModule b = new CountModule("B")
{
AdditionalOutputs = 2
};
CountModule c = new CountModule("C")
{
AdditionalOutputs = 3
};
CountModule d = new CountModule("B")
{
AdditionalOutputs = 2
};
engine.Pipelines.Add(
a,
new If((x, y) => x.Content == "1", b)
.ElseIf((x, y) => x.Content == "2", c),
d);
// When
engine.Execute();
// Then
Assert.AreEqual(1, a.ExecuteCount);
Assert.AreEqual(1, b.ExecuteCount);
Assert.AreEqual(1, c.ExecuteCount);
Assert.AreEqual(1, d.ExecuteCount);
Assert.AreEqual(1, a.InputCount);
Assert.AreEqual(1, b.InputCount);
Assert.AreEqual(1, c.InputCount);
Assert.AreEqual(8, d.InputCount);
Assert.AreEqual(3, a.OutputCount);
Assert.AreEqual(3, b.OutputCount);
Assert.AreEqual(4, c.OutputCount);
Assert.AreEqual(24, d.OutputCount);
}
public void OmittingCasesAndDefaultResultsInCorrectCounts()
{
// Given
Engine engine = new Engine();
CountModule a = new CountModule("A")
{
AdditionalOutputs = 2
};
CountModule b = new CountModule("B");
engine.Pipelines.Add(a, new Switch((x, y) => x.Content), b);
// When
engine.Execute();
// Then
Assert.AreEqual(3, b.InputCount);
}
public void SameSourceThrowsException()
{
// Given
Engine engine = new Engine();
CountModule a = new CountModule("A")
{
CloneSource = true
};
CountModule b = new CountModule("B");
CountModule c = new CountModule("A")
{
CloneSource = true
};
engine.Pipelines.Add("Count", a, new Concat(b, c));
// When, Then
Assert.Throws <Exception>(() => engine.Execute());
}
public void ElseResultsInCorrectCounts()
{
// Given
Engine engine = new Engine();
CountModule a = new CountModule("A")
{
AdditionalOutputs = 2
};
CountModule b = new CountModule("B")
{
AdditionalOutputs = 2
};
CountModule c = new CountModule("C")
{
AdditionalOutputs = 3
};
CountModule d = new CountModule("B")
{
AdditionalOutputs = 2
};
engine.Pipelines.Add(
a,
new If(x => x.Content == "1", b)
.Else(c),
d);
// When
engine.Execute();
// Then
Assert.AreEqual(1, a.ExecuteCount);
Assert.AreEqual(1, b.ExecuteCount);
Assert.AreEqual(1, c.ExecuteCount);
Assert.AreEqual(1, d.ExecuteCount);
Assert.AreEqual(1, a.InputCount);
Assert.AreEqual(1, b.InputCount);
Assert.AreEqual(2, c.InputCount);
Assert.AreEqual(11, d.InputCount);
Assert.AreEqual(3, a.OutputCount);
Assert.AreEqual(3, b.OutputCount);
Assert.AreEqual(8, c.OutputCount);
Assert.AreEqual(33, d.OutputCount);
}
public async Task ElseResultsInCorrectCounts()
{
// Given
CountModule a = new CountModule("A")
{
AdditionalOutputs = 2,
EnsureInputDocument = true
};
CountModule b = new CountModule("B")
{
AdditionalOutputs = 2
};
CountModule c = new CountModule("C")
{
AdditionalOutputs = 3
};
CountModule d = new CountModule("B")
{
AdditionalOutputs = 2
};
// When
await ExecuteAsync(
a,
new ExecuteIf(Config.FromDocument(async doc => await doc.GetContentStringAsync() == "1"), b)
.Else(c),
d);
// Then
Assert.AreEqual(1, a.ExecuteCount);
Assert.AreEqual(1, b.ExecuteCount);
Assert.AreEqual(1, c.ExecuteCount);
Assert.AreEqual(1, d.ExecuteCount);
Assert.AreEqual(1, a.InputCount);
Assert.AreEqual(1, b.InputCount);
Assert.AreEqual(2, c.InputCount);
Assert.AreEqual(11, d.InputCount);
Assert.AreEqual(3, a.OutputCount);
Assert.AreEqual(3, b.OutputCount);
Assert.AreEqual(8, c.OutputCount);
Assert.AreEqual(33, d.OutputCount);
}
public void SwitchResultsInCorrectCounts()
{
// Given
Engine engine = new Engine();
CountModule a = new CountModule("A") {AdditionalOutputs = 2};
CountModule b = new CountModule("B");
CountModule c = new CountModule("C");
CountModule d = new CountModule("D");
engine.Pipelines.Add(a, new Switch((x, y) => x.Content).Case("1", b).Case("2", c).Default(d));
// When
engine.Execute();
// Then
Assert.AreEqual(1, a.ExecuteCount);
Assert.AreEqual(1, b.ExecuteCount);
Assert.AreEqual(1, c.ExecuteCount);
Assert.AreEqual(1, d.ExecuteCount);
}
public void ArrayInCaseResultsInCorrectCounts()
{
// Given
Engine engine = new Engine();
CountModule a = new CountModule("A") {AdditionalOutputs = 2};
CountModule b = new CountModule("B");
CountModule c = new CountModule("C");
engine.Pipelines.Add(a, new Switch((x, y) => x.Content).Case(new string[] {"1", "2"}, b), c);
// When
engine.Execute();
// Then
Assert.AreEqual(1, a.ExecuteCount);
Assert.AreEqual(1, b.ExecuteCount);
Assert.AreEqual(2, b.InputCount);
Assert.AreEqual(2, b.OutputCount);
Assert.AreEqual(3, c.InputCount);
}
public void SwitchNoCasesResultsInCorrectCounts()
{
// Given
Engine engine = new Engine();
CountModule a = new CountModule("A") {AdditionalOutputs = 2};
CountModule b = new CountModule("B");
CountModule c = new CountModule("C");
engine.Pipelines.Add(a, new Switch((x, y) => x.Content).Default(b), c);
// When
engine.Execute();
// Then
Assert.AreEqual(1, a.ExecuteCount);
Assert.AreEqual(1, b.ExecuteCount);
Assert.AreEqual(3, b.InputCount);
Assert.AreEqual(3, b.OutputCount);
Assert.AreEqual(3, c.InputCount);
}
public async Task ExecutesModule()
{
// Given
Engine engine = new Engine();
IPipeline pipeline = engine.Pipelines.Add("TestPipeline");
CountModule module = new CountModule("Foo")
{
EnsureInputDocument = true
};
pipeline.ProcessModules.Add(module);
CancellationTokenSource cts = new CancellationTokenSource();
// When
IPipelineOutputs outputs = await engine.ExecuteAsync(cts.Token);
// Then
module.ExecuteCount.ShouldBe(1);
outputs["TestPipeline"].Select(x => x.GetInt("Foo")).ShouldBe(new int[] { 1 });
}
public async Task CombinesAndOverwritesMetadata()
{
// Given
CountModule a = new CountModule("A")
{
Value = 10,
EnsureInputDocument = true
};
CountModule b = new CountModule("A")
{
Value = 20,
EnsureInputDocument = true
};
// When
IReadOnlyList <IDocument> results = await ExecuteAsync(a, new MergeDocuments(b));
// Then
CollectionAssert.AreEqual(new[] { 21 }, results.Select(x => x["A"]));
}
public void CombinesAndOverwritesMetadata()
{
// Given
Engine engine = new Engine();
CountModule a = new CountModule("A")
{
Value = 10
};
CountModule b = new CountModule("A")
{
Value = 20
};
engine.Pipelines.Add("Test", a, new Merge(b));
// When
engine.Execute();
// Then
CollectionAssert.AreEqual(new[] { 21 }, engine.Documents["Test"].Select(x => x["A"]));
}
public async Task SwitchResultsInCorrectCounts()
{
// Given
CountModule a = new CountModule("A")
{
AdditionalOutputs = 2
};
CountModule b = new CountModule("B");
CountModule c = new CountModule("C");
CountModule d = new CountModule("D");
ExecuteSwitch switchModule = new ExecuteSwitch(Config.FromDocument(async x => (object)await x.GetContentStringAsync())).Case("1", b).Case("2", c).Default(d);
// When
await ExecuteAsync(a, switchModule);
// Then
Assert.AreEqual(1, a.ExecuteCount);
Assert.AreEqual(1, b.ExecuteCount);
Assert.AreEqual(1, c.ExecuteCount);
Assert.AreEqual(1, d.ExecuteCount);
}
public void MissingDefaultResultsInCorrectCounts()
{
// Given
Engine engine = new Engine();
engine.Trace.AddListener(new TestTraceListener());
CountModule a = new CountModule("A") { AdditionalOutputs = 2 };
CountModule b = new CountModule("B");
CountModule c = new CountModule("C");
engine.Pipelines.Add(a, new Switch((x, y) => x.Content).Case("1", b), c);
// When
engine.Execute();
// Then
Assert.AreEqual(1, a.ExecuteCount);
Assert.AreEqual(1, b.ExecuteCount);
Assert.AreEqual(1, b.InputCount);
Assert.AreEqual(1, b.OutputCount);
Assert.AreEqual(3, c.InputCount);
}
public void CombinesAndOverwritesMetadata()
{
// Given
Engine engine = new Engine();
CountModule a = new CountModule("A")
{
Value = 10
};
CountModule b = new CountModule("A")
{
Value = 20
};
engine.Pipelines.Add("Test", a, new Merge(b));
// When
engine.Execute();
// Then
CollectionAssert.AreEqual(new[] { 21 }, engine.Documents["Test"].Select(x => x["A"]));
}
public void ReplacesContent()
{
// Given
Engine engine = new Engine();
CountModule a = new CountModule("A")
{
Value = 10
};
CountModule b = new CountModule("B")
{
Value = 20
};
engine.Pipelines.Add("Test", a, new Merge(b),
new Core.Modules.Metadata.Meta("Content", (doc, ctx) => doc.Content));
// When
engine.Execute();
// Then
CollectionAssert.AreEqual(new [] { "21" }, engine.Documents["Test"].Select(x => x["Content"]));
}
public void ReprocessesPreviousDocumentsWithDistinctSources()
{
// Given
Engine engine = new Engine();
engine.CleanOutputPathOnExecute = false;
CountModule a = new CountModule("A")
{
CloneSource = true,
AdditionalOutputs = 1
};
CountModule b = new CountModule("B")
{
CloneSource = true,
AdditionalOutputs = 2
};
CountModule c = new CountModule("C")
{
CloneSource = true,
AdditionalOutputs = 3
};
engine.Pipelines.Add("Count", true, a, b, c);
// When
engine.Execute();
engine.Execute();
// Then
Assert.AreEqual(24, engine.Documents.FromPipeline("Count").Count());
Assert.AreEqual(2, a.ExecuteCount);
Assert.AreEqual(2, b.ExecuteCount);
Assert.AreEqual(2, c.ExecuteCount);
Assert.AreEqual(2, a.InputCount);
Assert.AreEqual(4, b.InputCount);
Assert.AreEqual(12, c.InputCount);
Assert.AreEqual(4, a.OutputCount);
Assert.AreEqual(12, b.OutputCount);
Assert.AreEqual(48, c.OutputCount);
}
public void ReprocessesPreviousDocumentsWithDistinctSources()
{
// Given
Engine engine = new Engine();
engine.CleanOutputFolderOnExecute = false;
engine.Trace.AddListener(new TestTraceListener());
CountModule a = new CountModule("A")
{
CloneSource = true,
AdditionalOutputs = 1
};
CountModule b = new CountModule("B")
{
CloneSource = true,
AdditionalOutputs = 2
};
CountModule c = new CountModule("C")
{
CloneSource = true,
AdditionalOutputs = 3
};
engine.Pipelines.Add("Count", true, a, b, c);
// When
engine.Execute();
engine.Execute();
// Then
Assert.AreEqual(24, engine.Documents.FromPipeline("Count").Count());
Assert.AreEqual(2, a.ExecuteCount);
Assert.AreEqual(2, b.ExecuteCount);
Assert.AreEqual(2, c.ExecuteCount);
Assert.AreEqual(2, a.InputCount);
Assert.AreEqual(4, b.InputCount);
Assert.AreEqual(12, c.InputCount);
Assert.AreEqual(4, a.OutputCount);
Assert.AreEqual(12, b.OutputCount);
Assert.AreEqual(48, c.OutputCount);
}
public void DoesNotProcessPreviousDocumentsWhenSameSource()
{
// Given
Engine engine = new Engine();
engine.CleanOutputPathOnExecute = false;
CountModule a = new CountModule("A")
{
CloneSource = true,
AdditionalOutputs = 1
};
CountModule b = new CountModule("B")
{
AdditionalOutputs = 2
};
CountModule c = new CountModule("C")
{
AdditionalOutputs = 3
};
engine.Pipelines.Add("Count", true, a, b, c);
// When
engine.Execute();
a.Value = 0; // Reset a.Value so output from a has same content
engine.Execute();
// Then
Assert.AreEqual(24, engine.Documents.FromPipeline("Count").Count());
Assert.AreEqual(2, a.ExecuteCount);
Assert.AreEqual(2, b.ExecuteCount);
Assert.AreEqual(2, c.ExecuteCount);
Assert.AreEqual(2, a.InputCount);
Assert.AreEqual(2, b.InputCount);
Assert.AreEqual(6, c.InputCount);
Assert.AreEqual(4, a.OutputCount);
Assert.AreEqual(6, b.OutputCount);
Assert.AreEqual(24, c.OutputCount);
}
public void ReplacesContent()
{
// Given
Engine engine = new Engine();
CountModule a = new CountModule("A")
{
Value = 10
};
CountModule b = new CountModule("B")
{
Value = 20
};
engine.Pipelines.Add("Test", a, new Merge(b),
new Core.Modules.Metadata.Meta("Content", (doc, ctx) => doc.Content));
// When
engine.Execute();
// Then
CollectionAssert.AreEqual(new [] { "21" }, engine.Documents["Test"].Select(x => x["Content"]));
}
public async Task ArrayInCaseResultsInCorrectCounts()
{
// Given
CountModule a = new CountModule("A")
{
AdditionalOutputs = 2,
EnsureInputDocument = true
};
CountModule b = new CountModule("B");
CountModule c = new CountModule("C");
ExecuteSwitch switchModule = new ExecuteSwitch(Config.FromDocument(async x => (object)await x.GetContentStringAsync())).Case(new string[] { "1", "2" }, b);
// When
await ExecuteAsync(a, switchModule, c);
// Then
Assert.AreEqual(1, a.ExecuteCount);
Assert.AreEqual(1, b.ExecuteCount);
Assert.AreEqual(2, b.InputCount);
Assert.AreEqual(2, b.OutputCount);
Assert.AreEqual(3, c.InputCount);
}
public void DoesNotProcessPreviousDocumentsWhenSameSource()
{
// Given
Engine engine = new Engine();
engine.CleanOutputFolderOnExecute = false;
engine.Trace.AddListener(new TestTraceListener());
CountModule a = new CountModule("A")
{
CloneSource = true,
AdditionalOutputs = 1
};
CountModule b = new CountModule("B")
{
AdditionalOutputs = 2
};
CountModule c = new CountModule("C")
{
AdditionalOutputs = 3
};
engine.Pipelines.Add("Count", true, a, b, c);
// When
engine.Execute();
a.Value = 0; // Reset a.Value so output from a has same content
engine.Execute();
// Then
Assert.AreEqual(24, engine.Documents.FromPipeline("Count").Count());
Assert.AreEqual(2, a.ExecuteCount);
Assert.AreEqual(2, b.ExecuteCount);
Assert.AreEqual(2, c.ExecuteCount);
Assert.AreEqual(2, a.InputCount);
Assert.AreEqual(2, b.InputCount);
Assert.AreEqual(6, c.InputCount);
Assert.AreEqual(4, a.OutputCount);
Assert.AreEqual(6, b.OutputCount);
Assert.AreEqual(24, c.OutputCount);
}
public void ReprocessPreviousDocumentsWithDifferentContent()
{
// Given
Engine engine = new Engine();
engine.Trace.AddListener(new TestTraceListener());
CountModule a = new CountModule("A")
{
CloneSource = true,
AdditionalOutputs = 1
};
CountModule b = new CountModule("B")
{
AdditionalOutputs = 2
};
CountModule c = new CountModule("C")
{
AdditionalOutputs = 3
};
engine.Pipelines.Add("Count", true, a, b, c);
// When
engine.Execute();
engine.Execute();
// Then
Assert.AreEqual(24, engine.Documents.FromPipeline("Count").Count());
Assert.AreEqual(2, a.ExecuteCount);
Assert.AreEqual(2, b.ExecuteCount);
Assert.AreEqual(2, c.ExecuteCount);
Assert.AreEqual(2, a.InputCount);
Assert.AreEqual(4, b.InputCount);
Assert.AreEqual(12, c.InputCount);
Assert.AreEqual(4, a.OutputCount);
Assert.AreEqual(12, b.OutputCount);
Assert.AreEqual(48, c.OutputCount);
}
public void SwitchNoCasesResultsInCorrectCounts()
{
// Given
Engine engine = new Engine();
CountModule a = new CountModule("A")
{
AdditionalOutputs = 2
};
CountModule b = new CountModule("B");
CountModule c = new CountModule("C");
engine.Pipelines.Add(a, new Switch((x, y) => x.Content).Default(b), c);
// When
engine.Execute();
// Then
Assert.AreEqual(1, a.ExecuteCount);
Assert.AreEqual(1, b.ExecuteCount);
Assert.AreEqual(3, b.InputCount);
Assert.AreEqual(3, b.OutputCount);
Assert.AreEqual(3, c.InputCount);
}
public void SwitchResultsInCorrectCounts()
{
// Given
Engine engine = new Engine();
CountModule a = new CountModule("A")
{
AdditionalOutputs = 2
};
CountModule b = new CountModule("B");
CountModule c = new CountModule("C");
CountModule d = new CountModule("D");
engine.Pipelines.Add(a, new Switch((x, y) => x.Content).Case("1", b).Case("2", c).Default(d));
// When
engine.Execute();
// Then
Assert.AreEqual(1, a.ExecuteCount);
Assert.AreEqual(1, b.ExecuteCount);
Assert.AreEqual(1, c.ExecuteCount);
Assert.AreEqual(1, d.ExecuteCount);
}
public async Task SingleInputSingleResult()
{
// Given
CountModule a = new CountModule("A")
{
Value = 10,
EnsureInputDocument = true
};
CountModule b = new CountModule("B")
{
Value = 20,
EnsureInputDocument = true
};
// When
IReadOnlyList <IDocument> results = await ExecuteAsync(a, new MergeDocuments(b));
// Then
Assert.AreEqual(1, a.OutputCount);
Assert.AreEqual(1, b.OutputCount);
CollectionAssert.AreEqual(new[] { 11 }, results.Select(x => x["A"]));
CollectionAssert.AreEqual(new[] { 21 }, results.Select(x => x["B"]));
}
public async Task ReverseReplacesContent()
{
// Given
CountModule a = new CountModule("A")
{
Value = 10,
EnsureInputDocument = true
};
CountModule b = new CountModule("B")
{
Value = 20,
EnsureInputDocument = true
};
// When
IReadOnlyList <IDocument> results = await ExecuteAsync(
a,
new MergeDocuments(b).Reverse(),
new AddMetadata("Content", Config.FromDocument(async doc => await doc.GetContentStringAsync())));
// Then
CollectionAssert.AreEqual(new[] { "11" }, results.Select(x => x["Content"]));
}
public async Task SetsCorrectMetadata()
{
// Given
List <int> groupKey = new List <int>();
CountModule count = new CountModule("A")
{
AdditionalOutputs = 7,
EnsureInputDocument = true
};
GroupDocuments groupByMany = new GroupDocuments(Config.FromDocument(d => new[] { d.GetInt("A") % 3, 3 }));
ForEachDocument gatherData = new ExecuteConfig(
Config.FromDocument(d =>
{
groupKey.Add(d.GetInt(Keys.GroupKey));
return(d);
})).ForEachDocument();
// When
IReadOnlyList <IDocument> results = await ExecuteAsync(count, groupByMany, gatherData);
// Then
CollectionAssert.AreEquivalent(new[] { 0, 1, 2, 3 }, groupKey);
}
public void SetsCorrectMetadata()
{
// Given
List<int> groupKey = new List<int>();
Engine engine = new Engine();
CountModule count = new CountModule("A")
{
AdditionalOutputs = 7
};
GroupByMany groupByMany = new GroupByMany((d, c) => new [] { d.Get<int>("A")%3, 3 }, count);
Execute gatherData = new Execute((d, c) =>
{
groupKey.Add(d.Get<int>(Keys.GroupKey));
return d;
});
engine.Pipelines.Add(groupByMany, gatherData);
// When
engine.Execute();
// Then
CollectionAssert.AreEquivalent(new[] {0, 1, 2, 3}, groupKey);
}
public void ArrayInCaseResultsInCorrectCounts()
{
// Given
Engine engine = new Engine();
CountModule a = new CountModule("A")
{
AdditionalOutputs = 2
};
CountModule b = new CountModule("B");
CountModule c = new CountModule("C");
engine.Pipelines.Add(a, new Switch((x, y) => x.Content).Case(new string[] { "1", "2" }, b), c);
// When
engine.Execute();
// Then
Assert.AreEqual(1, a.ExecuteCount);
Assert.AreEqual(1, b.ExecuteCount);
Assert.AreEqual(2, b.InputCount);
Assert.AreEqual(2, b.OutputCount);
Assert.AreEqual(3, c.InputCount);
}
public void PaginateSetsCorrectMetadata()
{
// Given
List <int> currentPage = new List <int>();
List <int> totalPages = new List <int>();
List <int> totalItems = new List <int>();
List <bool> hasNextPage = new List <bool>();
List <bool> hasPreviousPage = new List <bool>();
Engine engine = new Engine();
CountModule count = new CountModule("A")
{
AdditionalOutputs = 7
};
Paginate paginate = new Paginate(3, count);
Execute gatherData = new Execute(
(d, c) =>
{
currentPage.Add(d.Get <int>(Keys.CurrentPage));
totalPages.Add(d.Get <int>(Keys.TotalPages));
totalItems.Add(d.Get <int>(Keys.TotalItems));
hasNextPage.Add(d.Bool(Keys.HasNextPage));
hasPreviousPage.Add(d.Bool(Keys.HasPreviousPage));
return(null);
}, false);
engine.Pipelines.Add(paginate, gatherData);
// When
engine.Execute();
// Then
CollectionAssert.AreEqual(new[] { 1, 2, 3 }, currentPage);
CollectionAssert.AreEqual(new[] { 3, 3, 3 }, totalPages);
CollectionAssert.AreEqual(new[] { 8, 8, 8 }, totalItems);
CollectionAssert.AreEqual(new[] { true, true, false }, hasNextPage);
CollectionAssert.AreEqual(new[] { false, true, true }, hasPreviousPage);
}
public void GroupByMetadataKey()
{
// Given
List<int> groupKey = new List<int>();
Engine engine = new Engine();
CountModule count = new CountModule("A")
{
AdditionalOutputs = 7
};
Core.Modules.Metadata.Meta meta = new Core.Modules.Metadata.Meta("GroupMetadata", (d, c) => d.Get<int>("A") % 3);
GroupBy groupBy = new GroupBy("GroupMetadata", count, meta);
Execute gatherData = new Execute((d, c) =>
{
groupKey.Add(d.Get<int>(Keys.GroupKey));
return null;
});
engine.Pipelines.Add(groupBy, gatherData);
// When
engine.Execute();
// Then
CollectionAssert.AreEquivalent(new[] { 0, 1, 2 }, groupKey);
}
public void SingleInputSingleResult()
{
// Given
Engine engine = new Engine();
CountModule a = new CountModule("A")
{
Value = 10
};
CountModule b = new CountModule("B")
{
Value = 20
};
engine.Pipelines.Add("Test", a, new Merge(b));
// When
engine.Execute();
// Then
Assert.AreEqual(1, a.OutputCount);
Assert.AreEqual(1, b.OutputCount);
CollectionAssert.AreEqual(new[] { 11 }, engine.Documents["Test"].Select(x => x["A"]));
CollectionAssert.AreEqual(new[] { 21 }, engine.Documents["Test"].Select(x => x["B"]));
}
public void OmittingCasesAndDefaultResultsInCorrectCounts()
{
// Given
Engine engine = new Engine();
engine.Trace.AddListener(new TestTraceListener());
CountModule a = new CountModule("A") { AdditionalOutputs = 2 };
CountModule b = new CountModule("B");
engine.Pipelines.Add(a, new Switch((x, y) => x.Content), b);
// When
engine.Execute();
// Then
Assert.AreEqual(3, b.InputCount);
}
public void ExcludesDocumentsThatDontMatchPredicate()
{
// Given
List<int> groupKey = new List<int>();
Engine engine = new Engine();
CountModule count = new CountModule("A")
{
AdditionalOutputs = 7
};
GroupBy groupBy = new GroupBy((d, c) => d.Get<int>("A") % 3, count)
.Where((d, c) => d.Get<int>("A") % 3 != 0);
Execute gatherData = new Execute((d, c) =>
{
groupKey.Add(d.Get<int>(Keys.GroupKey));
return null;
});
engine.Pipelines.Add(groupBy, gatherData);
// When
engine.Execute();
// Then
CollectionAssert.AreEquivalent(new[] { 1, 2 }, groupKey);
}
public void IfElseAndElseResultsInCorrectCounts()
{
// Given
Engine engine = new Engine();
engine.Trace.AddListener(new TestTraceListener());
CountModule a = new CountModule("A")
{
AdditionalOutputs = 3
};
CountModule b = new CountModule("B")
{
AdditionalOutputs = 2
};
CountModule c = new CountModule("C")
{
AdditionalOutputs = 3
};
CountModule d = new CountModule("B")
{
AdditionalOutputs = 2
};
CountModule e = new CountModule("B")
{
AdditionalOutputs = 3
};
engine.Pipelines.Add(
a,
new If((x, y) => x.Content == "1", b)
.ElseIf((x, y) => x.Content == "3", c)
.Else(d),
e);
// When
engine.Execute();
// Then
Assert.AreEqual(1, a.ExecuteCount);
Assert.AreEqual(1, b.ExecuteCount);
Assert.AreEqual(1, c.ExecuteCount);
Assert.AreEqual(1, d.ExecuteCount);
Assert.AreEqual(1, e.ExecuteCount);
Assert.AreEqual(1, a.InputCount);
Assert.AreEqual(1, b.InputCount);
Assert.AreEqual(1, c.InputCount);
Assert.AreEqual(2, d.InputCount);
Assert.AreEqual(13, e.InputCount);
Assert.AreEqual(4, a.OutputCount);
Assert.AreEqual(3, b.OutputCount);
Assert.AreEqual(4, c.OutputCount);
Assert.AreEqual(6, d.OutputCount);
Assert.AreEqual(52, e.OutputCount);
}
public void GroupByMetadataKeyWithMissingMetadata()
{
// Given
List<int> groupKey = new List<int>();
Engine engine = new Engine();
CountModule count = new CountModule("A")
{
AdditionalOutputs = 7
};
Execute meta = new Execute((d, c) =>
{
int groupMetadata = d.Get<int>("A") % 3;
return groupMetadata == 0 ? d : c.GetDocument(d, new MetadataItems { {"GroupMetadata", groupMetadata} });
});
GroupBy groupBy = new GroupBy("GroupMetadata", count, meta);
Execute gatherData = new Execute((d, c) =>
{
groupKey.Add(d.Get<int>(Keys.GroupKey));
return null;
});
engine.Pipelines.Add(groupBy, gatherData);
// When
engine.Execute();
// Then
CollectionAssert.AreEquivalent(new[] { 1, 2 }, groupKey);
}
public void MultipleInputsMultipleResultsForEachDocument()
{
// Given
Engine engine = new Engine();
CountModule a = new CountModule("A")
{
Value = 10,
AdditionalOutputs = 1
};
CountModule b = new CountModule("B")
{
Value = 20,
AdditionalOutputs = 1
};
engine.Pipelines.Add("Test", a, new Merge(b).ForEachDocument(),
new Core.Modules.Metadata.Meta("Content", (doc, ctx) => doc.Content));
// When
engine.Execute();
// Then
Assert.AreEqual(2, a.OutputCount);
Assert.AreEqual(4, b.OutputCount);
CollectionAssert.AreEqual(new[] { "1121", "1122", "1223", "1224" }, engine.Documents["Test"].Select(x => x["Content"]));
}
