FOUNDATIONS: Contributor-AddAsync

GitFyle.Core.Api.Tests.Unit/Services/Foundations/Contributors/ContributorServiceTests.Exceptions.Add.cs

@@ -0,0 +1,232 @@
+// ----------------------------------------------------------------------------------
+// Copyright (c) The Standard Organization: A coalition of the Good-Hearted Engineers
+// ----------------------------------------------------------------------------------
+
+using System;
+using System.Threading.Tasks;
+using EFxceptions.Models.Exceptions;
+using FluentAssertions;
+using GitFyle.Core.Api.Models.Foundations.Contributors;
+using GitFyle.Core.Api.Models.Foundations.Contributors.Exceptions;
+using Microsoft.Data.SqlClient;
+using Microsoft.EntityFrameworkCore;
+using Moq;
+
+namespace GitFyle.Core.Api.Tests.Unit.Services.Foundations.Contributors
+{
+    public partial class ContributorServiceTests
+    {
+        [Fact]
+        public async Task ShouldThrowCriticalDependencyExceptionOnAddIfSqlErrorOccurredAndLogItAsync()
+        {
+            // given
+            Contributor someContributor = CreateRandomContributor();
+            SqlException sqlException = CreateSqlException();
+
+            var failedStorageContributorException =
+                new FailedStorageContributorException(
+                    message: "Failed storage contributor error occurred, contact support.",
+                    innerException: sqlException);
+
+            var expectedContributorDependencyException =
+                new ContributorDependencyException(
+                    message: "Contributor dependency error occurred, contact support.",
+                    innerException: failedStorageContributorException);
+
+            this.dateTimeBrokerMock.Setup(broker =>
+                broker.GetCurrentDateTimeOffsetAsync())
+                    .ThrowsAsync(sqlException);
+
+            // when
+            ValueTask<Contributor> addContributorTask =
+                this.contributorService.AddContributorAsync(
+                    someContributor);
+
+            ContributorDependencyException actualContributorDependencyException =
+                await Assert.ThrowsAsync<ContributorDependencyException>(
+                    testCode: addContributorTask.AsTask);
+
+            // then
+            actualContributorDependencyException.Should().BeEquivalentTo(
+                expectedContributorDependencyException);
+
+            this.dateTimeBrokerMock.Verify(broker =>
+                broker.GetCurrentDateTimeOffsetAsync(),
+                    Times.Once);
+
+            this.loggingBrokerMock.Verify(broker =>
+                broker.LogCriticalAsync(It.Is(SameExceptionAs(
+                    expectedContributorDependencyException))),
+                        Times.Once);
+
+            this.storageBrokerMock.Verify(broker =>
+                broker.InsertContributorAsync(It.IsAny<Contributor>()),
+                    Times.Never);
+
+            this.dateTimeBrokerMock.VerifyNoOtherCalls();
+            this.loggingBrokerMock.VerifyNoOtherCalls();
+            this.storageBrokerMock.VerifyNoOtherCalls();
+        }
+
+        [Fact]
+        public async Task ShouldThrowDependencyValidationExceptionOnAddIfContributorAlreadyExistsAndLogItAsync()
+        {
+            // given
+            Contributor someContributor = CreateRandomContributor();
+
+            var duplicateKeyException =
+                new DuplicateKeyException(
+                    message: "Duplicate key error occurred");
+
+            var alreadyExistsContributorException =
+                new AlreadyExistsContributorException(
+                    message: "Contributor already exists error occurred.",
+                    innerException: duplicateKeyException,
+                    data: duplicateKeyException.Data);
+
+            var expectedContributorDependencyValidationException =
+                new ContributorDependencyValidationException(
+                    message: "Contributor dependency validation error occurred, fix errors and try again.",
+                    innerException: alreadyExistsContributorException,
+                    data: alreadyExistsContributorException.Data);
+
+            this.dateTimeBrokerMock.Setup(broker =>
+                broker.GetCurrentDateTimeOffsetAsync())
+                    .ThrowsAsync(duplicateKeyException);
+
+            // when
+            ValueTask<Contributor> addContributorTask =
+                this.contributorService.AddContributorAsync(
+                    someContributor);
+
+            ContributorDependencyValidationException actualContributorDependencyValidationException =
+                await Assert.ThrowsAsync<ContributorDependencyValidationException>(
+                    testCode: addContributorTask.AsTask);
+
+            // then
+            actualContributorDependencyValidationException.Should().BeEquivalentTo(
+                expectedContributorDependencyValidationException);
+
+            this.dateTimeBrokerMock.Verify(broker =>
+                broker.GetCurrentDateTimeOffsetAsync(),
+                    Times.Once);
+
+            this.loggingBrokerMock.Verify(broker =>
+                broker.LogErrorAsync(It.Is(SameExceptionAs(
+                    expectedContributorDependencyValidationException))),
+                        Times.Once);
+
+            this.storageBrokerMock.Verify(broker =>
+                broker.InsertContributorAsync(It.IsAny<Contributor>()),
+                    Times.Never);
+
+            this.dateTimeBrokerMock.VerifyNoOtherCalls();
+            this.loggingBrokerMock.VerifyNoOtherCalls();
+            this.storageBrokerMock.VerifyNoOtherCalls();
+        }
+
+        [Fact]
+        public async Task ShouldThrowDependencyExceptionOnAddIfDependencyErrorOccurredAndLogItAsync()
+        {
+            // given
+            Contributor someContributor = CreateRandomContributor();
+            var dbUpdateException = new DbUpdateException();
+
+            var failedOperationContributorException =
+                new FailedOperationContributorException(
+                    message: "Failed operation contributor error occurred, contact support.",
+                    innerException: dbUpdateException);
+
+            var expectedContributorDependencyException =
+                new ContributorDependencyException(
+                    message: "Contributor dependency error occurred, contact support.",
+                    innerException: failedOperationContributorException);
+
+            this.dateTimeBrokerMock.Setup(broker =>
+                broker.GetCurrentDateTimeOffsetAsync())
+                    .ThrowsAsync(dbUpdateException);
+
+            // when
+            ValueTask<Contributor> addContributorTask =
+                this.contributorService.AddContributorAsync(
+                    someContributor);
+
+            ContributorDependencyException actualContributorDependencyException =
+                await Assert.ThrowsAsync<ContributorDependencyException>(
+                    testCode: addContributorTask.AsTask);
+
+            // then
+            actualContributorDependencyException.Should().BeEquivalentTo(
+                expectedContributorDependencyException);
+
+            this.dateTimeBrokerMock.Verify(broker =>
+                broker.GetCurrentDateTimeOffsetAsync(),
+                    Times.Once);
+
+            this.loggingBrokerMock.Verify(broker =>
+                broker.LogErrorAsync(It.Is(SameExceptionAs(
+                    expectedContributorDependencyException))),
+                        Times.Once);
+
+            this.storageBrokerMock.Verify(broker =>
+                broker.InsertContributorAsync(It.IsAny<Contributor>()),
+                    Times.Never);
+
+            this.dateTimeBrokerMock.VerifyNoOtherCalls();
+            this.loggingBrokerMock.VerifyNoOtherCalls();
+            this.storageBrokerMock.VerifyNoOtherCalls();
+        }
+
+        [Fact]
+        public async Task ShouldThrowServiceExceptionOnAddIfServiceErrorOccurredAndLogItAsync()
+        {
+            // given
+            Contributor randomContributor = CreateRandomContributor();
+            var serviceException = new Exception();
+
+            var failedServiceContributorException =
+                new FailedServiceContributorException(
+                    message: "Failed service contributor error occurred, contact support.",
+                    innerException: serviceException);
+
+            var expectedContributorServiceException =
+                new ContributorServiceException(
+                    message: "Service error occurred, contact support.",
+                    innerException: failedServiceContributorException);
+
+            this.dateTimeBrokerMock.Setup(broker =>
+                broker.GetCurrentDateTimeOffsetAsync())
+                    .ThrowsAsync(serviceException);
+
+            // when
+            ValueTask<Contributor> addContributorTask =
+                this.contributorService.AddContributorAsync(
+                    randomContributor);
+
+            ContributorServiceException actualContributorServiceException =
+                await Assert.ThrowsAsync<ContributorServiceException>(
+                    testCode: addContributorTask.AsTask);
+
+            // then
+            actualContributorServiceException.Should().BeEquivalentTo(
+                expectedContributorServiceException);
+
+            this.dateTimeBrokerMock.Verify(broker =>
+                broker.GetCurrentDateTimeOffsetAsync(),
+                        Times.Once);
+
+            this.loggingBrokerMock.Verify(broker =>
+                broker.LogErrorAsync(It.Is(SameExceptionAs(
+                    expectedContributorServiceException))),
+                        Times.Once);
+
+            this.storageBrokerMock.Verify(broker =>
+                broker.InsertContributorAsync(It.IsAny<Contributor>()),
+                    Times.Never);
+
+            this.dateTimeBrokerMock.VerifyNoOtherCalls();
+            this.loggingBrokerMock.VerifyNoOtherCalls();
+            this.storageBrokerMock.VerifyNoOtherCalls();
+        }
+    }
+}

GitFyle.Core.Api.Tests.Unit/Services/Foundations/Contributors/ContributorServiceTests.Logic.Add.cs

@@ -0,0 +1,55 @@
+// ----------------------------------------------------------------------------------
+// Copyright (c) The Standard Organization: A coalition of the Good-Hearted Engineers
+// ----------------------------------------------------------------------------------
+
+using System;
+using System.Threading.Tasks;
+using FluentAssertions;
+using Force.DeepCloner;
+using GitFyle.Core.Api.Models.Foundations.Contributors;
+using Moq;
+
+namespace GitFyle.Core.Api.Tests.Unit.Services.Foundations.Contributors
+{
+    public partial class ContributorServiceTests
+    {
+        [Fact]
+        public async Task ShouldAddContributorAsync()
+        {
+            // given
+            DateTimeOffset randomDateTime = GetRandomDateTimeOffset();
+            DateTimeOffset now = randomDateTime;
+            Contributor randomContributor = CreateRandomContributor(dateTimeOffset: now);
+            Contributor inputContributor = randomContributor;
+            Contributor insertedContributor = inputContributor.DeepClone();
+            Contributor expectedContributor = insertedContributor.DeepClone();
+
+            this.storageBrokerMock.Setup(broker =>
+                broker.InsertContributorAsync(inputContributor))
+                    .ReturnsAsync(insertedContributor);
+
+            this.dateTimeBrokerMock.Setup(broker =>
+                broker.GetCurrentDateTimeOffsetAsync())
+                    .ReturnsAsync(now);
+
+            // when
+            Contributor actualContributor =
+                await this.contributorService.AddContributorAsync(inputContributor);
+
+            // then
+            actualContributor.Should().BeEquivalentTo(expectedContributor);
+
+            this.dateTimeBrokerMock.Verify(broker =>
+                broker.GetCurrentDateTimeOffsetAsync(),
+                    Times.Once);
+
+            this.storageBrokerMock.Verify(broker =>
+                broker.InsertContributorAsync(inputContributor),
+                    Times.Once);
+
+            this.storageBrokerMock.VerifyNoOtherCalls();
+            this.loggingBrokerMock.VerifyNoOtherCalls();
+            this.dateTimeBrokerMock.VerifyNoOtherCalls();
+        }
+    }
+}