public async Task ShouldThrowValidationExceptionOnModifyWhenAttendanceIdIsInvalidAndLogItAsync() { //given Guid invalidAttendanceId = Guid.Empty; DateTimeOffset dateTime = GetRandomDateTime(); Attendance randomAttendance = CreateRandomAttendance(dateTime); Attendance invalidAttendance = randomAttendance; invalidAttendance.Id = invalidAttendanceId; var invalidAttendanceException = new InvalidAttendanceException( parameterName: nameof(Attendance.Id), parameterValue: invalidAttendance.Id); var expectedAttendanceValidationException = new AttendanceValidationException(invalidAttendanceException); //when ValueTask <Attendance> modifyAttendanceTask = this.attendanceService.ModifyAttendanceAsync(invalidAttendance); //then await Assert.ThrowsAsync <AttendanceValidationException>(() => modifyAttendanceTask.AsTask()); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameExceptionAs(expectedAttendanceValidationException))), Times.Once); this.loggingBrokerMock.VerifyNoOtherCalls(); this.storageBrokerMock.VerifyNoOtherCalls(); this.dateTimeBrokerMock.VerifyNoOtherCalls(); }
public async void ShouldThrowValidationExceptionOnCreateWhenAttendanceIsNullAndLogItAsync() { // given Attendance randomAttendance = null; Attendance nullAttendance = randomAttendance; var nullAttendanceException = new NullAttendanceException(); var expectedAttendanceValidationException = new AttendanceValidationException(nullAttendanceException); // when ValueTask <Attendance> createAttendanceTask = this.attendanceService.CreateAttendanceAsync(nullAttendance); // then await Assert.ThrowsAsync <AttendanceValidationException>(() => createAttendanceTask.AsTask()); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameExceptionAs(expectedAttendanceValidationException))), Times.Once); this.storageBrokerMock.Verify(broker => broker.InsertAttendanceAsync(It.IsAny <Attendance>()), Times.Never); this.dateTimeBrokerMock.Verify(broker => broker.GetCurrentDateTime(), Times.Never); this.dateTimeBrokerMock.VerifyNoOtherCalls(); this.loggingBrokerMock.VerifyNoOtherCalls(); this.storageBrokerMock.VerifyNoOtherCalls(); }
public async Task ShouldThrowValidationExceptionOnModifyWhenAttendanceIsNullAndLogItAsync() { //given Attendance invalidAttendance = null; var nullAttendanceException = new NullAttendanceException(); var expectedAttendanceValidationException = new AttendanceValidationException(nullAttendanceException); //when ValueTask <Attendance> modifyAttendanceTask = this.attendanceService.ModifyAttendanceAsync(invalidAttendance); //then await Assert.ThrowsAsync <AttendanceValidationException>(() => modifyAttendanceTask.AsTask()); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameExceptionAs(expectedAttendanceValidationException))), Times.Once); this.loggingBrokerMock.VerifyNoOtherCalls(); this.storageBrokerMock.VerifyNoOtherCalls(); this.dateTimeBrokerMock.VerifyNoOtherCalls(); }
public async void ShouldThrowValidationExceptionOnModifyWhenUpdatedDateIsSameAsCreatedDateAndLogItAsync() { // given DateTimeOffset dateTime = GetRandomDateTime(); Attendance randomAttendance = CreateRandomAttendance(dateTime); Attendance inputAttendance = randomAttendance; var invalidAttendanceException = new InvalidAttendanceException( parameterName: nameof(Attendance.UpdatedDate), parameterValue: inputAttendance.UpdatedDate); var expectedAttendanceValidationException = new AttendanceValidationException(invalidAttendanceException); // when ValueTask <Attendance> modifyAttendanceTask = this.attendanceService.ModifyAttendanceAsync(inputAttendance); // then await Assert.ThrowsAsync <AttendanceValidationException>(() => modifyAttendanceTask.AsTask()); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameExceptionAs(expectedAttendanceValidationException))), Times.Once); this.storageBrokerMock.Verify(broker => broker.SelectAttendanceByIdAsync(It.IsAny <Guid>()), Times.Never); this.dateTimeBrokerMock.VerifyNoOtherCalls(); this.loggingBrokerMock.VerifyNoOtherCalls(); this.storageBrokerMock.VerifyNoOtherCalls(); }
private AttendanceValidationException CreateAndLogValidationException(Exception exception) { var attendanceValidationException = new AttendanceValidationException(exception); this.loggingBroker.LogError(attendanceValidationException); return(attendanceValidationException); }
public async Task ShouldThrowValidationExceptionOnModifyIfStorageCreatedByNotSameAsCreatedByAndLogItAsync() { // given int randomNegativeMinutes = GetNegativeRandomNumber(); Guid differentId = Guid.NewGuid(); Guid invalidCreatedBy = differentId; DateTimeOffset randomDate = GetRandomDateTime(); Attendance randomAttendance = CreateRandomAttendance(randomDate); Attendance invalidAttendance = randomAttendance; invalidAttendance.CreatedDate = randomDate.AddMinutes(randomNegativeMinutes); Attendance storageAttendance = randomAttendance.DeepClone(); Guid attendanceId = invalidAttendance.Id; invalidAttendance.CreatedBy = invalidCreatedBy; var invalidAttendanceException = new InvalidAttendanceException( parameterName: nameof(Attendance.CreatedBy), parameterValue: invalidAttendance.CreatedBy); var expectedAttendanceValidationException = new AttendanceValidationException(invalidAttendanceException); this.storageBrokerMock.Setup(broker => broker.SelectAttendanceByIdAsync(attendanceId)) .ReturnsAsync(storageAttendance); this.dateTimeBrokerMock.Setup(broker => broker.GetCurrentDateTime()) .Returns(randomDate); // when ValueTask <Attendance> modifyAttendanceTask = this.attendanceService.ModifyAttendanceAsync(invalidAttendance); // then await Assert.ThrowsAsync <AttendanceValidationException>(() => modifyAttendanceTask.AsTask()); this.dateTimeBrokerMock.Verify(broker => broker.GetCurrentDateTime(), Times.Once); this.storageBrokerMock.Verify(broker => broker.SelectAttendanceByIdAsync(invalidAttendance.Id), Times.Once); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameExceptionAs( expectedAttendanceValidationException))), Times.Once); this.loggingBrokerMock.VerifyNoOtherCalls(); this.storageBrokerMock.VerifyNoOtherCalls(); this.dateTimeBrokerMock.VerifyNoOtherCalls(); }
public async void ShouldThrowValidationExceptionOnCreateWhenAttendanceAlreadyExistsAndLogItAsync() { // given DateTimeOffset dateTime = GetRandomDateTime(); Attendance randomAttendance = CreateRandomAttendance(dateTime); Attendance alreadyExistsAttendance = randomAttendance; alreadyExistsAttendance.UpdatedBy = alreadyExistsAttendance.CreatedBy; string randomMessage = GetRandomMessage(); string exceptionMessage = randomMessage; var duplicateKeyException = new DuplicateKeyException(exceptionMessage); var alreadyExistsAttendanceException = new AlreadyExistsAttendanceException(duplicateKeyException); var expectedAttendanceValidationException = new AttendanceValidationException(alreadyExistsAttendanceException); this.dateTimeBrokerMock.Setup(broker => broker.GetCurrentDateTime()) .Returns(dateTime); this.storageBrokerMock.Setup(broker => broker.InsertAttendanceAsync(alreadyExistsAttendance)) .ThrowsAsync(duplicateKeyException); // when ValueTask <Attendance> createAttendanceTask = this.attendanceService.CreateAttendanceAsync(alreadyExistsAttendance); // then await Assert.ThrowsAsync <AttendanceValidationException>(() => createAttendanceTask.AsTask()); this.dateTimeBrokerMock.Verify(broker => broker.GetCurrentDateTime(), Times.AtLeastOnce); this.storageBrokerMock.Verify(broker => broker.InsertAttendanceAsync(alreadyExistsAttendance), Times.Once); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameExceptionAs( expectedAttendanceValidationException))), Times.Once); this.dateTimeBrokerMock.VerifyNoOtherCalls(); this.storageBrokerMock.VerifyNoOtherCalls(); this.loggingBrokerMock.VerifyNoOtherCalls(); }
public async void ShouldThrowValidationExceptionOnCreateWhenCreatedDateIsNotRecentAndLogItAsync( int invallidMinutes) { // given DateTimeOffset dateTime = GetRandomDateTime(); Attendance randomAttendance = CreateRandomAttendance(dateTime: dateTime); Attendance inputAttendance = randomAttendance; inputAttendance.UpdatedBy = inputAttendance.CreatedBy; inputAttendance.CreatedDate = dateTime.AddMinutes(invallidMinutes); inputAttendance.UpdatedDate = inputAttendance.CreatedDate; var invalidAttendanceException = new InvalidAttendanceException(); invalidAttendanceException.AddData( key: nameof(Attendance.CreatedDate), values: $"Date is not recent"); var expectedAttendanceValidationException = new AttendanceValidationException(invalidAttendanceException); this.dateTimeBrokerMock.Setup(broker => broker.GetCurrentDateTime()) .Returns(dateTime); // when ValueTask <Attendance> createAttendanceTask = this.attendanceService.CreateAttendanceAsync(inputAttendance); // then await Assert.ThrowsAsync <AttendanceValidationException>(() => createAttendanceTask.AsTask()); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameExceptionAs( expectedAttendanceValidationException))), Times.Once); this.storageBrokerMock.Verify(broker => broker.InsertAttendanceAsync(It.IsAny <Attendance>()), Times.Never); this.dateTimeBrokerMock.Verify(broker => broker.GetCurrentDateTime(), Times.AtLeastOnce); this.loggingBrokerMock.VerifyNoOtherCalls(); this.storageBrokerMock.VerifyNoOtherCalls(); this.dateTimeBrokerMock.VerifyNoOtherCalls(); }
public async Task ShouldThrowValidationExceptionOnModifyIfAttendanceDoesntExistAndLogItAsync() { // given int randomNegativeMinutes = GetNegativeRandomNumber(); DateTimeOffset dateTime = GetRandomDateTime(); Attendance randomAttendance = CreateRandomAttendance(dateTime); Attendance nonExistentAttendance = randomAttendance; nonExistentAttendance.CreatedDate = dateTime.AddMinutes(randomNegativeMinutes); Attendance noAttendance = null; var notFoundAttendanceException = new NotFoundAttendanceException(nonExistentAttendance.Id); var expectedAttendanceValidationException = new AttendanceValidationException(notFoundAttendanceException); this.storageBrokerMock.Setup(broker => broker.SelectAttendanceByIdAsync(nonExistentAttendance.Id)) .ReturnsAsync(noAttendance); this.dateTimeBrokerMock.Setup(broker => broker.GetCurrentDateTime()) .Returns(dateTime); // when ValueTask <Attendance> modifyAttendanceTask = this.attendanceService.ModifyAttendanceAsync(nonExistentAttendance); // then await Assert.ThrowsAsync <AttendanceValidationException>(() => modifyAttendanceTask.AsTask()); this.dateTimeBrokerMock.Verify(broker => broker.GetCurrentDateTime(), Times.Once); this.storageBrokerMock.Verify(broker => broker.SelectAttendanceByIdAsync(nonExistentAttendance.Id), Times.Once); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameExceptionAs( expectedAttendanceValidationException))), Times.Once); this.loggingBrokerMock.VerifyNoOtherCalls(); this.storageBrokerMock.VerifyNoOtherCalls(); this.dateTimeBrokerMock.VerifyNoOtherCalls(); }
public async void ShouldThrowValidationExceptionOnCreateWhenUpdatedDateIsNotSameToCreatedDateAndLogItAsync() { // given DateTimeOffset dateTime = GetRandomDateTime(); Attendance randomAttendance = CreateRandomAttendance(dateTime); Attendance inputAttendance = randomAttendance.DeepClone(); inputAttendance.UpdatedBy = randomAttendance.CreatedBy; inputAttendance.UpdatedDate = GetRandomDateTime(); var invalidAttendanceException = new InvalidAttendanceException( parameterName: nameof(Attendance.UpdatedDate), parameterValue: inputAttendance.UpdatedDate); var expectedAttendanceValidationException = new AttendanceValidationException(invalidAttendanceException); this.dateTimeBrokerMock.Setup(broker => broker.GetCurrentDateTime()) .Returns(dateTime); // when ValueTask <Attendance> createAttendanceTask = this.attendanceService.CreateAttendanceAsync(inputAttendance); // then await Assert.ThrowsAsync <AttendanceValidationException>(() => createAttendanceTask.AsTask()); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameExceptionAs(expectedAttendanceValidationException))), Times.Once); this.storageBrokerMock.Verify(broker => broker.InsertAttendanceAsync(It.IsAny <Attendance>()), Times.Never); this.dateTimeBrokerMock.Verify(broker => broker.GetCurrentDateTime(), Times.Once); this.dateTimeBrokerMock.VerifyNoOtherCalls(); this.loggingBrokerMock.VerifyNoOtherCalls(); this.storageBrokerMock.VerifyNoOtherCalls(); }
public async void ShouldThrowValidationExceptionOnCreateWhenUpdatedByIsNotSameToCreatedByAndLogItAsync() { // given DateTimeOffset dateTime = GetRandomDateTime(); Attendance randomAttendance = CreateRandomAttendance(dateTime); Attendance invalidAttendance = randomAttendance; invalidAttendance.UpdatedBy = Guid.NewGuid(); var invalidAttendanceInputException = new InvalidAttendanceException(); invalidAttendanceInputException.AddData( key: nameof(Attendance.UpdatedBy), values: $"Id is not the same as {nameof(Attendance.CreatedBy)}"); var expectedAttendanceValidationException = new AttendanceValidationException(invalidAttendanceInputException); this.dateTimeBrokerMock.Setup(broker => broker.GetCurrentDateTime()) .Returns(dateTime); // when ValueTask <Attendance> createAttendanceTask = this.attendanceService.CreateAttendanceAsync(invalidAttendance); // then await Assert.ThrowsAsync <AttendanceValidationException>(() => createAttendanceTask.AsTask()); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameValidationExceptionAs( expectedAttendanceValidationException))), Times.Once); this.storageBrokerMock.Verify(broker => broker.InsertAttendanceAsync(It.IsAny <Attendance>()), Times.Never); this.loggingBrokerMock.VerifyNoOtherCalls(); this.storageBrokerMock.VerifyNoOtherCalls(); }
public async Task ShouldThrowValidatonExceptionOnDeleteWhenStorageAttendanceIsInvalidAndLogItAsync() { // given DateTimeOffset dateTimeOffset = GetRandomDateTime(); Attendance randomAttendance = CreateRandomAttendance(dateTime: dateTimeOffset); Guid inputAttendanceId = randomAttendance.Id; Attendance inputAttendance = randomAttendance; Attendance nullStorageAttendance = null; var notFoundAttendanceException = new NotFoundAttendanceException(inputAttendanceId); var expectedAttendanceValidationException = new AttendanceValidationException(notFoundAttendanceException); this.storageBrokerMock.Setup(broker => broker.SelectAttendanceByIdAsync(inputAttendanceId)) .ReturnsAsync(nullStorageAttendance); // when ValueTask <Attendance> actualAttendanceTask = this.attendanceService.RemoveAttendanceByIdAsync(inputAttendanceId); // then await Assert.ThrowsAsync <AttendanceValidationException>(() => actualAttendanceTask.AsTask()); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameExceptionAs( expectedAttendanceValidationException))), Times.Once); this.storageBrokerMock.Verify(broker => broker.SelectAttendanceByIdAsync(inputAttendanceId), Times.Once); this.storageBrokerMock.Verify(broker => broker.DeleteAttendanceAsync(It.IsAny <Attendance>()), Times.Never); this.storageBrokerMock.VerifyNoOtherCalls(); this.loggingBrokerMock.VerifyNoOtherCalls(); this.dateTimeBrokerMock.VerifyNoOtherCalls(); }
public async Task ShouldThrowValidationExceptionOnRetrieveWhenStorageAttendanceIsNullAndLogItAsync() { // given DateTimeOffset dateTimeOffset = GetRandomDateTime(); Guid randomAttendanceId = Guid.NewGuid(); Guid inputAttendanceId = randomAttendanceId; Attendance nullAttendance = default; var nullAttendanceException = new NotFoundAttendanceException(attendanceId: inputAttendanceId); var expectedValidationException = new AttendanceValidationException(nullAttendanceException); this.storageBrokerMock.Setup(broker => broker.SelectAttendanceByIdAsync(inputAttendanceId)) .ReturnsAsync(nullAttendance); // when ValueTask <Attendance> retrieveAttendanceTask = this.attendanceService.RetrieveAttendanceByIdAsync(inputAttendanceId); // then await Assert.ThrowsAsync <AttendanceValidationException>(() => retrieveAttendanceTask.AsTask()); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameExceptionAs( expectedValidationException))), Times.Once); this.storageBrokerMock.Verify(broker => broker.SelectAttendanceByIdAsync(inputAttendanceId), Times.Once); this.dateTimeBrokerMock.Verify(broker => broker.GetCurrentDateTime(), Times.Never); this.storageBrokerMock.VerifyNoOtherCalls(); this.loggingBrokerMock.VerifyNoOtherCalls(); this.dateTimeBrokerMock.VerifyNoOtherCalls(); }
public async Task ShouldThrowValidationExceptionOnCreateWhenAttendanceSemesterCourseIdIsInvalidAndLogItAsync() { // given DateTimeOffset dateTime = GetRandomDateTime(); Attendance randomAttendance = CreateRandomAttendance(dateTime: dateTime); Attendance invalidAttendance = randomAttendance; invalidAttendance.StudentSemesterCourseId = default; var invalidAttendanceException = new InvalidAttendanceException( parameterName: nameof(Attendance.StudentSemesterCourseId), parameterValue: invalidAttendance.StudentSemesterCourseId); var expectedAttendanceValidationException = new AttendanceValidationException(invalidAttendanceException); // when ValueTask <Attendance> createAttendanceTask = this.attendanceService.CreateAttendanceAsync(invalidAttendance); // then await Assert.ThrowsAsync <AttendanceValidationException>(() => createAttendanceTask.AsTask()); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameExceptionAs(expectedAttendanceValidationException))), Times.Once); this.storageBrokerMock.Verify(broker => broker.InsertAttendanceAsync(It.IsAny <Attendance>()), Times.Never); this.dateTimeBrokerMock.Verify(broker => broker.GetCurrentDateTime(), Times.Never); this.loggingBrokerMock.VerifyNoOtherCalls(); this.storageBrokerMock.VerifyNoOtherCalls(); this.dateTimeBrokerMock.VerifyNoOtherCalls(); }
public async Task ShouldThrowValidationExceptionOnRetrieveWhenIdIsNullAndLogItAsync() { // given DateTimeOffset dateTimeOffset = GetRandomDateTime(); Guid randomAttendanceId = default; Guid inputAttendanceId = randomAttendanceId; var invalidAttendanceException = new InvalidAttendanceException( parameterName: nameof(Attendance.Id), parameterValue: inputAttendanceId); var expectedValidationException = new AttendanceValidationException(invalidAttendanceException); // when ValueTask <Attendance> retrieveAttendanceTask = this.attendanceService.RetrieveAttendanceByIdAsync(inputAttendanceId); // then await Assert.ThrowsAsync <AttendanceValidationException>(() => retrieveAttendanceTask.AsTask()); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameExceptionAs( expectedValidationException))), Times.Once); this.storageBrokerMock.Verify(broker => broker.SelectAttendanceByIdAsync(inputAttendanceId), Times.Never); this.dateTimeBrokerMock.Verify(broker => broker.GetCurrentDateTime(), Times.Never); this.storageBrokerMock.VerifyNoOtherCalls(); this.loggingBrokerMock.VerifyNoOtherCalls(); this.dateTimeBrokerMock.VerifyNoOtherCalls(); }
public async Task ShouldThrowValidatonExceptionOnDeleteWhenIdIsInvalidAndLogItAsync() { // given Guid randomAttendanceId = default; Guid inputAttendanceId = randomAttendanceId; var invalidAttendanceException = new InvalidAttendanceException( parameterName: nameof(Attendance.Id), parameterValue: inputAttendanceId); var expectedAttendanceValidationException = new AttendanceValidationException(invalidAttendanceException); // when ValueTask <Attendance> actualAttendanceTask = this.attendanceService.RemoveAttendanceByIdAsync(inputAttendanceId); // then await Assert.ThrowsAsync <AttendanceValidationException>(() => actualAttendanceTask.AsTask()); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameExceptionAs( expectedAttendanceValidationException))), Times.Once); this.storageBrokerMock.Verify(broker => broker.SelectAttendanceByIdAsync(It.IsAny <Guid>()), Times.Never); this.storageBrokerMock.Verify(broker => broker.DeleteAttendanceAsync(It.IsAny <Attendance>()), Times.Never); this.storageBrokerMock.VerifyNoOtherCalls(); this.loggingBrokerMock.VerifyNoOtherCalls(); this.dateTimeBrokerMock.VerifyNoOtherCalls(); }
public async void ShouldThrowValidationExceptionOnCreateIfAttendanceIsInvalidAndLogItAsync( string invalidText) { // given var invalidStuent = new Attendance { Notes = invalidText }; var invalidAttendanceException = new InvalidAttendanceException(); invalidAttendanceException.AddData( key: nameof(Attendance.Id), values: "Id is required"); invalidAttendanceException.AddData( key: nameof(Attendance.StudentSemesterCourseId), values: "Id is required"); invalidAttendanceException.AddData( key: nameof(Attendance.AttendanceDate), values: "Date is required"); invalidAttendanceException.AddData( key: nameof(Attendance.Notes), values: "Text is required"); invalidAttendanceException.AddData( key: nameof(Attendance.CreatedBy), values: "Id is required"); invalidAttendanceException.AddData( key: nameof(Attendance.UpdatedBy), values: "Id is required"); invalidAttendanceException.AddData( key: nameof(Attendance.CreatedDate), values: "Date is required"); invalidAttendanceException.AddData( key: nameof(Attendance.UpdatedDate), values: "Date is required"); var expectedAttendanceValidationException = new AttendanceValidationException(invalidAttendanceException); // when ValueTask <Attendance> createAttendanceTask = this.attendanceService.CreateAttendanceAsync(invalidStuent); // then await Assert.ThrowsAsync <AttendanceValidationException>(() => createAttendanceTask.AsTask()); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameValidationExceptionAs( expectedAttendanceValidationException))), Times.Once); this.storageBrokerMock.Verify(broker => broker.InsertAttendanceAsync(It.IsAny <Attendance>()), Times.Never); this.loggingBrokerMock.VerifyNoOtherCalls(); this.storageBrokerMock.VerifyNoOtherCalls(); }