Issue rsm-hcd#34 and rsm-hcd#17: Implemented BulkCreateDistinctAsync …

…and some clean up
klauffer · Mar 25, 2022 · d1688f0 · d1688f0
1 parent 392be7c
commit d1688f0
Show file tree

Hide file tree

Showing 12 changed files with 159 additions and 35 deletions.
diff --git a/src/Conductors/RepositoryConductor.cs b/src/Conductors/RepositoryConductor.cs
@@ -2,7 +2,6 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Linq.Expressions;
-using System.Threading.Tasks;
 using AndcultureCode.CSharp.Core;
 using AndcultureCode.CSharp.Core.Extensions;
 using AndcultureCode.CSharp.Core.Interfaces;

diff --git a/src/Conductors/RepositoryConductorAsync.cs b/src/Conductors/RepositoryConductorAsync.cs
@@ -1,4 +1,5 @@
 using System.Collections.Generic;
+using System.Threading;
 using System.Threading.Tasks;
 using AndcultureCode.CSharp.Core.Interfaces;
 using AndcultureCode.CSharp.Core.Interfaces.Conductors;
@@ -72,7 +73,10 @@ public RepositoryConductor(
         #endregion Constructor
 
 
-        public Task<IResult<List<T>>> BulkCreateAsync(IEnumerable<T> items, long? createdById = null) => 
-            _createConductor.BulkCreateAsync(items, createdById);
+        public Task<IResult<List<T>>> BulkCreateAsync(IEnumerable<T> items, long? createdById = null, CancellationToken cancellationToken = default) => 
+            _createConductor.BulkCreateAsync(items, createdById, cancellationToken);
+
+        public Task<IResult<List<T>>> BulkCreateDistinctAsync<TKey>(IEnumerable<T> items, System.Func<T, TKey> property, long? createdById = null, CancellationToken cancellationToken = default) =>
+            _createConductor.BulkCreateDistinctAsync(items, property, createdById, cancellationToken);
     }
 }
diff --git a/src/Conductors/RepositoryCreateConductor.cs b/src/Conductors/RepositoryCreateConductor.cs
@@ -1,9 +1,7 @@
 using System;
 using System.Collections.Generic;
-using System.Threading.Tasks;
 using AndcultureCode.CSharp.Core.Interfaces;
 using AndcultureCode.CSharp.Core.Interfaces.Conductors;
-using AndcultureCode.CSharp.Core.Interfaces.Data;
 using AndcultureCode.CSharp.Core.Interfaces.Entity;
 
 namespace AndcultureCode.CSharp.Conductors

diff --git a/src/Conductors/RepositoryCreateConductorAsync.cs b/src/Conductors/RepositoryCreateConductorAsync.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading;
 using System.Threading.Tasks;
 using AndcultureCode.CSharp.Core.Interfaces;
 using AndcultureCode.CSharp.Core.Interfaces.Conductors;
@@ -36,11 +37,21 @@ IRepository<T> repository
         }
 
         /// <inheritdoc />
-        public virtual Task<IResult<List<T>>> BulkCreateAsync(IEnumerable<T> items, long? createdById = null) 
+        public virtual Task<IResult<List<T>>> BulkCreateAsync(IEnumerable<T> items, long? createdById = null, CancellationToken cancellationToken = default) 
         {
-            if(items == null) throw new ArgumentNullException(nameof(items));
+            cancellationToken.ThrowIfCancellationRequested();
+            if (items == null) throw new ArgumentNullException(nameof(items));
             if(!items.Any()) throw new ArgumentException("An empty collection was provided", nameof(items));
             return _repository.BulkCreateAsync(items, createdById);
         }
+
+        /// <inheritdoc />
+        public Task<IResult<List<T>>> BulkCreateDistinctAsync<TKey>(IEnumerable<T> items, Func<T, TKey> property, long? createdById = null, CancellationToken cancellationToken = default)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+            if (items == null) throw new ArgumentNullException(nameof(items));
+            if (!items.Any()) throw new ArgumentException("An empty collection was provided", nameof(items));
+            return _repository.BulkCreateDistinctAsync(items, property, createdById, cancellationToken);
+        }
     }
 }
diff --git a/src/Core/Interfaces/Conductors/IRepositoryConductor.cs b/src/Core/Interfaces/Conductors/IRepositoryConductor.cs
@@ -2,12 +2,12 @@
 
 namespace AndcultureCode.CSharp.Core.Interfaces.Conductors
 {
-    public interface IRepositoryConductor<T> : IConductor,
+    public partial interface IRepositoryConductor<T> : IConductor,
         IRepositoryCreateConductor<T>,
         IRepositoryDeleteConductor<T>,
         IRepositoryReadConductor<T>,
         IRepositoryUpdateConductor<T>
-    where T : AndcultureCode.CSharp.Core.Models.Entities.Entity
+    where T : Models.Entities.Entity
     {
         #region Properties
 

diff --git a/src/Core/Interfaces/Conductors/IRepositoryConductorAsync.cs b/src/Core/Interfaces/Conductors/IRepositoryConductorAsync.cs
@@ -0,0 +1,16 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace AndcultureCode.CSharp.Core.Interfaces.Conductors
+{
+    public partial interface IRepositoryConductor<T> : IConductor,
+        IRepositoryCreateConductor<T>,
+        IRepositoryDeleteConductor<T>,
+        IRepositoryReadConductor<T>,
+        IRepositoryUpdateConductor<T>
+    where T : Models.Entities.Entity
+    {
+
+    }
+}
diff --git a/src/Core/Interfaces/Conductors/IRepositoryCreateConductorAsync.cs b/src/Core/Interfaces/Conductors/IRepositoryCreateConductorAsync.cs
@@ -1,6 +1,6 @@
 using System;
 using System.Collections.Generic;
-using System.Text;
+using System.Threading;
 using System.Threading.Tasks;
 using AndcultureCode.CSharp.Core.Interfaces.Entity;
 
@@ -14,7 +14,22 @@ public partial interface IRepositoryCreateConductor<T>
         /// </summary>
         /// <param name="items">List of items to create</param>
         /// <param name="createdById">Id of user creating the items</param>
+        /// <param name="cancellationToken">a token allowing aborting of this request</param>
         /// <returns>A collection of the created items</returns>
-        Task<IResult<List<T>>> BulkCreateAsync(IEnumerable<T> items, long? createdById = null);
+        Task<IResult<List<T>>> BulkCreateAsync(IEnumerable<T> items, long? createdById = null, CancellationToken cancellationToken = default);
+
+        /// <summary>
+        /// Calls BulkCreate() with a de-duped list of objects as determined by the
+        /// property (or properties) of the object for the 'property' argument
+        /// NOTE: Bulking is generally faster than batching, but locks the table.
+        /// </summary>
+        /// <param name="items">List of items to attempt to create</param>
+        /// <param name="property">Property or properties of the typed object to determine distinctness</param>
+        /// <param name="createdById">Id of the user creating the entity</param>
+        /// <param name="cancellationToken">a token allowing aborting of this request</param>
+        /// <typeparam name="TKey"></typeparam>
+        /// <returns></returns>
+        Task<IResult<List<T>>> BulkCreateDistinctAsync<TKey>(IEnumerable<T> items, Func<T, TKey> property, long? createdById = null, CancellationToken cancellationToken = default);
+
     }
 }
diff --git a/src/Core/Interfaces/Data/IRepository.cs b/src/Core/Interfaces/Data/IRepository.cs
@@ -28,28 +28,18 @@ public partial interface IRepository<T>
         /// <summary>
         /// Perform a DbContext.BulkInsert on an enumeration of T within a single transaction
         /// </summary>
-        /// <param name="items"></param>
-        /// <param name="createdById"></param>
+        /// <param name="items">that items of type <see cref="IEnumerable{T}" to be inserted</param>
+        /// <param name="createdById">Audit field for who did this task</param>
         /// <returns></returns>
         IResult<List<T>> BulkCreate(IEnumerable<T> items, long? createdById = null);
 
-        /// <summary>
-        /// Calls BulkCreate() with a de-duped list of objects as determined by the
-        /// property (or properties) of the object for the 'property' argument
-        /// NOTE: Bulking is generally faster than batching, but locks the table.
-        /// </summary>
-        /// <param name="items">List of items to attempt to create</param>
-        /// <param name="property">Property or properties of the typed object to determine distinctness</param>
-        /// <param name="createdById">Id of the user creating the entity</param>
-        /// <typeparam name="TKey"></typeparam>
-        /// <returns></returns>
 
         /// <summary>
         /// Calls BulkCreate() after selecting a subset of 'items' based on the distinct value of 'property'
         /// </summary>
-        /// <param name="items"></param>
-        /// <param name="property"></param>
-        /// <param name="createdById"></param>
+        /// <param name="items">that items of type <see cref="IEnumerable{T}" to be inserted</param>
+        /// <param name="property">that determines distinct records</param>
+        /// <param name="createdById">Audit field for who did this task</param>
         /// <typeparam name="TKey"></typeparam>
         /// <returns></returns>
         IResult<List<T>> BulkCreateDistinct<TKey>(IEnumerable<T> items, Func<T, TKey> property, long? createdById = null);

diff --git a/src/Core/Interfaces/Data/IRepositoryAsync.cs b/src/Core/Interfaces/Data/IRepositoryAsync.cs
@@ -1,4 +1,6 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
+using System.Threading;
 using System.Threading.Tasks;
 using AndcultureCode.CSharp.Core.Interfaces.Entity;
 
@@ -10,10 +12,22 @@ public partial interface IRepository<T>
         /// <summary>
         /// Perform a DbContext.BulkInsert on an enumeration of T within a single transaction
         /// </summary>
-        /// <param name="items"></param>
-        /// <param name="createdById"></param>
+        /// <param name="items">that items of type <see cref="IEnumerable{T}" to be inserted</param>
+        /// <param name="createdById">Audit field for who did this task</param>
+        /// <param name="cancellationToken">a token allowing aborting of this request</param>
         /// <returns></returns>
-        Task<IResult<List<T>>> BulkCreateAsync(IEnumerable<T> items, long? createdById = null);
+        Task<IResult<List<T>>> BulkCreateAsync(IEnumerable<T> items, long? createdById = null, CancellationToken cancellationToken = default);
+
+        /// <summary>
+        /// Calls BulkCreate() after selecting a subset of 'items' based on the distinct value of 'property'
+        /// </summary>
+        /// <param name="items">that items of type <see cref="IEnumerable{T}" to be inserted</param>
+        /// <param name="property">that determines distinct records</param>
+        /// <param name="createdById">Audit field for who did this task</param>
+        /// <param name="cancellationToken">a token allowing aborting of this request</param>
+        /// <typeparam name="TKey"></typeparam>
+        /// <returns></returns>
+        Task<IResult<List<T>>> BulkCreateDistinctAsync<TKey>(IEnumerable<T> items, Func<T, TKey> property, long? createdById = null, CancellationToken cancellationToken = default);
 
     }
 }
diff --git a/test/Conductors.Tests/RepositoryConductorTests/BulkCreateAsyncShould.cs b/test/Conductors.Tests/RepositoryConductorTests/BulkCreateAsyncShould.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Threading;
 using System.Threading.Tasks;
 using AndcultureCode.CSharp.Core.Interfaces.Conductors;
 using AndcultureCode.CSharp.Testing.Models.Stubs;
@@ -10,8 +11,6 @@ namespace AndcultureCode.CSharp.Conductors.Tests.RepositoryConductorTests
 {
     public class BulkCreateAsyncShould : ProjectUnitTest
     {
-        #region Setup
-
         public BulkCreateAsyncShould(ITestOutputHelper output) : base(output)
         {
         }
@@ -29,8 +28,6 @@ IRepositoryMock<UserStub> repositoryMock
             );
         }
 
-        #endregion Setup
-
         [Fact]
         public async Task Throw_Argument_Null_Exception_When_Given_Null_Input()
         {
@@ -53,5 +50,17 @@ public async Task Throw_Argument_Exception_When_Given_Empty_Input()
             await Assert.ThrowsAsync<ArgumentException>(() => respositoryConductor.BulkCreateAsync(new List<UserStub>()));
         }
 
+        [Fact]
+        public async Task Throw_Stop_If_Canceled()
+        {
+            // Arrange 
+            var repositoryMock = new IRepositoryMock<UserStub>();
+            var respositoryConductor = SetupSut(repositoryMock);
+            var cancellationTokenSource = new CancellationTokenSource();
+            var cancellationToken = cancellationTokenSource.Token;
+            cancellationTokenSource.Cancel();
+            // Act & Assert
+            await Assert.ThrowsAsync<OperationCanceledException>(() => respositoryConductor.BulkCreateAsync(new List<UserStub>(), 5, cancellationToken));
+        }
     }
 }
diff --git a/test/Conductors.Tests/RepositoryConductorTests/BulkCreateDistinctAsyncShould.cs b/test/Conductors.Tests/RepositoryConductorTests/BulkCreateDistinctAsyncShould.cs
@@ -0,0 +1,67 @@
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using AndcultureCode.CSharp.Core.Interfaces.Conductors;
+using AndcultureCode.CSharp.Testing.Models.Stubs;
+using Xunit;
+using Xunit.Abstractions;
+
+
+namespace AndcultureCode.CSharp.Conductors.Tests.RepositoryConductorTests
+{
+    public class BulkCreateDistinctAsyncShould : ProjectUnitTest
+    {
+        public BulkCreateDistinctAsyncShould(ITestOutputHelper output) : base(output)
+        {
+        }
+
+        private IRepositoryConductor<UserStub> SetupSut(
+            IRepositoryMock<UserStub> repositoryMock
+        )
+        {
+            var repositoryCreateConductor = new RepositoryCreateConductor<UserStub>(repositoryMock.Object);
+            return new RepositoryConductor<UserStub>(
+                createConductor: repositoryCreateConductor,
+                deleteConductor: null,
+                readConductor: null,
+                updateConductor: null
+            );
+        }
+
+        [Fact]
+        public async Task Throw_Argument_Null_Exception_When_Given_Null_Input()
+        {
+            // Arrange 
+            var repositoryMock = new IRepositoryMock<UserStub>();
+            var respositoryConductor = SetupSut(repositoryMock);
+
+            // Act & Assert
+            await Assert.ThrowsAsync<ArgumentNullException>(() => respositoryConductor.BulkCreateAsync(null));
+        }
+
+        [Fact]
+        public async Task Throw_Argument_Exception_When_Given_Empty_Input()
+        {
+            // Arrange 
+            var repositoryMock = new IRepositoryMock<UserStub>();
+            var respositoryConductor = SetupSut(repositoryMock);
+
+            // Act & Assert
+            await Assert.ThrowsAsync<ArgumentException>(() => respositoryConductor.BulkCreateAsync(new List<UserStub>()));
+        }
+
+        [Fact]
+        public async Task Throw_Stop_If_Canceled()
+        {
+            // Arrange 
+            var repositoryMock = new IRepositoryMock<UserStub>();
+            var respositoryConductor = SetupSut(repositoryMock);
+            var cancellationTokenSource = new CancellationTokenSource();
+            var cancellationToken = cancellationTokenSource.Token;
+            cancellationTokenSource.Cancel();
+            // Act & Assert
+            await Assert.ThrowsAsync<OperationCanceledException>(() => respositoryConductor.BulkCreateAsync(new List<UserStub>(), 5, cancellationToken));
+        }
+    }
+}
diff --git a/test/Conductors.Tests/RepositoryConductorTests/IRepositoryMock.cs b/test/Conductors.Tests/RepositoryConductorTests/IRepositoryMock.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Threading;
 using System.Threading.Tasks;
 using AndcultureCode.CSharp.Core.Interfaces;
 using AndcultureCode.CSharp.Core.Interfaces.Data;
@@ -13,7 +14,7 @@ internal sealed class IRepositoryMock<T> : Mock<IRepository<T>>
     {
         public IRepositoryMock<T> BulkCreateAsync(IResult<List<T>> output, Action<long> callback)
         {
-            Setup(x => x.BulkCreateAsync(It.IsAny<IEnumerable<T>>(), null))
+            Setup(x => x.BulkCreateAsync(It.IsAny<IEnumerable<T>>(), null, It.IsAny<CancellationToken>()))
                 .Returns(Task.FromResult(output));
             return this;
         }