Merge pull request #2 from tmacharia/stable

Bug fix to support Xml Serialization

Author: tmacharia

PagedResult.cs

@@ -36,7 +36,7 @@ public PagedResult()
         /// <summary>
         /// Collection containing items in the current page.
         /// </summary>
-        public IList<T> Items { get; set; }
+        public List<T> Items { get; set; }
 
         /// <summary>
         /// Calculates &amp; returns the hashcode of the current object.
@@ -53,7 +53,11 @@ public override int GetHashCode()
         /// <returns></returns>
         public override string ToString()
         {
-            return string.Format("Page: {0:N0} Perpage: {1:N0} Totalpages: {2:N0} TotalItems: {3:N0}", Page, ItemsPerPage, TotalPages, TotalItems);
+            return string.Format("{0:N0} items, Pg {1:N0}/{2:N0}, Total: {3:N0}",
+                (Items != null && Items.Count > 0) ? Items.Count : ItemsPerPage,
+                Page,
+                TotalPages,
+                TotalItems);
         }
     }
 }

Paginator.cs

@@ -16,6 +16,22 @@ public static class Paginator
         internal const int DEF_PERPAGE = 10;
         internal const bool DEF_SKIPCOUNT = false;
 
+        /// <summary>
+        /// Asynchronously lists items in the pagination request.
+        /// </summary>
+        /// <typeparam name="TEntity"></typeparam>
+        /// <param name="query"></param>
+        /// <param name="page">Page</param>
+        /// <param name="perpage">Items per page.</param>
+        /// <param name="cancellationToken">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"/>
+        /// <exception cref="ObjectDisposedException"/>
+        public static Task<PagedResult<TEntity>> PaginateAsync<TEntity>(this IQueryable<TEntity> query, int page = DEF_PAGE, int perpage = DEF_PERPAGE, CancellationToken cancellationToken = default)
+            where TEntity : class
+            => query.ProcessPaginationAsync(page, perpage, DEF_SKIPCOUNT, cancellationToken);
         /// <summary>
         /// Asynchronously lists items in the pagination request.
         /// </summary>
@@ -24,15 +40,16 @@ public static class Paginator
         /// <param name="page">Page</param>
         /// <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>
-        /// <param name="token">Cancellation token.</param>
+        /// <param name="cancellationToken">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"/>
+        /// <exception cref="ObjectDisposedException"/>
         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)
+            int page, int perpage, bool skipCount, CancellationToken cancellationToken = default)
             where TEntity : class
-            => query.ProcessPaginationAsync(page, perpage, skipCount, token);
+            => query.ProcessPaginationAsync(page, perpage, skipCount, cancellationToken);
         /// <summary>
         /// Lists items in the sequence and only returns the specified number.
         /// </summary>
@@ -49,21 +66,23 @@ public static PagedResult<TEntity> Paginate<TEntity>(this IQueryable<TEntity> qu
             where TEntity : class
             => query.ProcessPagination(page, perpage, skipCount);
 
+
+
         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)
+                    int page = DEF_PAGE, int perpage = DEF_PERPAGE, bool skipCount = DEF_SKIPCOUNT, CancellationToken cancellationToken = default)
         {
             ValidateParams_IfInvalid_Throw(page, perpage);
 
             int total = 0;
             var list = new List<TEntity>();
 
-            token.ThrowIfCancellationRequested();
+            cancellationToken.ThrowIfCancellationRequested();
 
             if (!skipCount)
-                total = await query.CountEntitiesAsync(token);
+                total = await query.CountEntitiesAsync(cancellationToken);
 
             if (skipCount || (!skipCount && total > 0))
-                list = await query.Skip((page - 1) * perpage).Take(perpage).ToListAsync(token);
+                list = await query.Skip((page - 1) * perpage).Take(perpage).ToListAsync(cancellationToken);
 
             if (skipCount)
                 total = list.Count;
@@ -104,19 +123,11 @@ internal static PagedResult<TEntity> ProcessPagination<TEntity>(this IQueryable<
             };
         }
 
-        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)
+        internal static Task<int> CountEntitiesAsync<TEntity>(this IQueryable<TEntity> query, CancellationToken cancellationToken = default)
         {
-            return query.CountAsync(token);
+            return query.CountAsync(cancellationToken);
         }
         internal static int CalculateTotalPages(int totalItems, int perpage)
         {
@@ -128,5 +139,18 @@ internal static int CalculateTotalPages(int totalItems, int perpage)
             }
             return ans;
         }
+
+
+
+        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;
+        }
     }
 }

tests/AsynchronousTests.cs

@@ -0,0 +1,89 @@
+using Paginator.EntityFrameworkCore;
+using NUnit.Framework;
+using System;
+using System.Threading.Tasks;
+using System.Threading;
+
+namespace tests
+{
+    [TestFixture]
+    [SingleThreaded]
+    internal class AsynchronousTests : TestBaseContext
+    {
+        [SetUp]
+        public void Setup()
+        {
+            InitContx();
+        }
+
+        #region Asynchronous
+        [Order(0)]
+        [TestCase(Category = ASYNC_TESTS)]
+        public async Task AsyncPg_Empty()
+        {
+            var paged = await Context.Cars.PaginateAsync(1, 10);
+
+            Assert.IsNotNull(paged);
+            Assert.Zero(paged.TotalItems);
+
+            Log(paged);
+        }
+        [Order(1)]
+        [TestCase(Category = ASYNC_TESTS)]
+        public void AsyncPg_Invalid_PageParam_ThrowEx()
+        {
+            Assert.ThrowsAsync<ArgumentException>(() => Context.Cars.PaginateAsync(0, 2));
+            Assert.ThrowsAsync<ArgumentException>(() => Context.Cars.PaginateAsync(-1, 2));
+        }
+        [Order(1)]
+        [TestCase(Category = ASYNC_TESTS)]
+        public void AsyncPg_Invalid_PerPageParam_ThrowEx()
+        {
+            Assert.ThrowsAsync<ArgumentException>(() => Context.Cars.PaginateAsync(1, -1));
+        }
+        [Order(1)]
+        [TestCase(Category = ASYNC_TESTS)]
+        public void AsyncPg_CancelledToken_Throw()
+        {
+            var src = new CancellationTokenSource();
+            src.Cancel();
+            Assert.ThrowsAsync<OperationCanceledException>(() => Context.Cars.PaginateAsync(1, 2, cancellationToken: src.Token));
+        }
+        [Order(2)]
+        [TestCase(Category = ASYNC_TESTS)]
+        public async Task AsyncPg_Skip_Count()
+        {
+            Add(new Car());
+            Add(new Car());
+            Add(new Car());
+            Add(new Car());
+
+            var paged = await Context.Cars.PaginateAsync(1, 2, true);
+
+            Assert.IsNotNull(paged);
+            Assert.AreEqual(2, paged.TotalItems);
+            Assert.AreEqual(1, paged.TotalPages);
+
+            Log(paged);
+        }
+        [Order(2)]
+        [TestCase(Category = ASYNC_TESTS)]
+        public async Task AsyncPg_With_Items()
+        {
+            int k = 5174;
+            for (int i = 0; i < k; i++)
+                Context.Add(new Car());
+
+            Save();
+
+            var paged = await Context.Cars.PaginateAsync(35, 8);
+
+            Assert.IsNotNull(paged);
+            Assert.AreEqual(k, paged.TotalItems);
+            Assert.AreEqual(647, paged.TotalPages);
+
+            Log(paged);
+        }
+        #endregion
+    }
+}

tests/SynchronousTests.cs

@@ -0,0 +1,80 @@
+using Paginator.EntityFrameworkCore;
+using NUnit.Framework;
+using System;
+
+namespace tests
+{
+    [TestFixture]
+    //[SingleThreaded]
+    internal class SynchronousTests : TestBaseContext
+    {
+        [SetUp]
+        public void Setup()
+        {
+            InitContx();
+        }
+
+        #region Synchronous
+        [Order(0)]
+        [TestCase(Category = SYNC_TESTS)]
+        public void Pg_Empty()
+        {
+            var paged = Context.Cars.Paginate(1, 10);
+
+            Assert.IsNotNull(paged);
+            Assert.Zero(paged.TotalItems);
+
+            Log(paged);
+        }
+        [Order(1)]
+        [TestCase(Category = SYNC_TESTS)]
+        public void Pg_Invalid_PageParam_ThrowEx()
+        {
+            Assert.Throws<ArgumentException>(() => Context.Cars.Paginate(0, 2));
+            Assert.Throws<ArgumentException>(() => Context.Cars.Paginate(-1, 2));
+        }
+        [Order(1)]
+        [TestCase(Category = SYNC_TESTS)]
+        public void Pg_Invalid_PerPageParam_ThrowEx()
+        {
+            Assert.Throws<ArgumentException>(() => Context.Cars.Paginate(1, -1));
+        }
+        [Order(2)]
+        [TestCase(Category = SYNC_TESTS)]
+        public void Pg_Skip_Count()
+        {
+            Add(new Car());
+            Add(new Car());
+            Add(new Car());
+            Add(new Car());
+
+            var paged = Context.Cars.Paginate(1, 2, true);
+
+            Assert.IsNotNull(paged);
+            Assert.AreEqual(2, paged.TotalItems);
+            Assert.AreEqual(1, paged.TotalPages);
+
+            Log(paged);
+        }
+        [Order(2)]
+        [RequiresThread]
+        [TestCase(Category = SYNC_TESTS)]
+        public void Pg_With_Items()
+        {
+            int k = 5174;
+            for (int i = 0; i < k; i++)
+                Context.Add(new Car());
+
+            Save();
+
+            var paged = Context.Cars.Paginate(35, 8);
+
+            Assert.IsNotNull(paged);
+            Assert.AreEqual(k, paged.TotalItems);
+            Assert.AreEqual(647, paged.TotalPages);
+
+            Log(paged);
+        }
+        #endregion
+    }
+}

tests/TestBase.cs

@@ -0,0 +1,16 @@
+using System;
+
+namespace tests
+{
+    internal class TestBase
+    {
+        internal const string SYNC_TESTS = "Synchronous";
+        internal const string ASYNC_TESTS = "Asynchronous";
+        internal const string SERIAL_TESTS = "Serialization";
+
+        internal void Log(object obj)
+            => Console.WriteLine(obj);
+        internal void Log(string format, params object[] args)
+            => Console.WriteLine(format, args);
+    }
+}

tests/TestBaseContext.cs

@@ -1,31 +1,34 @@
 using Microsoft.EntityFrameworkCore;
+using NUnit.Framework;
 
 namespace tests
 {
-    internal class TestBaseContext
+    internal class TestBaseContext : TestBase
     {
         private TestDbContext _context;
         private DbContextOptions<TestDbContext> DbContextOptions;
 
         public TestBaseContext()
         { }
-
+        
         protected TestDbContext Context
         {
             get
             {
                 if (_context == null)
-                {
-                    DbContextOptions = new DbContextOptionsBuilder<TestDbContext>()
+                    InitContx();
+                return _context;
+            }
+        }
+        protected void InitContx()
+        {
+            DbContextOptions = new DbContextOptionsBuilder<TestDbContext>()
                         .UseInMemoryDatabase(databaseName: "test_db")
                         .EnableServiceProviderCaching(true)
                         .EnableSensitiveDataLogging(true)
                         .UseQueryTrackingBehavior(QueryTrackingBehavior.TrackAll)
                         .Options;
-                    _context = new TestDbContext(DbContextOptions);
-                }
-                return _context;
-            }
+            _context = new TestDbContext(DbContextOptions);
         }
 
 

tests/TestDbContext.cs

@@ -10,7 +10,7 @@ public TestDbContext(DbContextOptions<TestDbContext> options)
 
         public DbSet<Car> Cars { get; set; }
     }
-    internal class Car
+    public class Car
     {
         public int Id { get; set; }
     }