public void ContentAndMetadataReturnsCorrectDocuments()
        {
            // Given
            List<string> content = new List<string>();
            List<object> values = new List<object>();
            Engine engine = new Engine();
            engine.Trace.AddListener(new TestTraceListener());
            Core.Modules.Documents documents = new Core.Modules.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);
        }
Exemple #2
0
        public void GroupBySetsDocumentsInMetadata()
        {
            // 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
            };
            GroupBy groupBy = new GroupBy((d, c) => d.Get<int>("A") % 3, count);
            OrderBy orderBy = new OrderBy((d, c) => d.Get<int>(MetadataKeys.GroupKey));
            Execute gatherData = new Execute((d, c) =>
            {
                content.Add(d.Get<IList<IDocument>>(MetadataKeys.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]);
        }
Exemple #3
0
        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);
        }
Exemple #4
0
        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>>(MetadataKeys.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]);
        }
Exemple #5
0
        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>(MetadataKeys.CurrentPage));
                totalPages.Add(d.Get<int>(MetadataKeys.TotalPages));
                hasNextPage.Add(d.Get<bool>(MetadataKeys.HasNextPage));
                hasPreviousPage.Add(d.Get<bool>(MetadataKeys.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);
        }
Exemple #6
0
        public void OrderByOrdersInDescendingOrder()
        {
            // 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("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);
        }
Exemple #7
0
        public void ExecuteDoesNotThrowForNullResultWithDocumentConfig()
        {
            // Given
            Engine engine = new Engine();
            engine.Trace.AddListener(new TestTraceListener());
            Execute execute = new Execute((d, c) => null);
            engine.Pipelines.Add(execute);

            // When
            engine.Execute();

            // Then
        }
        public void ContentReturnsCorrectDocuments()
        {
            // Given
            List<string> content = new List<string>();
            Engine engine = new Engine();
            engine.Trace.AddListener(new TestTraceListener());
            Core.Modules.Documents documents = new Core.Modules.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);
        }
Exemple #9
0
        public void GroupBySetsCorrectMetadata()
        {
            // Given
            List<int> groupKey = new List<int>();
            Engine engine = new Engine();
            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>(MetadataKeys.GroupKey));
                return null;
            });
            engine.Pipelines.Add(groupBy, gatherData);

            // When
            engine.Execute();

            // Then
            CollectionAssert.AreEquivalent(new[] { 0, 1, 2 }, groupKey);
        }
        public void MetadataReturnsCorrectDocuments()
        {
            // Given
            List<object> values = new List<object>();
            Engine engine = new Engine();
            engine.Trace.AddListener(new TestTraceListener());
            Core.Modules.Documents documents = new Core.Modules.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);
        }