Made unit tests for get list and removed type for order by

Author: Morten Turn Pedersen

NetCoreEntityFramework.Tests/EntityRepositoryTests.cs

@@ -1,8 +1,11 @@
 using AutoFixture.NUnit3;
 using Microsoft.EntityFrameworkCore;
+using Nodes.NetCore.EntityFramework.Enums;
 using Nodes.NetCore.EntityFramework.Tests.Mocks;
 using NUnit.Framework;
 using System;
+using System.Collections.Generic;
+using System.Linq;
 using System.Threading.Tasks;
 using TestContext = Nodes.NetCore.EntityFramework.Tests.Mocks.TestContext;
 
@@ -14,6 +17,7 @@ public class EntityRepositoryTests
         private TestContext _context;
         private TestEntity _entity;
         private TestEntity _deletedEntity;
+        private IEnumerable<TestEntity> _listEntities;
 
         [SetUp]
         public void Setup()
@@ -50,6 +54,9 @@ public void Setup()
             _context.Table.Add(_entity);
             _context.Table.Add(_deletedEntity);
 
+            _listEntities = GetTestList();
+            _context.Table.AddRange(_listEntities);
+
             _context.SaveChanges();
 
             _repository = new TestEntityRepository(_context);
@@ -99,6 +106,129 @@ public void AddThrowsExceptionIfEntityIsNull()
         }
         #endregion
 
+        #region List
+        [Test]
+        public async Task GetListReturnsAllNotDeleted()
+        {
+            var entities = await _repository.GetList();
+
+            Assert.AreEqual(_listEntities.Count() + 1, entities.Count());
+        }
+
+        [Test]
+        public async Task GetListReturnsAll()
+        {
+            var entities = await _repository.GetList(null, null, OrderBy.Ascending, GetListMode.IncludeDeleted);
+
+            Assert.AreEqual(_listEntities.Count() + 2, entities.Count());
+        }
+
+        [Test]
+        public async Task GetListReturnsAllDeleted()
+        {
+            var entities = await _repository.GetList(null, null, OrderBy.Ascending, GetListMode.OnlyDeleted);
+
+            Assert.AreEqual(1, entities.Count());
+        }
+
+        [Test]
+        public async Task GetListWhere()
+        {
+            var entities = await _repository.GetList(x => x.Property == "b");
+
+            Assert.AreEqual(1, entities.Count());
+            Assert.AreSame(_listEntities.First(x => x.Property == "b"), entities.ElementAt(0));
+        }
+
+        [Test]
+        public async Task GetListOrderBy()
+        {
+            var entities = await _repository.GetList(x => x.Property.Length == 1, x => x.Property);
+
+            Assert.AreEqual(_listEntities.Count(), entities.Count());
+            Assert.AreSame(_listEntities.First(x => x.Property == "a"), entities.ElementAt(0));
+            Assert.AreSame(_listEntities.First(x => x.Property == "b"), entities.ElementAt(1));
+            Assert.AreSame(_listEntities.First(x => x.Property == "c"), entities.ElementAt(2));
+            Assert.AreSame(_listEntities.First(x => x.Property == "d"), entities.ElementAt(3));
+            Assert.AreSame(_listEntities.First(x => x.Property == "e"), entities.ElementAt(4));
+            Assert.AreSame(_listEntities.First(x => x.Property == "f"), entities.ElementAt(5));
+            Assert.AreSame(_listEntities.First(x => x.Property == "g"), entities.ElementAt(6));
+            Assert.AreSame(_listEntities.First(x => x.Property == "h"), entities.ElementAt(7));
+            Assert.AreSame(_listEntities.First(x => x.Property == "i"), entities.ElementAt(8));
+            Assert.AreSame(_listEntities.First(x => x.Property == "j"), entities.ElementAt(9));
+            Assert.AreSame(_listEntities.First(x => x.Property == "k"), entities.ElementAt(10));
+            Assert.AreSame(_listEntities.First(x => x.Property == "l"), entities.ElementAt(11));
+            Assert.AreSame(_listEntities.First(x => x.Property == "m"), entities.ElementAt(12));
+            Assert.AreSame(_listEntities.First(x => x.Property == "n"), entities.ElementAt(13));
+        }
+
+        [Test]
+        public async Task GetListOrderByDescending()
+        {
+            var entities = await _repository.GetList(x => x.Property.Length == 1, x => x.Property, OrderBy.Descending);
+
+            Assert.AreEqual(_listEntities.Count(), entities.Count());
+            Assert.AreSame(_listEntities.First(x => x.Property == "n"), entities.ElementAt(0));
+            Assert.AreSame(_listEntities.First(x => x.Property == "m"), entities.ElementAt(1));
+            Assert.AreSame(_listEntities.First(x => x.Property == "l"), entities.ElementAt(2));
+            Assert.AreSame(_listEntities.First(x => x.Property == "k"), entities.ElementAt(3));
+            Assert.AreSame(_listEntities.First(x => x.Property == "j"), entities.ElementAt(4));
+            Assert.AreSame(_listEntities.First(x => x.Property == "i"), entities.ElementAt(5));
+            Assert.AreSame(_listEntities.First(x => x.Property == "h"), entities.ElementAt(6));
+            Assert.AreSame(_listEntities.First(x => x.Property == "g"), entities.ElementAt(7));
+            Assert.AreSame(_listEntities.First(x => x.Property == "f"), entities.ElementAt(8));
+            Assert.AreSame(_listEntities.First(x => x.Property == "e"), entities.ElementAt(9));
+            Assert.AreSame(_listEntities.First(x => x.Property == "d"), entities.ElementAt(10));
+            Assert.AreSame(_listEntities.First(x => x.Property == "c"), entities.ElementAt(11));
+            Assert.AreSame(_listEntities.First(x => x.Property == "b"), entities.ElementAt(12));
+            Assert.AreSame(_listEntities.First(x => x.Property == "a"), entities.ElementAt(13));
+        }
+
+        [Test]
+        public async Task GetListPaginated()
+        {
+            const int pageSize = 6;
+
+            var entities = await _repository.GetList(1, pageSize);
+            var entitiesLastPage = await _repository.GetList(3, pageSize);
+
+            Assert.AreEqual(pageSize, entities.Count());
+            Assert.AreEqual(3, entitiesLastPage.Count());
+        }
+
+        private IEnumerable<TestEntity> GetTestList()
+        {
+            return new List<TestEntity>
+            {
+                GetTestEntity("a"),
+                GetTestEntity("b"),
+                GetTestEntity("c"),
+                GetTestEntity("d"),
+                GetTestEntity("e"),
+                GetTestEntity("f"),
+                GetTestEntity("g"),
+                GetTestEntity("h"),
+                GetTestEntity("i"),
+                GetTestEntity("j"),
+                GetTestEntity("k"),
+                GetTestEntity("l"),
+                GetTestEntity("m"),
+                GetTestEntity("n")
+            };
+        }
+
+        private TestEntity GetTestEntity(string property)
+        {
+            return new TestEntity
+            {
+                Id = Guid.NewGuid(),
+                Created = DateTime.UtcNow,
+                Updated = DateTime.UtcNow,
+                Property = property
+            };
+        }
+        #endregion
+
         #region Get
         [Test]
         public async Task GetValidEntityReturnsEntity()

NetCoreEntityFramework/NetCoreEntityFramework.csproj

@@ -3,7 +3,7 @@
   <PropertyGroup>
     <TargetFramework>netstandard2.0</TargetFramework>
     <PackageId>Nodes.NetCore.EntityFramework.Helpers</PackageId>
-    <Version>1.0.0</Version>
+    <Version>1.1.0</Version>
     <Authors>Nodes</Authors>
     <Company>Nodes</Company>
     <Product>.NET Core Entity Framework Helpers</Product>

NetCoreEntityFramework/Repositories/EntityRepository.cs

@@ -41,11 +41,11 @@ public async Task<TEntity> Get(Guid id, bool includeDeleted = false)
         /// <param name="orderBy">To order by ascending or descending.</param>
         /// <param name="mode">Whether to include deleted or not.</param>
         /// <exception cref="ArgumentException"></exception>
-        public async Task<IEnumerable<TEntity>> GetList<TKey>(
+        public async Task<IEnumerable<TEntity>> GetList(
             [Range(1, int.MaxValue)] int page,
             [Range(1, int.MaxValue)] int pageSize,
             Expression<Func<TEntity, bool>> where = null,
-            Expression<Func<TEntity, TKey>> orderByExpression = null,
+            Expression<Func<TEntity, object>> orderByExpression = null,
             OrderBy orderBy = OrderBy.Ascending,
             GetListMode mode = GetListMode.ExcludeDeleted)
         {
@@ -73,9 +73,9 @@ public async Task<IEnumerable<TEntity>> GetList<TKey>(
         /// <param name="orderBy">To order by ascending or descending.</param>
         /// <param name="mode">Whether to include deleted or not.</param>
         /// <exception cref="ArgumentException"></exception>
-        public async Task<IEnumerable<TEntity>> GetList<TKey>(
+        public async Task<IEnumerable<TEntity>> GetList(
             Expression<Func<TEntity, bool>> where = null,
-            Expression<Func<TEntity, TKey>> orderByExpression = null,
+            Expression<Func<TEntity, object>> orderByExpression = null,
             OrderBy orderBy = OrderBy.Ascending,
             GetListMode mode = GetListMode.ExcludeDeleted)
         {
@@ -201,9 +201,9 @@ public void Dispose()
             Context.SaveChanges();
         }
 
-        private IQueryable<TEntity> GetQueryable<TKey>(
+        private IQueryable<TEntity> GetQueryable(
             Expression<Func<TEntity, bool>> where = null,
-            Expression<Func<TEntity, TKey>> orderByExpression = null,
+            Expression<Func<TEntity, object>> orderByExpression = null,
             OrderBy orderBy = OrderBy.Ascending,
             GetListMode mode = GetListMode.ExcludeDeleted)
         {