Skip to content

Commit 6dddad1

Browse files
cjdutoitcjdutoit
authored
Merge pull request #24 from rcruzfreelance/users/rcruzfreelance/foundations-postgreSqlEfException-throwMeaningfulException
FOUNDATIONS: PostgreSql EFxception Service
2 parents 8b3fea2 + 581a194 commit 6dddad1

17 files changed

+591
-35
lines changed

‎STX.EFxceptions.PostgreSQL.Base.Tests.Unit/DeleteMe.cs

-13
This file was deleted.

‎STX.EFxceptions.PostgreSQL.Base.Tests.Unit/STX.EFxceptions.PostgreSQL.Base.Tests.Unit.csproj

+19-13
Original file line numberDiff line numberDiff line change
@@ -1,32 +1,38 @@
11
<Project Sdk="Microsoft.NET.Sdk">
22

33
<PropertyGroup>
4-
<TargetFramework>net8.0</TargetFramework>
4+
<TargetFramework>net8.0</TargetFramework>
55
<ImplicitUsings>disable</ImplicitUsings>
66
<Nullable>disable</Nullable>
77
<IsPackable>false</IsPackable>
88
<IsTestProject>true</IsTestProject>
99
</PropertyGroup>
1010

1111
<ItemGroup>
12-
<PackageReference Include="coverlet.collector" Version="6.0.2">
13-
<PrivateAssets>all</PrivateAssets>
14-
<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
15-
</PackageReference>
16-
<PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.10.0" />
17-
<PackageReference Include="xunit" Version="2.9.0" />
18-
<PackageReference Include="xunit.runner.visualstudio" Version="2.8.2">
19-
<PrivateAssets>all</PrivateAssets>
20-
<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
21-
</PackageReference>
12+
<PackageReference Include="FluentAssertions" Version="6.12.0" />
13+
<PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.10.0" />
14+
<PackageReference Include="CleanMoq" Version="42.42.42" />
15+
<PackageReference Include="STX.EFxceptions.Abstractions" Version="0.1.7" />
16+
<PackageReference Include="STX.EFxceptions.Core" Version="0.1.7" />
17+
<PackageReference Include="STX.EFxceptions.Identity.Core" Version="0.1.7" />
18+
<PackageReference Include="Tynamix.ObjectFiller" Version="1.5.9" />
19+
<PackageReference Include="xunit" Version="2.9.0" />
20+
<PackageReference Include="xunit.runner.visualstudio" Version="2.8.2">
21+
<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
22+
<PrivateAssets>all</PrivateAssets>
23+
</PackageReference>
24+
<PackageReference Include="coverlet.collector" Version="6.0.2">
25+
<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
26+
<PrivateAssets>all</PrivateAssets>
27+
</PackageReference>
2228
</ItemGroup>
2329

2430
<ItemGroup>
25-
<ProjectReference Include="..\STX.EFxceptions.PostgreSQL.Base\STX.EFxceptions.PostgreSQL.Base.csproj" />
31+
<ProjectReference Include="..\STX.EFxceptions.PostgreSQL.Base\STX.EFxceptions.PostgreSQL.Base.csproj" />
2632
</ItemGroup>
2733

2834
<ItemGroup>
29-
<Using Include="Xunit" />
35+
<Using Include="Xunit" />
3036
</ItemGroup>
3137

3238
</Project>

‎STX.EFxceptions.PostgreSQL.Base.Tests.Unit/Services/Foundations/PostgreSqlEFxceptionServiceTests.Exceptions.cs

+285
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,285 @@
1+
// ----------------------------------------------------------------------------------
2+
// Copyright (c) The Standard Organization: A coalition of the Good-Hearted Engineers
3+
// ----------------------------------------------------------------------------------
4+
5+
using FluentAssertions;
6+
using Microsoft.EntityFrameworkCore;
7+
using Moq;
8+
using Npgsql;
9+
using STX.EFxceptions.Abstractions.Models.Exceptions;
10+
using STX.EFxceptions.PostgreSQL.Base.Models.Exceptions;
11+
12+
namespace STX.EFxceptions.PostgreSQL.Base.Tests.Unit.Services.Foundations
13+
{
14+
public partial class PostgreSqlEFxceptionServiceTests
15+
{
16+
[Fact]
17+
public void ShouldThrowDbUpdateExceptionIfErrorCodeIsNotRecognized()
18+
{
19+
// given
20+
string sqlForeignKeyConstraintConflictErrorCode = "0000";
21+
string randomErrorMessage = CreateRandomErrorMessage();
22+
23+
NpgsqlException foreignKeyConstraintConflictExceptionThrown =
24+
CreatePostgreSqlException(
25+
message: randomErrorMessage,
26+
errorCode: sqlForeignKeyConstraintConflictErrorCode);
27+
28+
var dbUpdateException = new DbUpdateException(
29+
message: randomErrorMessage,
30+
innerException: foreignKeyConstraintConflictExceptionThrown);
31+
32+
DbUpdateException expectedDbUpdateException = dbUpdateException;
33+
34+
this.postgreSqlErrorBrokerMock.Setup(broker =>
35+
broker.GetErrorCode(foreignKeyConstraintConflictExceptionThrown))
36+
.Returns(sqlForeignKeyConstraintConflictErrorCode);
37+
38+
// when
39+
DbUpdateException actualDbUpdateException =
40+
Assert.Throws<DbUpdateException>(() => this.postgreSqlEFxceptionService
41+
.ThrowMeaningfulException(dbUpdateException));
42+
43+
// then
44+
actualDbUpdateException.Should()
45+
.BeEquivalentTo(
46+
expectation: expectedDbUpdateException,
47+
config: options => options
48+
.Excluding(ex => ex.TargetSite)
49+
.Excluding(ex => ex.StackTrace)
50+
.Excluding(ex => ex.Source)
51+
.Excluding(ex => ex.InnerException.TargetSite)
52+
.Excluding(ex => ex.InnerException.StackTrace)
53+
.Excluding(ex => ex.InnerException.Source));
54+
55+
this.postgreSqlErrorBrokerMock.Verify(broker => broker
56+
.GetErrorCode(foreignKeyConstraintConflictExceptionThrown), Times.Once());
57+
58+
postgreSqlErrorBrokerMock.VerifyNoOtherCalls();
59+
}
60+
61+
[Fact]
62+
public void ShouldThrowInvalidColumnNamePostgreSqlException()
63+
{
64+
// given
65+
string postgreSqlInvalidColumnNameErrorCode = "42703";
66+
string randomErrorMessage = CreateRandomErrorMessage();
67+
68+
NpgsqlException invalidColumnNameExceptionThrown =
69+
CreatePostgreSqlException(
70+
message: randomErrorMessage,
71+
errorCode: postgreSqlInvalidColumnNameErrorCode);
72+
73+
string randomDbUpdateExceptionMessage = CreateRandomErrorMessage();
74+
75+
var dbUpdateException = new DbUpdateException(
76+
message: randomDbUpdateExceptionMessage,
77+
innerException: invalidColumnNameExceptionThrown);
78+
79+
var invalidColumnNamePostgreSqlException =
80+
new InvalidColumnNamePostgreSqlException(
81+
message: invalidColumnNameExceptionThrown.Message);
82+
83+
var expectedInvalidColumnNameException =
84+
new InvalidColumnNameException(
85+
message: invalidColumnNamePostgreSqlException.Message,
86+
innerException: invalidColumnNamePostgreSqlException);
87+
88+
this.postgreSqlErrorBrokerMock.Setup(broker =>
89+
broker.GetErrorCode(invalidColumnNameExceptionThrown))
90+
.Returns(postgreSqlInvalidColumnNameErrorCode);
91+
92+
// when
93+
InvalidColumnNameException actualInvalidColumnNameException =
94+
Assert.Throws<InvalidColumnNameException>(() =>
95+
this.postgreSqlEFxceptionService
96+
.ThrowMeaningfulException(dbUpdateException));
97+
98+
// then
99+
actualInvalidColumnNameException.Should()
100+
.BeEquivalentTo(
101+
expectation: expectedInvalidColumnNameException,
102+
config: options => options
103+
.Excluding(ex => ex.TargetSite)
104+
.Excluding(ex => ex.StackTrace)
105+
.Excluding(ex => ex.Source)
106+
.Excluding(ex => ex.InnerException.TargetSite)
107+
.Excluding(ex => ex.InnerException.StackTrace)
108+
.Excluding(ex => ex.InnerException.Source));
109+
110+
this.postgreSqlErrorBrokerMock.Verify(broker => broker
111+
.GetErrorCode(invalidColumnNameExceptionThrown),
112+
Times.Once());
113+
114+
this.postgreSqlErrorBrokerMock.VerifyNoOtherCalls();
115+
}
116+
117+
[Fact]
118+
public void ShouldThrowInvalidObjectNamePostgreSqlException()
119+
{
120+
// given
121+
string postgreSqlInvalidObjectNameErrorCode = "42P01";
122+
string randomErrorMessage = CreateRandomErrorMessage();
123+
124+
NpgsqlException invalidObjectNameExceptionThrown =
125+
CreatePostgreSqlException(
126+
message: randomErrorMessage,
127+
errorCode: postgreSqlInvalidObjectNameErrorCode);
128+
129+
string randomDbUpdateExceptionMessage = CreateRandomErrorMessage();
130+
131+
var dbUpdateException = new DbUpdateException(
132+
message: randomDbUpdateExceptionMessage,
133+
innerException: invalidObjectNameExceptionThrown);
134+
135+
var invalidObjectNameSqlException =
136+
new InvalidObjectNamePostgreSqlException(
137+
message: invalidObjectNameExceptionThrown.Message);
138+
139+
var expectedInvalidObjectNameException =
140+
new InvalidObjectNameException(
141+
message: invalidObjectNameSqlException.Message,
142+
innerException: invalidObjectNameSqlException);
143+
144+
this.postgreSqlErrorBrokerMock.Setup(broker =>
145+
broker.GetErrorCode(invalidObjectNameExceptionThrown))
146+
.Returns(postgreSqlInvalidObjectNameErrorCode);
147+
148+
// when
149+
InvalidObjectNameException actualInvalidObjectNameException =
150+
Assert.Throws<InvalidObjectNameException>(() =>
151+
this.postgreSqlEFxceptionService
152+
.ThrowMeaningfulException(dbUpdateException));
153+
154+
// then
155+
actualInvalidObjectNameException.Should()
156+
.BeEquivalentTo(
157+
expectation: expectedInvalidObjectNameException,
158+
config: options => options
159+
.Excluding(ex => ex.TargetSite)
160+
.Excluding(ex => ex.StackTrace)
161+
.Excluding(ex => ex.Source)
162+
.Excluding(ex => ex.InnerException.TargetSite)
163+
.Excluding(ex => ex.InnerException.StackTrace)
164+
.Excluding(ex => ex.InnerException.Source));
165+
166+
this.postgreSqlErrorBrokerMock.Verify(broker => broker
167+
.GetErrorCode(invalidObjectNameExceptionThrown),
168+
Times.Once());
169+
170+
this.postgreSqlErrorBrokerMock.VerifyNoOtherCalls();
171+
}
172+
173+
[Fact]
174+
public void ShouldThrowForeignKeyConstraintConflictPostgreSqlException()
175+
{
176+
// given
177+
string postgreSqlForeignKeyConstraintConflictErrorCode = "23503";
178+
string randomErrorMessage = CreateRandomErrorMessage();
179+
180+
NpgsqlException foreignKeyConstraintConflictExceptionThrown =
181+
CreatePostgreSqlException(
182+
message: randomErrorMessage,
183+
errorCode: postgreSqlForeignKeyConstraintConflictErrorCode);
184+
185+
string randomDbUpdateExceptionMessage = CreateRandomErrorMessage();
186+
187+
var dbUpdateException = new DbUpdateException(
188+
message: randomDbUpdateExceptionMessage,
189+
innerException: foreignKeyConstraintConflictExceptionThrown);
190+
191+
var foreignKeyConstraintConflictSqlException =
192+
new ForeignKeyConstraintConflictPostgreSqlException(
193+
message: foreignKeyConstraintConflictExceptionThrown.Message);
194+
195+
var expectedForeignKeyConstraintConflictException =
196+
new ForeignKeyConstraintConflictException(
197+
message: foreignKeyConstraintConflictSqlException.Message,
198+
innerException: foreignKeyConstraintConflictSqlException);
199+
200+
this.postgreSqlErrorBrokerMock.Setup(broker =>
201+
broker.GetErrorCode(foreignKeyConstraintConflictExceptionThrown))
202+
.Returns(postgreSqlForeignKeyConstraintConflictErrorCode);
203+
204+
// when
205+
ForeignKeyConstraintConflictException actualForeignKeyConstraintConflictException =
206+
Assert.Throws<ForeignKeyConstraintConflictException>(() =>
207+
this.postgreSqlEFxceptionService
208+
.ThrowMeaningfulException(dbUpdateException));
209+
210+
// then
211+
actualForeignKeyConstraintConflictException.Should()
212+
.BeEquivalentTo(
213+
expectation: expectedForeignKeyConstraintConflictException,
214+
config: options => options
215+
.Excluding(ex => ex.TargetSite)
216+
.Excluding(ex => ex.StackTrace)
217+
.Excluding(ex => ex.Source)
218+
.Excluding(ex => ex.InnerException.TargetSite)
219+
.Excluding(ex => ex.InnerException.StackTrace)
220+
.Excluding(ex => ex.InnerException.Source));
221+
222+
this.postgreSqlErrorBrokerMock.Verify(broker => broker
223+
.GetErrorCode(foreignKeyConstraintConflictExceptionThrown),
224+
Times.Once());
225+
226+
this.postgreSqlErrorBrokerMock.VerifyNoOtherCalls();
227+
}
228+
229+
[Fact]
230+
public void ShouldThrowDuplicateKeyWithUniqueIndexPostgreSqlException()
231+
{
232+
// given
233+
string postgreSqlDuplicateKeyWithUniqueIndexErrorCode = "42710";
234+
string randomErrorMessage = CreateRandomErrorMessage();
235+
236+
NpgsqlException duplicateKeyWithUniqueIndexExceptionThrown =
237+
CreatePostgreSqlException(
238+
message: randomErrorMessage,
239+
errorCode: postgreSqlDuplicateKeyWithUniqueIndexErrorCode);
240+
241+
string randomDbUpdateExceptionMessage = CreateRandomErrorMessage();
242+
243+
var dbUpdateException = new DbUpdateException(
244+
message: randomDbUpdateExceptionMessage,
245+
innerException: duplicateKeyWithUniqueIndexExceptionThrown);
246+
247+
var duplicateKeyWithUniqueIndexSqlException =
248+
new DuplicateKeyWithUniqueIndexPostgreSqlException(
249+
message: duplicateKeyWithUniqueIndexExceptionThrown.Message);
250+
251+
var expectedDuplicateKeyWithUniqueIndexException =
252+
new DuplicateKeyWithUniqueIndexException(
253+
message: duplicateKeyWithUniqueIndexSqlException.Message,
254+
innerException: duplicateKeyWithUniqueIndexSqlException);
255+
256+
this.postgreSqlErrorBrokerMock.Setup(broker =>
257+
broker.GetErrorCode(duplicateKeyWithUniqueIndexExceptionThrown))
258+
.Returns(postgreSqlDuplicateKeyWithUniqueIndexErrorCode);
259+
260+
// when
261+
DuplicateKeyWithUniqueIndexException actualDuplicateKeyWithUniqueIndexException =
262+
Assert.Throws<DuplicateKeyWithUniqueIndexException>(() =>
263+
this.postgreSqlEFxceptionService
264+
.ThrowMeaningfulException(dbUpdateException));
265+
266+
// then
267+
actualDuplicateKeyWithUniqueIndexException.Should()
268+
.BeEquivalentTo(
269+
expectation: expectedDuplicateKeyWithUniqueIndexException,
270+
config: options => options
271+
.Excluding(ex => ex.TargetSite)
272+
.Excluding(ex => ex.StackTrace)
273+
.Excluding(ex => ex.Source)
274+
.Excluding(ex => ex.InnerException.TargetSite)
275+
.Excluding(ex => ex.InnerException.StackTrace)
276+
.Excluding(ex => ex.InnerException.Source));
277+
278+
this.postgreSqlErrorBrokerMock.Verify(broker => broker
279+
.GetErrorCode(duplicateKeyWithUniqueIndexExceptionThrown),
280+
Times.Once());
281+
282+
this.postgreSqlErrorBrokerMock.VerifyNoOtherCalls();
283+
}
284+
}
285+
}

0 commit comments

Comments
 (0)