Skip to content

Commit d0639c5

Browse files
DilmurodDeveloperDilmurodDeveloper
authored
Merge pull request #60 from DilmurodDeveloper/users/DilmurodDeveloper/foundations-reader-modify
FOUNDATIONS: Modify Reader
2 parents 796fbc0 + 6cd3869 commit d0639c5

File tree

8 files changed

+496
-1
lines changed

8 files changed

+496
-1
lines changed

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

Lines changed: 209 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,209 @@
1+
//-----------------------------------------------------------
2+
// Copyright (c) Coalition of Good-Hearted Engineers
3+
// Free To Use To Build Reliable Library Management Solutions
4+
//-----------------------------------------------------------
5+
6+
using FluentAssertions;
7+
using LibraryManagement.Api.Models.Foundations.Readers;
8+
using LibraryManagement.Api.Models.Foundations.Readers.Exceptions;
9+
using Microsoft.Data.SqlClient;
10+
using Microsoft.EntityFrameworkCore;
11+
using Moq;
12+
13+
namespace LibraryManagement.Api.Tests.Unit.Services.Foundations.Readers
14+
{
15+
public partial class ReaderServiceTests
16+
{
17+
[Fact]
18+
public async Task ShouldThrowCriticalDependencyExceptionOnModifyIfSqlErrorOccursAndLogItAsync()
19+
{
20+
// given
21+
Reader randomReader = CreateRandomReader();
22+
Reader someReader = randomReader;
23+
Guid readerId = someReader.ReaderId;
24+
SqlException sqlException = GetSqlError();
25+
26+
var failedReaderStorageException =
27+
new FailedReaderStorageException(sqlException);
28+
29+
var expectedReaderDependencyException =
30+
new ReaderDependencyException(failedReaderStorageException);
31+
32+
this.storageBrokerMock.Setup(broker =>
33+
broker.SelectReaderByIdAsync(readerId))
34+
.Throws(sqlException);
35+
36+
// when
37+
ValueTask<Reader> modifyReaderTask =
38+
this.readerService.ModifyReaderAsync(someReader);
39+
40+
ReaderDependencyException actualReaderDependencyException =
41+
await Assert.ThrowsAsync<ReaderDependencyException>(() =>
42+
modifyReaderTask.AsTask());
43+
44+
// then
45+
actualReaderDependencyException.Should()
46+
.BeEquivalentTo(expectedReaderDependencyException);
47+
48+
this.loggingBrokerMock.Verify(broker =>
49+
broker.LogCritical(It.Is(SameExceptionAs(
50+
expectedReaderDependencyException))),
51+
Times.Once);
52+
53+
this.storageBrokerMock.Verify(broker =>
54+
broker.SelectReaderByIdAsync(readerId),
55+
Times.Once);
56+
57+
this.storageBrokerMock.Verify(broker =>
58+
broker.UpdateReaderAsync(someReader),
59+
Times.Never);
60+
61+
this.loggingBrokerMock.VerifyNoOtherCalls();
62+
this.storageBrokerMock.VerifyNoOtherCalls();
63+
}
64+
65+
[Fact]
66+
public async Task ShouldThrowDependencyExceptionOnModifyIfDatabaseUpdateExceptionOccursAndLogItAsync()
67+
{
68+
// given
69+
Reader randomReader = CreateRandomReader();
70+
Reader someReader = randomReader;
71+
Guid readerId = someReader.ReaderId;
72+
var databaseUpdateException = new DbUpdateException();
73+
74+
var failedReaderStorageException =
75+
new FailedReaderStorageException(databaseUpdateException);
76+
77+
var expectedReaderDependencyException =
78+
new ReaderDependencyException(failedReaderStorageException);
79+
80+
this.storageBrokerMock.Setup(broker =>
81+
broker.SelectReaderByIdAsync(readerId))
82+
.Throws(databaseUpdateException);
83+
84+
// when
85+
ValueTask<Reader> modifyReaderTask =
86+
this.readerService.ModifyReaderAsync(someReader);
87+
88+
ReaderDependencyException actualReaderDependencyException =
89+
await Assert.ThrowsAsync<ReaderDependencyException>(() =>
90+
modifyReaderTask.AsTask());
91+
92+
// then
93+
actualReaderDependencyException.Should()
94+
.BeEquivalentTo(expectedReaderDependencyException);
95+
96+
this.loggingBrokerMock.Verify(broker =>
97+
broker.LogError(It.Is(SameExceptionAs(
98+
expectedReaderDependencyException))),
99+
Times.Once);
100+
101+
this.storageBrokerMock.Verify(broker =>
102+
broker.SelectReaderByIdAsync(readerId),
103+
Times.Once);
104+
105+
this.storageBrokerMock.Verify(broker =>
106+
broker.UpdateReaderAsync(someReader),
107+
Times.Never);
108+
109+
this.loggingBrokerMock.VerifyNoOtherCalls();
110+
this.storageBrokerMock.VerifyNoOtherCalls();
111+
}
112+
113+
[Fact]
114+
public async Task ShouldThrowDependencyValidationExceptionOnModifyIfDatabaseUpdateConcurrencyErrorOccursAndLogItAsync()
115+
{
116+
// given
117+
Reader randomReader = CreateRandomReader();
118+
Reader someReader = randomReader;
119+
Guid readerId = someReader.ReaderId;
120+
var dbUpdateConcurrencyException = new DbUpdateConcurrencyException();
121+
122+
var lockedReaderException =
123+
new LockedReaderException(dbUpdateConcurrencyException);
124+
125+
var expectedReaderDependencyValidationException =
126+
new ReaderDependencyValidationException(lockedReaderException);
127+
128+
this.storageBrokerMock.Setup(broker =>
129+
broker.SelectReaderByIdAsync(readerId))
130+
.Throws(dbUpdateConcurrencyException);
131+
132+
// when
133+
ValueTask<Reader> modifyReaderTask =
134+
this.readerService.ModifyReaderAsync(someReader);
135+
136+
ReaderDependencyValidationException actualReaderDependencyValidationException =
137+
await Assert.ThrowsAsync<ReaderDependencyValidationException>(() =>
138+
modifyReaderTask.AsTask());
139+
140+
// then
141+
actualReaderDependencyValidationException.Should()
142+
.BeEquivalentTo(expectedReaderDependencyValidationException);
143+
144+
this.loggingBrokerMock.Verify(broker =>
145+
broker.LogError(It.Is(SameExceptionAs(
146+
expectedReaderDependencyValidationException))),
147+
Times.Once);
148+
149+
this.storageBrokerMock.Verify(broker =>
150+
broker.SelectReaderByIdAsync(readerId),
151+
Times.Once);
152+
153+
this.storageBrokerMock.Verify(broker =>
154+
broker.UpdateReaderAsync(someReader),
155+
Times.Never);
156+
157+
this.loggingBrokerMock.VerifyNoOtherCalls();
158+
this.storageBrokerMock.VerifyNoOtherCalls();
159+
}
160+
161+
[Fact]
162+
public async Task ShouldThrowServiceExceptionOnModifyIfDatabaseUpdateErrorOccursAndLogItAsync()
163+
{
164+
// given
165+
Reader randomReader = CreateRandomReader();
166+
Reader someReader = randomReader;
167+
Guid readerId = someReader.ReaderId;
168+
var serviceException = new Exception();
169+
170+
var failedReaderServiceException =
171+
new FailedReaderServiceException(serviceException);
172+
173+
var expectedReaderServiceException =
174+
new ReaderServiceException(failedReaderServiceException);
175+
176+
this.storageBrokerMock.Setup(broker =>
177+
broker.SelectReaderByIdAsync(readerId))
178+
.Throws(serviceException);
179+
180+
// when
181+
ValueTask<Reader> modifyReaderTask =
182+
this.readerService.ModifyReaderAsync(someReader);
183+
184+
ReaderServiceException actualReaderServiceException =
185+
await Assert.ThrowsAsync<ReaderServiceException>(() =>
186+
modifyReaderTask.AsTask());
187+
188+
// then
189+
actualReaderServiceException.Should()
190+
.BeEquivalentTo(expectedReaderServiceException);
191+
192+
this.loggingBrokerMock.Verify(broker =>
193+
broker.LogError(It.Is(SameExceptionAs(
194+
expectedReaderServiceException))),
195+
Times.Once);
196+
197+
this.storageBrokerMock.Verify(broker =>
198+
broker.SelectReaderByIdAsync(readerId),
199+
Times.Once);
200+
201+
this.storageBrokerMock.Verify(broker =>
202+
broker.UpdateReaderAsync(someReader),
203+
Times.Never);
204+
205+
this.loggingBrokerMock.VerifyNoOtherCalls();
206+
this.storageBrokerMock.VerifyNoOtherCalls();
207+
}
208+
}
209+
}

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

Lines changed: 54 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,54 @@
1+
//-----------------------------------------------------------
2+
// Copyright (c) Coalition of Good-Hearted Engineers
3+
// Free To Use To Build Reliable Library Management Solutions
4+
//-----------------------------------------------------------
5+
6+
using FluentAssertions;
7+
using Force.DeepCloner;
8+
using LibraryManagement.Api.Models.Foundations.Readers;
9+
using Moq;
10+
11+
namespace LibraryManagement.Api.Tests.Unit.Services.Foundations.Readers
12+
{
13+
public partial class ReaderServiceTests
14+
{
15+
[Fact]
16+
public async Task ShouldModifyReaderAsync()
17+
{
18+
// given
19+
Reader randomReader = CreateRandomReader();
20+
Reader inputReader = randomReader;
21+
Reader persistedReader = inputReader.DeepClone();
22+
Reader updatedReader = inputReader;
23+
Reader expectedReader = updatedReader.DeepClone();
24+
Guid InputReaderId = inputReader.ReaderId;
25+
26+
this.storageBrokerMock.Setup(broker =>
27+
broker.SelectReaderByIdAsync(InputReaderId))
28+
.ReturnsAsync(persistedReader);
29+
30+
this.storageBrokerMock.Setup(broker =>
31+
broker.UpdateReaderAsync(inputReader))
32+
.ReturnsAsync(updatedReader);
33+
34+
// when
35+
Reader actualReader =
36+
await this.readerService
37+
.ModifyReaderAsync(inputReader);
38+
39+
// then
40+
actualReader.Should().BeEquivalentTo(expectedReader);
41+
42+
this.storageBrokerMock.Verify(broker =>
43+
broker.SelectReaderByIdAsync(InputReaderId),
44+
Times.Once);
45+
46+
this.storageBrokerMock.Verify(broker =>
47+
broker.UpdateReaderAsync(inputReader),
48+
Times.Once);
49+
50+
this.storageBrokerMock.VerifyNoOtherCalls();
51+
this.loggingBrokerMock.VerifyNoOtherCalls();
52+
}
53+
}
54+
}

0 commit comments

Comments
 (0)