FOUNDATIONS: Retrieve Reader

LibraryManagement.Api.Tests.Unit/Services/Foundations/Readers/ReaderServiceTests.Exceptions.RetrieveAll.cs

@@ -0,0 +1,94 @@
+//-----------------------------------------------------------
+// Copyright (c) Coalition of Good-Hearted Engineers
+// Free To Use To Build Reliable Library Management Solutions
+//-----------------------------------------------------------
+
+using FluentAssertions;
+using LibraryManagement.Api.Models.Foundations.Readers.Exceptions;
+using Microsoft.Data.SqlClient;
+using Moq;
+
+namespace LibraryManagement.Api.Tests.Unit.Services.Foundations.Readers
+{
+    public partial class ReaderServiceTests
+    {
+        [Fact]
+        public void ShouldThrowCriticalDependencyExceptionOnRetrieveAllWhenSqlExceptionOccursAndLogIt()
+        {
+            // given
+            SqlException sqlException = GetSqlError();
+
+            var failedReaderStorageException =
+                new FailedReaderStorageException(sqlException);
+
+            var expectedReaderDependencyException =
+                new ReaderDependencyException(failedReaderStorageException);
+
+            this.storageBrokerMock.Setup(broker =>
+                broker.SelectAllReaders()).Throws(sqlException);
+
+            // when
+            Action retrieveAllReadersAction = () =>
+                this.readerService.RetrieveAllReaders();
+
+            ReaderDependencyException actualReaderDependencyException =
+                Assert.Throws<ReaderDependencyException>(retrieveAllReadersAction);
+
+            // then
+            actualReaderDependencyException.Should()
+                .BeEquivalentTo(expectedReaderDependencyException);
+
+            this.storageBrokerMock.Verify(broker =>
+                broker.SelectAllReaders(),
+                    Times.Once());
+
+            this.loggingBrokerMock.Verify(broker =>
+                broker.LogCritical(It.Is(SameExceptionAs(
+                    expectedReaderDependencyException))),
+                        Times.Once);
+
+            this.storageBrokerMock.VerifyNoOtherCalls();
+            this.loggingBrokerMock.VerifyNoOtherCalls();
+        }
+
+        [Fact]
+        public void ShouldThrowServiceExceptionOnRetrieveAllIfServiceErrorOccursAndLogItAsync()
+        {
+            // given
+            string exceptionMessage = GetRandomString();
+            var serverException = new Exception(exceptionMessage);
+
+            var failedReaderServiceException =
+                new FailedReaderServiceException(serverException);
+
+            var expectedReaderServiceException =
+                new ReaderServiceException(failedReaderServiceException);
+
+            this.storageBrokerMock.Setup(broker =>
+                broker.SelectAllReaders()).Throws(serverException);
+
+            // when
+            Action retrieveAllReaderActions = () =>
+                this.readerService.RetrieveAllReaders();
+
+            ReaderServiceException actualReaderServiceException =
+                Assert.Throws<ReaderServiceException>(retrieveAllReaderActions);
+
+            // then
+            actualReaderServiceException.Should()
+                .BeEquivalentTo(expectedReaderServiceException);
+
+            this.storageBrokerMock.Verify(broker =>
+                broker.SelectAllReaders(),
+                    Times.Once());
+
+            this.loggingBrokerMock.Verify(broker =>
+                broker.LogError(It.Is(SameExceptionAs(
+                    expectedReaderServiceException))),
+                        Times.Once);
+
+            this.storageBrokerMock.VerifyNoOtherCalls();
+            this.loggingBrokerMock.VerifyNoOtherCalls();
+        }
+    }
+}

LibraryManagement.Api.Tests.Unit/Services/Foundations/Readers/ReaderServiceTests.Exceptions.RetrieveById.cs

@@ -0,0 +1,100 @@
+//-----------------------------------------------------------
+// Copyright (c) Coalition of Good-Hearted Engineers
+// Free To Use To Build Reliable Library Management Solutions
+//-----------------------------------------------------------
+
+using FluentAssertions;
+using LibraryManagement.Api.Models.Foundations.Readers;
+using LibraryManagement.Api.Models.Foundations.Readers.Exceptions;
+using Microsoft.Data.SqlClient;
+using Moq;
+
+namespace LibraryManagement.Api.Tests.Unit.Services.Foundations.Readers
+{
+    public partial class ReaderServiceTests
+    {
+        [Fact]
+        public async Task ShouldThrowCriticalDependencyExceptionOnRetrieveByIdIfSqlErrorOccursAndLogItAsync()
+        {
+            // given
+            Guid someId = Guid.NewGuid();
+            SqlException sqlException = GetSqlError();
+
+            var failedReaderStorageException =
+                new FailedReaderStorageException(sqlException);
+
+            var expectedReaderDependencyException =
+                new ReaderDependencyException(failedReaderStorageException);
+
+            this.storageBrokerMock.Setup(broker =>
+                broker.SelectReaderByIdAsync(It.IsAny<Guid>()))
+                    .ThrowsAsync(sqlException);
+
+            // when
+            ValueTask<Reader> retrieveReaderById =
+                this.readerService.RetrieveReaderByIdAsync(someId);
+
+            ReaderDependencyException actualReaderDependencyException =
+                await Assert.ThrowsAsync<ReaderDependencyException>(() =>
+                    retrieveReaderById.AsTask());
+
+            // then
+            actualReaderDependencyException.Should()
+                .BeEquivalentTo(expectedReaderDependencyException);
+
+            this.storageBrokerMock.Verify(broker =>
+                broker.SelectReaderByIdAsync(someId),
+                    Times.Once());
+
+            this.loggingBrokerMock.Verify(broker =>
+                broker.LogCritical(It.Is(SameExceptionAs(
+                    expectedReaderDependencyException))),
+                        Times.Once);
+
+            this.storageBrokerMock.VerifyNoOtherCalls();
+            this.loggingBrokerMock.VerifyNoOtherCalls();
+        }
+
+        [Fact]
+        public async Task ShouldThrowServiceExceptionOnRetrieveByIdAsyncIfServiceErrorOccursAndLogItAsync()
+        {
+            // given
+            Guid someId = Guid.NewGuid();
+            var serverException = new Exception();
+
+            var failedReaderServiceException =
+                new FailedReaderServiceException(serverException);
+
+            var expectedReaderServiceException =
+                new ReaderServiceException(failedReaderServiceException);
+
+            this.storageBrokerMock.Setup(broker =>
+                broker.SelectReaderByIdAsync(It.IsAny<Guid>()))
+                    .ThrowsAsync(serverException);
+
+            // when
+            ValueTask<Reader> retrieveReaderById =
+                this.readerService.RetrieveReaderByIdAsync(someId);
+
+            ReaderServiceException actualReaderServiceException =
+                await Assert.ThrowsAsync<ReaderServiceException>(() =>
+                    retrieveReaderById.AsTask());
+
+            // then
+            actualReaderServiceException.Should()
+                .BeEquivalentTo(expectedReaderServiceException);
+
+            this.storageBrokerMock.Verify(broker =>
+                broker.SelectReaderByIdAsync(someId),
+                    Times.Once);
+
+            this.loggingBrokerMock.Verify(broker =>
+                broker.LogError(It.Is(SameExceptionAs(
+                    expectedReaderServiceException))),
+                        Times.Once);
+
+            this.storageBrokerMock.VerifyNoOtherCalls();
+            this.loggingBrokerMock.VerifyNoOtherCalls();
+        }
+    }
+}

LibraryManagement.Api.Tests.Unit/Services/Foundations/Readers/ReaderServiceTests.Logic.RetrieveAll.cs

@@ -0,0 +1,42 @@
+//-----------------------------------------------------------
+// Copyright (c) Coalition of Good-Hearted Engineers
+// Free To Use To Build Reliable Library Management Solutions
+//-----------------------------------------------------------
+
+using FluentAssertions;
+using Force.DeepCloner;
+using LibraryManagement.Api.Models.Foundations.Readers;
+using Moq;
+
+namespace LibraryManagement.Api.Tests.Unit.Services.Foundations.Readers
+{
+    public partial class ReaderServiceTests
+    {
+        [Fact]
+        public void ShouldRetrieveAllReaders()
+        {
+            // given
+            IQueryable<Reader> randomReader = CreateRandomReaders();
+            IQueryable<Reader> storageReader = randomReader;
+            IQueryable<Reader> expectedReader = storageReader.DeepClone();
+
+            this.storageBrokerMock.Setup(broker =>
+                broker.SelectAllReaders())
+                    .Returns(storageReader);
+
+            // when
+            IQueryable<Reader> actualReader =
+                this.readerService.RetrieveAllReaders();
+
+            // then
+            actualReader.Should().BeEquivalentTo(expectedReader);
+
+            this.storageBrokerMock.Verify(broker =>
+                broker.SelectAllReaders(),
+                    Times.Once);
+
+            this.storageBrokerMock.VerifyNoOtherCalls();
+            this.loggingBrokerMock.VerifyNoOtherCalls();
+        }
+    }
+}

LibraryManagement.Api.Tests.Unit/Services/Foundations/Readers/ReaderServiceTests.Logic.RetrieveById.cs

@@ -0,0 +1,44 @@
+//-----------------------------------------------------------
+// Copyright (c) Coalition of Good-Hearted Engineers
+// Free To Use To Build Reliable Library Management Solutions
+//-----------------------------------------------------------
+
+using FluentAssertions;
+using Force.DeepCloner;
+using LibraryManagement.Api.Models.Foundations.Readers;
+using Moq;
+
+namespace LibraryManagement.Api.Tests.Unit.Services.Foundations.Readers
+{
+    public partial class ReaderServiceTests
+    {
+        [Fact]
+        public async Task ShouldRetrieveReaderByIdAsync()
+        {
+            // given
+            Guid randomReaderId = Guid.NewGuid();
+            Guid inputReaderId = randomReaderId;
+            Reader randomReader = CreateRandomReader();
+            Reader storageReader = randomReader;
+            Reader expectedReader = storageReader.DeepClone();
+
+            this.storageBrokerMock.Setup(broker =>
+                broker.SelectReaderByIdAsync(inputReaderId))
+                    .ReturnsAsync(storageReader);
+
+            // when
+            Reader actualReader = await this
+                .readerService.RetrieveReaderByIdAsync(inputReaderId);
+
+            // then
+            actualReader.Should().BeEquivalentTo(expectedReader);
+
+            this.storageBrokerMock.Verify(broker =>
+                broker.SelectReaderByIdAsync(inputReaderId),
+                    Times.Once);
+
+            this.storageBrokerMock.VerifyNoOtherCalls();
+            this.loggingBrokerMock.VerifyNoOtherCalls();
+        }
+    }
+}

LibraryManagement.Api.Tests.Unit/Services/Foundations/Readers/ReaderServiceTests.Validations.RetrieveById.cs

@@ -0,0 +1,96 @@
+//-----------------------------------------------------------
+// Copyright (c) Coalition of Good-Hearted Engineers
+// Free To Use To Build Reliable Library Management Solutions
+//-----------------------------------------------------------
+
+using FluentAssertions;
+using LibraryManagement.Api.Models.Foundations.Readers;
+using LibraryManagement.Api.Models.Foundations.Readers.Exceptions;
+using Moq;
+
+namespace LibraryManagement.Api.Tests.Unit.Services.Foundations.Readers
+{
+    public partial class ReaderServiceTests
+    {
+        [Fact]
+        public async Task ShouldThrowValidationExceptionOnRetrieveByIdIfIdIsInvalidAndLogItAsync()
+        {
+            // given
+            Guid invalidReaderId = Guid.Empty;
+            var invalidReaderException = new InvalidReaderException();
+
+            invalidReaderException.AddData(
+                key: nameof(Reader.ReaderId),
+                values: "Id is required");
+
+            var expectedReaderValidationException =
+                new ReaderValidationException(invalidReaderException);
+
+            // when
+            ValueTask<Reader> retrieveReaderById =
+                this.readerService.RetrieveReaderByIdAsync(invalidReaderId);
+
+            ReaderValidationException actualReaderValidationException =
+                await Assert.ThrowsAsync<ReaderValidationException>(() =>
+                    retrieveReaderById.AsTask());
+
+            // then
+            actualReaderValidationException.Should()
+                .BeEquivalentTo(expectedReaderValidationException);
+
+            this.loggingBrokerMock.Verify(broker =>
+                broker.LogError(It.Is(SameExceptionAs(
+                    expectedReaderValidationException))),
+                        Times.Once);
+
+            this.storageBrokerMock.Verify(broker =>
+                broker.SelectReaderByIdAsync(It.IsAny<Guid>()),
+                    Times.Never);
+
+            this.loggingBrokerMock.VerifyNoOtherCalls();
+            this.storageBrokerMock.VerifyNoOtherCalls();
+        }
+
+        [Fact]
+        public async Task ShouldThrowValidationExceptionOnRetrieveByIdIfReaderNotFoundAndLogItAsync()
+        {
+            // given
+            Guid someReaderId = Guid.NewGuid();
+            Reader noReader = null;
+
+            var notFoundReaderException =
+                new NotFoundReaderException(someReaderId);
+
+            var expectedReaderValidationException =
+                new ReaderValidationException(notFoundReaderException);
+
+            this.storageBrokerMock.Setup(broker =>
+                broker.SelectReaderByIdAsync(It.IsAny<Guid>()))
+                    .ReturnsAsync(noReader);
+
+            // when
+            ValueTask<Reader> retriveByIdReaderTask =
+                this.readerService.RetrieveReaderByIdAsync(someReaderId);
+
+            var actualReaderValidationException =
+                await Assert.ThrowsAsync<ReaderValidationException>(() =>
+                    retriveByIdReaderTask.AsTask());
+
+            // then
+            actualReaderValidationException.Should()
+                .BeEquivalentTo(expectedReaderValidationException);
+
+            this.storageBrokerMock.Verify(broker =>
+                broker.SelectReaderByIdAsync(someReaderId),
+                    Times.Once);
+
+            this.loggingBrokerMock.Verify(broker =>
+                broker.LogError(It.Is(SameExceptionAs(
+                    expectedReaderValidationException))),
+                        Times.Once);
+
+            this.storageBrokerMock.VerifyNoOtherCalls();
+            this.loggingBrokerMock.VerifyNoOtherCalls();
+        }
+    }
+}

LibraryManagement.Api.Tests.Unit/Services/Foundations/Readers/ReaderServiceTests.cs

@@ -37,6 +37,15 @@ private static Reader CreateRandomReader() =>
         private static DateTimeOffset GetRandomDateTimeOffset() =>
             new DateTimeRange(earliestDate: new DateTime()).GetValue();
 
+        private IQueryable<Reader> CreateRandomReaders()
+        {
+            return CreateReaderFiller(GetRandomDateTimeOffset())
+                .Create(count: GetRandomNumber()).AsQueryable();
+        }
+
+        private static int GetRandomNumber() =>
+            new IntRange(2, 9).GetValue();
+
         private static SqlException GetSqlError() =>
             (SqlException)RuntimeHelpers.GetUninitializedObject(typeof(SqlException));