Merge c3428cc into ce0b247

Author: tmacharia

Paginator.EntityFrameworkCore.csproj

@@ -13,16 +13,22 @@
 	  <RepositoryUrl>https://github.com/tmacharia/paginator.efcore</RepositoryUrl>
 	  <PackageTags>linq, pagination, paginator, paging, efcore</PackageTags>
 	  <PackageId>Paginator.EntityFrameworkCore</PackageId>
-	  <Version>3.1.5-rc</Version>
+	  <Version>3.1.15</Version>
 	  <NeutralLanguage>en</NeutralLanguage>
 	  <PackageLicenseUrl></PackageLicenseUrl>
 	  <RepositoryType>git</RepositoryType>
 	  <PackageLicenseFile>LICENSE</PackageLicenseFile>
 	  <GenerateDocumentationFile>true</GenerateDocumentationFile>
 	  <Description>
-		  Asynchronous pagination of queries to your data store using EntityFrameworkCore.
+		  Asynchronous &amp; Synchronous pagination of queries to your data store using EntityFrameworkCore. With the help of some simple to use extension methods, querying portions/chunks of data just gets easier.
 	  </Description>
   </PropertyGroup>
+
+  <ItemGroup>
+    <Compile Remove="tests\**" />
+    <EmbeddedResource Remove="tests\**" />
+    <None Remove="tests\**" />
+  </ItemGroup>
 
   <ItemGroup>
     <None Include=".\LICENSE">

Paginator.EntityFrameworkCore.sln

@@ -3,7 +3,9 @@ Microsoft Visual Studio Solution File, Format Version 12.00
 # Visual Studio Version 16
 VisualStudioVersion = 16.0.31004.235
 MinimumVisualStudioVersion = 10.0.40219.1
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Paginator.EntityFrameworkCore", "Paginator.EntityFrameworkCore.csproj", "{2642CB54-145C-4403-92ED-13B000A78E4E}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Paginator.EntityFrameworkCore", "Paginator.EntityFrameworkCore.csproj", "{2642CB54-145C-4403-92ED-13B000A78E4E}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "tests", "tests\tests.csproj", "{96E4E2AA-FD17-498F-A62C-3F6ACA3B00DF}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
@@ -15,6 +17,10 @@ Global
 		{2642CB54-145C-4403-92ED-13B000A78E4E}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{2642CB54-145C-4403-92ED-13B000A78E4E}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{2642CB54-145C-4403-92ED-13B000A78E4E}.Release|Any CPU.Build.0 = Release|Any CPU
+		{96E4E2AA-FD17-498F-A62C-3F6ACA3B00DF}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{96E4E2AA-FD17-498F-A62C-3F6ACA3B00DF}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{96E4E2AA-FD17-498F-A62C-3F6ACA3B00DF}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{96E4E2AA-FD17-498F-A62C-3F6ACA3B00DF}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

Paginator.cs

@@ -26,6 +26,8 @@ public static class Paginator
         /// <param name="skipCount">Specify whether to omit running a count operation on your query againt the data store.</param>
         /// <param name="token">Cancellation token.</param>
         /// <returns>A task that represents the asynchronous operation which you can await.</returns>
+        /// <exception cref="ArgumentException"/>
+        /// <exception cref="ArgumentNullException"/>
         /// <exception cref="OperationCanceledException"/>
         public static Task<PagedResult<TEntity>> PaginateAsync<TEntity>(this IQueryable<TEntity> query,
             int page = DEF_PAGE, int perpage = DEF_PERPAGE, bool skipCount = DEF_SKIPCOUNT, CancellationToken token = default)
@@ -40,7 +42,8 @@ public static Task<PagedResult<TEntity>> PaginateAsync<TEntity>(this IQueryable<
         /// <param name="perpage">Items per page.</param>
         /// <param name="skipCount">Specify whether to omit running a count operation on your query againt the data store.</param>
         /// <returns>A <see cref="PagedResult{TEntity}"/> response object.</returns>
-        /// <exception cref="OperationCanceledException"/>
+        /// <exception cref="ArgumentException"/>
+        /// <exception cref="ArgumentNullException"/>
         public static PagedResult<TEntity> Paginate<TEntity>(this IQueryable<TEntity> query,
             int page = DEF_PAGE, int perpage = DEF_PERPAGE, bool skipCount = DEF_SKIPCOUNT)
             where TEntity : class
@@ -49,6 +52,8 @@ public static PagedResult<TEntity> Paginate<TEntity>(this IQueryable<TEntity> qu
         internal static async Task<PagedResult<TEntity>> ProcessPaginationAsync<TEntity>(this IQueryable<TEntity> query,
                     int page = DEF_PAGE, int perpage = DEF_PERPAGE, bool skipCount = DEF_SKIPCOUNT, CancellationToken token = default)
         {
+            ValidateParams_IfInvalid_Throw(page, perpage);
+
             int total = 0;
             var list = new List<TEntity>();
 
@@ -75,6 +80,8 @@ internal static async Task<PagedResult<TEntity>> ProcessPaginationAsync<TEntity>
         internal static PagedResult<TEntity> ProcessPagination<TEntity>(this IQueryable<TEntity> query,
                     int page = DEF_PAGE, int perpage = DEF_PERPAGE, bool skipCount = DEF_SKIPCOUNT)
         {
+            ValidateParams_IfInvalid_Throw(page, perpage);
+
             int total = 0;
             var list = new List<TEntity>();
 
@@ -96,6 +103,17 @@ internal static PagedResult<TEntity> ProcessPagination<TEntity>(this IQueryable<
                 Items = list
             };
         }
+
+        internal static void ValidateParams_IfInvalid_Throw(int page, int perpage)
+        {
+            if (page <= 0)
+                throw new ArgumentException("Page parameter must be greater than zero.", nameof(page));
+
+            if (perpage < 0)
+                throw new ArgumentException("Per-page parameter must be 0 or greater than 0.", nameof(perpage));
+
+            return;
+        }
         internal static Task<int> CountEntitiesAsync<TEntity>(this IQueryable<TEntity> query, CancellationToken token = default)
         {
             return query.CountAsync(token);
@@ -107,7 +125,6 @@ internal static int CalculateTotalPages(int totalItems, int perpage)
             {
                 ans = totalItems / perpage;
                 ans += (totalItems % perpage) > 0 ? 1 : 0;
-                return ans;
             }
             return ans;
         }

tests/TestBaseContext.cs

@@ -0,0 +1,42 @@
+using Microsoft.EntityFrameworkCore;
+
+namespace tests
+{
+    internal class TestBaseContext
+    {
+        private TestDbContext _context;
+        private DbContextOptions<TestDbContext> DbContextOptions;
+
+        public TestBaseContext()
+        { }
+
+        protected TestDbContext Context
+        {
+            get
+            {
+                if (_context == null)
+                {
+                    DbContextOptions = new DbContextOptionsBuilder<TestDbContext>()
+                        .UseInMemoryDatabase(databaseName: "test_db")
+                        .EnableServiceProviderCaching(true)
+                        .EnableSensitiveDataLogging(true)
+                        .UseQueryTrackingBehavior(QueryTrackingBehavior.TrackAll)
+                        .Options;
+                    _context = new TestDbContext(DbContextOptions);
+                }
+                return _context;
+            }
+        }
+
+
+        internal T Add<T>(T obj, bool save = true)
+            where T : class
+        {
+            obj = Context.Add(obj).Entity;
+            if (save)
+                Save();
+            return obj;
+        }
+        protected void Save() => Context.SaveChanges();
+    }
+}

tests/TestDbContext.cs

@@ -0,0 +1,17 @@
+using Microsoft.EntityFrameworkCore;
+
+namespace tests
+{
+    internal class TestDbContext : DbContext
+    {
+        public TestDbContext(DbContextOptions<TestDbContext> options)
+            :base(options)
+        { }
+
+        public DbSet<Car> Cars { get; set; }
+    }
+    internal class Car
+    {
+        public int Id { get; set; }
+    }
+}

tests/UnitTests.cs

@@ -0,0 +1,119 @@
+using System.Linq;
+using Paginator.EntityFrameworkCore;
+using NUnit.Framework;
+using System;
+using System.Threading.Tasks;
+using System.Threading;
+
+namespace tests
+{
+    internal class UnitTests : TestBaseContext
+    {
+        [SetUp]
+        public void Setup()
+        {
+        }
+
+        #region Synchronous
+        [Test]
+        [Order(0)]
+        public void Pg_Empty()
+        {
+            var list = Context.Cars.Paginate(1, 10);
+            Assert.IsNotNull(list);
+            Assert.Zero(list.TotalItems);
+        }
+        [Test]
+        [Order(1)]
+        public void Pg_With_Items()
+        {
+            Add(new Car());
+            Add(new Car());
+            Add(new Car());
+            Add(new Car());
+
+            var list = Context.Cars.Paginate(1, 2);
+            Assert.IsNotNull(list);
+            Assert.AreEqual(4, list.TotalItems);
+            Assert.AreEqual(2, list.TotalPages);
+        }
+        [Test]
+        [Order(2)]
+        public void Pg_Skip_Count()
+        {
+            Add(new Car());
+            Add(new Car());
+            Add(new Car());
+            Add(new Car());
+
+            var list = Context.Cars.Paginate(1, 2, true);
+            Assert.IsNotNull(list);
+            Assert.AreEqual(2, list.TotalItems);
+            Assert.AreEqual(1, list.TotalPages);
+        }
+        [Test]
+        [Order(2)]
+        public void Pg_Invalid_PageParam_ThrowEx()
+        {
+            Assert.Throws<ArgumentException>(() => Context.Cars.Paginate(0, 2));
+            Assert.Throws<ArgumentException>(() => Context.Cars.Paginate(-1, 2));
+        }
+        [Test]
+        [Order(2)]
+        public void Pg_Invalid_PerPageParam_ThrowEx()
+        {
+            Assert.Throws<ArgumentException>(() => Context.Cars.Paginate(1, -1));
+        }
+        #endregion
+
+        #region Asynchronous
+        [Test]
+        [Order(0)]
+        public async Task AsyncPg_Empty()
+        {
+            var list = await Context.Cars.PaginateAsync(1, 10);
+            Assert.IsNotNull(list);
+            Assert.Zero(list.TotalItems);
+        }
+        [Test]
+        [Order(1)]
+        public async Task AsyncPg_With_Items()
+        {
+            var list = await Context.Cars.PaginateAsync(1, 2);
+            Assert.IsNotNull(list);
+            Assert.AreEqual(4, list.TotalItems);
+            Assert.AreEqual(2, list.TotalPages);
+        }
+        [Test]
+        [Order(2)]
+        public async Task AsyncPg_Skip_Count()
+        {
+            var list = await Context.Cars.PaginateAsync(1, 2, true);
+            Assert.IsNotNull(list);
+            Assert.AreEqual(2, list.TotalItems);
+            Assert.AreEqual(1, list.TotalPages);
+        }
+        [Test]
+        [Order(2)]
+        public void AsyncPg_Invalid_PageParam_ThrowEx()
+        {
+            Assert.ThrowsAsync<ArgumentException>(() => Context.Cars.PaginateAsync(0, 2));
+            Assert.ThrowsAsync<ArgumentException>(() => Context.Cars.PaginateAsync(-1, 2));
+        }
+        [Test]
+        [Order(2)]
+        public void AsyncPg_Invalid_PerPageParam_ThrowEx()
+        {
+            Assert.ThrowsAsync<ArgumentException>(() => Context.Cars.PaginateAsync(1, -1));
+        }
+        [Test]
+        [Order(3)]
+        public void AsyncPg_CancelledToken_Throw()
+        {
+            var src = new CancellationTokenSource();
+            src.Cancel();
+            Assert.ThrowsAsync<OperationCanceledException>(() => Context.Cars.PaginateAsync(1, 2, token: src.Token));
+        }
+        #endregion
+    }
+}

tests/tests.csproj

@@ -0,0 +1,21 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netcoreapp3.1</TargetFramework>
+
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+
+  <ItemGroup>
+	<PackageReference Include="Moq" Version="4.16.1" />
+    <PackageReference Include="NUnit" Version="3.13.2" />
+    <PackageReference Include="NUnit3TestAdapter" Version="3.17.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.10.0" />
+	<PackageReference Include="Microsoft.EntityFrameworkCore.InMemory" Version="3.1.15" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\Paginator.EntityFrameworkCore.csproj" />
+  </ItemGroup>
+
+</Project>