Example #1
0
        public void Filter()
        {
            using (var scope = TestScope.Create())
            {
                scope.Resolve <ISqlExecuter>().ExecuteSql(new[] { "DELETE FROM TestQueryDataStructureCommand.Source;" });
                scope.Resolve <ISqlExecuter>().ExecuteSql(new[] { "a1", "b1", "b2", "c1" }
                                                          .Select(name => "INSERT INTO TestQueryDataStructureCommand.Source (Name) SELECT N'" + name + "';"));

                var info = new ReadCommandInfo {
                    DataSource = "TestQueryDataStructureCommand.Source", ReadRecords = true, ReadTotalCount = true
                };
                Assert.AreEqual("a1, b1, b2, c1 /4", ReportCommandResult2(scope, info, true));

                info.Filters = new[] { new FilterCriteria(new TestQueryDataStructureCommand.FilterByPrefix {
                        Prefix = "b"
                    }) };
                Assert.AreEqual("b1, b2 /2", ReportCommandResult2(scope, info, true));

                info.OrderByProperties = new[] { new OrderByProperty {
                                                     Property = "Name", Descending = true
                                                 } };
                Assert.AreEqual("b2, b1 /2", ReportCommandResult2(scope, info));

                info.Top = 1;
                Assert.AreEqual("b2 /2", ReportCommandResult2(scope, info));

                info.Filters = info.Filters.Concat(new[] { new FilterCriteria {
                                                               Property = "Name", Operation = "Contains", Value = "1"
                                                           } }).ToArray();
                Assert.AreEqual("b1 /1", ReportCommandResult2(scope, info));
            }
        }
Example #2
0
        //================================================================
        #region Sorting and paging

        public static IQueryable <T> SortAndPaginate <T>(IQueryable <T> query, ReadCommandInfo commandInfo)
        {
            bool pagingIsUsed = commandInfo.Top > 0 || commandInfo.Skip > 0;

            if (pagingIsUsed && (commandInfo.OrderByProperties == null || commandInfo.OrderByProperties.Length == 0))
            {
                throw new ClientException("Invalid ReadCommand argument: Sort order must be set if paging is used (Top or Skip).");
            }

            if (commandInfo.OrderByProperties != null)
            {
                foreach (var order in commandInfo.OrderByProperties)
                {
                    query = Sort(query, order.Property, ascending: !order.Descending);
                }
            }

            Type itemType = query.GetType().GetInterface("IQueryable`1").GetGenericArguments().Single();

            if (commandInfo.Skip > 0)
            {
                // "query.Skip(commandInfo.Skip)" would convert the result IQueryable<T> and not use the actual queryable generic type.
                var skipMethod = typeof(Queryable).GetMethod("Skip").MakeGenericMethod(itemType);
                query = (IQueryable <T>)skipMethod.InvokeEx(null, query, commandInfo.Skip);
            }

            if (commandInfo.Top > 0)
            {
                // "query.Take(commandInfo.Top)" would convert the result IQueryable<T> and not use the actual queryable generic type.
                var takeMethod = typeof(Queryable).GetMethod("Take").MakeGenericMethod(itemType);
                query = (IQueryable <T>)takeMethod.InvokeEx(null, query, commandInfo.Top);
            }

            return(query);
        }
Example #3
0
        public void NullGenericFilter()
        {
            using (var scope = TestScope.Create())
            {
                var genericRepos = scope.Resolve <GenericRepositories>().GetGenericRepository("Common.Claim");

                var readCommand = new ReadCommandInfo
                {
                    DataSource        = "Common.Claim",
                    Top               = 3,
                    OrderByProperties = new[] { new OrderByProperty {
                                                    Property = "ClaimResource"
                                                } },
                    ReadRecords    = true,
                    ReadTotalCount = true,
                };

                var serverCommandsUtility = scope.Resolve <ServerCommandsUtility>();

                var readResult = serverCommandsUtility.ExecuteReadCommand(readCommand, genericRepos);
                Console.WriteLine("Records.Length: " + readResult.Records.Length);
                Console.WriteLine("TotalCount: " + readResult.TotalCount);
                Assert.IsTrue(readResult.Records.Length < readResult.TotalCount);
            }
        }
Example #4
0
        private static ReadCommandResult ExecuteCommand(ReadCommandInfo commandInfo, RhetosTestContainer container)
        {
            var commands    = container.Resolve <IIndex <Type, IEnumerable <ICommandImplementation> > >();
            var readCommand = (ReadCommand)commands[typeof(ReadCommandInfo)].Single();

            return((ReadCommandResult)readCommand.Execute(commandInfo).Data.Value);
        }
        private static ReadCommandResult ExecuteCommand(ReadCommandInfo commandInfo, UnitOfWorkScope scope)
        {
            var commands    = scope.Resolve <IIndex <Type, IEnumerable <ICommandImplementation> > >();
            var readCommand = (ReadCommand)commands[typeof(ReadCommandInfo)].Single();

            return((ReadCommandResult)readCommand.Execute(commandInfo).Data.Value);
        }
Example #6
0
        public void ReadCommand()
        {
            var entityRepos  = new ImplicitReadCommandRepository();
            var genericRepos = NewRepos(entityRepos);

            var command = new ReadCommandInfo
            {
                Filters = new[] { new FilterCriteria {
                                      Property = "Name", Operation = "StartsWith", Value = "b"
                                  } },
                OrderByProperties = new[] { new OrderByProperty {
                                                Property = "Name"
                                            } },
                Top            = 3,
                Skip           = 3,
                ReadRecords    = true,
                ReadTotalCount = true,
            };

            Assert.AreEqual("a1, b1, b2 / 10", Dump(NewRepos(new ExplicitReadCommandRepository()).ExecuteReadCommand(command)));
            Assert.AreEqual(0, entityRepos.DropQueryCount());
            Assert.AreEqual("b4, b5 / 5", Dump(genericRepos.ExecuteReadCommand(command)));
            Assert.AreEqual(2, entityRepos.DropQueryCount()); // Paging should result with two queries: selecting items and count.

            command = new ReadCommandInfo {
                ReadRecords = true, ReadTotalCount = true
            };
            Assert.AreEqual("a1, b1, b2, b3, b4, b5 / 6", Dump(genericRepos.ExecuteReadCommand(command)));
            Assert.AreEqual(1, entityRepos.DropQueryCount()); // Without paging, there is no need for two queries.

            command = new ReadCommandInfo {
                Filters = new[] { new FilterCriteria("1") }, ReadRecords = true, ReadTotalCount = true
            };
            Assert.AreEqual("a1, b1 / 2", Dump(genericRepos.ExecuteReadCommand(command)));
            Assert.AreEqual(1, entityRepos.DropQueryCount()); // Without paging, there is no need for two queries.

            command = new ReadCommandInfo {
                Filters = new[] { new FilterCriteria("1"), new FilterCriteria {
                                      Property = "Name", Operation = "StartsWith", Value = "b"
                                  } }, ReadRecords = true, ReadTotalCount = true
            };
            Assert.AreEqual("b1 / 1", Dump(genericRepos.ExecuteReadCommand(command)));
            Assert.AreEqual(1, entityRepos.DropQueryCount()); // Without paging, there is no need for two queries.

            command = new ReadCommandInfo {
                Filters = new[] { new FilterCriteria("1"), new FilterCriteria {
                                      Filter = "System.String", Value = "b"
                                  } }, ReadRecords = true, ReadTotalCount = true
            };
            Assert.AreEqual("b1 / 1", Dump(genericRepos.ExecuteReadCommand(command)));
            Assert.AreEqual(1, entityRepos.DropQueryCount()); // Without paging, there is no need for two queries.

            command = new ReadCommandInfo {
                Filters = new[] { new FilterCriteria("b") }, Top = 2, Skip = 2, OrderByProperties = new[] { new OrderByProperty {
                                                                                                                Property = "Name"
                                                                                                            } }, ReadRecords = true, ReadTotalCount = true
            };
            Assert.AreEqual("b3, b4 / 5", Dump(genericRepos.ExecuteReadCommand(command)));
            Assert.AreEqual(1, entityRepos.DropQueryCount()); // Enumerable filter will cause GenericRepository to materialize of the query, so it will be executed only once even though the paging is used.
        }
        public RecordsAndTotalCountResult <T> GetData <T>(string filter, string fparam, string genericfilter, string filters, IDictionary <string, Type[]> filterTypesByName, int top, int skip, int page, int psize, string sort, bool readRecords, bool readTotalCount)
        {
            // Legacy interface:
            if (page != 0 || psize != 0)
            {
                if (top != 0 || skip != 0)
                {
                    throw new ClientException("Invalid paging parameter: Use either 'top' and 'skip', or 'page' and 'psize'.");
                }

                top  = psize;
                skip = page > 0 ? psize * (page - 1) : 0;
            }

            var readCommandInfo = new ReadCommandInfo
            {
                DataSource        = typeof(T).FullName,
                Filters           = ParseFilterParameters(filter, fparam, genericfilter, filters, filterTypesByName),
                Top               = top,
                Skip              = skip,
                ReadRecords       = readRecords,
                ReadTotalCount    = readTotalCount,
                OrderByProperties = ParseSortParameter(sort)
            };

            var readCommandResult = ExecuteReadCommand(readCommandInfo);

            return(new RecordsAndTotalCountResult <T>
            {
                Records = readCommandResult.Records != null?readCommandResult.Records.Cast <T>().ToArray() : null,
                              TotalCount = readCommandResult.TotalCount != null ? readCommandResult.TotalCount.Value : 0
            });
        }
Example #8
0
        public void ExternalFilterType()
        {
            using (var container = new RhetosTestContainer())
            {
                var repository = container.Resolve <Common.DomRepository>();

                repository.TestFilter.ExternalFilter.Delete(repository.TestFilter.ExternalFilter.Query());
                repository.TestFilter.ExternalFilter.Insert(
                    new[] { "str", "snull", "date", "dnull", "ddef" }
                    .Select(name => new TestFilter.ExternalFilter {
                    Name = name
                }));

                var tests = new List <Tuple <Type, object, string> >
                {
                    Tuple.Create <Type, object, string>(null, "abc", "str"),
                    Tuple.Create <Type, object, string>(typeof(string), null, "snull"),
                    Tuple.Create <Type, object, string>(null, DateTime.Now, "date"),
                    Tuple.Create <Type, object, string>(typeof(DateTime), null, "ddef"), // A value type instance cannot be null.
                    Tuple.Create <Type, object, string>(typeof(DateTime), default(DateTime), "ddef"),
                };

                var gr = container.Resolve <GenericRepository <TestFilter.ExternalFilter> >();

                foreach (var test in tests)
                {
                    Type filterType = test.Item1 ?? test.Item2.GetType();

                    string testReport = filterType.FullName + ": " + test.Item2;
                    Console.WriteLine(testReport);

                    {
                        var reposReadResult = gr.Load(test.Item2, filterType);
                        Assert.AreEqual(
                            test.Item3,
                            TestUtility.DumpSorted(reposReadResult, item => item.Name),
                            "ReadRepos: " + testReport);
                    }

                    {
                        var readCommand = new ReadCommandInfo
                        {
                            DataSource = "TestFilter.ExternalFilter",
                            Filters    = new FilterCriteria[] { new FilterCriteria {
                                                                    Filter = filterType.FullName,
                                                                    Value  = test.Item2
                                                                } },
                            ReadRecords = true
                        };

                        var commandResult = (TestFilter.ExternalFilter[])ExecuteCommand(readCommand, container).Records;
                        Assert.AreEqual(
                            test.Item3,
                            TestUtility.DumpSorted(commandResult, item => item.Name),
                            "ReadCommand: " + testReport);
                    }
                }
            }
        }
Example #9
0
        public void AutoFilter_NoRedundantAutoFilter()
        {
            using (var container = new RhetosTestContainer())
            {
                var repository = container.Resolve <Common.DomRepository>();
                repository.TestFilter.AutoFilter1.Delete(repository.TestFilter.AutoFilter1.Query());
                repository.TestFilter.AutoFilter2.Delete(repository.TestFilter.AutoFilter2.Query());

                repository.TestFilter.AutoFilter1.Insert(
                    new[] { "a1", "a2", "b1", "b2" }
                    .Select(name => new TestFilter.AutoFilter1 {
                    Name = name
                }));

                repository.TestFilter.AutoFilter2.Insert(
                    new[] { "a1", "a2", "b1", "b2" }
                    .Select(name => new TestFilter.AutoFilter2 {
                    Name = name
                }));

                var gr = container.Resolve <GenericRepositories>();

                // Number of 'x' characters in the Name property shows how many times the filter was applied.
                // Auto filter should not be applied if the filter was already manually applied.

                var readCommand = new ReadCommandInfo
                {
                    Filters = new FilterCriteria[] {
                        new FilterCriteria("Name2", "contains", "2"),
                        new FilterCriteria(typeof(string))
                    },
                    OrderByProperties = new OrderByProperty[] { new OrderByProperty {
                                                                    Property = "Name2", Descending = true
                                                                } },
                    ReadTotalCount = true,
                    Top            = 1
                };
                TestClientRead <TestFilter.AutoFilter2Browse>(container, "b2x", item => item.Name2, readCommand);

                // Same filter manually applied multiple times.

                readCommand = new ReadCommandInfo
                {
                    Filters = new FilterCriteria[] {
                        new FilterCriteria("Name2", "contains", "2"),
                        new FilterCriteria(typeof(string)),
                        new FilterCriteria("abc")
                    },
                    OrderByProperties = new OrderByProperty[] { new OrderByProperty {
                                                                    Property = "Name2", Descending = true
                                                                } },
                    ReadTotalCount = true,
                    Top            = 1
                };
                TestClientRead <TestFilter.AutoFilter2Browse>(container, "b2xx", item => item.Name2, readCommand);
            }
        }
        public string ReadBooks()
        {
            var readCommandInfo = new ReadCommandInfo {
                DataSource = "Bookstore.Book", ReadTotalCount = true
            };
            var result = processingEngine.Execute(readCommandInfo);

            return($"{result.TotalCount} books.");
        }
Example #11
0
        private ReadCommandResult ExecuteReadCommand(ReadCommandInfo commandInfo)
        {
            var result = _processingEngine.Execute(new[] { commandInfo });

            CheckForErrors(result);
            var resultData = (ReadCommandResult)(((Rhetos.XmlSerialization.XmlBasicData <ReadCommandResult>)(result.CommandResults.Single().Data)).Value);

            return(resultData);
        }
Example #12
0
        public void TestReadNoRowPermissions()
        {
            using (var container = new RhetosTestContainer())
            {
                var gRepository = container.Resolve <GenericRepository <NoRP> >();
                gRepository.Save(Enumerable.Range(0, 50).Select(a => new NoRP()
                {
                    value = a
                }), null, gRepository.Load());

                {
                    var all = new ReadCommandInfo()
                    {
                        DataSource  = "TestRowPermissions.NoRP",
                        ReadRecords = true
                    };
                    var result = ExecuteReadCommand(all, container);
                    Assert.AreEqual(50, result.Records.Count());
                }

                {
                    var filtered = new ReadCommandInfo()
                    {
                        DataSource  = "TestRowPermissions.NoRP",
                        ReadRecords = true,
                        Filters     = new FilterCriteria[] { new FilterCriteria()
                                                             {
                                                                 Filter = "TestRowPermissions.Value30"
                                                             } }
                    };
                    var result = ExecuteReadCommand(filtered, container);
                    Assert.AreEqual(19, result.Records.Count());
                }

                {
                    var guid = Guid.NewGuid();
                    gRepository.Save(new NoRP[] { new NoRP()
                                                  {
                                                      ID = guid, value = 51
                                                  } }, null, null);

                    var single = new ReadCommandInfo()
                    {
                        DataSource  = "TestRowPermissions.NoRP",
                        ReadRecords = true,
                        Filters     = new FilterCriteria[] { new FilterCriteria()
                                                             {
                                                                 Property = "ID", Operation = "equal", Value = guid
                                                             } }
                    };
                    var result = ExecuteReadCommand(single, container);
                    Assert.AreEqual(1, result.Records.Count());
                    Assert.AreEqual(51, (result.Records[0] as NoRP).value);
                }
            }
        }
Example #13
0
        public static ReadCommandResult ExecuteReadCommand(
            this GenericRepository <IEntity> genericRepository,
            ReadCommandInfo readCommandInfo)
        {
            readCommandInfo.DataSource = typeof(ServerCommandsUtilityTest.SimpleEntity).FullName;
            var serverCommandsUtility = new ServerCommandsUtility(new ConsoleLogProvider(), new ApplyFiltersOnClientRead());
            var commandResult         = serverCommandsUtility.ExecuteReadCommand(readCommandInfo, genericRepository);

            return(commandResult);
        }
Example #14
0
 public ReadCommandResult ReadCommand(ReadCommandInfo commandInfo)
 {
     return(new ReadCommandResult
     {
         Records = new SimpleEntityList {
             "a1", "b1", "b2"
         }.ToArray(),
         TotalCount = 10
     });
 }
Example #15
0
        public void Entity()
        {
            using (var scope = TestScope.Create())
            {
                InitializeData(scope);

                var info = new ReadCommandInfo {
                    DataSource = "TestQueryDataStructureCommand.E", ReadRecords = true, ReadTotalCount = true
                };
                Assert.AreEqual("a, b, c, d, e /5", ReportCommandResult(scope, info, true));
            }
        }
Example #16
0
        private static string ReportFilteredBrowse(RhetosTestContainer container, ReadCommandInfo readCommandInfo)
        {
            readCommandInfo.DataSource = "TestFilter.ComposableFilterBrowse";

            return(TestUtility.DumpSorted(
                       ExecuteCommand(readCommandInfo, container).Records,
                       item =>
            {
                var x = (TestFilter.ComposableFilterBrowse)item;
                return x.Name + " " + (x.DebugInfoSimpleName ?? "null");
            }));
        }
        private ReadCommandResult ExecuteReadCommand(ReadCommandInfo commandInfo)
        {
            var sw = Stopwatch.StartNew();

            var result = _processingEngine.Execute(new[] { commandInfo });

            CheckForErrors(result);
            var resultData = (ReadCommandResult)(((Rhetos.XmlSerialization.XmlBasicData <ReadCommandResult>)(result.CommandResults.Single().Data)).Value);

            _performanceLogger.Write(sw, "RestService: ExecuteReadCommand(" + commandInfo.DataSource + ") Executed.");
            return(resultData);
        }
        private IPrincipal[] ReadUsers(params string[] usernames)
        {
            var command = new ReadCommandInfo
            {
                DataSource  = typeof(Common.Principal).FullName,
                Filters     = new[] { new FilterCriteria("Name", "in", usernames) },
                ReadRecords = true
            };
            var result = Exec <ReadCommandResult>(command);

            return((IPrincipal[])result.Records);
        }
Example #19
0
        string ReadErrorData(RhetosTestContainer container, string testName)
        {
            Console.WriteLine("Test: " + testName);
            var readCommand = new ReadCommandInfo()
            {
                DataSource = "TestRowPermissions.ErrorData", ReadRecords = true, Filters = new[] { new FilterCriteria(testName) }
            };
            var    loaded = ExecuteReadCommand(readCommand, container).Records;
            string report = TestUtility.DumpSorted(loaded, item => ((ErrorData)item).Name);

            Console.WriteLine("Result: " + report);
            return(report);
        }
        public string DemoEntity()
        {
            var readCommand = new ReadCommandInfo()
            {
                DataSource  = "AspNetDemo.DemoEntity",
                ReadRecords = true,
            };
            var result = rhetosProcessingEngine.Value.Execute(new List <ICommandInfo>()
            {
                readCommand
            });

            return(JsonConvert.SerializeObject(result, Formatting.Indented));
        }
        public void OnGet()
        {
            var readCommand = new ReadCommandInfo()
            {
                DataSource  = "AspNetDemo.DemoEntity",
                ReadRecords = true
            };
            var result = rhetosProcessingEngine.Value.Execute(new List <ICommandInfo>()
            {
                readCommand
            });
            var readCommandResult = result.CommandResults.FirstOrDefault()?.Data.Value as ReadCommandResult;

            DemoEntityList = readCommandResult?.Records.Cast <DemoEntity>().ToList();
        }
    public string ReadBooks()
    {
        var readCommandInfo = new ReadCommandInfo()
        {
            DataSource = "Bookstore.Book", ReadTotalCount = true
        };

        var processingResult = rhetosProcessingEngine.Value.Execute(new List <ICommandInfo>()
        {
            readCommandInfo
        });
        var result = (ReadCommandResult)processingResult.CommandResults.Single().Data.Value;

        return(result.TotalCount.ToString());
    }
        public void Sort()
        {
            var readCommand = new ReadCommandInfo
            {
                OrderByProperties = new[]
                {
                    new OrderByProperty {
                        Property = "Name", Descending = true
                    },
                    new OrderByProperty {
                        Property = "Size", Descending = false
                    },
                }
            };

            IQueryable <Entity2> query = new[]
            {
                new Entity2 {
                    Name = "b", Size = 2, Ignore = 1
                },
                new Entity2 {
                    Name = "b", Size = 2, Ignore = 2
                },
                new Entity2 {
                    Name = "b", Size = 3, Ignore = 3
                },
                new Entity2 {
                    Name = "b", Size = 1, Ignore = 4
                },
                new Entity2 {
                    Name = "a", Size = 1, Ignore = 5
                },
                new Entity2 {
                    Name = "c", Size = 3, Ignore = 6
                }
            }.AsQueryable();

            query = query.OrderBy(item => item.Ignore); // SortAndPaginate should ignore previous ordering, not append to it.

            var result = GenericFilterHelper.SortAndPaginate(query, readCommand);

            Console.WriteLine(result.ToString());
            Assert.AreEqual(
                "c3, b1, b2, b2, b3, a1",
                TestUtility.Dump(result, item => item.Name + item.Size));
        }
Example #24
0
        private static string ReportCommandResult(UnitOfWorkScope scope, ReadCommandInfo info, bool sort = false)
        {
            var commands    = scope.Resolve <IIndex <Type, IEnumerable <ICommandImplementation> > >();
            var readCommand = (ReadCommand)commands[typeof(ReadCommandInfo)].Single();

            var result = (ReadCommandResult)readCommand.Execute(info).Data.Value;
            var items  = ((IEnumerable <TestQueryDataStructureCommand.E>)result.Records).Select(item => item.Name);

            if (sort)
            {
                items = items.OrderBy(x => x);
            }
            var report = string.Join(", ", items) + " /" + result.TotalCount.Value;

            Console.WriteLine(report);
            return(report);
        }
Example #25
0
        public void AutoFilter_Complex()
        {
            using (var container = new RhetosTestContainer())
            {
                var repository = container.Resolve <Common.DomRepository>();
                repository.TestFilter.AutoFilter1.Delete(repository.TestFilter.AutoFilter1.Query());
                repository.TestFilter.AutoFilter2.Delete(repository.TestFilter.AutoFilter2.Query());

                repository.TestFilter.AutoFilter1.Insert(
                    new[] { "a1", "a2", "b1", "b2" }
                    .Select(name => new TestFilter.AutoFilter1 {
                    Name = name
                }));

                repository.TestFilter.AutoFilter2.Insert(
                    new[] { "a1", "a2", "b1", "b2" }
                    .Select(name => new TestFilter.AutoFilter2 {
                    Name = name
                }));

                var gr = container.Resolve <GenericRepositories>();

                var readCommand = new ReadCommandInfo
                {
                    Filters           = new FilterCriteria[] { new FilterCriteria("Name", "contains", "2") },
                    OrderByProperties = new OrderByProperty[] { new OrderByProperty {
                                                                    Property = "Name", Descending = true
                                                                } },
                    ReadTotalCount = true,
                    Top            = 1
                };
                TestClientRead <TestFilter.AutoFilter1>(container, "a2", item => item.Name, readCommand);

                readCommand = new ReadCommandInfo
                {
                    Filters           = new FilterCriteria[] { new FilterCriteria("Name2", "contains", "2") },
                    OrderByProperties = new OrderByProperty[] { new OrderByProperty {
                                                                    Property = "Name2", Descending = true
                                                                } },
                    ReadTotalCount = true,
                    Top            = 1
                };
                TestClientRead <TestFilter.AutoFilter2Browse>(container, "b2x", item => item.Name2, readCommand);
            }
        }
Example #26
0
        public void PagingWithoutOrder()
        {
            using (var scope = TestScope.Create())
            {
                InitializeData(scope);

                var info = new ReadCommandInfo
                {
                    DataSource     = "TestQueryDataStructureCommand.E",
                    Top            = 3,
                    Skip           = 3,
                    ReadRecords    = true,
                    ReadTotalCount = true
                };

                TestUtility.ShouldFail(() => ReportCommandResult(scope, info), "Sort order must be set if paging is used");
            }
        }
Example #27
0
        public void Filters()
        {
            using (var scope = TestScope.Create())
            {
                InitializeData(scope);

                var info = new ReadCommandInfo
                {
                    DataSource = "TestQueryDataStructureCommand.E",
                    Filters    = new[] { new FilterCriteria {
                                             Property = "Name", Operation = "NotEqual", Value = "c"
                                         } },
                    ReadRecords    = true,
                    ReadTotalCount = true
                };
                Assert.AreEqual("a, b, d, e /4", ReportCommandResult(scope, info, true));
            }
        }
Example #28
0
        public void Ordering()
        {
            using (var scope = TestScope.Create())
            {
                InitializeData(scope);

                var info = new ReadCommandInfo
                {
                    DataSource        = "TestQueryDataStructureCommand.E",
                    OrderByProperties = new[] { new OrderByProperty {
                                                    Property = "Name", Descending = true
                                                } },
                    ReadRecords    = true,
                    ReadTotalCount = true
                };
                Assert.AreEqual("e, d, c, b, a /5", ReportCommandResult(scope, info));
            }
        }
        public void LogCommandDescription()
        {
            var log = new List <string>();

            using (var scope = TestScope.Create(builder => builder
                                                .ConfigureLogMonitor(log)
                                                .ConfigureIgnoreClaims()))
            {
                var processingEngine = scope.Resolve <IProcessingEngine>();
                var readPrincipals   = new ReadCommandInfo
                {
                    DataSource     = "Common.Principal",
                    ReadTotalCount = true,
                    Filters        = new[] { new FilterCriteria {
                                                 Filter = "System.Guid[]", Value = new[] { new Guid("546df18b-5df8-4ffa-9b08-8da909efe067") }
                                             } }
                };
                var processingEngineResult = processingEngine.Execute(new[] { readPrincipals });
                Assert.IsTrue(processingEngineResult.Success);

                var excected = new ListOfTuples <string, IEnumerable <string> >()
                {
                    { "request info", new[] {
                          "ProcessingEngine Request",
                          "ReadCommandInfo Common.Principal count, filters: System.Guid[] \"1 items: 546df18b-5df8-4ffa-9b08-8da909efe067\""
                      } },
                    { "command xml", new[] {
                          "ProcessingEngine Commands", "Common.Principal</DataSource>", "true</ReadTotalCount>"
                      } },
                };

                foreach (var test in excected)
                {
                    Assert.IsTrue(log.Any(line => test.Item2.All(pattern => line.Contains(pattern))), "Missing a log entry for test '" + test.Item1 + "'.");
                }

                var notExpected = new[] { "error info", "CommandsWithClientError", "CommandsWithClientError", "CommandsWithServerError", "CommandsWithServerError" };

                foreach (var test in notExpected)
                {
                    Assert.IsFalse(log.Any(line => line.Contains(test)), "Unexpected log entry for test '" + test + "'.");
                }
            }
        }
        public string CommonLog()
        {
            var readCommand = new ReadCommandInfo()
            {
                DataSource        = "Common.Log",
                ReadRecords       = true,
                OrderByProperties = new [] { new OrderByProperty()
                                             {
                                                 Property = "Created", Descending = true
                                             } },
                Top = 100
            };
            var result = rhetosProcessingEngine.Value.Execute(new List <ICommandInfo>()
            {
                readCommand
            });

            return(JsonConvert.SerializeObject(result, Formatting.Indented));
        }