public void PaginateSetsDocumentsInMetadata()
{
// Given
List<IList<string>> content = new List<IList<string>>();
Engine engine = new Engine();
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 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 OrderByOrdersInDescendingOrder()
{
// Given
List<string> content = new List<string>();
Engine engine = new Engine();
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 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 ResultsInCorrectCountsWithPredicate()
{
// 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).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();
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 ExecuteDoesNotThrowForNullResultWithContextConfig()
{
// Given
Engine engine = new Engine();
Execute execute = new Execute(c => null);
engine.Pipelines.Add(execute);
// When
engine.Execute();
// Then
}
public void TestTraceListenerThrows(TraceEventType traceEventType)
{
// Given
Engine engine = new Engine();
engine.Pipelines.Add(new Trace(traceEventType.ToString()).EventType(traceEventType));
// When
TestDelegate test = () => engine.Execute();
// Then
Assert.Throws<Exception>(test);
}
public void ExecuteDoesNotRequireReturnValueForContextConfig()
{
// Given
int a = 0;
Engine engine = new Engine();
Execute execute = new Execute(c => { a = a + 1; });
engine.Pipelines.Add(execute);
// When
engine.Execute();
// Then
}
public void CountReturnsCorrectDocuments()
{
// Given
Engine engine = new Engine();
Core.Modules.Control.Documents documents = new Core.Modules.Control.Documents(5);
engine.Pipelines.Add(documents);
// When
engine.Execute();
// Then
Assert.AreEqual(5, engine.Documents.Count());
}
public void ExecuteReturnsDocumentForSingleResultDocumentFromContextConfig()
{
// Given
Engine engine = new Engine();
IDocument document = Substitute.For<IDocument>();
Execute execute = new Execute(c => document);
engine.Pipelines.Add("Test", execute);
// When
engine.Execute();
// Then
CollectionAssert.AreEquivalent(new[] { document }, engine.Documents["Test"]);
}
public void ReprocessesPreviousDocumentsWithDistinctSources()
{
// Given
Engine engine = new Engine();
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();
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 ElseIfResultsInCorrectCounts()
{
// 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, 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 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 ContentReturnsCorrectDocuments()
{
// Given
List<string> content = new List<string>();
Engine engine = new Engine();
Core.Modules.Control.Documents documents = new Core.Modules.Control.Documents("A", "B", "C", "D");
Execute gatherData = new Execute((d, c) =>
{
content.Add(d.Content);
return null;
});
engine.Pipelines.Add(documents, gatherData);
// When
engine.Execute();
// Then
Assert.AreEqual(4, content.Count);
CollectionAssert.AreEqual(new[] {"A", "B", "C", "D"}, content);
}
public void MissingDefaultResultsInCorrectCounts()
{
// 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("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 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 MetadataReturnsCorrectDocuments()
{
// Given
List<object> values = new List<object>();
Engine engine = new Engine();
Core.Modules.Control.Documents documents = new Core.Modules.Control.Documents(
new Dictionary<string, object> {{"Foo", "a"}},
new Dictionary<string, object> {{"Foo", "b"}},
new Dictionary<string, object> {{"Foo", "c"}});
Execute gatherData = new Execute((d, c) =>
{
values.Add(d["Foo"]);
return null;
});
engine.Pipelines.Add(documents, gatherData);
// When
engine.Execute();
// Then
Assert.AreEqual(3, values.Count);
CollectionAssert.AreEqual(new[] {"a", "b", "c"}, values);
}
public void SetsCorrectMetadata()
{
// 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);
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 CompletedMetadataIsPopulatedAfterRun()
{
// Given
Engine engine = new Engine();
int c = 0;
engine.Pipelines.Add("Pipeline",
new Execute((x, ctx) => new[]
{
ctx.GetDocument(x, (string)null, new Dictionary<string, object> { { c.ToString(), c++ } }),
ctx.GetDocument(x, (string)null, new Dictionary<string, object> { { c.ToString(), c++ } })
}),
new Execute((x, ctx) => new[]
{
ctx.GetDocument(x, (string)null, new Dictionary<string, object> { { c.ToString(), c++ } })
}));
// When
engine.Execute();
// Then
Assert.AreEqual(2, engine.Documents.FromPipeline("Pipeline").Count());
Assert.IsTrue(engine.Documents.FromPipeline("Pipeline").First().Metadata.ContainsKey("0"));
Assert.AreEqual(0, engine.Documents.FromPipeline("Pipeline").First().Metadata["0"]);
Assert.IsTrue(engine.Documents.FromPipeline("Pipeline").First().Metadata.ContainsKey("2"));
Assert.AreEqual(2, engine.Documents.FromPipeline("Pipeline").First().Metadata["2"]);
Assert.IsFalse(engine.Documents.FromPipeline("Pipeline").First().Metadata.ContainsKey("1"));
Assert.IsFalse(engine.Documents.FromPipeline("Pipeline").First().Metadata.ContainsKey("3"));
Assert.IsTrue(engine.Documents.FromPipeline("Pipeline").Skip(1).First().Metadata.ContainsKey("1"));
Assert.AreEqual(1, engine.Documents.FromPipeline("Pipeline").Skip(1).First().Metadata["1"]);
Assert.IsTrue(engine.Documents.FromPipeline("Pipeline").Skip(1).First().Metadata.ContainsKey("3"));
Assert.AreEqual(3, engine.Documents.FromPipeline("Pipeline").Skip(1).First().Metadata["3"]);
Assert.IsFalse(engine.Documents.FromPipeline("Pipeline").Skip(1).First().Metadata.ContainsKey("0"));
Assert.IsFalse(engine.Documents.FromPipeline("Pipeline").Skip(1).First().Metadata.ContainsKey("2"));
}
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 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 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 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"]));
}
public void OrderByOrdersThenByInAscendingOrder()
{
// Given
List<string> content = new List<string>();
Engine engine = new Engine();
CountModule count = new CountModule("A")
{
AdditionalOutputs = 4
};
CountModule count2 = new CountModule("B")
{
AdditionalOutputs = 1
};
OrderBy orderBy = new OrderBy((d, c) => d.Get<int>("A"))
.ThenBy((d, c) => d.Get<int>("B"));
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[] {"11", "12", "23", "24", "35", "36", "47", "48", "59", "510"}, content);
}
public void ContentAndMetadataReturnsCorrectDocuments()
{
// Given
List<string> content = new List<string>();
List<object> values = new List<object>();
Engine engine = new Engine();
Core.Modules.Control.Documents documents = new Core.Modules.Control.Documents(
Tuple.Create("A", new Dictionary<string, object> {{"Foo", "a"}}.AsEnumerable()),
Tuple.Create("B", new Dictionary<string, object> {{"Foo", "b"}}.AsEnumerable()),
Tuple.Create("C", new Dictionary<string, object> {{"Foo", "c"}}.AsEnumerable()));
Execute gatherData = new Execute((d, c) =>
{
content.Add(d.Content);
values.Add(d["Foo"]);
return null;
});
engine.Pipelines.Add(documents, gatherData);
// When
engine.Execute();
// Then
Assert.AreEqual(3, content.Count);
Assert.AreEqual(3, values.Count);
CollectionAssert.AreEqual(new[] {"A", "B", "C"}, content);
CollectionAssert.AreEqual(new[] {"a", "b", "c"}, values);
}
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) => new[] { d.Get<int>("A") % 3, 3 });
GroupByMany groupByMany = new GroupByMany("GroupMetadata", count, meta);
Execute gatherData = new Execute((d, c) =>
{
groupKey.Add(d.Get<int>(Keys.GroupKey));
return null;
});
engine.Pipelines.Add(groupByMany, gatherData);
// When
engine.Execute();
// Then
CollectionAssert.AreEquivalent(new[] { 0, 1, 2, 3 }, groupKey);
}
public void MultipleInputsMultipleResults()
{
// 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));
// When
engine.Execute();
// Then
Assert.AreEqual(2, a.OutputCount);
Assert.AreEqual(2, b.OutputCount);
CollectionAssert.AreEqual(new[] { 11, 11, 12, 12 }, engine.Documents["Test"].Select(x => x["A"]));
CollectionAssert.AreEqual(new[] { 21, 22, 21, 22 }, engine.Documents["Test"].Select(x => x["B"]));
}
