Merge pull request #657 from PathfinderHonorManager/develop

Added tests and validation for club

Author: brian-cummings

PathfinderHonorManager.Tests/Service/ClubServiceTests.cs

@@ -3,7 +3,9 @@
 using System.Threading;
 using System.Threading.Tasks;
 using AutoMapper;
+using FluentValidation;
 using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Logging.Abstractions;
 using NUnit.Framework;
 using PathfinderHonorManager.DataAccess;
@@ -12,54 +14,50 @@
 using PathfinderHonorManager.Model;
 using PathfinderHonorManager.Service;
 using PathfinderHonorManager.Tests.Helpers;
+using PathfinderHonorManager.Validators;
+using Incoming = PathfinderHonorManager.Dto.Incoming;
 
 namespace PathfinderHonorManager.Tests.Service
 {
     public class ClubServiceTests
     {
+        protected DbContextOptions<PathfinderContext> ContextOptions { get; }
+        private ClubService _clubService;
+        private List<Club> _clubs;
+        private IValidator<Incoming.ClubDto> _validator;
+
         public ClubServiceTests()
         {
             ContextOptions = new DbContextOptionsBuilder<PathfinderContext>()
                 .UseInMemoryDatabase(databaseName: "TestDb")
                 .Options;
         }
 
-        protected DbContextOptions<PathfinderContext> ContextOptions { get; }
-
-        private ClubService _clubService;
-
-        private List<Club> _clubs;
-
         [SetUp]
         public async Task SetUp()
         {
-            using (var dbContext = new PathfinderContext(ContextOptions))
-            {
-                await SeedDatabase(dbContext);
-            }
+            using var dbContext = new PathfinderContext(ContextOptions);
+            await DatabaseCleaner.CleanDatabase(dbContext);
+            await SeedDatabase(dbContext);
         }
 
         private async Task SeedDatabase(PathfinderContext dbContext)
         {
             _clubs = new List<Club>
-        {
-            new Club
             {
-                ClubID = Guid.NewGuid(),
-                Name = "Test Club 1"
-            },
-            new Club
-            {
-                ClubID = Guid.NewGuid(),
-                Name = "Test Club 2"
-            },
-            new Club
-            {
-                ClubID = Guid.NewGuid(),
-                Name = "Test Club 3"
-            }
-    };
-
+                new Club
+                {
+                    ClubID = Guid.NewGuid(),
+                    ClubCode = "TESTCLUB1",
+                    Name = "Test Club 1"
+                },
+                new Club
+                {
+                    ClubID = Guid.NewGuid(),
+                    ClubCode = "TESTCLUB2",
+                    Name = "Test Club 2"
+                }
+            };
 
             await dbContext.Clubs.AddRangeAsync(_clubs);
             await dbContext.SaveChangesAsync();
@@ -70,26 +68,23 @@ public async Task GetAllAsync_ReturnsAllClubs()
         {
             var mapperConfiguration = new MapperConfiguration(cfg => cfg.AddProfile<AutoMapperConfig>());
             IMapper mapper = mapperConfiguration.CreateMapper();
-
             var logger = new NullLogger<ClubService>();
 
-            var validator = new DummyValidator<ClubDto>();
-
             using (var dbContext = new PathfinderContext(ContextOptions))
             {
-                _clubService = new ClubService(dbContext, mapper, logger);
+                _validator = new ClubValidator(dbContext);
+                _clubService = new ClubService(dbContext, mapper, logger, _validator);
 
                 // Act
                 CancellationToken token = new();
                 var result = await _clubService.GetAllAsync(token);
+
                 // Assert
                 Assert.That(result, Is.Not.Null);
                 Assert.That(result.Count, Is.EqualTo(_clubs.Count));
             }
         }
 
-        // ...
-
         [TestCase(0)]
         public async Task GetByIdAsync_ClubExists_ReturnsClub(int clubIndex)
         {
@@ -99,7 +94,8 @@ public async Task GetByIdAsync_ClubExists_ReturnsClub(int clubIndex)
 
             using (var dbContext = new PathfinderContext(ContextOptions))
             {
-                _clubService = new ClubService(dbContext, mapper, logger);
+                _validator = new ClubValidator(dbContext);
+                _clubService = new ClubService(dbContext, mapper, logger, _validator);
 
                 // Act
                 CancellationToken token = new();
@@ -122,7 +118,8 @@ public async Task GetByIdAsync_ClubDoesNotExist_ReturnsNull()
 
             using (var dbContext = new PathfinderContext(ContextOptions))
             {
-                _clubService = new ClubService(dbContext, mapper, logger);
+                _validator = new ClubValidator(dbContext);
+                _clubService = new ClubService(dbContext, mapper, logger, _validator);
 
                 // Act
                 CancellationToken token = new();
@@ -133,17 +130,165 @@ public async Task GetByIdAsync_ClubDoesNotExist_ReturnsNull()
                 Assert.That(result, Is.Null);
             }
         }
+        
+        [TestCase]
+        public async Task CreateAsync_ValidClub_ReturnsCreatedClub()
+        {
+            var mapperConfiguration = new MapperConfiguration(cfg => cfg.AddProfile<AutoMapperConfig>());
+            IMapper mapper = mapperConfiguration.CreateMapper();
+            var logger = new NullLogger<ClubService>();
+
+            using (var dbContext = new PathfinderContext(ContextOptions))
+            {
+                _validator = new ClubValidator(dbContext);
+                _clubService = new ClubService(dbContext, mapper, logger, _validator);
+
+                // Act
+                CancellationToken token = new();
+                var newClub = new Incoming.ClubDto
+                {
+                    Name = "New Test Club",
+                    ClubCode = "NEWCLUB"
+                };
+
+                var result = await _clubService.CreateAsync(newClub, token);
+
+                // Assert
+                Assert.That(result, Is.Not.Null);
+                Assert.That(result.Name, Is.EqualTo(newClub.Name));
+                Assert.That(result.ClubCode, Is.EqualTo(newClub.ClubCode));
+                Assert.That(result.ClubID, Is.Not.EqualTo(Guid.Empty));
+
+                // Verify the club was added to the database
+                var savedClub = await dbContext.Clubs.SingleOrDefaultAsync(c => c.ClubCode == newClub.ClubCode);
+                Assert.That(savedClub, Is.Not.Null);
+                Assert.That(savedClub.Name, Is.EqualTo(newClub.Name));
+            }
+        }
+
+        [TestCase]
+        public async Task CreateAsync_DuplicateClubCode_ThrowsValidationException()
+        {
+            var mapperConfiguration = new MapperConfiguration(cfg => cfg.AddProfile<AutoMapperConfig>());
+            IMapper mapper = mapperConfiguration.CreateMapper();
+            var logger = new NullLogger<ClubService>();
+
+            using (var dbContext = new PathfinderContext(ContextOptions))
+            {
+                _validator = new ClubValidator(dbContext);
+                _clubService = new ClubService(dbContext, mapper, logger, _validator);
+
+                // Act
+                CancellationToken token = new();
+                var newClub = new Incoming.ClubDto
+                {
+                    Name = "Duplicate Club",
+                    ClubCode = _clubs[0].ClubCode // Using existing club code to trigger exception
+                };
+
+                // Assert
+                Assert.ThrowsAsync<ValidationException>(() => 
+                    _clubService.CreateAsync(newClub, token));
+            }
+        }
+
+        [TestCase(0)]
+        public async Task UpdateAsync_ValidClub_ReturnsUpdatedClub(int clubIndex)
+        {
+            var mapperConfiguration = new MapperConfiguration(cfg => cfg.AddProfile<AutoMapperConfig>());
+            IMapper mapper = mapperConfiguration.CreateMapper();
+            var logger = new NullLogger<ClubService>();
+
+            using (var dbContext = new PathfinderContext(ContextOptions))
+            {
+                _validator = new ClubValidator(dbContext);
+                _clubService = new ClubService(dbContext, mapper, logger, _validator);
+
+                // Act
+                CancellationToken token = new();
+                var clubId = _clubs[clubIndex].ClubID;
+                var updatedClub = new Incoming.ClubDto
+                {
+                    Name = "Updated Club Name",
+                    ClubCode = "UPDATED"
+                };
+
+                var result = await _clubService.UpdateAsync(clubId, updatedClub, token);
+
+                // Assert
+                Assert.That(result, Is.Not.Null);
+                Assert.That(result.ClubID, Is.EqualTo(clubId));
+                Assert.That(result.Name, Is.EqualTo(updatedClub.Name));
+                Assert.That(result.ClubCode, Is.EqualTo(updatedClub.ClubCode));
+
+                // Verify the club was updated in the database
+                var savedClub = await dbContext.Clubs.FindAsync(clubId);
+                Assert.That(savedClub, Is.Not.Null);
+                Assert.That(savedClub.Name, Is.EqualTo(updatedClub.Name));
+                Assert.That(savedClub.ClubCode, Is.EqualTo(updatedClub.ClubCode));
+            }
+        }
+
+        [TestCase]
+        public async Task UpdateAsync_NonExistentClub_ReturnsNull()
+        {
+            var mapperConfiguration = new MapperConfiguration(cfg => cfg.AddProfile<AutoMapperConfig>());
+            IMapper mapper = mapperConfiguration.CreateMapper();
+            var logger = new NullLogger<ClubService>();
+
+            using (var dbContext = new PathfinderContext(ContextOptions))
+            {
+                _validator = new ClubValidator(dbContext);
+                _clubService = new ClubService(dbContext, mapper, logger, _validator);
+
+                // Act
+                CancellationToken token = new();
+                var nonExistentId = Guid.NewGuid();
+                var updatedClub = new Incoming.ClubDto
+                {
+                    Name = "Non Existent Club",
+                    ClubCode = "NONEXIST"
+                };
+
+                var result = await _clubService.UpdateAsync(nonExistentId, updatedClub, token);
+
+                // Assert
+                Assert.That(result, Is.Null);
+            }
+        }
 
+        [TestCase(0)]
+        public async Task UpdateAsync_DuplicateClubCode_ThrowsValidationException(int clubIndex)
+        {
+            var mapperConfiguration = new MapperConfiguration(cfg => cfg.AddProfile<AutoMapperConfig>());
+            IMapper mapper = mapperConfiguration.CreateMapper();
+            var logger = new NullLogger<ClubService>();
+
+            using (var dbContext = new PathfinderContext(ContextOptions))
+            {
+                _validator = new ClubValidator(dbContext);
+                _clubService = new ClubService(dbContext, mapper, logger, _validator);
+
+                // Act
+                CancellationToken token = new();
+                var clubId = _clubs[clubIndex].ClubID;
+                var updatedClub = new Incoming.ClubDto
+                {
+                    Name = "Updated Club Name",
+                    ClubCode = _clubs[1].ClubCode // Using another club's code to trigger duplicate exception
+                };
+
+                // Assert
+                Assert.ThrowsAsync<ValidationException>(() => 
+                    _clubService.UpdateAsync(clubId, updatedClub, token));
+            }
+        }
 
         [TearDown]
         public async Task TearDown()
         {
             using var dbContext = new PathfinderContext(ContextOptions);
-
-            dbContext.Clubs.RemoveRange();
-
-            await dbContext.SaveChangesAsync();
+            await DatabaseCleaner.CleanDatabase(dbContext);
         }
     }
-
 }

PathfinderHonorManager/Service/ClubService.cs

@@ -23,14 +23,18 @@ public class ClubService : IClubService
 
         private readonly ILogger _logger;
 
+        private readonly IValidator<Incoming.ClubDto> _validator;
+
         public ClubService(
             PathfinderContext context,
             IMapper mapper,
-            ILogger<ClubService> logger)
+            ILogger<ClubService> logger,
+            IValidator<Incoming.ClubDto> validator)
         {
             _dbContext = context;
             _mapper = mapper;
             _logger = logger;
+            _validator = validator;
         }
 
         public async Task<ICollection<Outgoing.ClubDto>> GetAllAsync(CancellationToken token)
@@ -88,6 +92,8 @@ public ClubService(
 
             try
             {
+                await _validator.ValidateAsync(club, options => options.ThrowOnFailures().IncludeRuleSets("post"), token);
+
                 var entity = _mapper.Map<Club>(club);
                 await _dbContext.Clubs.AddAsync(entity, token);
                 await _dbContext.SaveChangesAsync(token);
@@ -117,6 +123,11 @@ public ClubService(
                     return default;
                 }
 
+                if (entity.ClubCode != club.ClubCode)
+                {
+                    await _validator.ValidateAsync(club, options => options.ThrowOnFailures().IncludeRuleSets("post"), token);
+                }
+
                 _mapper.Map(club, entity);
                 await _dbContext.SaveChangesAsync(token);