CODE RUB: Events Exceptions Upgrade v2.10.0

Closes: #506

Taarafo.Core.Tests.Unit/Services/Foundations/Events/EventServiceTests.Exceptions.Add.cs

@@ -19,18 +19,24 @@ namespace Taarafo.Core.Tests.Unit.Services.Foundations.Events
     public partial class EventServiceTests
     {
         [Fact]
-        public async Task ShouldThrowCriticalDependencyExceptionOnCreateIfSqlErrorOccursAndLogItAsync()
+        private async Task ShouldThrowCriticalDependencyExceptionOnCreateIfSqlErrorOccursAndLogItAsync()
         {
             // given
             DateTimeOffset randomDateTime = GetRandomDateTimeOffset();
             Event someEvent = CreateRandomEvent(randomDateTime);
-            SqlException sqlException = GetSqlException();
+
+            SqlException sqlException = 
+                GetSqlException();
 
             var failedEventStorageException =
-                new FailedEventStorageException(sqlException);
+                new FailedEventStorageException(
+                    message: "Failed event storage error occured, contact support.",
+                    innerException: sqlException);
 
             var expectedEventDependencyException =
-                new EventDependencyException(failedEventStorageException);
+                new EventDependencyException(
+                    message: "Event dependency validation occurred, please try again.",
+                    innerException: failedEventStorageException);
 
             this.dateTimeBrokerMock.Setup(broker =>
                 broker.GetCurrentDateTimeOffset())
@@ -67,7 +73,7 @@ await Assert.ThrowsAsync<EventDependencyException>(
         }
 
         [Fact]
-        public async Task ShouldThrowDependencyValidationExceptionOnAddIfEventAlreadyExsitsAndLogItAsync()
+        private async Task ShouldThrowDependencyValidationExceptionOnAddIfEventAlreadyExsitsAndLogItAsync()
         {
             // given
             DateTimeOffset randomDateTimeOffset = GetRandomDateTimeOffset();
@@ -79,10 +85,14 @@ public async Task ShouldThrowDependencyValidationExceptionOnAddIfEventAlreadyExs
                 new DuplicateKeyException(randomMessage);
 
             var alreadyExistsEventException =
-                new AlreadyExistsEventException(duplicateKeyException);
+                new AlreadyExistsEventException(
+                    message: "Event with the same id already exists.",
+                    innerException: duplicateKeyException);
 
             var expectedEventDependencyValidationException =
-                new EventDependencyValidationException(alreadyExistsEventException);
+                new EventDependencyValidationException(
+                    message: "Event dependency validation occurred, please try again.",
+                    innerException: alreadyExistsEventException);
 
             this.dateTimeBrokerMock.Setup(broker =>
                 broker.GetCurrentDateTimeOffset())
@@ -119,7 +129,7 @@ await Assert.ThrowsAsync<EventDependencyValidationException>(
         }
 
         [Fact]
-        public async void ShouldThrowDependencyValidationExceptionOnAddIfReferenceErrorOccursAndLogItAsync()
+        private async void ShouldThrowDependencyValidationExceptionOnAddIfReferenceErrorOccursAndLogItAsync()
         {
             // given
             Event someEvent = CreateRandomEvent();
@@ -130,10 +140,14 @@ public async void ShouldThrowDependencyValidationExceptionOnAddIfReferenceErrorO
                 new ForeignKeyConstraintConflictException(exceptionMessage);
 
             var invalidEventReferenceException =
-                new InvalidEventReferenceException(foreignKeyConstraintConflictException);
+                new InvalidEventReferenceException(
+                    message: "Invalid eventt reference error occurred.",
+                    innerException: foreignKeyConstraintConflictException);
 
             var expectedEventDependencyValidationException =
-                new EventDependencyValidationException(invalidEventReferenceException);
+                new EventDependencyValidationException(
+                    message: "Event dependency validation occurred, please try again.",
+                    innerException: invalidEventReferenceException);
 
             this.dateTimeBrokerMock.Setup(broker =>
                 broker.GetCurrentDateTimeOffset())
@@ -170,7 +184,7 @@ await Assert.ThrowsAsync<EventDependencyValidationException>(
         }
 
         [Fact]
-        public async Task ShouldThrowDependencyExceptionOnAddIfDatabaseUpdateErrorOccursAndLogItAsync()
+        private async Task ShouldThrowDependencyExceptionOnAddIfDatabaseUpdateErrorOccursAndLogItAsync()
         {
             // given
             Event someEvent = CreateRandomEvent();
@@ -179,10 +193,14 @@ public async Task ShouldThrowDependencyExceptionOnAddIfDatabaseUpdateErrorOccurs
                 new DbUpdateException();
 
             var failedEventStorageException =
-                new FailedEventStorageException(databaseUpdateException);
+                new FailedEventStorageException(
+                    message: "Failed event storage error occured, contact support.",
+                    innerException: databaseUpdateException);
 
             var expectedEventDependencyException =
-                new EventDependencyException(failedEventStorageException);
+                new EventDependencyException(
+                    message: "Event dependency validation occurred, please try again.",
+                    innerException: failedEventStorageException);
 
             this.dateTimeBrokerMock.Setup(broker =>
                 broker.GetCurrentDateTimeOffset())
@@ -219,17 +237,21 @@ await Assert.ThrowsAsync<EventDependencyException>(
         }
 
         [Fact]
-        public async Task ShouldThrowServiceExceptionOnAddIfServiceErrorOccursAndLogItAsync()
+        private async Task ShouldThrowServiceExceptionOnAddIfServiceErrorOccursAndLogItAsync()
         {
             // given
             Event someEvent = CreateRandomEvent();
             var serviceException = new Exception();
 
             var failedEventServiceException =
-                new FailedEventServiceException(serviceException);
+                new FailedEventServiceException(
+                    message: "Failed event service occurred, please contact support.",
+                    innerException: serviceException);
 
             var expectedEventServiceException =
-                new EventServiceException(failedEventServiceException);
+                new EventServiceException(
+                    message: "Event service error occurred, contact support.",
+                    innerException: failedEventServiceException);
 
             this.dateTimeBrokerMock.Setup(broker =>
                 broker.GetCurrentDateTimeOffset())
@@ -265,4 +287,4 @@ await Assert.ThrowsAsync<EventServiceException>(
             this.loggingBrokerMock.VerifyNoOtherCalls();
         }
     }
-}
+}

Taarafo.Core.Tests.Unit/Services/Foundations/Events/EventServiceTests.Exceptions.RetrieveAll.cs

@@ -15,15 +15,18 @@ namespace Taarafo.Core.Tests.Unit.Services.Foundations.Events
     public partial class EventServiceTests
     {
         [Fact]
-        public void ShouldThrowCriticalDependencyExceptionOnRetrieveAllWhenSqlExceptionOccursAndLogIt()
+        private void ShouldThrowCriticalDependencyExceptionOnRetrieveAllWhenSqlExceptionOccursAndLogIt()
         {
             // given
             SqlException sqlException = CreateSqlException();
+
             var failedEventStorageException =
                 new FailedEventStorageException(sqlException);
 
             var expectedEventDependencyException =
-                new EventDependencyException(failedEventStorageException);
+                new EventDependencyException(
+                    message: "Event dependency validation occurred, please try again.",
+                    innerException: failedEventStorageException);
 
             this.storageBrokerMock.Setup(broker =>
                 broker.SelectAllEvents()).Throws(sqlException);
@@ -36,30 +39,37 @@ public void ShouldThrowCriticalDependencyExceptionOnRetrieveAllWhenSqlExceptionO
                 Assert.Throws<EventDependencyException>(retrieveAllEventAction);
 
             // then
-            actualEventDependencyException.Should().BeEquivalentTo(expectedEventDependencyException);
+            actualEventDependencyException.Should().BeEquivalentTo(
+                expectedEventDependencyException);
 
             this.storageBrokerMock.Verify(broker =>
                 broker.SelectAllEvents(), Times.Once);
 
             this.loggingBrokerMock.Verify(broker =>
-                broker.LogCritical(It.Is(SameExceptionAs(expectedEventDependencyException))),
+                broker.LogCritical(It.Is(SameExceptionAs(
+                    expectedEventDependencyException))),
                     Times.Once);
 
             this.storageBrokerMock.VerifyNoOtherCalls();
             this.loggingBrokerMock.VerifyNoOtherCalls();
         }
 
         [Fact]
-        public void ShouldThrowServiceExceptionOnRetrieveAllIfServiceErrorOccursAndLogItAsync()
+        private void ShouldThrowServiceExceptionOnRetrieveAllIfServiceErrorOccursAndLogItAsync()
         {
             // given
             string exceptionMessage = GetRandomMessage();
-            var serviceException = new Exception(exceptionMessage);
+
+            var serviceException = 
+                new Exception(exceptionMessage);
 
-            var failedEventServiceException = new FailedEventServiceException(serviceException);
+            var failedEventServiceException = 
+                new FailedEventServiceException(serviceException);
 
             var expectedEventServiceException = new
-                EventServiceException(failedEventServiceException);
+                EventServiceException(
+                    message: "Event service error occurred, contact support.",
+                    innerException: failedEventServiceException);
 
             this.storageBrokerMock.Setup(broker =>
                 broker.SelectAllEvents()).Throws(serviceException);
@@ -73,16 +83,19 @@ public void ShouldThrowServiceExceptionOnRetrieveAllIfServiceErrorOccursAndLogIt
                     retrieveAllEventsAction);
 
             // then
-            actualEventServiceException.Should().BeEquivalentTo(expectedEventServiceException);
+            actualEventServiceException.Should().BeEquivalentTo(
+                expectedEventServiceException);
 
-            this.storageBrokerMock.Verify(broker => broker.SelectAllEvents(), Times.Once);
+            this.storageBrokerMock.Verify(broker =>
+                broker.SelectAllEvents(), Times.Once);
 
             this.loggingBrokerMock.Verify(broker =>
-                broker.LogError(It.Is(SameExceptionAs(expectedEventServiceException))),
+                broker.LogError(It.Is(SameExceptionAs(
+                    expectedEventServiceException))),
                     Times.Once);
 
             this.storageBrokerMock.VerifyNoOtherCalls();
             this.loggingBrokerMock.VerifyNoOtherCalls();
         }
     }
-}
+}

Taarafo.Core.Tests.Unit/Services/Foundations/Events/EventServiceTests.Logic.Add.cs

@@ -16,7 +16,7 @@ namespace Taarafo.Core.Tests.Unit.Services.Foundations.Events
     public partial class EventServiceTests
     {
         [Fact]
-        public async Task ShouldAddEventAsync()
+        private async Task ShouldAddEventAsync()
         {
             // given
             DateTimeOffset randomDateTime = GetRandomDateTimeOffset();
@@ -47,4 +47,4 @@ public async Task ShouldAddEventAsync()
             this.storageBrokerMock.VerifyNoOtherCalls();
         }
     }
-}
+}

Taarafo.Core.Tests.Unit/Services/Foundations/Events/EventServiceTests.Logic.RetrieveAll.cs

@@ -14,7 +14,7 @@ namespace Taarafo.Core.Tests.Unit.Services.Foundations.Events
     public partial class EventServiceTests
     {
         [Fact]
-        public void ShouldRetrieveAllEvents()
+        private void ShouldRetrieveAllEvents()
         {
             // given
             IQueryable<Event> randomEvents = CreateRandomEvents();
@@ -39,4 +39,4 @@ public void ShouldRetrieveAllEvents()
             this.dateTimeBrokerMock.VerifyNoOtherCalls();
         }
     }
-}
+}

Taarafo.Core.Tests.Unit/Services/Foundations/Events/EventServiceTests.Validations.Add.cs

@@ -16,7 +16,7 @@ namespace Taarafo.Core.Tests.Unit.Services.Foundations.Events
     public partial class EventServiceTests
     {
         [Fact]
-        public async Task ShouldThrowValidationExceptionOnAddIfEventIsNullAndLogitAsync()
+        private async Task ShouldThrowValidationExceptionOnAddIfEventIsNullAndLogitAsync()
         {
             // given
             Event nullEvent = null;
@@ -25,7 +25,9 @@ public async Task ShouldThrowValidationExceptionOnAddIfEventIsNullAndLogitAsync(
                 new NullEventException();
 
             var expectedEventValidationException =
-                new EventValidationException(nullEventException);
+                new EventValidationException(
+                    message: "Event validation error occurred, please try again.",
+                    innerException: nullEventException);
 
             // when
             ValueTask<Event> addEventTask =
@@ -50,7 +52,7 @@ await Assert.ThrowsAsync<EventValidationException>(
         }
 
         [Fact]
-        public async Task ShouldThrowValidationExceptionOnAddIfEventIsInvalidAndLogItAsync()
+        private async Task ShouldThrowValidationExceptionOnAddIfEventIsInvalidAndLogItAsync()
         {
             // given
             Guid invalidGuid = Guid.Empty;
@@ -85,7 +87,9 @@ public async Task ShouldThrowValidationExceptionOnAddIfEventIsInvalidAndLogItAsy
                 values: "Id is required");
 
             var expectedEventValidationException =
-                new EventValidationException(invalidEventException);
+                new EventValidationException(
+                    message: "Event validation error occurred, please try again.",
+                    innerException: invalidEventException);
 
             //when
             ValueTask<Event> addEventTask =
@@ -119,7 +123,7 @@ await Assert.ThrowsAsync<EventValidationException>(
 
         [Theory]
         [MemberData(nameof(MinutesBeforeOrAfter))]
-        public async Task ShouldThrowValidationExceptionOnAddIfEventDateIsNotRecentAndLogItAsync(
+        private async Task ShouldThrowValidationExceptionOnAddIfEventDateIsNotRecentAndLogItAsync(
             int minutesBeforeOrAfter)
         {
             // given
@@ -131,6 +135,7 @@ public async Task ShouldThrowValidationExceptionOnAddIfEventDateIsNotRecentAndLo
 
             Event randomEvent = CreateRandomEvent(invalidDateTime);
             Event invalidEvent = randomEvent;
+
             var invalidEventException =
                 new InvalidEventException();
 
@@ -143,7 +148,9 @@ public async Task ShouldThrowValidationExceptionOnAddIfEventDateIsNotRecentAndLo
                 values: "Date is not recent");
 
             var expectedEventValidationException =
-                new EventValidationException(invalidEventException);
+                new EventValidationException(
+                    message: "Event validation error occurred, please try again.",
+                    innerException: invalidEventException);
 
             this.dateTimeBrokerMock.Setup(broker =>
                 broker.GetCurrentDateTimeOffset())
@@ -179,4 +186,4 @@ await Assert.ThrowsAsync<EventValidationException>(
             this.storageBrokerMock.VerifyNoOtherCalls();
         }
     }
-}
+}

Taarafo.Core.Tests.Unit/Services/Foundations/Events/EventServiceTests.cs

@@ -94,4 +94,4 @@ private static Filler<Event> CreateEventFiller(DateTimeOffset dates)
             return filler;
         }
     }
-}
+}

Taarafo.Core/Models/Events/Exceptions/AlreadyExistsEventException.cs

@@ -8,10 +8,16 @@
 
 namespace Taarafo.Core.Models.Events.Exceptions
 {
-	public class AlreadyExistsEventException : Xeption
-	{
-		public AlreadyExistsEventException(Exception innerException)
-			: base(message: "Event with the same id already exists.", innerException)
-		{ }
-	}
+    public class AlreadyExistsEventException : Xeption
+    {
+        public AlreadyExistsEventException(Exception innerException)
+            : base(
+                message: "Event with the same id already exists.",
+                innerException: innerException)
+        { }
+
+        public AlreadyExistsEventException(string message, Exception innerException)
+            : base(message, innerException)
+        { }
+    }
 }

Taarafo.Core/Models/Events/Exceptions/EventDependencyException.cs

@@ -10,7 +10,13 @@ namespace Taarafo.Core.Models.Events.Exceptions
     public class EventDependencyException : Xeption
     {
         public EventDependencyException(Xeption innerException)
-            : base(message: "Event dependency validation occurred, please try again.", innerException)
+            : base(
+                message: "Event dependency validation occurred, please try again.",
+                innerException: innerException)
+        { }
+
+        public EventDependencyException(string message, Xeption innerException)
+            : base(message, innerException)
         { }
     }
-}
+}

Taarafo.Core/Models/Events/Exceptions/EventDependencyValidationException.cs

@@ -10,7 +10,13 @@ namespace Taarafo.Core.Models.Events.Exceptions
     public class EventDependencyValidationException : Xeption
     {
         public EventDependencyValidationException(Xeption innerException)
-            : base(message: "Event dependency validation occurred, please try again.", innerException)
+            : base(
+                message: "Event dependency validation occurred, please try again.",
+                innerException: innerException)
+        { }
+
+        public EventDependencyValidationException(string message, Xeption innerException)
+            : base(message, innerException)
         { }
     }
 }