Example #1
0
        public void Nested()
        {
            IndexManager.PurgeIndexes();
            var expected = new List <SampleNest>
            {
                new SampleNest
                {
                    Id    = "1",
                    Title = "Nested Test",
                    Items = new List <NestedEntity>
                    {
                        new NestedEntity
                        {
                            Created = new DateTime(2019, 3, 7),
                            Code    = 3,
                            Data    = "item"
                        }
                    }
                }
            };

            IndexManager.BulkInsert(expected);
            var searchData = new FindRequest <SampleNest>(0, 10);
            var results    = searchData
                             .Must(SearchClause <SampleNest> .Range(x => x.Items, new DateTime(2019, 2, 7), new DateTime(2019, 6, 1), x => x.Items[0].Created))
                             .Must(SearchClause <SampleNest> .Range(x => x.Items, 2, 5, x => x.Items[0].Code))
                             .Must(SearchClause <SampleNest> .Term(x => x.Items, "item", x => x.Items[0].Data))
                             .Execute();
            var actual = results.Documents.ToList();

            Assert.Equal(expected.Count, actual.Count);
        }
Example #2
0
        public void InRange()
        {
            IndexManager.PurgeIndexes();
            var expected = new List <SampleWeight>
            {
                new SampleWeight
                {//0
                    Weight = 100
                },
                new SampleWeight
                {//1
                    Weight = 110
                },
                new SampleWeight
                {//2
                    Weight = 120
                },
                new SampleWeight
                {//3
                    Weight = 130
                },
                new SampleWeight
                {//4
                    Weight = 200
                },
                new SampleWeight
                {//5
                    Weight = 210
                },
                new SampleWeight
                {//6
                    Weight = 220
                },
                new SampleWeight
                {//7
                    Weight = 230
                },
            };

            IndexManager.BulkInsert(expected);
            var searchData = new FindRequest <SampleWeight>(0, 10);
            var results    = searchData
                             .Should(SearchClause <SampleWeight> .Range(x => x.Weight, 119, 201))
                             .Sort(x => x.Weight)
                             .Execute();
            var actual = results.Documents.ToList();

            //range
            Assert.Equal(3, actual.Count);
            Assert.Equal(expected[2].Weight, actual[0].Weight);
            Assert.Equal(expected[3].Weight, actual[1].Weight);
            Assert.Equal(expected[4].Weight, actual[2].Weight);
        }
Example #3
0
        public void DateRange()
        {
            IndexManager.PurgeIndexes();
            var expected = new List <SampleDate>
            {
                new SampleDate
                {//0
                    DocDate = new DateTime(2019, 1, 1)
                },
                new SampleDate
                {//1
                    DocDate = new DateTime(2019, 2, 1)
                },
                new SampleDate
                {//2
                    DocDate = new DateTime(2019, 3, 7)
                },
                new SampleDate
                {//3
                    DocDate = new DateTime(2019, 4, 7)
                },
                new SampleDate
                {//4
                    DocDate = new DateTime(2019, 5, 7)
                },
                new SampleDate
                {//5
                    DocDate = new DateTime(2019, 6, 7)
                }
            };

            IndexManager.BulkInsert(expected);
            var searchData = new FindRequest <SampleDate>(0, 10);
            var results    = searchData
                             .Should(SearchClause <SampleDate> .Range(x => x.DocDate, new DateTime(2019, 2, 7), new DateTime(2019, 6, 1)))
                             .Sort(x => x.DocDate)
                             .Execute();
            var actual = results.Documents.ToList();

            //range
            Assert.Equal(3, actual.Count);
            Assert.Equal(expected[2].DocDate, actual[0].DocDate);
            Assert.Equal(expected[3].DocDate, actual[1].DocDate);
            Assert.Equal(expected[4].DocDate, actual[2].DocDate);
        }