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

Author: klauffer

src/Conductors/RepositoryConductor.cs

@@ -46,6 +46,7 @@ public partial class RepositoryConductor<T> : Conductor, IRepositoryConductor<T>
         /// <param name="item">Item to be created</param>
         /// <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)]
         public virtual IResult<T> Create(T item, long? createdById = default(long?)) => _createConductor.Create(item, createdById);
 
         /// <summary>

src/Conductors/RepositoryConductorAsync.cs

@@ -72,11 +72,16 @@ public RepositoryConductor(
 
         #endregion Constructor
 
-
+        /// <inheritdoc />
         public Task<IResult<List<T>>> BulkCreateAsync(IEnumerable<T> items, long? createdById = null, CancellationToken cancellationToken = default) => 
             _createConductor.BulkCreateAsync(items, createdById, cancellationToken);
 
+        /// <inheritdoc />
         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);
+
+        /// <inheritdoc />
+        public Task<IResult<T>> CreateAsync(T item, long? createdById = null, CancellationToken cancellationToken = default) => 
+            _createConductor.CreateAsync(item, createdById, cancellationToken);
     }
 }

src/Conductors/RepositoryCreateConductor.cs

@@ -23,24 +23,15 @@ public partial class RepositoryCreateConductor<T> : Conductor, IRepositoryCreate
             return _repository.BulkCreate(items, createdById);
         }
 
-        /// <summary>
-        /// Ability to create entities using a list in a single bulk operation without duplicates.
-        /// </summary>
-        /// <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>> BulkCreateDistinct<TKey>(IEnumerable<T> items, Func<T, TKey> property, long? createdById = null)
         {
             return _repository.BulkCreateDistinct(items, property, createdById);
         }
 
-        /// <summary>
-        /// Ability to create an entity 
-        /// </summary>
-        /// <param name="item">Item to be created</param>
-        /// <param name="createdById">Id of user creating the item</param>
-        /// <returns></returns>
+        /// <inheritdoc />
+        [Obsolete("This method is deprecated in favor of its async counter part", false)]
         public virtual IResult<T> Create(T item, long? createdById = default(long?))
         {
             return _repository.Create(item, createdById);

src/Conductors/RepositoryCreateConductorAsync.cs

@@ -53,5 +53,13 @@ public Task<IResult<List<T>>> BulkCreateDistinctAsync<TKey>(IEnumerable<T> items
             if (!items.Any()) throw new ArgumentException("An empty collection was provided", nameof(items));
             return _repository.BulkCreateDistinctAsync(items, property, createdById, cancellationToken);
         }
+
+        /// <inheritdoc />
+        public virtual Task<IResult<T>> CreateAsync(T item, long? createdById = null, CancellationToken cancellationToken = default)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+            if (item == null) throw new ArgumentNullException(nameof(item));
+            return _repository.CreateAsync(item, createdById);
+        }
     }
 }

src/Core/Interfaces/Conductors/IRepositoryCreateConductor.cs

@@ -41,6 +41,13 @@ public partial interface IRepositoryCreateConductor<T>
         [Obsolete("This method is deprecated in favor of its async counter part", false)]
         IResult<List<T>> BulkCreateDistinct<TKey>(IEnumerable<T> items, Func<T, TKey> property, long? createdById = null);
 
+        /// <summary>
+        /// Ability to create an entity 
+        /// </summary>
+        /// <param name="item">Item to be created</param>
+        /// <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<List<T>> Create(IEnumerable<T> items, long? createdById = null);
 

src/Core/Interfaces/Conductors/IRepositoryCreateConductorAsync.cs

@@ -31,5 +31,13 @@ public partial interface IRepositoryCreateConductor<T>
         /// <returns></returns>
         Task<IResult<List<T>>> BulkCreateDistinctAsync<TKey>(IEnumerable<T> items, Func<T, TKey> property, long? createdById = null, CancellationToken cancellationToken = default);
 
+        /// <summary>
+        /// Ability to create an entity 
+        /// </summary>
+        /// <param name="item">Item to be created</param>
+        /// <param name="createdById">Id of user creating the item</param>
+        /// <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);
     }
 }

src/Core/Interfaces/Data/IRepository.cs

@@ -71,6 +71,7 @@ public partial interface IRepository<T>
         /// <param name="item">Item to be created</param>
         /// <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);
 
         /// <summary>

src/Core/Interfaces/Data/IRepositoryAsync.cs

@@ -29,5 +29,13 @@ public partial interface IRepository<T>
         /// <returns></returns>
         Task<IResult<List<T>>> BulkCreateDistinctAsync<TKey>(IEnumerable<T> items, Func<T, TKey> property, long? createdById = null, CancellationToken cancellationToken = default);
 
+        /// <summary>
+        /// Ability to create an entity 
+        /// </summary>
+        /// <param name="item">Item to be created</param>
+        /// <param name="createdById">Id of user creating the item</param>
+        /// <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);
     }
 }

test/Conductors.Tests/RepositoryConductorTests/BulkCreateDistinctAsyncShould.cs

@@ -37,7 +37,7 @@ public async Task Throw_Argument_Null_Exception_When_Given_Null_Input()
             var respositoryConductor = SetupSut(repositoryMock);
 
             // Act & Assert
-            await Assert.ThrowsAsync<ArgumentNullException>(() => respositoryConductor.BulkCreateAsync(null));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => respositoryConductor.BulkCreateDistinctAsync(null, (x) => x.Id));
         }
 
         [Fact]
@@ -48,7 +48,7 @@ public async Task Throw_Argument_Exception_When_Given_Empty_Input()
             var respositoryConductor = SetupSut(repositoryMock);
 
             // Act & Assert
-            await Assert.ThrowsAsync<ArgumentException>(() => respositoryConductor.BulkCreateAsync(new List<UserStub>()));
+            await Assert.ThrowsAsync<ArgumentException>(() => respositoryConductor.BulkCreateDistinctAsync(new List<UserStub>(), (x) => x.Id));
         }
 
         [Fact]
@@ -61,7 +61,7 @@ public async Task Throw_Stop_If_Canceled()
             var cancellationToken = cancellationTokenSource.Token;
             cancellationTokenSource.Cancel();
             // Act & Assert
-            await Assert.ThrowsAsync<OperationCanceledException>(() => respositoryConductor.BulkCreateAsync(new List<UserStub>(), 5, cancellationToken));
+            await Assert.ThrowsAsync<OperationCanceledException>(() => respositoryConductor.BulkCreateDistinctAsync(new List<UserStub>(), (x) => x.Id, 5, cancellationToken));
         }
     }
 }

test/Conductors.Tests/RepositoryConductorTests/CreateAsyncShould.cs

@@ -0,0 +1,56 @@
+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 CreateAsyncShould : ProjectUnitTest
+    {
+        public CreateAsyncShould(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.CreateAsync(null));
+        }
+
+        [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();
+            var userStub = new UserStub();
+            // Act & Assert
+            await Assert.ThrowsAsync<OperationCanceledException>(() => respositoryConductor.CreateAsync(userStub, 5, cancellationToken));
+        }
+    }
+}