コード例 #1
0
        public void ShouldThrowServiceExceptionOnRetrieveAllWhenExceptionOccursAndLogIt()
        {
            // given
            var exception = new Exception();

            var expectedContactServiceException =
                new ContactServiceException(exception);

            this.storageBrokerMock.Setup(broker =>
                                         broker.SelectAllContacts())
            .Throws(exception);

            // when . then
            Assert.Throws <ContactServiceException>(() =>
                                                    this.contactService.RetrieveAllContacts());

            this.loggingBrokerMock.Verify(broker =>
                                          broker.LogError(It.Is(SameExceptionAs(expectedContactServiceException))),
                                          Times.Once);

            this.storageBrokerMock.Verify(broker =>
                                          broker.SelectAllContacts(),
                                          Times.Once);

            this.dateTimeBrokerMock.Verify(broker =>
                                           broker.GetCurrentDateTime(),
                                           Times.Never);

            this.dateTimeBrokerMock.VerifyNoOtherCalls();
            this.loggingBrokerMock.VerifyNoOtherCalls();
            this.storageBrokerMock.VerifyNoOtherCalls();
        }
コード例 #2
0
        private ContactServiceException CreateAndLogServiceException(Exception exception)
        {
            var contactServiceException = new ContactServiceException(exception);

            this.loggingBroker.LogError(contactServiceException);

            return(contactServiceException);
        }
コード例 #3
0
        public async Task ShouldThrowServiceExceptionOnModifyIfServiceExceptionOccursAndLogItAsync()
        {
            // given
            int            randomNegativeNumber = GetNegativeRandomNumber();
            DateTimeOffset randomDateTime       = GetRandomDateTime();
            Contact        randomContact        = CreateRandomContact(randomDateTime);
            Contact        someContact          = randomContact;

            someContact.CreatedDate = randomDateTime.AddMinutes(randomNegativeNumber);
            var serviceException = new Exception();

            var failedContactServiceException =
                new FailedContactServiceException(serviceException);

            var expectedContactServiceException =
                new ContactServiceException(failedContactServiceException);

            this.storageBrokerMock.Setup(broker =>
                                         broker.SelectContactByIdAsync(someContact.Id))
            .ThrowsAsync(serviceException);

            this.dateTimeBrokerMock.Setup(broker =>
                                          broker.GetCurrentDateTime())
            .Returns(randomDateTime);

            // when
            ValueTask <Contact> modifyContactTask =
                this.contactService.ModifyContactAsync(someContact);

            // then
            await Assert.ThrowsAsync <ContactServiceException>(() =>
                                                               modifyContactTask.AsTask());

            this.dateTimeBrokerMock.Verify(broker =>
                                           broker.GetCurrentDateTime(),
                                           Times.Once);

            this.storageBrokerMock.Verify(broker =>
                                          broker.SelectContactByIdAsync(someContact.Id),
                                          Times.Once);

            this.loggingBrokerMock.Verify(broker =>
                                          broker.LogError(It.Is(SameExceptionAs(
                                                                    expectedContactServiceException))),
                                          Times.Once);

            this.loggingBrokerMock.VerifyNoOtherCalls();
            this.storageBrokerMock.VerifyNoOtherCalls();
            this.dateTimeBrokerMock.VerifyNoOtherCalls();
        }
コード例 #4
0
        public async Task ShouldThrowServiceExceptionOnAddWhenExceptionOccursAndLogItAsync()
        {
            // given
            DateTimeOffset dateTime      = GetRandomDateTime();
            Contact        randomContact = CreateRandomContact(dateTime);
            Contact        inputContact  = randomContact;

            inputContact.UpdatedBy = inputContact.CreatedBy;
            var serviceException = new Exception();

            var failedContactServiceException =
                new FailedContactServiceException(serviceException);

            var expectedContactServiceException =
                new ContactServiceException(failedContactServiceException);

            this.dateTimeBrokerMock.Setup(broker =>
                                          broker.GetCurrentDateTime())
            .Returns(dateTime);

            this.storageBrokerMock.Setup(broker =>
                                         broker.InsertContactAsync(inputContact))
            .ThrowsAsync(serviceException);

            // when
            ValueTask <Contact> registerContactTask =
                this.contactService.AddContactAsync(inputContact);

            // then
            await Assert.ThrowsAsync <ContactServiceException>(() =>
                                                               registerContactTask.AsTask());

            this.loggingBrokerMock.Verify(broker =>
                                          broker.LogError(It.Is(SameExceptionAs(
                                                                    expectedContactServiceException))),
                                          Times.Once);

            this.storageBrokerMock.Verify(broker =>
                                          broker.InsertContactAsync(inputContact),
                                          Times.Once);

            this.dateTimeBrokerMock.Verify(broker =>
                                           broker.GetCurrentDateTime(),
                                           Times.Once);

            this.dateTimeBrokerMock.VerifyNoOtherCalls();
            this.loggingBrokerMock.VerifyNoOtherCalls();
            this.storageBrokerMock.VerifyNoOtherCalls();
        }
コード例 #5
0
        public async Task ShouldThrowServiceExceptionOnDeleteWhenExceptionOccursAndLogItAsync()
        {
            // given
            Guid randomContactId  = Guid.NewGuid();
            Guid inputContactId   = randomContactId;
            var  serviceException = new Exception();

            var failedContactServiceException =
                new FailedContactServiceException(serviceException);

            var expectedContactServiceException =
                new ContactServiceException(failedContactServiceException);

            this.storageBrokerMock.Setup(broker =>
                                         broker.SelectContactByIdAsync(inputContactId))
            .ThrowsAsync(serviceException);

            // when
            ValueTask <Contact> deleteContactTask =
                this.contactService.RemoveContactByIdAsync(inputContactId);

            // then
            await Assert.ThrowsAsync <ContactServiceException>(() =>
                                                               deleteContactTask.AsTask());

            this.loggingBrokerMock.Verify(broker =>
                                          broker.LogError(It.Is(SameExceptionAs(
                                                                    expectedContactServiceException))),
                                          Times.Once);

            this.storageBrokerMock.Verify(broker =>
                                          broker.SelectContactByIdAsync(inputContactId),
                                          Times.Once);

            this.storageBrokerMock.Verify(broker =>
                                          broker.DeleteContactAsync(It.IsAny <Contact>()),
                                          Times.Never);

            this.dateTimeBrokerMock.VerifyNoOtherCalls();
            this.loggingBrokerMock.VerifyNoOtherCalls();
            this.storageBrokerMock.VerifyNoOtherCalls();
        }
コード例 #6
0
        public async Task ShouldThrowServiceExceptionOnRetrieveWhenExceptionOccursAndLogIt()
        {
            // given
            var serviceException = new Exception();

            var failedContactServiceException =
                new FailedContactServiceException(serviceException);

            var expectedContactServiceException =
                new ContactServiceException(failedContactServiceException);

            var guid = Guid.NewGuid();

            this.storageBrokerMock.Setup(broker =>
                                         broker.SelectContactByIdAsync(guid))
            .Throws(serviceException);

            // when
            ValueTask <Contact> retrieveTask = this.contactService.RetrieveContactByIdAsync(guid);

            // then
            await Assert.ThrowsAsync <ContactServiceException>(() => retrieveTask.AsTask());

            this.loggingBrokerMock.Verify(broker =>
                                          broker.LogError(It.Is(SameExceptionAs(
                                                                    expectedContactServiceException))),
                                          Times.Once);

            this.storageBrokerMock.Verify(broker =>
                                          broker.SelectContactByIdAsync(guid),
                                          Times.Once);

            this.dateTimeBrokerMock.Verify(broker =>
                                           broker.GetCurrentDateTime(),
                                           Times.Never);

            this.dateTimeBrokerMock.VerifyNoOtherCalls();
            this.loggingBrokerMock.VerifyNoOtherCalls();
            this.storageBrokerMock.VerifyNoOtherCalls();
        }