public async Task ShouldThrowValidationExceptionOnModifyWhenRegistrationIsNullAndLogItAsync() { //given Registration invalidRegistration = null; var nullRegistrationException = new NullRegistrationException(); var expectedRegistrationValidationException = new RegistrationValidationException(nullRegistrationException); //when ValueTask <Registration> modifyRegistrationTask = this.registrationService.ModifyRegistrationAsync(invalidRegistration); //then await Assert.ThrowsAsync <RegistrationValidationException>(() => modifyRegistrationTask.AsTask()); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameExceptionAs(expectedRegistrationValidationException))), Times.Once); this.loggingBrokerMock.VerifyNoOtherCalls(); this.storageBrokerMock.VerifyNoOtherCalls(); this.dateTimeBrokerMock.VerifyNoOtherCalls(); }
public async Task ShouldThrowValidationExceptionOnModifyWhenRegistrationIdIsInvalidAndLogItAsync() { //given Guid invalidRegistrationId = Guid.Empty; DateTimeOffset dateTime = GetRandomDateTime(); Registration randomRegistration = CreateRandomRegistration(dateTime); Registration invalidRegistration = randomRegistration; invalidRegistration.Id = invalidRegistrationId; var invalidRegistrationException = new InvalidRegistrationException( parameterName: nameof(Registration.Id), parameterValue: invalidRegistration.Id); var expectedRegistrationValidationException = new RegistrationValidationException(invalidRegistrationException); //when ValueTask <Registration> modifyRegistrationTask = this.registrationService.ModifyRegistrationAsync(invalidRegistration); //then await Assert.ThrowsAsync <RegistrationValidationException>(() => modifyRegistrationTask.AsTask()); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameExceptionAs(expectedRegistrationValidationException))), Times.Once); this.loggingBrokerMock.VerifyNoOtherCalls(); this.storageBrokerMock.VerifyNoOtherCalls(); this.dateTimeBrokerMock.VerifyNoOtherCalls(); }
public async void ShouldThrowValidationExceptionOnAddWhenRegistrationIsNullAndLogItAsync() { // given Registration randomRegistration = default; Registration nullRegistration = randomRegistration; var nullRegistrationException = new NullRegistrationException(); var expectedRegistrationValidationException = new RegistrationValidationException(nullRegistrationException); // when ValueTask <Registration> createRegistrationTask = this.registrationService.AddRegistrationAsync(nullRegistration); // then await Assert.ThrowsAsync <RegistrationValidationException>(() => createRegistrationTask.AsTask()); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameExceptionAs(expectedRegistrationValidationException))), Times.Once); this.storageBrokerMock.Verify(broker => broker.InsertRegistrationAsync(It.IsAny <Registration>()), Times.Never); this.dateTimeBrokerMock.VerifyNoOtherCalls(); this.loggingBrokerMock.VerifyNoOtherCalls(); this.storageBrokerMock.VerifyNoOtherCalls(); }
private RegistrationValidationException CreateAndLogValidationException(Exception exception) { var RegistrationValidationException = new RegistrationValidationException(exception); this.loggingBroker.LogError(RegistrationValidationException); return(RegistrationValidationException); }
ShouldThrowValidationExceptionOnModifyWhenCreatedByIsNotSameAsStorageCreatedByIsInvalidAndLogItAsync() { // given DateTimeOffset dateTime = GetRandomDateTime(); Guid randomCreatedById = Guid.NewGuid(); int randomNumber = GetRandomNumber(); Registration randomRegistration = CreateRandomRegistration(dateTime); Registration inputRegistration = randomRegistration; inputRegistration.CreatedDate = dateTime.AddMinutes(randomNumber * -1); Registration storageRegistration = randomRegistration.DeepClone(); storageRegistration.CreatedBy = randomCreatedById; var invalidRegistrationInputException = new InvalidRegistrationException( parameterName: nameof(Registration.CreatedBy), parameterValue: inputRegistration.CreatedBy); var expectedRegistrationValidationException = new RegistrationValidationException(invalidRegistrationInputException); this.dateTimeBrokerMock.Setup(broker => broker.GetCurrentDateTime()) .Returns(dateTime); this.storageBrokerMock.Setup(broker => broker.SelectRegistrationByIdAsync(inputRegistration.Id)) .ReturnsAsync(storageRegistration); // when ValueTask <Registration> modifyRegistrationTask = this.registrationService.ModifyRegistrationAsync(inputRegistration); // then await Assert.ThrowsAsync <RegistrationValidationException>(() => modifyRegistrationTask.AsTask()); this.dateTimeBrokerMock.Verify(broker => broker.GetCurrentDateTime(), Times.Once); this.storageBrokerMock.Verify(broker => broker.SelectRegistrationByIdAsync(It.IsAny <Guid>()), Times.Once); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameExceptionAs( expectedRegistrationValidationException))), Times.Once); this.storageBrokerMock.Verify(broker => broker.UpdateRegistrationAsync(It.IsAny <Registration>()), Times.Never); this.dateTimeBrokerMock.VerifyNoOtherCalls(); this.loggingBrokerMock.VerifyNoOtherCalls(); this.storageBrokerMock.VerifyNoOtherCalls(); }
public async Task ShouldThrowValidationExceptionOnModifyIfRegistrationDoesntExistAndLogItAsync() { // given int randomNegativeMinutes = GetNegativeRandomNumber(); DateTimeOffset dateTime = GetRandomDateTime(); Registration randomRegistration = CreateRandomRegistration(dateTime); Registration nonExistentRegistration = randomRegistration; nonExistentRegistration.CreatedDate = dateTime.AddMinutes(randomNegativeMinutes); Registration noRegistration = null; var notFoundRegistrationException = new NotFoundRegistrationException(nonExistentRegistration.Id); var expectedRegistrationValidationException = new RegistrationValidationException(notFoundRegistrationException); this.dateTimeBrokerMock.Setup(broker => broker.GetCurrentDateTime()) .Returns(dateTime); this.storageBrokerMock.Setup(broker => broker.SelectRegistrationByIdAsync(nonExistentRegistration.Id)) .ReturnsAsync(noRegistration); // when ValueTask <Registration> modifyRegistrationTask = this.registrationService.ModifyRegistrationAsync(nonExistentRegistration); // then await Assert.ThrowsAsync <RegistrationValidationException>(() => modifyRegistrationTask.AsTask()); this.dateTimeBrokerMock.Verify(broker => broker.GetCurrentDateTime(), Times.Once); this.storageBrokerMock.Verify(broker => broker.SelectRegistrationByIdAsync(nonExistentRegistration.Id), Times.Once); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameExceptionAs( expectedRegistrationValidationException))), Times.Once); this.storageBrokerMock.Verify(broker => broker.UpdateRegistrationAsync(It.IsAny <Registration>()), Times.Never); this.loggingBrokerMock.VerifyNoOtherCalls(); this.storageBrokerMock.VerifyNoOtherCalls(); this.dateTimeBrokerMock.VerifyNoOtherCalls(); }
public async void ShouldThrowValidationExceptionOnAddWhenRegistrationAlreadyExistsAndLogItAsync() { // given DateTimeOffset dateTime = GetRandomDateTime(); Registration randomRegistration = CreateRandomRegistration(dateTime); Registration alreadyExistsRegistration = randomRegistration; alreadyExistsRegistration.UpdatedBy = alreadyExistsRegistration.CreatedBy; string randomMessage = GetRandomMessage(); string exceptionMessage = randomMessage; var duplicateKeyException = new DuplicateKeyException(exceptionMessage); var alreadyExistsRegistrationException = new AlreadyExistsRegistrationException(duplicateKeyException); var expectedRegistrationValidationException = new RegistrationValidationException(alreadyExistsRegistrationException); this.dateTimeBrokerMock.Setup(broker => broker.GetCurrentDateTime()) .Returns(dateTime); this.storageBrokerMock.Setup(broker => broker.InsertRegistrationAsync(alreadyExistsRegistration)) .ThrowsAsync(duplicateKeyException); // when ValueTask <Registration> registerRegistrationTask = this.registrationService.AddRegistrationAsync(alreadyExistsRegistration); // then await Assert.ThrowsAsync <RegistrationValidationException>(() => registerRegistrationTask.AsTask()); this.dateTimeBrokerMock.Verify(broker => broker.GetCurrentDateTime(), Times.Once); this.storageBrokerMock.Verify(broker => broker.InsertRegistrationAsync(alreadyExistsRegistration), Times.Once); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameExceptionAs( expectedRegistrationValidationException))), Times.Once); this.dateTimeBrokerMock.VerifyNoOtherCalls(); this.storageBrokerMock.VerifyNoOtherCalls(); this.loggingBrokerMock.VerifyNoOtherCalls(); }
public async void ShouldThrowValidationExceptionOnModifyWhenUpdatedDateIsNotRecentAndLogItAsync( int minutes) { // given DateTimeOffset dateTime = GetRandomDateTime(); Registration randomRegistration = CreateRandomRegistration(dateTime); Registration inputRegistration = randomRegistration; inputRegistration.UpdatedDate = dateTime.AddMinutes(minutes); var invalidRegistrationInputException = new InvalidRegistrationException( parameterName: nameof(Registration.UpdatedDate), parameterValue: inputRegistration.UpdatedDate); var expectedRegistrationValidationException = new RegistrationValidationException(invalidRegistrationInputException); this.dateTimeBrokerMock.Setup(broker => broker.GetCurrentDateTime()) .Returns(dateTime); // when ValueTask <Registration> modifyRegistrationTask = this.registrationService.ModifyRegistrationAsync(inputRegistration); // then await Assert.ThrowsAsync <RegistrationValidationException>(() => modifyRegistrationTask.AsTask()); this.dateTimeBrokerMock.Verify(broker => broker.GetCurrentDateTime(), Times.Once); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameExceptionAs( expectedRegistrationValidationException))), Times.Once); this.storageBrokerMock.Verify(broker => broker.SelectRegistrationByIdAsync(It.IsAny <Guid>()), Times.Never); this.storageBrokerMock.Verify(broker => broker.UpdateRegistrationAsync(It.IsAny <Registration>()), Times.Never); this.dateTimeBrokerMock.VerifyNoOtherCalls(); this.loggingBrokerMock.VerifyNoOtherCalls(); this.storageBrokerMock.VerifyNoOtherCalls(); }
public async Task ShouldThrowValidationExceptionOnModifyWhenSubmitterEmailIsInvalidAndLogItAsync( string invalidRegistrationSubmitterEmail) { // given DateTimeOffset datetime = GetRandomDateTime(); Registration randomRegistration = CreateRandomRegistration(datetime); Registration invalidRegistration = randomRegistration; invalidRegistration.SubmitterEmail = invalidRegistrationSubmitterEmail; var invalidRegistrationInputException = new InvalidRegistrationException( parameterName: nameof(Registration.SubmitterEmail), parameterValue: invalidRegistration.SubmitterEmail); var expectedRegistrationValidationException = new RegistrationValidationException(invalidRegistrationInputException); // when ValueTask <Registration> modifyRegistrationTask = this.registrationService.ModifyRegistrationAsync(invalidRegistration); // then await Assert.ThrowsAsync <RegistrationValidationException>(() => modifyRegistrationTask.AsTask()); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameExceptionAs( expectedRegistrationValidationException))), Times.Once); this.dateTimeBrokerMock.Verify(broker => broker.GetCurrentDateTime(), Times.Never); this.storageBrokerMock.Verify(broker => broker.SelectRegistrationByIdAsync(It.IsAny <Guid>()), Times.Never); this.storageBrokerMock.Verify(broker => broker.UpdateRegistrationAsync(It.IsAny <Registration>()), Times.Never); this.loggingBrokerMock.VerifyNoOtherCalls(); this.storageBrokerMock.VerifyNoOtherCalls(); this.dateTimeBrokerMock.VerifyNoOtherCalls(); }
public async Task ShouldThrowValidationExceptionOnRemoveIfRegistrationIsNotFoundAndLogItAsync() { // given DateTimeOffset randomDateTime = GetRandomDateTime(); Registration randomRegistration = CreateRandomRegistration(dateTime: randomDateTime); Guid inputRegistrationId = randomRegistration.Id; Registration noRegistration = null; var notFoundRegistrationException = new NotFoundRegistrationException(randomRegistration.Id); var expectedRegistrationValidationException = new RegistrationValidationException(notFoundRegistrationException); this.storageBrokerMock.Setup(broker => broker.SelectRegistrationByIdAsync(It.IsAny <Guid>())). ReturnsAsync(noRegistration); // when ValueTask <Registration> removeRegistrationByIdTask = this.registrationService.RemoveRegistrationByIdAsync(inputRegistrationId); // then await Assert.ThrowsAsync <RegistrationValidationException>(() => removeRegistrationByIdTask.AsTask()); this.storageBrokerMock.Verify(broker => broker.SelectRegistrationByIdAsync(It.IsAny <Guid>()), Times.Once); this.storageBrokerMock.Verify(broker => broker.DeleteRegistrationAsync(It.IsAny <Registration>()), Times.Never); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameExceptionAs( expectedRegistrationValidationException))), Times.Once); this.storageBrokerMock.VerifyNoOtherCalls(); this.loggingBrokerMock.VerifyNoOtherCalls(); this.dateTimeBrokerMock.VerifyNoOtherCalls(); }
public async void ShouldThrowValidationExceptionOnRetrieveByIdWhenStorageRegistrationIsNullAndLogItAsync() { //given Guid randomRegistrationId = Guid.NewGuid(); Guid someRegistrationId = randomRegistrationId; Registration invalidStorageRegistration = null; var notFoundRegistrationException = new NotFoundRegistrationException(someRegistrationId); var expectedRegistrationValidationException = new RegistrationValidationException(notFoundRegistrationException); this.storageBrokerMock.Setup(broker => broker.SelectRegistrationByIdAsync(It.IsAny <Guid>())) .ReturnsAsync(invalidStorageRegistration); //when ValueTask <Registration> retrieveRegistrationByIdTask = this.registrationService.RetrieveRegistrationByIdAsync(someRegistrationId); //then await Assert.ThrowsAsync <RegistrationValidationException>(() => retrieveRegistrationByIdTask.AsTask()); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameExceptionAs(expectedRegistrationValidationException))), Times.Once); this.storageBrokerMock.Verify(broker => broker.SelectRegistrationByIdAsync(It.IsAny <Guid>()), Times.Once); this.dateTimeBrokerMock.Verify(broker => broker.GetCurrentDateTime(), Times.Never); this.storageBrokerMock.VerifyNoOtherCalls(); this.loggingBrokerMock.VerifyNoOtherCalls(); this.dateTimeBrokerMock.VerifyNoOtherCalls(); }
public async Task ShouldThrowValidationExceptionOnAddWhenStudentEmailIsInvalidAndLogItAsync( string invalidRegistrationStudentEmail) { // given DateTimeOffset datetime = DateTimeOffset.UtcNow; Registration randomRegistration = CreateRandomRegistration(datetime); Registration invalidRegistration = randomRegistration; invalidRegistration.StudentEmail = invalidRegistrationStudentEmail; var invalidRegistrationInputException = new InvalidRegistrationException( parameterName: nameof(Registration.StudentEmail), parameterValue: invalidRegistration.StudentEmail); var expectedRegistrationValidationException = new RegistrationValidationException(invalidRegistrationInputException); // when ValueTask <Registration> registerRegistrationTask = this.registrationService.AddRegistrationAsync(invalidRegistration); // then await Assert.ThrowsAsync <RegistrationValidationException>(() => registerRegistrationTask.AsTask()); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameExceptionAs( expectedRegistrationValidationException))), Times.Once); this.storageBrokerMock.Verify(broker => broker.InsertRegistrationAsync(It.IsAny <Registration>()), Times.Never); this.loggingBrokerMock.VerifyNoOtherCalls(); this.storageBrokerMock.VerifyNoOtherCalls(); this.dateTimeBrokerMock.VerifyNoOtherCalls(); }
public async void ShouldThrowValidationExceptionOnAddWhenUpdatedDateIsNotSameToCreatedDateAndLogItAsync() { // given DateTimeOffset dateTime = GetRandomDateTime(); Registration randomRegistration = CreateRandomRegistration(dateTime); Registration inputRegistration = randomRegistration; inputRegistration.UpdatedBy = randomRegistration.CreatedBy; inputRegistration.UpdatedDate = GetRandomDateTime(); var invalidRegistrationInputException = new InvalidRegistrationException( parameterName: nameof(Registration.UpdatedDate), parameterValue: inputRegistration.UpdatedDate); var expectedRegistrationValidationException = new RegistrationValidationException(invalidRegistrationInputException); // when ValueTask <Registration> registerRegistrationTask = this.registrationService.AddRegistrationAsync(inputRegistration); // then await Assert.ThrowsAsync <RegistrationValidationException>(() => registerRegistrationTask.AsTask()); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameExceptionAs( expectedRegistrationValidationException))), Times.Once); this.storageBrokerMock.Verify(broker => broker.InsertRegistrationAsync(It.IsAny <Registration>()), Times.Never); this.dateTimeBrokerMock.VerifyNoOtherCalls(); this.loggingBrokerMock.VerifyNoOtherCalls(); this.storageBrokerMock.VerifyNoOtherCalls(); }
public async Task ShouldThrowValidationExceptionOnRemoveIfIdIsInvalidAndLogItAsync() { // given Guid invalidTaskCategotyId = Guid.Empty; var invalidRegistrationException = new InvalidRegistrationException( parameterName: nameof(Registration.Id), parameterValue: invalidTaskCategotyId); var expectedRegistrationValidationException = new RegistrationValidationException(invalidRegistrationException); // when ValueTask <Registration> deleteRegistrationTask = this.registrationService.RemoveRegistrationByIdAsync(invalidTaskCategotyId); // then await Assert.ThrowsAsync <RegistrationValidationException>(() => deleteRegistrationTask.AsTask()); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameExceptionAs( expectedRegistrationValidationException))), Times.Once); this.storageBrokerMock.Verify(broker => broker.SelectRegistrationByIdAsync(It.IsAny <Guid>()), Times.Never); this.storageBrokerMock.Verify(broker => broker.DeleteRegistrationAsync(It.IsAny <Registration>()), Times.Never); this.loggingBrokerMock.VerifyNoOtherCalls(); this.storageBrokerMock.VerifyNoOtherCalls(); this.dateTimeBrokerMock.VerifyNoOtherCalls(); }
public async void ShouldThrowValidationExceptionOnRetrieveByIdWhenIdIsInvalidAndLogItAsync() { //given Guid randomRegistrationId = default; Guid inputRegistrationId = randomRegistrationId; var invalidRegistrationException = new InvalidRegistrationException( parameterName: nameof(Registration.Id), parameterValue: inputRegistrationId); var expectedRegistrationValidationException = new RegistrationValidationException(invalidRegistrationException); //when ValueTask <Registration> retrieveRegistrationByIdTask = this.registrationService.RetrieveRegistrationByIdAsync(inputRegistrationId); //then await Assert.ThrowsAsync <RegistrationValidationException>(() => retrieveRegistrationByIdTask.AsTask()); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameExceptionAs(expectedRegistrationValidationException))), Times.Once); this.storageBrokerMock.Verify(broker => broker.SelectRegistrationByIdAsync(It.IsAny <Guid>()), Times.Never); this.dateTimeBrokerMock.Verify(broker => broker.GetCurrentDateTime(), Times.Never); this.loggingBrokerMock.VerifyNoOtherCalls(); this.storageBrokerMock.VerifyNoOtherCalls(); this.dateTimeBrokerMock.VerifyNoOtherCalls(); }
public async Task ShouldThrowValidationOnModifyIfForeignKeyConstraintConflictExceptionOccursAndLogItAsync() { // given DateTimeOffset randomDateTime = GetRandomDateTime(); DateTimeOffset dateTime = randomDateTime; Registration randomRegistration = CreateRandomRegistration(dateTime); Registration storageRegistration = randomRegistration; Registration foreignKeyConflictedRegistration = storageRegistration.DeepClone(); storageRegistration.UpdatedDate = dateTime.AddMinutes(GetNegativeRandomNumber()); string randomMessage = GetRandomMessage(); string exceptionMessage = randomMessage; var foreignKeyConstraintConflictException = new ForeignKeyConstraintConflictException(exceptionMessage); var invalidRegistrationReferenceException = new InvalidRegistrationReferenceException(foreignKeyConstraintConflictException); var registrationValidationException = new RegistrationValidationException(invalidRegistrationReferenceException); this.dateTimeBrokerMock.Setup(broker => broker.GetCurrentDateTime()) .Returns(randomDateTime); this.storageBrokerMock.Setup(broker => broker.SelectRegistrationByIdAsync(foreignKeyConflictedRegistration.Id)) .ReturnsAsync(storageRegistration); this.storageBrokerMock.Setup(broker => broker.UpdateRegistrationAsync(foreignKeyConflictedRegistration)) .ThrowsAsync(foreignKeyConstraintConflictException); // when ValueTask <Registration> modifyRegistrationTask = this.registrationService.ModifyRegistrationAsync(foreignKeyConflictedRegistration); // then await Assert.ThrowsAsync <RegistrationValidationException>(() => modifyRegistrationTask.AsTask()); this.dateTimeBrokerMock.Verify(broker => broker.GetCurrentDateTime(), Times.Once); this.storageBrokerMock.Verify(broker => broker.SelectRegistrationByIdAsync(foreignKeyConflictedRegistration.Id), Times.Once); this.storageBrokerMock.Verify(broker => broker.UpdateRegistrationAsync(foreignKeyConflictedRegistration), Times.Once); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameExceptionAs(registrationValidationException))), Times.Once); this.dateTimeBrokerMock.VerifyNoOtherCalls(); this.storageBrokerMock.VerifyNoOtherCalls(); this.loggingBrokerMock.VerifyNoOtherCalls(); }