コード例 #1
0
        public void TestOrderBy()
        {
            E.Test t = Assert.Single(Assert.ScriptCalled(_databaseFixture, Query.Select, () => _queryable.ToList().Where(x => x.Id == 1)));

            Assert.ScriptCalled(_databaseFixture, Query.OrderBy, () =>
                                Assert.Collection(_subQueryable.Where(x => x.Test == t).OrderBy(x => x.Second),
                                                  x => Assert.Equal(10, x.Id),
                                                  x => Assert.Equal(9, x.Id),
                                                  x => Assert.Equal(8, x.Id),
                                                  x => Assert.Equal(7, x.Id),
                                                  x => Assert.Equal(6, x.Id),
                                                  x => Assert.Equal(5, x.Id),
                                                  x => Assert.Equal(4, x.Id),
                                                  x => Assert.Equal(3, x.Id),
                                                  x => Assert.Equal(2, x.Id),
                                                  x => Assert.Equal(1, x.Id)));

            Assert.ScriptCalled(_databaseFixture, Query.OrderByDescending, () =>
                                Assert.Collection(_subQueryable.Where(x => x.Test == t).OrderByDescending(x => x.Second),
                                                  x => Assert.Equal(1, x.Id),
                                                  x => Assert.Equal(2, x.Id),
                                                  x => Assert.Equal(3, x.Id),
                                                  x => Assert.Equal(4, x.Id),
                                                  x => Assert.Equal(5, x.Id),
                                                  x => Assert.Equal(6, x.Id),
                                                  x => Assert.Equal(7, x.Id),
                                                  x => Assert.Equal(8, x.Id),
                                                  x => Assert.Equal(9, x.Id),
                                                  x => Assert.Equal(10, x.Id)));
        }
コード例 #2
0
        public void TestCheckChanged()
        {
            List <string> recordedPropertyChanged = new List <string>();
            List <E.Test> elements = Assert.ScriptCalled(_databaseFixture, Query.Select, () => _queryable.ToList());

            PropertyChangedEventHandler propertyChangedHandler = (s, e) =>
            {
                recordedPropertyChanged.Add(e.PropertyName);
            };

            ((INotifyPropertyChanged)elements[0]).PropertyChanged += propertyChangedHandler;

            try
            {
                string originalDescription = elements[0].Description;
                string newDescription      = elements[0].Description == FirstRandomText ? SecondRandomText : FirstRandomText;

                Assert.False(_queryable.CheckChanged());

                elements[0].Description = newDescription;

                Assert.True(_queryable.CheckChanged());

                elements[0].Description = originalDescription;

                Assert.False(_queryable.CheckChanged());

                elements[0].Description = newDescription;

                Assert.True(_queryable.CheckChanged());

                _queryable.DropChanges();

                Assert.False(_queryable.CheckChanged());


                Assert.Collection(recordedPropertyChanged,
                                  x => Assert.Equal(nameof(E.Test.Description), x),
                                  x => Assert.Equal(nameof(E.Test.Description), x),
                                  x => Assert.Equal(nameof(E.Test.Description), x),
                                  x => Assert.True(string.IsNullOrEmpty(x)),
                                  x => Assert.True(string.IsNullOrEmpty(x)));
            }
            finally
            {
                ((INotifyPropertyChanged)elements[0]).PropertyChanged -= propertyChangedHandler;
            }
        }
コード例 #3
0
        public void TestTake()
        {
            List <E.SubTest> subResult = Assert.ScriptCalled(_databaseFixture, Query.SelectSubTake10, () => _subQueryable.OrderBy(x => x.Id).Take(10).ToList());

            Assert.Collection(subResult,
                              x => Assert.Equal(1, x.Id),
                              x => Assert.Equal(2, x.Id),
                              x => Assert.Equal(3, x.Id),
                              x => Assert.Equal(4, x.Id),
                              x => Assert.Equal(5, x.Id),
                              x => Assert.Equal(6, x.Id),
                              x => Assert.Equal(7, x.Id),
                              x => Assert.Equal(8, x.Id),
                              x => Assert.Equal(9, x.Id),
                              x => Assert.Equal(10, x.Id));
        }
コード例 #4
0
        public void TestSelect()
        {
            List <E.Test> result = Assert.ScriptCalled(_databaseFixture, Query.Select, () => _queryable.ToList()).OrderBy(x => x.Id).ToList();

            E.Test t = result.First();

            IQueryable <E.SubTest> queryable       = _subQueryable.Where(x => x.Test == t);
            IQueryable <string>    selectQueryable = queryable.Select(x => x.Name);

            List <string>    selectResult = selectQueryable.ToList();
            List <E.SubTest> subResult    = queryable.ToList();

            selectResult.Sort();

            Assert.Collection(selectResult,
                              x => Assert.Equal("SubEntity0", x),
                              x => Assert.Equal("SubEntity10", x),
                              x => Assert.Equal("SubEntity12", x),
                              x => Assert.Equal("SubEntity14", x),
                              x => Assert.Equal("SubEntity16", x),
                              x => Assert.Equal("SubEntity18", x),
                              x => Assert.Equal("SubEntity2", x),
                              x => Assert.Equal("SubEntity4", x),
                              x => Assert.Equal("SubEntity6", x),
                              x => Assert.Equal("SubEntity8", x));

            int removeCount = 0;

            NotifyCollectionChangedEventHandler collectionChangedHandler = (s, e) =>
            {
                if (e.Action == NotifyCollectionChangedAction.Remove)
                {
                    removeCount++;
                }
            };

            try
            {
                ((INotifyCollectionChanged)selectQueryable).CollectionChanged += collectionChangedHandler;

                subResult.First().Test = result[1];

                Assert.Equal(1, removeCount);

                selectResult = selectQueryable.ToList();
                selectResult.Sort();

                Assert.Collection(selectResult,
                                  x => Assert.Equal("SubEntity10", x),
                                  x => Assert.Equal("SubEntity12", x),
                                  x => Assert.Equal("SubEntity14", x),
                                  x => Assert.Equal("SubEntity16", x),
                                  x => Assert.Equal("SubEntity18", x),
                                  x => Assert.Equal("SubEntity2", x),
                                  x => Assert.Equal("SubEntity4", x),
                                  x => Assert.Equal("SubEntity6", x),
                                  x => Assert.Equal("SubEntity8", x));

                _subQueryable.DropChanges();
            }
            finally
            {
                ((INotifyCollectionChanged)selectQueryable).CollectionChanged -= collectionChangedHandler;
            }
        }
コード例 #5
0
        public async Task TestBeginFetch()
        {
            int              collectionChangedCounter       = 0;
            List <Query>     hittedCommands                 = new List <Query>();
            ManualResetEvent manualResetEvent               = new ManualResetEvent(false);
            ManualResetEvent manualResetEvent2              = new ManualResetEvent(false);
            EventHandler <HitCommandEventArgs> blockHandler = (s, e) =>
            {
                hittedCommands.Add(e.Key);
                manualResetEvent2.Set();
                manualResetEvent.WaitOne();
            };

            NotifyCollectionChangedEventHandler collectionChangedHandler = (s, e) =>
            {
                lock (this)
                {
                    collectionChangedCounter++;
                }
            };

            IQueryable <E.Test>    testQueryable    = _databaseFixture.ObjectProvider.GetQueryable <E.Test>();
            IQueryable <E.SubTest> subTestQueryable = _databaseFixture.ObjectProvider.GetQueryable <E.SubTest>();


            _databaseFixture.HitCommand += blockHandler;
            try
            {
                ((INotifyCollectionChanged)testQueryable).CollectionChanged    += collectionChangedHandler;
                ((INotifyCollectionChanged)subTestQueryable).CollectionChanged += collectionChangedHandler;

                Task[] tasks = new Task[] {
                    subTestQueryable.FetchAsync(),
                       testQueryable.FetchAsync(),
                       subTestQueryable.FetchAsync()
                };

                manualResetEvent2.WaitOne();
                Assert.Collection(hittedCommands,
                                  x => Assert.Equal(Query.SelectSub, x));

                manualResetEvent.Set();

                await tasks[0];
                await tasks[1];
                await tasks[2];

                Assert.Collection(hittedCommands,
                                  x => Assert.Equal(Query.SelectSub, x),
                                  x => Assert.Equal(Query.Select, x),
                                  x => Assert.Equal(Query.SelectSub, x));

                Assert.InRange(collectionChangedCounter, 20, int.MaxValue);
            }
            finally
            {
                _databaseFixture.HitCommand -= blockHandler;
                ((INotifyCollectionChanged)testQueryable).CollectionChanged    -= collectionChangedHandler;
                ((INotifyCollectionChanged)subTestQueryable).CollectionChanged -= collectionChangedHandler;
            }
        }