Clean Architecture Demo
Loading...
Searching...
No Matches
ArchitectureTests.cs
Go to the documentation of this file.
1using ArchUnitNET.Loader;
2using ArchUnitNET.NUnit;
3using static ArchUnitNET.Fluent.ArchRuleDefinition;
4
6
13[TestFixture]
15{
16 private static readonly ArchUnitNET.Domain.Architecture Architecture = new ArchLoader()
17 .LoadAssemblies(
18 typeof(TaskManagement.Domain.Entities.TaskItem).Assembly,
22 )
23 .Build();
24
25 // Domain Layer Rules
26
31 [Test]
33 {
34 var rule = Types()
35 .That()
36 .ResideInNamespaceMatching("TaskManagement.Domain*")
37 .Should()
38 .NotDependOnAny(
39 Types()
40 .That()
41 .ResideInNamespaceMatching("TaskManagement.Application*")
42 .Or()
43 .ResideInNamespaceMatching("TaskManagement.Infrastructure*")
44 .Or()
45 .ResideInNamespaceMatching("TaskManagement.API*")
46 );
47
48 rule.Check(Architecture);
49 }
50
51 // Application Layer Rules
52
57 [Test]
59 {
60 var rule = Types()
61 .That()
62 .ResideInNamespaceMatching("TaskManagement.Application*")
63 .Should()
64 .NotDependOnAny(
65 Types()
66 .That()
67 .ResideInNamespaceMatching("TaskManagement.API*")
68 .Or()
69 .ResideInNamespaceMatching("TaskManagement.Infrastructure*")
70 );
71
72 rule.Check(Architecture);
73 }
74
75 // Infrastructure Layer Rules
76
80 [Test]
82 {
83 var rule = Types()
84 .That()
85 .ResideInNamespaceMatching("TaskManagement.Infrastructure*")
86 .Should()
87 .NotDependOnAny(
88 Types()
89 .That()
90 .ResideInNamespaceMatching("TaskManagement.API*")
91 );
92
93 rule.Check(Architecture);
94 }
95
96 // API Layer Rules
97
102 [Test]
104 {
105 var rule = Types()
106 .That()
107 .ResideInNamespaceMatching("TaskManagement.Domain*")
108 .Or()
109 .ResideInNamespaceMatching("TaskManagement.Application*")
110 .Or()
111 .ResideInNamespaceMatching("TaskManagement.Infrastructure*")
112 .Should()
113 .NotDependOnAny(
114 Types()
115 .That()
116 .ResideInNamespaceMatching("TaskManagement.API*")
117 );
118
119 rule.Check(Architecture);
120 }
121
122 // Interface Adapter Rules
123
128 [Test]
130 {
131 var rule = Types()
132 .That()
133 .ResideInNamespaceMatching("TaskManagement.Application*")
134 .Should()
135 .NotDependOnAny(
136 Types(true)
137 .That()
138 .ResideInNamespaceMatching("MediatR*")
139 .Or()
140 .ResideInNamespaceMatching("FluentValidation*")
141 .Or()
142 .ResideInNamespaceMatching("Microsoft.AspNetCore*")
143 .Or()
144 .ResideInNamespaceMatching("Dapper*")
145 );
146
147 rule.Check(Architecture);
148 }
149
154 [Test]
156 {
157 var rule = Types()
158 .That()
159 .ResideInNamespace("TaskManagement.API.Controllers")
160 .Or()
161 .ResideInNamespace("TaskManagement.API.Presenters")
162 .Or()
163 .ResideInNamespace("TaskManagement.API.ViewModels")
164 .Or()
165 .ResideInNamespace("TaskManagement.API.Requests")
166 .Should()
167 .NotDependOnAny(
168 Types()
169 .That()
170 .ResideInNamespaceMatching("TaskManagement.Infrastructure*")
171 );
172
173 rule.Check(Architecture);
174 }
175
180 [Test]
182 {
183 var rule = Types()
184 .That()
185 .ResideInNamespace("TaskManagement.API.Controllers")
186 .Or()
187 .ResideInNamespace("TaskManagement.API.Presenters")
188 .Or()
189 .ResideInNamespace("TaskManagement.API.ViewModels")
190 .Or()
191 .ResideInNamespace("TaskManagement.API.Requests")
192 .Should()
193 .NotDependOnAny(
194 Types()
195 .That()
196 .ResideInNamespaceMatching("TaskManagement.Domain*")
197 );
198
199 rule.Check(Architecture);
200 }
201
205 [Test]
207 {
208 var rule = Classes()
209 .That()
210 .HaveNameEndingWith("Presenter")
211 .Should()
212 .ResideInNamespace("TaskManagement.API.Presenters");
213
214 rule.Check(Architecture);
215 }
216
220 [Test]
222 {
223 var rule = Types()
224 .That()
225 .ResideInNamespaceMatching("TaskManagement.Application*")
226 .Or()
227 .ResideInNamespaceMatching("TaskManagement.API*")
228 .Should()
229 .NotDependOnAny(
230 Types()
231 .That()
232 .ResideInNamespace("TaskManagement.Infrastructure.Persistence.Records")
233 );
234
235 rule.Check(Architecture);
236 }
237
238 // Cross-Layer Naming Convention Rules
239
245 [Test]
247 {
248 // TaskManagement.API.Controllers solo tiene *Controllers
249 var rule = Types()
250 .That()
251 .ResideInNamespace("TaskManagement.API.Controllers")
252 .Should()
253 .HaveNameEndingWith("Controller");
254
255 rule.Check(Architecture);
256
257 // Los *Controllers deben residir en TaskManagement.API.Controllers
258 rule = Types()
259 .That()
260 .HaveNameEndingWith("Controller")
261 .Should()
262 .ResideInNamespace("TaskManagement.API.Controllers");
263
264 rule.Check(Architecture);
265 }
266
271 [Test]
273 {
274 var rule = Types()
275 .That()
276 .ResideInNamespace("TaskManagement.Application.Commands")
277 .Should()
278 .HaveNameEndingWith("Interactor")
279 .OrShould()
280 .HaveNameEndingWith("Boundary")
281 .OrShould()
282 .HaveNameEndingWith("Input")
283 .OrShould()
284 .HaveNameEndingWith("Output");
285
286 rule.Check(Architecture);
287 }
288
293 [Test]
295 {
296 var rule = Types()
297 .That()
298 .ResideInNamespace("TaskManagement.Application.Queries")
299 .Should()
300 .HaveNameEndingWith("Interactor")
301 .OrShould()
302 .HaveNameEndingWith("Boundary")
303 .OrShould()
304 .HaveNameEndingWith("Input")
305 .OrShould()
306 .HaveNameEndingWith("Dto");
307
308 rule.Check(Architecture);
309 }
310
314 [Test]
316 {
317 var rule = Classes()
318 .That()
319 .HaveNameEndingWith("Interactor")
320 .Should()
321 .ResideInNamespace("TaskManagement.Application.Commands")
322 .OrShould()
323 .ResideInNamespace("TaskManagement.Application.Queries");
324
325 rule.Check(Architecture);
326 }
327
334 [Test]
336 {
337 var rule = Types()
338 .That()
339 .ResideInNamespaceMatching("TaskManagement.Domain*")
340 .Should()
341 .NotDependOnAny(
342 Types(true)
343 .That()
344 .ResideInNamespaceMatching("Microsoft.EntityFrameworkCore*")
345 .Or()
346 .ResideInNamespaceMatching("Dapper*")
347 );
348
349 rule.Check(Architecture);
350 }
351
357 [Test]
359 {
360 // Verifica que el dominio no dependa de MediatR.
361 var rule = Types()
362 .That()
363 .ResideInNamespaceMatching("TaskManagement.Domain*")
364 .Should()
365 .NotDependOnAny(
366 Types(true)
367 .That()
368 .ResideInNamespaceMatching("MediatR*")
369 );
370
371 rule.Check(Architecture);
372 }
373
378 [Test]
380 {
381 var rule = Types()
382 .That()
383 .ResideInNamespaceMatching("TaskManagement.Domain*")
384 .Should()
385 .NotDependOnAny(
386 Types(true)
387 .That()
388 .ResideInNamespaceMatching("Microsoft.AspNetCore*")
389 .Or()
390 .ResideInNamespaceMatching("System.Web*")
391 );
392
393 rule.Check(Architecture);
394 }
395
402 [Test]
404 {
405 // Verifica que el dominio no dependa de proveedores de base de datos: SqlClient, Sqlite, MySql, PostgreSQL
406 var rule = Types()
407 .That()
408 .ResideInNamespaceMatching("TaskManagement.Domain*")
409 .Should()
410 .NotDependOnAny(
411 Types(true)
412 .That()
413 .ResideInNamespaceMatching("Microsoft.Data*")
414 .Or()
415 .ResideInNamespaceMatching("Sqlite*")
416 );
417
418 rule.Check(Architecture);
419 }
420
426 [Test]
428 {
429 var rule = Types()
430 .That()
431 .ResideInNamespaceMatching("TaskManagement.Domain*")
432 .Should()
433 .NotDependOnAny(
434 Types(true)
435 .That()
436 .ResideInNamespaceMatching("Microsoft.Extensions.Logging*")
437 .Or()
438 .ResideInNamespaceMatching("Microsoft.Extensions.Configuration*")
439 .Or()
440 .ResideInNamespaceMatching("Microsoft.Extensions.DependencyInjection*")
441 .Or()
442 .ResideInNamespaceMatching("Microsoft.Extensions.Caching*")
443 );
444
445 rule.Check(Architecture);
446 }
447
453 [Test]
455 {
456 // Verifica que el dominio no dependa de frameworks de autenticación/identidad
457 var rule = Types()
458 .That()
459 .ResideInNamespaceMatching("TaskManagement.Domain*")
460 .Should()
461 .NotDependOnAny(
462 Types(true)
463 .That()
464 .ResideInNamespaceMatching("Microsoft.IdentityModel*")
465 .Or()
466 .ResideInNamespaceMatching("System.Security.Principal*")
467 .Or()
468 .ResideInNamespaceMatching("IdentityModel*")
469 );
470
471 rule.Check(Architecture);
472 }
473
479 [Test]
481 {
482 var rule = Classes()
483 .That()
484 .HaveNameEndingWith("Repository")
485 .Should()
486 .ResideInNamespace("TaskManagement.Infrastructure.Persistence.Repositories");
487
488 rule.Check(Architecture);
489 }
490
497 [Test]
499 {
500 var rule = Types()
501 .That()
502 .ResideInNamespaceMatching("TaskManagement.Application*")
503 .Should()
504 .NotDependOnAny(
505 Types(true)
506 .That()
507 .ResideInNamespaceMatching("Microsoft.EntityFrameworkCore*")
508 );
509
510 rule.Check(Architecture);
511 }
512}
TasksController es el endpoint de la API REST para operaciones de gestión de tareas.
CreateTaskInteractor implementa el caso de uso de crear una tarea.
Tests de arquitectura para asegurar la aplicación de los principios de Clean Architecture usando NUni...
void DomainLayer_ShouldNotDependOnOrmFrameworks()
Verifica que la capa del dominio no dependa de frameworks de mapeo de objetos relacionales -ORM- como...
void DomainLayer_ShouldNotDependOnAnyOtherLayer()
Verifica que la capa del dominio no dependa de ninguna otra capa -aplicación, infraestructura o API-.
void DomainLayer_ShouldNotDependOnMicrosoftExtensions()
Verifica que la capa del dominio no dependa de servicios de Microsoft.Extensions como Logging,...
void DomainLayer_ShouldNotDependOnIdentityFrameworks()
Verifica que la capa del dominio no dependa de frameworks de autenticación e identidad como Microsoft...
void RepositoriesShouldResideInPersistenceLayer()
Verifica que todas las clases de repositorio -y no las interfaces- residan en el namespace TaskManage...
void InterfaceAdapters_ShouldNotDependOnDomain()
Verifica que las entidades del dominio no lleguen a la interfaz de usuario: controllers,...
void Controllers_ShouldBeInApiControllers()
Verifica que todos los controladores residan en el namespace TaskManagement.API.Controllers y que el ...
void Queries_ShouldContainOnlyUseCaseElements()
Verifica que el namespace TaskManagement.Application.Queries contenga solo interactores,...
void Presenters_ShouldBeInApiPresenters()
Verifica que los presenters residan en TaskManagement.API.Presenters.
void DomainLayer_ShouldNotDependOnMessagingFrameworks()
Verifica que la capa del dominio no dependa de frameworks de mensajería como MediatR -que ya no se us...
void DomainLayer_ShouldNotDependOnDataProviders()
Verifica que la capa del dominio no dependa de proveedores específicos de bases de datos como Microso...
void ApplicationLayer_ShouldNotDependOnFrameworks()
Verifica que la capa de aplicación no dependa de frameworks de mensajería, validación,...
void OrmRecords_ShouldNotLeaveInfrastructure()
Verifica que los objetos del ORM no salgan de la capa de infraestructura.
void InterfaceAdapters_ShouldNotDependOnInfrastructure()
Verifica que controllers, presenters, view models y requests no dependan de la capa de infraestructur...
void ApplicationLayer_ShouldNotDependOnApiOrInfrastructureLayer()
Verifica que la capa de aplicación no dependa de la capa API ni de la capa de infraestructura.
void Interactors_ShouldBeInCommandsOrQueries()
Verifica que los interactores residan en los namespaces de comandos o de consultas.
void InfrastructureLayer_ShouldNotDependOnApiLayer()
Verifica que la capa de infraestructura no dependa de la capa API.
void Commands_ShouldContainOnlyUseCaseElements()
Verifica que el namespace TaskManagement.Application.Commands contenga solo interactores,...
void ApiLayer_ShouldNotHaveDependenciesFromOtherLayers()
Verifica que ninguna capa interna -dominio, aplicación e infraestructura- dependa de la capa API.
void DomainLayer_ShouldNotDependOnWebFrameworks()
Verifica que la capa del dominio no dependa de frameworks web como ASP.NET Core o System....
void ApplicationLayer_ShouldNotDirectlyUseDbContext()
Verifica que la capa de aplicación no dependa directamente de Entity Framework Core -donde se define ...
TaskItem es una entidad del dominio que representa una tarea en el sistema.
Definition TaskItem.cs:51
TaskRepository es el repositorio de escritura para entidades TaskItem.