MEDIUM CONTROLLERS: Contributor Post Tests

GitFyle.Core.Api.Tests.Unit/Controllers/ContributionTypes/ContributionTypesControllerTests.Exceptions.Get.cs

@@ -18,7 +18,7 @@ public partial class ContributionTypesControllerTests
         [Theory]
         [MemberData(nameof(ServerExceptions))]
         public async Task ShouldReturnInternalServerErrorOnGetIfServerErrorOccurredAsync(
-                Xeption serverException)
+            Xeption serverException)
         {
             // given
             InternalServerErrorObjectResult expectedInternalServerErrorObjectResult =

GitFyle.Core.Api.Tests.Unit/Controllers/ContributionTypes/ContributionTypesControllerTests.Exceptions.GetById.cs

@@ -19,7 +19,7 @@ public partial class ContributionTypesControllerTests
         [Theory]
         [MemberData(nameof(ValidationExceptions))]
         public async Task ShouldReturnBadRequestOnGetByIdIfValidationErrorOccursAsync(
-                Xeption validationException)
+            Xeption validationException)
         {
             // given
             Guid someId = Guid.NewGuid();
@@ -51,7 +51,7 @@ public async Task ShouldReturnBadRequestOnGetByIdIfValidationErrorOccursAsync(
         [Theory]
         [MemberData(nameof(ServerExceptions))]
         public async Task ShouldReturnInternalServerErrorOnGetByIdIfServerErrorOccursAsync(
-                Xeption validationException)
+            Xeption validationException)
         {
             // given
             Guid someId = Guid.NewGuid();

GitFyle.Core.Api.Tests.Unit/Controllers/Contributors/ContributorsControllerTests.Exceptions.Post.cs

@@ -0,0 +1,172 @@
+// ----------------------------------------------------------------------------------
+// Copyright (c) The Standard Organization: A coalition of the Good-Hearted Engineers
+// ----------------------------------------------------------------------------------
+
+using System;
+using System.Threading.Tasks;
+using GitFyle.Core.Api.Models.Foundations.Contributors;
+using GitFyle.Core.Api.Models.Foundations.Contributors.Exceptions;
+using Microsoft.AspNetCore.Mvc;
+using Moq;
+using RESTFulSense.Clients.Extensions;
+using RESTFulSense.Models;
+using Xeptions;
+
+namespace GitFyle.Core.Api.Tests.Unit.Controllers.Contributors
+{
+    public partial class ContributorsControllerTests
+    {
+        [Theory]
+        [MemberData(nameof(ValidationExceptions))]
+        public async Task ShouldReturnBadRequestOnPostIfValidationErrorOccursAsync(
+            Xeption validationException)
+        {
+            // given
+            Contributor someContributor = CreateRandomContributor();
+
+            BadRequestObjectResult expectedBadRequestObjectResult =
+                BadRequest(validationException.InnerException);
+
+            var expectedActionResult =
+                new ActionResult<Contributor>(expectedBadRequestObjectResult);
+
+            this.contributorServiceMock.Setup(service =>
+                service.AddContributorAsync(It.IsAny<Contributor>()))
+                    .ThrowsAsync(validationException);
+
+            // when
+            ActionResult<Contributor> actualActionResult =
+                await this.contributorsController.PostContributorAsync(someContributor);
+
+            // then
+            actualActionResult.ShouldBeEquivalentTo(expectedActionResult);
+
+            this.contributorServiceMock.Verify(service =>
+                service.AddContributorAsync(It.IsAny<Contributor>()),
+                    Times.Once);
+
+            this.contributorServiceMock.VerifyNoOtherCalls();
+        }
+
+        [Theory]
+        [MemberData(nameof(ServerExceptions))]
+        public async Task ShouldReturnInternalServerErrorOnPostIfServerErrorOccurredAsync(
+            Xeption serverException)
+        {
+            // given
+            Contributor someContributor = CreateRandomContributor();
+
+            InternalServerErrorObjectResult expectedInternalServerErrorObjectResult =
+                InternalServerError(serverException);
+
+            var expectedActionResult =
+                new ActionResult<Contributor>(expectedInternalServerErrorObjectResult);
+
+            this.contributorServiceMock.Setup(service =>
+                service.AddContributorAsync(It.IsAny<Contributor>()))
+                    .ThrowsAsync(serverException);
+
+            // when
+            ActionResult<Contributor> actualActionResult =
+                await this.contributorsController.PostContributorAsync(someContributor);
+
+            // then
+            actualActionResult.ShouldBeEquivalentTo(expectedActionResult);
+
+            this.contributorServiceMock.Verify(service =>
+                service.AddContributorAsync(It.IsAny<Contributor>()),
+                    Times.Once);
+
+            this.contributorServiceMock.VerifyNoOtherCalls();
+        }
+
+        [Fact]
+        public async Task ShouldReturnConflictOnPostIfAlreadyExistsContributorErrorOccurredAsync()
+        {
+            // given
+            Contributor someContributor = CreateRandomContributor();
+            var someInnerException = new Exception();
+            string someMessage = GetRandomString();
+            var someDictionaryData = GetRandomDictionaryData();
+
+            var alreadyExistsContributorException =
+                new AlreadyExistsContributorException(
+                    message: someMessage,
+                    innerException: someInnerException,
+                    data: someInnerException.Data);
+
+            var contributorDependencyValidationException =
+                new ContributorDependencyValidationException(
+                    message: someMessage,
+                    innerException: alreadyExistsContributorException,
+                    data: someDictionaryData);
+
+            ConflictObjectResult expectedConflictObjectResult =
+                Conflict(alreadyExistsContributorException);
+
+            var expectedActionResult =
+                new ActionResult<Contributor>(expectedConflictObjectResult);
+
+            this.contributorServiceMock.Setup(service =>
+                service.AddContributorAsync(It.IsAny<Contributor>()))
+                    .ThrowsAsync(contributorDependencyValidationException);
+
+            // when
+            ActionResult<Contributor> actualActionResult =
+                await this.contributorsController.PostContributorAsync(someContributor);
+
+            // then
+            actualActionResult.ShouldBeEquivalentTo(expectedActionResult);
+
+            this.contributorServiceMock.Verify(service =>
+                service.AddContributorAsync(It.IsAny<Contributor>()),
+                    Times.Once);
+
+            this.contributorServiceMock.VerifyNoOtherCalls();
+        }
+
+        [Fact]
+        public async Task ShouldReturnFailedDependencyOnPostIfReferenceExceptionOccursAsync()
+        {
+            // given
+            Contributor someContributor = CreateRandomContributor();
+            var someInnerException = new Exception();
+            string someMessage = GetRandomString();
+
+            var invalidReferenceContributorException =
+                new InvalidReferenceContributorException(
+                    message: someMessage,
+                    innerException: someInnerException,
+                    data: someInnerException.Data);
+
+            var contributorDependencyValidationException =
+                new ContributorDependencyValidationException(
+                    message: someMessage,
+                    innerException: invalidReferenceContributorException,
+                    data: invalidReferenceContributorException.Data);
+
+            FailedDependencyObjectResult expectedFailedDependencyObjectResult =
+                    FailedDependency(invalidReferenceContributorException);
+
+            var expectedActionResult =
+                new ActionResult<Contributor>(expectedFailedDependencyObjectResult);
+
+            this.contributorServiceMock.Setup(service =>
+                service.AddContributorAsync(It.IsAny<Contributor>()))
+                    .ThrowsAsync(contributorDependencyValidationException);
+
+            // when
+            ActionResult<Contributor> actualActionResult =
+                await this.contributorsController.PostContributorAsync(someContributor);
+
+            // then
+            actualActionResult.ShouldBeEquivalentTo(expectedActionResult);
+
+            this.contributorServiceMock.Verify(service =>
+                service.AddContributorAsync(It.IsAny<Contributor>()),
+                    Times.Once);
+
+            this.contributorServiceMock.VerifyNoOtherCalls();
+        }
+    }
+}

GitFyle.Core.Api.Tests.Unit/Controllers/Contributors/ContributorsControllerTests.Logic.Post.cs

@@ -0,0 +1,52 @@
+// ----------------------------------------------------------------------------------
+// Copyright (c) The Standard Organization: A coalition of the Good-Hearted Engineers
+// ----------------------------------------------------------------------------------
+
+using System.Threading.Tasks;
+using Force.DeepCloner;
+using GitFyle.Core.Api.Models.Foundations.Contributors;
+using Microsoft.AspNetCore.Mvc;
+using Moq;
+using RESTFulSense.Clients.Extensions;
+using RESTFulSense.Models;
+
+namespace GitFyle.Core.Api.Tests.Unit.Controllers.Contributors
+{
+    public partial class ContributorsControllerTests
+    {
+        [Fact]
+        public async Task ShouldReturnCreatedOnPostAsync()
+        {
+            // given
+            Contributor randomContributor = CreateRandomContributor();
+            Contributor inputContributor = randomContributor;
+            Contributor addedContributor = inputContributor;
+            Contributor expectedContributor = addedContributor.DeepClone();
+
+            var expectedObjectResult =
+                new CreatedObjectResult(expectedContributor);
+
+            var expectedActionResult =
+                new ActionResult<Contributor>(expectedObjectResult);
+
+            this.contributorServiceMock.Setup(service =>
+                service.AddContributorAsync(inputContributor))
+                    .ReturnsAsync(addedContributor);
+
+            // when
+            ActionResult<Contributor> actualActionResult =
+                await this.contributorsController.PostContributorAsync(
+                    inputContributor);
+
+            // then
+            actualActionResult.ShouldBeEquivalentTo(
+                expectedActionResult);
+
+            this.contributorServiceMock.Verify(service =>
+                service.AddContributorAsync(inputContributor),
+                    Times.Once);
+
+            this.contributorServiceMock.VerifyNoOtherCalls();
+        }
+    }
+}

GitFyle.Core.Api.Tests.Unit/Controllers/Contributors/ContributorsControllerTests.cs

@@ -0,0 +1,107 @@
+// ----------------------------------------------------------------------------------
+// Copyright (c) The Standard Organization: A coalition of the Good-Hearted Engineers
+// ----------------------------------------------------------------------------------
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using GitFyle.Core.Api.Controllers;
+using GitFyle.Core.Api.Models.Foundations.Contributors;
+using GitFyle.Core.Api.Models.Foundations.Contributors.Exceptions;
+using GitFyle.Core.Api.Services.Foundations.Contributors;
+using Moq;
+using RESTFulSense.Controllers;
+using Tynamix.ObjectFiller;
+using Xeptions;
+
+namespace GitFyle.Core.Api.Tests.Unit.Controllers.Contributors
+{
+    public partial class ContributorsControllerTests : RESTFulController
+    {
+        private readonly Mock<IContributorService> contributorServiceMock;
+        private readonly ContributorsController contributorsController;
+
+        public ContributorsControllerTests()
+        {
+            this.contributorServiceMock = new Mock<IContributorService>();
+
+            this.contributorsController = new ContributorsController(
+                contributorService: this.contributorServiceMock.Object);
+        }
+
+        public static TheoryData<Xeption> ValidationExceptions()
+        {
+            var someInnerException = new Xeption();
+            string someMessage = GetRandomString();
+            var someDictionaryData = GetRandomDictionaryData();
+
+            return new TheoryData<Xeption>
+            {
+                new ContributorValidationException(
+                    message: someMessage,
+                    innerException: someInnerException),
+
+                new ContributorDependencyValidationException(
+                    message: someMessage,
+                    innerException: someInnerException,
+                    data: someDictionaryData)
+            };
+        }
+
+        public static TheoryData<Xeption> ServerExceptions()
+        {
+            var someInnerException = new Xeption();
+            string someMessage = GetRandomString();
+
+            return new TheoryData<Xeption>
+            {
+                new ContributorDependencyException(
+                    message: someMessage,
+                    innerException: someInnerException),
+
+                new ContributorServiceException(
+                    message: someMessage,
+                    innerException: someInnerException)
+            };
+        }
+
+        private static string GetRandomString() =>
+            new MnemonicString().GetValue();
+
+        private static int GetRandomNumber() =>
+            new IntRange(min: 2, max: 9).GetValue();
+
+        private static Dictionary<string, string[]> GetRandomDictionaryData()
+        {
+            var filler = new Filler<Dictionary<string, string[]>>();
+
+            filler.Setup()
+                .DictionaryItemCount(maxCount: 10);
+
+            return filler.Create();
+        }
+
+        private static DateTimeOffset GetRandomDateTimeOffset() =>
+            new DateTimeRange(earliestDate: DateTime.UnixEpoch).GetValue();
+
+        private static IQueryable<Contributor> CreateRandomnContributors() =>
+            CreateContributorFiller().Create(count: GetRandomNumber()).AsQueryable();
+
+        private static Contributor CreateRandomContributor() =>
+            CreateContributorFiller().Create();
+
+        private static Filler<Contributor> CreateContributorFiller()
+        {
+            var filler = new Filler<Contributor>();
+
+            filler.Setup()
+                .OnProperty(contributor =>
+                    contributor.Contributions).IgnoreIt()
+
+                .OnType<DateTimeOffset>().Use(
+                    GetRandomDateTimeOffset);
+
+            return filler;
+        }
+    }
+}