EFCore.QueryRepository.Tests Project added.

tests/EFCore.QueryRepository.Tests/DemoDbContext.cs

@@ -30,16 +30,5 @@ public class Employee
 {
     public int Id { get; set; }
 
-    public int DepartmentId { get; set; }
-
-    public string Name { get; set; }
-
-    public Department Department { get; set; }
-}
-
-public class Department
-{
-    public int Id { get; set; }
-
     public string Name { get; set; }
 }

tests/EFCore.QueryRepository.Tests/EFCore.QueryRepository.Tests.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net8.0</TargetFramework>
+    <TargetFramework>net6.0</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
     <IsPackable>false</IsPackable>
     <IsTestProject>true</IsTestProject>

tests/EFCore.QueryRepository.Tests/QueryRepositoryTests.cs

@@ -7,36 +7,16 @@ namespace EFCore.QueryRepository.Tests;
 
 public class QueryRepositoryTests
 {
-    private readonly List<Employee> fakeEmployees = new()
-    {
-        new()
-        {
-            Id = 1,
-            DepartmentId = 1,
-            Name = "Mark",
-            Department = new Department
-            {
-                Id = 1,
-                Name = "IT"
-            }
-        },
-        new()
-        {
-            Id = 2,
-            DepartmentId = 1,
-            Name = "Merry",
-            Department = new Department
-            {
-                Id = 2,
-                Name = "HR"
-            }
-        }
-    };
-
     [Fact]
     public async Task GetListAsyncTest()
     {
         // Arrange
+        var fakeEmployees = new List<Employee>()
+        {
+            new() {Id = 1,Name = "Mark"},
+            new() {Id = 1, Name = "Merry"}
+        };
+
         Mock<DemoDbContext> mockDemoContext = new();
         mockDemoContext.Setup(context => context.Set<Employee>()).ReturnsDbSet(fakeEmployees);
 
@@ -54,6 +34,12 @@ public async Task GetListAsyncTest()
     public async Task GetListAsync_WithCondition_Test()
     {
         // Arrange
+        var fakeEmployees = new List<Employee>()
+        {
+            new() {Id = 1,Name = "Mark"},
+            new() {Id = 2, Name = "Merry"}
+        };
+
         int expectedCount = fakeEmployees.Where(e => e.Id == 1).Count();
         string expectedName = "Mark";
 
@@ -70,21 +56,4 @@ public async Task GetListAsync_WithCondition_Test()
         Assert.True(employees.Count == expectedCount);
         Assert.Equal(expectedName, employees.First().Name);
     }
-
-    [Fact]
-    public async Task GetListAsync_WithInclude_Test()
-    {
-        // Arrange
-        Mock<DemoDbContext> mockDemoContext = new();
-        mockDemoContext.Setup(context => context.Set<Employee>()).ReturnsDbSet(fakeEmployees);
-
-        // Act
-        QueryRepository<DemoDbContext> queryRepository = new(mockDemoContext.Object);
-        List<Employee> employees = await queryRepository.GetListAsync<Employee>(q => q.Include(e => e.Department));
-
-        // Assert
-        Assert.NotNull(employees);
-        Assert.NotEmpty(employees);
-        Assert.True(employees.Count == fakeEmployees.Count);
-    }
 }

tests/EFCore.QueryRepository.Tests/QueryableExtensions.cs

@@ -0,0 +1,62 @@
+using System.Collections;
+using System.Linq.Expressions;
+
+namespace EFCore.QueryRepository.Tests;
+
+public static class QueryableExtensions
+{
+    public static IQueryable<T> AsAsyncQueryable<T>(this IEnumerable<T> input)
+    {
+        return new NotInDbSet<T>(input);
+    }
+}
+
+public class NotInDbSet<T> : IQueryable<T>, IAsyncEnumerable<T>, IEnumerable<T>, IEnumerable
+{
+    private readonly List<T> _innerCollection;
+    public NotInDbSet(IEnumerable<T> innerCollection)
+    {
+        _innerCollection = innerCollection.ToList();
+    }
+
+
+    public IAsyncEnumerator<T> GetAsyncEnumerator(CancellationToken cancellationToken = new CancellationToken())
+    {
+        return new AsyncEnumerator(GetEnumerator());
+    }
+
+    public IEnumerator<T> GetEnumerator()
+    {
+        return _innerCollection.GetEnumerator();
+    }
+
+    IEnumerator IEnumerable.GetEnumerator()
+    {
+        return GetEnumerator();
+    }
+
+    public class AsyncEnumerator : IAsyncEnumerator<T>
+    {
+        private readonly IEnumerator<T> _enumerator;
+        public AsyncEnumerator(IEnumerator<T> enumerator)
+        {
+            _enumerator = enumerator;
+        }
+
+        public ValueTask DisposeAsync()
+        {
+            return new ValueTask();
+        }
+
+        public ValueTask<bool> MoveNextAsync()
+        {
+            return new ValueTask<bool>(_enumerator.MoveNext());
+        }
+
+        public T Current => _enumerator.Current;
+    }
+
+    public Type ElementType => typeof(T);
+    public Expression Expression => Expression.Empty();
+    public IQueryProvider Provider => new EnumerableQuery<T>(Expression);
+}