Issue rsm-hcd#34 and rsm-hcd#17: Implemented CreateAsync and CreateDistinctAsync

Author: klauffer

src/Conductors/RepositoryConductor.cs

@@ -55,6 +55,7 @@ public partial class RepositoryConductor<T> : Conductor, IRepositoryConductor<T>
         /// <param name="items">List of items to be created</param>
         /// <param name="createdById">Id of user creating the items</param>
         /// <returns></returns>
+        [Obsolete("This method is deprecated in favor of its async counter part", false)]
         public virtual IResult<List<T>> Create(IEnumerable<T> items, long? createdById = default(long?)) => _createConductor.Create(items, createdById);
 
         /// <summary>
@@ -65,6 +66,7 @@ public partial class RepositoryConductor<T> : Conductor, IRepositoryConductor<T>
         /// <param name="property">Property used to remove duplicates</param>
         /// <param name="createdById">Id of user creating the items</param>
         /// <returns></returns>
+        [Obsolete("This method is deprecated in favor of its async counter part", false)]
         public virtual IResult<List<T>> CreateDistinct<TKey>(IEnumerable<T> items, Func<T, TKey> property, long? createdById = null) => _createConductor.CreateDistinct(items, property, createdById);
 
         #endregion Create

src/Conductors/RepositoryConductorAsync.cs

@@ -83,5 +83,13 @@ public Task<IResult<List<T>>> BulkCreateDistinctAsync<TKey>(IEnumerable<T> items
         /// <inheritdoc />
         public Task<IResult<T>> CreateAsync(T item, long? createdById = null, CancellationToken cancellationToken = default) => 
             _createConductor.CreateAsync(item, createdById, cancellationToken);
+
+        /// <inheritdoc />
+        public Task<IResult<List<T>>> CreateAsync(IEnumerable<T> items, long? createdById = null, CancellationToken cancellationToken = default) =>
+            _createConductor.CreateAsync(items, createdById, cancellationToken);
+
+        /// <inheritdoc />
+        public Task<IResult<List<T>>> CreateDistinctAsync<TKey>(IEnumerable<T> items, System.Func<T, TKey> property, long? createdById = null, CancellationToken cancellationToken = default) => 
+            _createConductor.CreateDistinctAsync(items, property, createdById, cancellationToken);
     }
 }

src/Conductors/RepositoryCreateConductor.cs

@@ -37,25 +37,15 @@ public IResult<List<T>> BulkCreateDistinct<TKey>(IEnumerable<T> items, Func<T, T
             return _repository.Create(item, createdById);
         }
 
-        /// <summary>
-        /// Ability to create entities individually using a list 
-        /// </summary>
-        /// <param name="items">List of items to be created</param>
-        /// <param name="createdById">Id of user creating the items</param>
-        /// <returns></returns>
+        /// <inheritdoc />
+        [Obsolete("This method is deprecated in favor of its async counter part", false)]
         public virtual IResult<List<T>> Create(IEnumerable<T> items, long? createdById = default(long?))
         {
             return _repository.Create(items, createdById);
         }
 
-        /// <summary>
-        /// Ability to create entities individually without duplicates
-        /// </summary>
-        /// <typeparam name="TKey"></typeparam>
-        /// <param name="items">List of items to create</param>
-        /// <param name="property">Property used to remove duplicates</param>
-        /// <param name="createdById">Id of user creating the items</param>
-        /// <returns></returns>
+        /// <inheritdoc />
+        [Obsolete("This method is deprecated in favor of its async counter part", false)]
         public IResult<List<T>> CreateDistinct<TKey>(IEnumerable<T> items, Func<T, TKey> property, long? createdById = null)
         {
             return _repository.CreateDistinct(items, property, createdById);

src/Conductors/RepositoryCreateConductorAsync.cs

@@ -23,7 +23,7 @@ public int? CommandTimeout
         }
 
         readonly IRepository<T> _repository;
-
+        const string ARGUMENT_EXCEPTION_MESSAGE = "An empty collection was provided";
 
         /// <summary>
         /// Constructor
@@ -41,7 +41,7 @@ public virtual Task<IResult<List<T>>> BulkCreateAsync(IEnumerable<T> items, long
         {
             cancellationToken.ThrowIfCancellationRequested();
             if (items == null) throw new ArgumentNullException(nameof(items));
-            if(!items.Any()) throw new ArgumentException("An empty collection was provided", nameof(items));
+            if(!items.Any()) throw new ArgumentException(ARGUMENT_EXCEPTION_MESSAGE, nameof(items));
             return _repository.BulkCreateAsync(items, createdById);
         }
 
@@ -50,7 +50,7 @@ public Task<IResult<List<T>>> BulkCreateDistinctAsync<TKey>(IEnumerable<T> items
         {
             cancellationToken.ThrowIfCancellationRequested();
             if (items == null) throw new ArgumentNullException(nameof(items));
-            if (!items.Any()) throw new ArgumentException("An empty collection was provided", nameof(items));
+            if (!items.Any()) throw new ArgumentException(ARGUMENT_EXCEPTION_MESSAGE, nameof(items));
             return _repository.BulkCreateDistinctAsync(items, property, createdById, cancellationToken);
         }
 
@@ -61,5 +61,21 @@ public virtual Task<IResult<T>> CreateAsync(T item, long? createdById = null, Ca
             if (item == null) throw new ArgumentNullException(nameof(item));
             return _repository.CreateAsync(item, createdById);
         }
+
+        public Task<IResult<List<T>>> CreateAsync(IEnumerable<T> items, long? createdById = null, CancellationToken cancellationToken = default)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+            if (items == null) throw new ArgumentNullException(nameof(items));
+            if (!items.Any()) throw new ArgumentException(ARGUMENT_EXCEPTION_MESSAGE, nameof(items));
+            return _repository.CreateAsync(items, createdById, cancellationToken);
+        }
+
+        public Task<IResult<List<T>>> CreateDistinctAsync<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(ARGUMENT_EXCEPTION_MESSAGE, nameof(items));
+            return _repository.BulkCreateDistinctAsync(items, property, createdById, cancellationToken);
+        }
     }
 }

src/Core/Interfaces/Conductors/IRepositoryCreateConductor.cs

@@ -48,7 +48,15 @@ public partial interface IRepositoryCreateConductor<T>
         /// <param name="createdById">Id of user creating the item</param>
         /// <returns></returns>
         [Obsolete("This method is deprecated in favor of its async counter part", false)]
-        IResult<T>       Create(T item, long? createdById = null);
+        IResult<T> Create(T item, long? createdById = null);
+
+        /// <summary>
+        /// Ability to create entities individually using a list 
+        /// </summary>
+        /// <param name="items">List of items to be created</param>
+        /// <param name="createdById">Id of user creating the items</param>
+        /// <returns></returns>
+        [Obsolete("This method is deprecated in favor of its async counter part", false)]
         IResult<List<T>> Create(IEnumerable<T> items, long? createdById = null);
 
         /// <summary>
@@ -61,6 +69,7 @@ public partial interface IRepositoryCreateConductor<T>
         /// <param name="createdById">Id of the user creating the entity</param>
         /// <typeparam name="TKey"></typeparam>
         /// <returns></returns>
+        [Obsolete("This method is deprecated in favor of its async counter part", false)]
         IResult<List<T>> CreateDistinct<TKey>(IEnumerable<T> items, Func<T, TKey> property, long? createdById = null);
 
         #endregion Methods

src/Core/Interfaces/Conductors/IRepositoryCreateConductorAsync.cs

@@ -39,5 +39,28 @@ public partial interface IRepositoryCreateConductor<T>
         /// <param name="cancellationToken">a token allowing aborting of this request</param>
         /// <returns></returns>
         Task<IResult<T>> CreateAsync(T item, long? createdById = null, CancellationToken cancellationToken = default);
+
+        /// <summary>
+        /// Ability to create entities individually using a list 
+        /// </summary>
+        /// <param name="items">List of items to be created</param>
+        /// <param name="createdById">Id of user creating the items</param>
+        /// <param name="cancellationToken">a token allowing aborting of this request</param>
+        /// <returns></returns>
+        Task<IResult<List<T>>> CreateAsync(IEnumerable<T> items, long? createdById = null, CancellationToken cancellationToken = default);
+
+        /// <summary>
+        /// Calls batched overload of Create() with a de-duped list of objects as determined by the
+        /// property (or properties) of the object for the 'property' argument.
+        /// NOTE: Batching is generally slower than bulking, but does not lock 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>>> CreateDistinctAsync<TKey>(IEnumerable<T> items, Func<T, TKey> property, long? createdById = null, CancellationToken cancellationToken = default);
+
     }
 }

src/Core/Interfaces/Data/IRepositoryAsync.cs

@@ -37,5 +37,28 @@ public partial interface IRepository<T>
         /// <param name="cancellationToken">a token allowing aborting of this request</param>
         /// <returns></returns>
         Task<IResult<T>> CreateAsync(T item, long? createdById = null, CancellationToken cancellationToken = default);
+
+        /// <summary>
+        /// Ability to create entities individually using a list 
+        /// </summary>
+        /// <param name="items">List of items to be created</param>
+        /// <param name="createdById">Id of user creating the items</param>
+        /// <param name="cancellationToken">a token allowing aborting of this request</param>
+        /// <returns></returns>
+        Task<IResult<List<T>>> CreateAsync(IEnumerable<T> items, long? createdById = null, CancellationToken cancellationToken = default);
+
+        /// <summary>
+        /// Calls batched overload of Create() with a de-duped list of objects as determined by the
+        /// property (or properties) of the object for the 'property' argument.
+        /// NOTE: Batching is generally slower than bulking, but does not lock 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>>> CreateDistinctAsync<TKey>(IEnumerable<T> items, Func<T, TKey> property, long? createdById = null, CancellationToken cancellationToken = default);
+
     }
 }

test/Conductors.Tests/RepositoryConductorTests/BulkCreateDistinctAsyncShould.cs

@@ -7,7 +7,6 @@
 using Xunit;
 using Xunit.Abstractions;
 
-
 namespace AndcultureCode.CSharp.Conductors.Tests.RepositoryConductorTests
 {
     public class BulkCreateDistinctAsyncShould : ProjectUnitTest

test/Conductors.Tests/RepositoryConductorTests/CreateAsyncShould.cs

@@ -34,9 +34,34 @@ public async Task Throw_Argument_Null_Exception_When_Given_Null_Input()
             // Arrange 
             var repositoryMock = new IRepositoryMock<UserStub>();
             var respositoryConductor = SetupSut(repositoryMock);
+            UserStub userStub = null;
 
             // Act & Assert
-            await Assert.ThrowsAsync<ArgumentNullException>(() => respositoryConductor.CreateAsync(null));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => respositoryConductor.CreateAsync(userStub));
+        }
+
+        [Fact]
+        public async Task Throw_Argument_Null_Exception_When_Given_Null_List_Input()
+        {
+            // Arrange 
+            var repositoryMock = new IRepositoryMock<UserStub>();
+            var respositoryConductor = SetupSut(repositoryMock);
+            IEnumerable<UserStub> userStub = null;
+
+            // Act & Assert
+            await Assert.ThrowsAsync<ArgumentNullException>(() => respositoryConductor.CreateAsync(userStub));
+        }
+
+        [Fact]
+        public async Task Throw_Argument_Exception_When_Given_Empty_Input()
+        {
+            // Arrange 
+            var repositoryMock = new IRepositoryMock<UserStub>();
+            var respositoryConductor = SetupSut(repositoryMock);
+            IEnumerable<UserStub> userStubs = new List<UserStub>();
+
+            // Act & Assert
+            await Assert.ThrowsAsync<ArgumentException>(() => respositoryConductor.CreateAsync(userStubs));
         }
 
         [Fact]

test/Conductors.Tests/RepositoryConductorTests/CreateDistinctAsyncShould.cs

@@ -0,0 +1,66 @@
+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 CreateDistinctAsyncShould : ProjectUnitTest
+    {
+        public CreateDistinctAsyncShould(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.CreateDistinctAsync(null, (x) => x.Id));
+        }
+
+        [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.CreateDistinctAsync(new List<UserStub>(), (x) => x.Id));
+        }
+
+        [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.CreateDistinctAsync(new List<UserStub>(), (x) => x.Id, 5, cancellationToken));
+        }
+    }
+}