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"])); }