work

Govor.API.Tests/IntegrationTests/EF/Repositories/UsersRepositoryTests.cs

@@ -14,19 +14,19 @@ public class UsersRepositoryTests
     private Fixture _fixture;
     private DbContextOptions<GovorDbContext> _options;
     private readonly IObjectValidator<User> _userValidator = new UserValidator();
-    
+
     [SetUp]
     public void SetUp()
     {
         _fixture = new Fixture();
-        
+
         _fixture.Behaviors
             .OfType<ThrowingRecursionBehavior>()
             .ToList()
             .ForEach(b => _fixture.Behaviors.Remove(b));
 
         _fixture.Behaviors.Add(new OmitOnRecursionBehavior());
-        
+
         _options = new DbContextOptionsBuilder<GovorDbContext>()
             .UseInMemoryDatabase(databaseName: "DbGovor")
             .Options;
@@ -38,17 +38,17 @@ public class UsersRepositoryTests
         // Arrange
         var random = new Random();
         var users = _fixture.CreateMany<User>(random.Next(2, 10)).ToList();
-        
+
         await using var context = new GovorDbContext(_options);
         var userRepository = new UsersRepository(context, _userValidator);
-        
+
         context.Users.AddRange(users);
         await context.SaveChangesAsync();
-        
+
         // Act 
-        
+
         var result = await userRepository.GetAll();
-        
+
         // Assert 
         Assert.That(result, Is.Not.Null);
         Assert.That(result.Count, Is.EqualTo(users.Count));
@@ -60,70 +60,71 @@ public class UsersRepositoryTests
     public async Task Given_ValidUserId_When_FindById_Then_Returns_User()
     {
         // Arrange
-        var user  = _fixture.Create<User>();
+        var user = _fixture.Create<User>();
         await using var context = new GovorDbContext(_options);
         var userRepository = new UsersRepository(context, _userValidator);
-        
+
         context.Users.Add(user);
         await context.SaveChangesAsync();
-        
+
         // Act 
         var result = await userRepository.FindById(user.Id);
-        
+
         // Assert 
         Assert.That(result, Is.Not.Null);
         Assert.That(result.Username, Is.EqualTo(user.Username));
         Assert.That(result.Id, Is.EqualTo(user.Id));
     }
-    
+
     [Test]
     public async Task Given_InvalidUserId_When_FindById_Should_Throw_NotFoundException()
     {
         // Arrange 
         var id = Guid.NewGuid();
-        
+
         await using var context = new GovorDbContext(_options);
         var userRepository = new UsersRepository(context, _userValidator);
-        
+
         // Act & Assert  
         Assert.ThrowsAsync<NotFoundByKeyException<Guid>>(async () => await userRepository.FindById(id));
     }
-    
+
     [Test]
     public async Task Given_RangeValidUserId_When_FindByRangeId_Then_Returns_Users()
     {
         // Arrange 
         var random = new Random();
         var users = _fixture.CreateMany<User>(random.Next(2, 10)).ToList();
-        
+
         await using var context = new GovorDbContext(_options);
         var userRepository = new UsersRepository(context, _userValidator);
-        
+
         context.Users.AddRange(users);
         await context.SaveChangesAsync();
-        
+
         // Act 
         var result = await userRepository.FindByRangeId(users.Select(u => u.Id));
-        
+
         // Assert 
         Assert.That(result, Is.Not.Null);
         Assert.That(result.Count, Is.EqualTo(users.Count));
         Assert.That(result.Select(r => r.Id), Is.EquivalentTo(users.Select(u => u.Id)));
         Assert.That(result.Select(u => u.Username), Is.EquivalentTo(users.Select(u => u.Username)));
     }
-    
+
     [Test]
     public async Task Given_InvalidRangeId_When_FindByRangeId_Should_Throw_NotFoundException()
     {
         // Arrange 
         var random = new Random();
         var ids = _fixture.CreateMany<Guid>(random.Next(2, 10)).ToList();
-        
+
         await using var context = new GovorDbContext(_options);
         var userRepository = new UsersRepository(context, _userValidator);
-        
+
         // Act & Assert 
-        Assert.ThrowsAsync<NotFoundByKeyException<IEnumerable<Guid>>>(async () => await userRepository.FindByRangeId(ids));
+        Assert.ThrowsAsync<NotFoundByKeyException<IEnumerable<Guid>>>(async () =>
+            await userRepository.FindByRangeId(ids));
     }
 
     [Test]
@@ -131,13 +132,13 @@ public class UsersRepositoryTests
     {
         // Arrange 
         var user = _fixture.Create<User>();
-        
+
         await using var context = new GovorDbContext(_options);
         var userRepository = new UsersRepository(context, _userValidator);
-        
+
         context.Users.Add(user);
         await context.SaveChangesAsync();
-        
+
         // Act 
         var result = await userRepository.FindByUsername(user.Username);
         // Assert
@@ -145,54 +146,55 @@ public class UsersRepositoryTests
         Assert.That(result.Username, Is.EqualTo(user.Username));
         Assert.That(result.Id, Is.EqualTo(user.Id));
     }
-    
+
     [Test]
     public async Task Given_InvalidUsername_When_FindByUsername_Should_Throw_NotFoundByKeyException()
     {
         // Arrange 
         string username = _fixture.Create<string>();
-        
+
         await using var context = new GovorDbContext(_options);
         var userRepository = new UsersRepository(context, _userValidator);
         // Act & Assert 
-        
+
         Assert.ThrowsAsync<NotFoundByKeyException<string>>(async () => await userRepository.FindByUsername(username));
     }
-    
+
     [Test]
     public async Task Given_ValidUsernames_When_FindByRangeUsernames_Then_Returns_Users()
     {
         // Arrange 
         var random = new Random();
         var users = _fixture.CreateMany<User>(random.Next(3, 10)).ToList();
-        
+
         await using var context = new GovorDbContext(_options);
         var userRepository = new UsersRepository(context, _userValidator);
-        
+
         context.Users.AddRange(users);
         await context.SaveChangesAsync();
-        
+
         // Act 
         var result = await userRepository.FindByRangeUsernames(users.Select(u => u.Username));
-        
+
         // Assert
         Assert.That(result, Is.Not.Null);
         Assert.That(result.Select(u => u.Username), Is.EquivalentTo(users.Select(u => u.Username)));
         Assert.That(result.Select(u => u.Id), Is.EquivalentTo(users.Select(u => u.Id)));
     }
-    
+
     [Test]
     public async Task Given_InvalidUsernames_When_FindByRangeUsernames_Should_Throw_NotFoundByKeyException()
     {
         // Arrange 
         var random = new Random();
         var usernames = _fixture.CreateMany<string>(random.Next(3, 10)).ToList();
-        
+
         await using var context = new GovorDbContext(_options);
         var userRepository = new UsersRepository(context, _userValidator);
-        
+
         // Act & Assert 
-        Assert.ThrowsAsync<NotFoundByKeyException<IEnumerable<string>>>(async () => await userRepository.FindByRangeUsernames(usernames));
+        Assert.ThrowsAsync<NotFoundByKeyException<IEnumerable<string>>>(async () =>
+            await userRepository.FindByRangeUsernames(usernames));
     }
 
     [Test]
@@ -201,9 +203,9 @@ public class UsersRepositoryTests
         // Arrange 
         var random = new Random();
         var users = _fixture.CreateMany<User>(random.Next(3, 10)).ToList();
-        
+
         var selectedDate = users[random.Next(users.Count)].CreatedOn;
-        
+
         await using var context = new GovorDbContext(_options);
         var userRepository = new UsersRepository(context, _userValidator);
 
@@ -228,28 +230,29 @@ public class UsersRepositoryTests
     {
         // Arrange 
         var date = _fixture.Create<DateOnly>();
-        
+
         await using var context = new GovorDbContext(_options);
         var userRepository = new UsersRepository(context, _userValidator);
-        
+
         // Act & Assert 
-        Assert.ThrowsAsync<NotFoundByKeyException<DateOnly>>(async () => await userRepository.FindUsersByCreatedDate(date));
+        Assert.ThrowsAsync<NotFoundByKeyException<DateOnly>>(async () =>
+            await userRepository.FindUsersByCreatedDate(date));
     }
 
     [Test]
     public async Task Given_ValidUser_When_AddUser_Then_CreateUser()
     {
         var user = _fixture.Create<User>();
-        
+
         await using var context = new GovorDbContext(_options);
         var userRepository = new UsersRepository(context, _userValidator);
-        
+
         // Act 
         userRepository.Add(user);
         var res = context.Users.Find(user.Id);
-        
+
         // Assert 
-        
+
         Assert.That(res, Is.Not.Null);
         Assert.That(res.Username, Is.EqualTo(user.Username));
         Assert.That(res.Id, Is.EqualTo(user.Id));
@@ -260,12 +263,32 @@ public class UsersRepositoryTests
     {
         var user = _fixture.Create<User>();
         user.Username = string.Empty;
+
+        await using var context = new GovorDbContext(_options);
+        var userRepository = new UsersRepository(context, _userValidator);
+
+        // Act & Assert
+        Assert.ThrowsAsync<AdditionUserException>(async () => await userRepository.Add(user));
+    }
+
+    [Test]
+    public async Task Given_ValidUser_When_RemoveUser_Then_RemoveUser()
+    {
+        // Arrange 
+        var user = _fixture.Create<User>();
         
         await using var context = new GovorDbContext(_options);
         var userRepository = new UsersRepository(context, _userValidator);
         
-        // Act & Assert
+        context.Users.Add(user);
-        Assert.ThrowsAsync<AdditionUserException>(async () => await userRepository.Add(user));
+        await context.SaveChangesAsync();
+        
+        // Act 
+        
+        await userRepository.Remove(user);
+        var res = context.Users.AsNoTracking().FirstOrDefault(u => u.Id == user.Id);
+        
+        // Assert 
+        Assert.That(res, Is.Null);
     }
-    
 }

Govor.Data/Repositories/UsersRepository.cs

@@ -87,7 +87,6 @@ public class UsersRepository : IUsersRepository
             _validator.Validate(user);
 
             _context.Users.Add(user);
-
             await _context.SaveChangesAsync();
         }
         catch (InvalidObjectException<User> ex)
@@ -99,7 +98,8 @@ public class UsersRepository : IUsersRepository
             throw new AdditionUserException("Cannot add user", ex);
         }
     }
-
+    
+    // TODO: Test this block
     public async Task Update(User user)
     {
         try
@@ -130,34 +130,64 @@ public class UsersRepository : IUsersRepository
         }
     }
 
-    public Task Remove(User user)
+    public async Task Remove(User user)
     {
-        _validator.Validate(user);
+        try
-        throw new NotImplementedException();
+        {
+            _validator.Validate(user);
+            await Remove(user.Id);
+        }
+        catch (InvalidObjectException<User> ex)
+        {
+            throw new UserRemoveException("User with given data invalid", ex);
+        }
     }
 
-    public Task Remove(Guid userId)
+    public async Task Remove(Guid userId)
     {
-        throw new NotImplementedException();
+        try
+        {
+            var result = await FindById(userId);
+
+            _context.Users.Remove(result);
+            await _context.SaveChangesAsync();
+        }
+        catch (NotFoundByKeyException<Guid> ex)
+        {
+            throw new UserRemoveException($"Not found user by given id {userId}", ex);
+        }
+        catch (Exception ex)
+        {
+            throw new UserRemoveException("Error when removing the user", ex);
+        }
     }
 
     public Task<bool> Exists(User user)
     {
         _validator.Validate(user);
-        throw new NotImplementedException();
+
+        return _context.Users.AnyAsync(u =>
+            u.Id == user.Id &&
+            u.Username == user.Username &&
+            u.HashPassword == user.HashPassword
+        );
     }
 
     public Task<bool> ExistsById(Guid id)
     {
-        throw new NotImplementedException();
+        return _context.Users.AnyAsync(u => u.Id == id);
     }
 
     public Task<bool> ExistsUsername(string username)
     {
-        throw new NotImplementedException();
+        return _context.Users.AnyAsync(u => u.Username == username);
     }
+
 }
 
+public class UserRemoveException(string s, Exception exception)
+    : Exception(s, exception);
+
 public class AdditionUserException(string s, Exception ex) 
     : Exception(s, ex);