Code cleanup

Added async enumerable tests
Test entity changes applied

src/EntityFrameworkCore.DefaultBehaviour.Tests/ByTypeDbQueryTests.cs

@@ -1,4 +1,5 @@
 using System;
+using System.ComponentModel;
 using System.Linq;
 using EntityFrameworkCore.Testing.Common.Tests;
 using Microsoft.EntityFrameworkCore;
@@ -16,6 +17,8 @@ public class ByTypeDbQueryTests : BaseForTests
         [SetUp]
         public override void SetUp()
         {
+            base.SetUp();
+
             DbContext = new TestDbContext(new DbContextOptionsBuilder<TestDbContext>().UseInMemoryDatabase(Guid.NewGuid().ToString()).Options);
         }
 
@@ -34,5 +37,12 @@ public virtual void AsQueryable_ReturnsQueryable()
 
             Assert.That(queryable, Is.Not.Null);
         }
+
+        [Test]
+        public void ContainsListCollection_ReturnsFalse()
+        {
+            var containsListCollection = ((IListSource) DbQuery).ContainsListCollection;
+            Assert.That(containsListCollection, Is.False);
+        }
     }
 }

src/EntityFrameworkCore.Testing.Common.Tests/AsyncEnumerableTests.cs

@@ -0,0 +1,30 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using AutoFixture;
+using NUnit.Framework;
+
+namespace EntityFrameworkCore.Testing.Common.Tests
+{
+    public class AsyncEnumerableTests : BaseForQueryableTests<TestEntity>
+    {
+        private IQueryable<TestEntity> _source;
+
+        protected override IQueryable<TestEntity> Queryable => _source;
+
+        [SetUp]
+        public override void SetUp()
+        {
+            base.SetUp();
+
+            _source = new AsyncEnumerable<TestEntity>(new List<TestEntity>());
+        }
+
+        protected override void SeedQueryableSource()
+        {
+            var itemsToAdd = Fixture.Build<TestEntity>().With(p => p.CreatedAt, DateTime.Today).With(p => p.LastModifiedAt, DateTime.Today).CreateMany().ToList();
+            _source = new AsyncEnumerable<TestEntity>(itemsToAdd);
+            ItemsAddedToQueryableSource = itemsToAdd;
+        }
+    }
+}

src/EntityFrameworkCore.Testing.Common.Tests/BaseForDbContextTests.cs

@@ -5,7 +5,6 @@
 using System.Threading.Tasks;
 using AutoFixture;
 using Microsoft.EntityFrameworkCore;
-using Microsoft.Extensions.Logging;
 using NUnit.Framework;
 
 namespace EntityFrameworkCore.Testing.Common.Tests
@@ -404,5 +403,14 @@ public void Set_TypeNotIncludedInModel_ThrowsException()
                 Assert.That(ex.Message, Is.EqualTo(string.Format(ExceptionMessages.CannotCreateDbSetTypeNotIncludedInModel, nameof(NotRegisteredEntity))));
             });
         }
+
+        [Test]
+        public virtual void SetCommandTimeout_ValidTimeout_DoesNotThrowException()
+        {
+            Assert.DoesNotThrow(() =>
+            {
+                MockedDbContext.Database.SetCommandTimeout(60);
+            });
+        }
     }
 }

src/EntityFrameworkCore.Testing.Common.Tests/BaseForDbQueryTests.cs

@@ -2,35 +2,36 @@
 using System.Collections.Generic;
 using System.Data.SqlClient;
 using System.Linq;
+using System.Threading.Tasks;
 using AutoFixture;
 using Microsoft.EntityFrameworkCore;
-using Microsoft.Extensions.Logging;
+using Microsoft.EntityFrameworkCore.Extensions.Internal;
 using NUnit.Framework;
 
 namespace EntityFrameworkCore.Testing.Common.Tests
 {
-    public abstract class BaseForDbQueryTests<TQuery> : BaseForMockedQueryableTests<TQuery> where TQuery : BaseTestEntity
+    public abstract class BaseForDbQueryTests<TEntity> : BaseForMockedQueryableTests<TEntity> where TEntity : BaseTestEntity
     {
+        protected DbQuery<TEntity> DbQuery => (DbQuery<TEntity>) Queryable;
+
         protected override void SeedQueryableSource()
         {
-            var itemsToAdd = Fixture.Build<TQuery>().With(p => p.FixedDateTime, DateTime.Parse("2019-01-01")).CreateMany().ToList();
+            var itemsToAdd = Fixture.Build<TEntity>().With(p => p.CreatedAt, DateTime.Parse("2019-01-01")).CreateMany().ToList();
             AddRangeToReadOnlySource(DbQuery, itemsToAdd);
             //MockedDbContext.SaveChanges();
             ItemsAddedToQueryableSource = itemsToAdd;
         }
 
-        protected DbQuery<TQuery> DbQuery => (DbQuery<TQuery>) Queryable;
-
-        protected abstract void AddToReadOnlySource(DbQuery<TQuery> mockedDbQuery, TQuery item);
+        protected abstract void AddToReadOnlySource(DbQuery<TEntity> mockedDbQuery, TEntity item);
 
-        protected abstract void AddRangeToReadOnlySource(DbQuery<TQuery> mockedDbQuery, IEnumerable<TQuery> items);
+        protected abstract void AddRangeToReadOnlySource(DbQuery<TEntity> mockedDbQuery, IEnumerable<TEntity> items);
 
-        protected abstract void ClearReadOnlySource(DbQuery<TQuery> mockedDbQuery);
+        protected abstract void ClearReadOnlySource(DbQuery<TEntity> mockedDbQuery);
 
         [Test]
         public virtual void AddRangeToReadOnlySource_Items_AddsItemsToReadOnlySource()
         {
-            var expectedResult = Fixture.CreateMany<TQuery>().ToList();
+            var expectedResult = Fixture.CreateMany<TEntity>().ToList();
 
             AddRangeToReadOnlySource(DbQuery, expectedResult);
 
@@ -40,7 +41,7 @@ public virtual void AddRangeToReadOnlySource_Items_AddsItemsToReadOnlySource()
         [Test]
         public virtual void AddRangeToReadOnlySourceThenAddRangeToReadOnlySource_Items_AddsAllItemsToReadOnlySource()
         {
-            var expectedResult = Fixture.CreateMany<TQuery>(4).ToList();
+            var expectedResult = Fixture.CreateMany<TEntity>(4).ToList();
 
             AddRangeToReadOnlySource(DbQuery, expectedResult.Take(2));
             AddRangeToReadOnlySource(DbQuery, expectedResult.Skip(2));
@@ -51,7 +52,7 @@ public virtual void AddRangeToReadOnlySourceThenAddRangeToReadOnlySource_Items_A
         [Test]
         public virtual void AddToReadOnlySource_Item_AddsItemToReadOnlySource()
         {
-            var expectedResult = Fixture.Create<TQuery>();
+            var expectedResult = Fixture.Create<TEntity>();
 
             AddToReadOnlySource(DbQuery, expectedResult);
             var numberOfItemsAdded = DbQuery.ToList().Count;
@@ -62,7 +63,7 @@ public virtual void AddToReadOnlySource_Item_AddsItemToReadOnlySource()
         [Test]
         public virtual void AddToReadOnlySourceThenAddToReadOnlySource_Items_AddsBothItemsToReadOnlySource()
         {
-            var expectedResult = Fixture.CreateMany<TQuery>(2).ToList();
+            var expectedResult = Fixture.CreateMany<TEntity>(2).ToList();
 
             AddToReadOnlySource(DbQuery, expectedResult.First());
             AddToReadOnlySource(DbQuery, expectedResult.Last());
@@ -74,7 +75,7 @@ public virtual void AddToReadOnlySourceThenAddToReadOnlySource_Items_AddsBothIte
         public virtual void AnyThenAddToReadOnlySourceThenAny_ReturnsFalseThenTrue()
         {
             var actualResult1 = DbQuery.Any();
-            AddToReadOnlySource(DbQuery, Fixture.Create<TQuery>());
+            AddToReadOnlySource(DbQuery, Fixture.Create<TEntity>());
             var actualResult2 = DbQuery.Any();
 
             Assert.Multiple(() =>
@@ -84,6 +85,42 @@ public virtual void AnyThenAddToReadOnlySourceThenAny_ReturnsFalseThenTrue()
             });
         }
 
+        [Test]
+        public virtual async Task AsAsyncEnumerable_ReturnsAsyncEnumerable()
+        {
+            var expectedResult = Fixture.Create<TEntity>();
+            AddToReadOnlySource(DbQuery, expectedResult);
+
+            var asyncEnumerable = await DbQuery.AsAsyncEnumerable().ToList();
+
+            var actualResults = new List<TEntity>();
+            foreach (var item in asyncEnumerable)
+            {
+                actualResults.Add(item);
+            }
+
+            Assert.Multiple(() =>
+            {
+                Assert.That(actualResults.Single(), Is.EqualTo(expectedResult));
+                Assert.That(actualResults.Single(), Is.EqualTo(expectedResult));
+            });
+        }
+
+        [Test]
+        public virtual void AsQueryable_ReturnsQueryable()
+        {
+            var expectedResult = Fixture.Create<TEntity>();
+            AddToReadOnlySource(DbQuery, expectedResult);
+
+            var queryable = DbQuery.AsQueryable();
+
+            Assert.Multiple(() =>
+            {
+                Assert.That(queryable.Single(), Is.EqualTo(expectedResult));
+                Assert.That(queryable.Single(), Is.EqualTo(expectedResult));
+            });
+        }
+
         [Test]
         public virtual void ClearReadOnlySource_WithNoItemsAddedToReadOnlySource_DoesNothing()
         {
@@ -102,7 +139,7 @@ public virtual void ClearReadOnlySource_WithNoItemsAddedToReadOnlySource_DoesNot
         [Test]
         public virtual void ClearReadOnlySourceWithExistingItems_RemovesAllItemsFromReadOnlySource()
         {
-            var expectedResult = Fixture.CreateMany<TQuery>().ToList();
+            var expectedResult = Fixture.CreateMany<TEntity>().ToList();
             AddRangeToReadOnlySource(DbQuery, expectedResult);
             var numberOfItemsAdded = DbQuery.ToList().Count;
 
@@ -119,16 +156,16 @@ public virtual void ClearReadOnlySourceWithExistingItems_RemovesAllItemsFromRead
         public override void FromSql_QueryProviderWithManyFromSqlResults_ReturnsExpectedResults()
         {
             var sql1 = "sp_NoParams";
-            var expectedResult1 = Fixture.CreateMany<TQuery>().ToList();
+            var expectedResult1 = Fixture.CreateMany<TEntity>().ToList();
 
             var sql2 = "sp_WithParams";
             var parameters2 = new List<SqlParameter> { new SqlParameter("@SomeParameter1", "Value1"), new SqlParameter("@SomeParameter2", "Value2") };
-            var expectedResult2 = Fixture.CreateMany<TQuery>().ToList();
+            var expectedResult2 = Fixture.CreateMany<TEntity>().ToList();
 
             AddFromSqlResult(DbQuery, sql1, expectedResult1);
 
             //Change the source, this will force the query provider mock to aggregate
-            AddRangeToReadOnlySource(DbQuery, Fixture.CreateMany<TQuery>().ToList());
+            AddRangeToReadOnlySource(DbQuery, Fixture.CreateMany<TEntity>().ToList());
 
             AddFromSqlResult(DbQuery, sql2, parameters2, expectedResult2);
 

src/EntityFrameworkCore.Testing.Common.Tests/BaseForDbSetTests.cs

@@ -1,16 +1,22 @@
 using System;
 using System.Collections.Generic;
+using System.ComponentModel;
 using System.Linq;
 using System.Threading.Tasks;
 using AutoFixture;
 using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Extensions.Internal;
 using NUnit.Framework;
 
 namespace EntityFrameworkCore.Testing.Common.Tests
 {
     public abstract class BaseForDbSetTests<TDbContext, TEntity> : BaseForMockedQueryableTests<TEntity> where TDbContext : DbContext
         where TEntity : BaseTestEntity
     {
+        protected TDbContext MockedDbContext;
+
+        protected DbSet<TEntity> DbSet => (DbSet<TEntity>) Queryable;
+
         [SetUp]
         public override void SetUp()
         {
@@ -21,16 +27,12 @@ public override void SetUp()
 
         protected override void SeedQueryableSource()
         {
-            var itemsToAdd = Fixture.Build<TEntity>().With(p => p.FixedDateTime, DateTime.Parse("2019-01-01")).CreateMany().ToList();
+            var itemsToAdd = Fixture.Build<TEntity>().With(p => p.CreatedAt, DateTime.Parse("2019-01-01")).CreateMany().ToList();
             DbSet.AddRange(itemsToAdd);
             MockedDbContext.SaveChanges();
             ItemsAddedToQueryableSource = itemsToAdd;
         }
 
-        protected TDbContext MockedDbContext;
-
-        protected DbSet<TEntity> DbSet => (DbSet<TEntity>) Queryable;
-
         protected abstract TDbContext CreateMockedDbContext();
 
         [Test]
@@ -142,5 +144,50 @@ public virtual void AnyThenAddThenPersistThenAny_ReturnsFalseThenTrue()
                 Assert.That(actualResult2, Is.True);
             });
         }
+
+        [Test]
+        public virtual async Task AsAsyncEnumerable_ReturnsAsyncEnumerable()
+        {
+            var expectedResult = Fixture.Create<TEntity>();
+            DbSet.Add(expectedResult);
+            MockedDbContext.SaveChanges();
+
+            var asyncEnumerable = await DbSet.AsAsyncEnumerable().ToList();
+
+            var actualResults = new List<TEntity>();
+            foreach (var item in asyncEnumerable)
+            {
+                actualResults.Add(item);
+            }
+
+            Assert.Multiple(() =>
+            {
+                Assert.That(actualResults.Single(), Is.EqualTo(expectedResult));
+                Assert.That(actualResults.Single(), Is.EqualTo(expectedResult));
+            });
+        }
+
+        [Test]
+        public virtual void AsQueryable_ReturnsQueryable()
+        {
+            var expectedResult = Fixture.Create<TEntity>();
+            DbSet.Add(expectedResult);
+            MockedDbContext.SaveChanges();
+
+            var queryable = DbSet.AsQueryable();
+
+            Assert.Multiple(() =>
+            {
+                Assert.That(queryable.Single(), Is.EqualTo(expectedResult));
+                Assert.That(queryable.Single(), Is.EqualTo(expectedResult));
+            });
+        }
+
+        [Test]
+        public void ContainsListCollection_ReturnsFalse()
+        {
+            var containsListCollection = ((IListSource) Queryable).ContainsListCollection;
+            Assert.That(containsListCollection, Is.False);
+        }
     }
 }

src/EntityFrameworkCore.Testing.Common.Tests/BaseForMockedQueryableTests.cs

@@ -5,7 +5,6 @@
 using System.Threading.Tasks;
 using AutoFixture;
 using Microsoft.EntityFrameworkCore;
-using Microsoft.Extensions.Logging;
 using NUnit.Framework;
 
 namespace EntityFrameworkCore.Testing.Common.Tests