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