UserValidatorTests

Govor.API.Tests/Govor.API.Tests.csproj

@@ -26,7 +26,6 @@
 
     <ItemGroup>
       <Folder Include="IntegrationTests\Controllers\" />
-      <Folder Include="UnitTests\Infrastructure\" />
       <Folder Include="UnitTests\Services\" />
     </ItemGroup>
 

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

@@ -53,7 +53,7 @@ public class UsersRepositoryTests
         Assert.That(result, Is.Not.Null);
         Assert.That(result.Count, Is.EqualTo(users.Count));
         Assert.That(result.Select(u => u.Id), Is.EquivalentTo(users.Select(u => u.Id)));
-        Assert.That(result.Select(u => u.Username), Is.EquivalentTo(users.Select(u => u.Username)));
+        Assert.That(result.Select(u => u.Name), Is.EquivalentTo(users.Select(u => u.Name)));
     }
 
     [Test]
@@ -72,7 +72,7 @@ public class UsersRepositoryTests
 
         // Assert 
         Assert.That(result, Is.Not.Null);
-        Assert.That(result.Username, Is.EqualTo(user.Username));
+        Assert.That(result.Name, Is.EqualTo(user.Name));
         Assert.That(result.Id, Is.EqualTo(user.Id));
     }
 
@@ -109,7 +109,7 @@ public class UsersRepositoryTests
         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)));
+        Assert.That(result.Select(u => u.Name), Is.EquivalentTo(users.Select(u => u.Name)));
     }
 
     [Test]
@@ -140,10 +140,10 @@ public class UsersRepositoryTests
         await context.SaveChangesAsync();
 
         // Act 
-        var result = await userRepository.FindByUsername(user.Username);
+        var result = await userRepository.FindByUsername(user.Name);
         // Assert
         Assert.That(result, Is.Not.Null);
-        Assert.That(result.Username, Is.EqualTo(user.Username));
+        Assert.That(result.Name, Is.EqualTo(user.Name));
         Assert.That(result.Id, Is.EqualTo(user.Id));
     }
 
@@ -174,11 +174,11 @@ public class UsersRepositoryTests
         await context.SaveChangesAsync();
 
         // Act 
-        var result = await userRepository.FindByRangeUsernames(users.Select(u => u.Username));
+        var result = await userRepository.FindByRangeUsernames(users.Select(u => u.Name));
 
         // 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.Name), Is.EquivalentTo(users.Select(u => u.Name)));
         Assert.That(result.Select(u => u.Id), Is.EquivalentTo(users.Select(u => u.Id)));
     }
 
@@ -254,7 +254,7 @@ public class UsersRepositoryTests
         // Assert 
 
         Assert.That(res, Is.Not.Null);
-        Assert.That(res.Username, Is.EqualTo(user.Username));
+        Assert.That(res.Name, Is.EqualTo(user.Name));
         Assert.That(res.Id, Is.EqualTo(user.Id));
     }
 
@@ -262,7 +262,7 @@ public class UsersRepositoryTests
     public async Task Given_InvalidUser_When_AddUser_Should_Throw_AdditionUserException()
     {
         var user = _fixture.Create<User>();
-        user.Username = string.Empty;
+        user.Name = string.Empty;
 
         await using var context = new GovorDbContext(_options);
         var userRepository = new UsersRepository(context, _userValidator);
@@ -361,7 +361,7 @@ public class UsersRepositoryTests
         await context.SaveChangesAsync();
         
         // Act 
-        var res = await userRepository.ExistsUsername(user.Username);
+        var res = await userRepository.ExistsUsername(user.Name);
         
         // Assert 
         Assert.That(res, Is.True);
@@ -378,7 +378,7 @@ public class UsersRepositoryTests
         
         
         // Act 
-        var res = await userRepository.ExistsUsername(user.Username);
+        var res = await userRepository.ExistsUsername(user.Name);
         
         // Assert 
         Assert.That(res, Is.False);

Govor.API.Tests/UnitTests/Infrastructure/Validators/UserValidatorTests.cs

@@ -0,0 +1,169 @@
+using AutoFixture;
+using Govor.Core.Infrastructure.Validators;
+using Govor.Core.Models;
+
+namespace Govor.API.Tests.UnitTests.Infrastructure.Validators;
+
+[TestFixture]
+public class UserValidatorTests 
+{
+    private IObjectValidator<User> _userValidator;
+    private Fixture _fixture;
+    
+    [SetUp]
+    public void SetUp()
+    {
+        _userValidator = new UserValidator();
+        
+        _fixture = new Fixture();
+
+        _fixture.Behaviors
+            .OfType<ThrowingRecursionBehavior>()
+            .ToList()
+            .ForEach(b => _fixture.Behaviors.Remove(b));
+
+        _fixture.Behaviors.Add(new OmitOnRecursionBehavior());
+    }
+    
+    [Test]
+    public void Given_NullUser_ShouldThrow_InvalidObjectException()
+    {
+        // Act & Assert 
+        Assert.ThrowsAsync<InvalidObjectException<User>>(async () => _userValidator.Validate(default));
+    }
+    
+    [Test]
+    public void Given_NullUser_Then_Returns_False()
+    {
+        // Act & Assert 
+        Assert.That(_userValidator.TryValidate(default), Is.False);
+    }
+    
+    [Test]
+    public void Given_EmptyId_ShouldThrow_InvalidObjectException()
+    {
+        // Arrange 
+        User user = new User()
+        {
+            PasswordHash = _fixture.Create<string>(),
+            Name = _fixture.Create<string>(),
+            Id = Guid.Empty,
+            CreatedOn = DateOnly.FromDateTime(DateTime.Now),
+        };
+        
+        // Act & Assert
+        Assert.ThrowsAsync<InvalidObjectException<User>>(async () => _userValidator.Validate(user));
+    }
+    
+    [Test]
+    public void Given_EmptyId_Then_Returns_False()
+    {
+        // Arrange 
+        User user = new User()
+        {
+            PasswordHash = _fixture.Create<string>(),
+            Name = _fixture.Create<string>(),
+            Id = Guid.Empty,
+            CreatedOn = DateOnly.FromDateTime(DateTime.Now),
+        };
+        
+        // Act & Assert
+        Assert.That(_userValidator.TryValidate(user), Is.False);
+    }
+    
+    [Test]
+    public void Given_EmptyPassword_ShouldThrow_InvalidObjectException()
+    {
+        // Arrange
+        User user = new User()
+        {
+            PasswordHash = string.Empty,
+            Name = _fixture.Create<string>(),
+            Id = Guid.NewGuid(),
+            CreatedOn = DateOnly.FromDateTime(DateTime.Now),
+        };
+        
+        // Act & Assert 
+        Assert.ThrowsAsync<InvalidObjectException<User>>(async () => _userValidator.Validate(user));
+    }
+
+    [Test]
+    public void Given_EmptyPassword_Then_Returns_False()
+    {
+        // Arrange
+        User user = new User()
+        {
+            PasswordHash = string.Empty,
+            Name = _fixture.Create<string>(),
+            Id = Guid.NewGuid(),
+            CreatedOn = DateOnly.FromDateTime(DateTime.Now),
+        };
+        
+        // Act & Assert 
+        Assert.That(_userValidator.TryValidate(user), Is.False);
+    }
+    
+    [Test]
+    public void Given_EmptyName_ShouldThrow_InvalidObjectException()
+    {
+        // Arrange
+        User user = new User()
+        {
+            PasswordHash = _fixture.Create<string>(),
+            Name = String.Empty,
+            Id = Guid.NewGuid(),
+            CreatedOn = DateOnly.FromDateTime(DateTime.Now),
+        };
+        
+        // Act & Assert 
+        Assert.ThrowsAsync<InvalidObjectException<User>>(async () => _userValidator.Validate(user));
+    }
+    
+    [Test]
+    public void Given_EmptyName_Then_Returns_False()
+    {
+        // Arrange
+        User user = new User()
+        {
+            PasswordHash = _fixture.Create<string>(),
+            Name = String.Empty,
+            Id = Guid.NewGuid(),
+            CreatedOn = DateOnly.FromDateTime(DateTime.Now),
+        };
+        
+        // Act & Assert 
+        Assert.That(_userValidator.TryValidate(user), Is.False);
+    }
+    
+    [Test]
+    public void Given_ValidUser_ShouldNotThrow_InvalidObjectException()
+    {
+        // Arrange
+        User user = new User()
+        {
+            PasswordHash = _fixture.Create<string>(),
+            Name = _fixture.Create<string>(),
+            Id = Guid.NewGuid(),
+            CreatedOn = DateOnly.FromDateTime(DateTime.Now),
+        };
+        
+        // Act & Assert 
+        Assert.DoesNotThrowAsync(async () => _userValidator.Validate(user));
+    }
+    
+    [Test]
+    public void Given_ValidUser_Then_Returns_True()
+    {
+        // Arrange
+        User user = new User()
+        {
+            PasswordHash = _fixture.Create<string>(),
+            Name = _fixture.Create<string>(),
+            Id = Guid.NewGuid(),
+            CreatedOn = DateOnly.FromDateTime(DateTime.Now),
+        };
+        
+        // Act & Assert 
+        Assert.That(_userValidator.TryValidate(user), Is.True);
+    }
+}

Govor.Core/Infrastructure/Validators/UserValidator.cs

@@ -7,6 +7,7 @@ public class UserValidator : IObjectValidator<User>
 {
     public const int MIN_LENGHT_OF_NAME = 4;
     public const int MAX_LENGHT_OF_NAME = 100;
+    
     public void Validate(User user)
     {
         try
@@ -15,12 +16,12 @@ public class UserValidator : IObjectValidator<User>
                 throw new ArgumentNullException(nameof(user));
             if(user.Id == Guid.Empty)
                 throw new ArgumentException("User ID cannot be empty", nameof(user.Id));
-            if(user.Username is null 
+            if(user.Name is null 
-               || user.Username.Length < MIN_LENGHT_OF_NAME 
+               || user.Name.Length < MIN_LENGHT_OF_NAME 
-               || user.Username.Length > MAX_LENGHT_OF_NAME)
+               || user.Name.Length > MAX_LENGHT_OF_NAME)
-                throw new ArgumentException($"Username cannot be empty or less then {MIN_LENGHT_OF_NAME} chars or more then {MAX_LENGHT_OF_NAME}", nameof(user.Username));
+                throw new ArgumentException($"Username cannot be empty or less then {MIN_LENGHT_OF_NAME} chars or more then {MAX_LENGHT_OF_NAME}", nameof(user.Name));
-            if(user.HashPassword is null || user.HashPassword == string.Empty)
+            if(user.PasswordHash is null || user.PasswordHash == string.Empty)
-                throw new ArgumentException("Password cannot be empty", nameof(user.HashPassword));
+                throw new ArgumentException("Password cannot be empty", nameof(user.PasswordHash));
             if(user.CreatedOn == DateOnly.MinValue)
                 throw new ArgumentException("Time of creation account cannot be empty", nameof(user.CreatedOn));
         }

Govor.Core/Models/User.cs

@@ -5,9 +5,9 @@ namespace Govor.Core.Models;
 public class User
 {
     public Guid Id {get; set;}
-    public string Username {get; set;} 
+    public string Name {get; set;} 
     public string Description {get; set;} 
-    public string HashPassword {get; set;}
+    public string PasswordHash {get; set;}
     public Guid IconId {get; set;} 
     public DateOnly CreatedOn {get; set;}
     public DateTime WasOnline {get; set;}

Govor.Data/Repositories/UsersRepository.cs

@@ -54,7 +54,7 @@ public class UsersRepository : IUsersRepository
         
         return await _context.Users
             .AsNoTracking()
-            .FirstOrDefaultAsync(x => x.Username == username) 
+            .FirstOrDefaultAsync(x => x.Name == username) 
                ?? throw new NotFoundByKeyException<string>(username, "User with given username does not exist");
     }
     
@@ -65,7 +65,7 @@ public class UsersRepository : IUsersRepository
 
         return await _context.Users
             .AsNoTracking()
-            .Where(x => usernames.Contains(x.Username))
+            .Where(x => usernames.Contains(x.Name))
             .ToListOrThrowIfEmpty(new NotFoundByKeyException<IEnumerable<string>>(usernames, "Users with given usernames not found"));
     }
 
@@ -109,11 +109,11 @@ public class UsersRepository : IUsersRepository
             var rowsAffected = await _context.Users
                 .Where(u => u.Id == user.Id)
                 .ExecuteUpdateAsync(u => u
-                    .SetProperty(a => a.Username, user.Username)
+                    .SetProperty(a => a.Name, user.Name)
                     .SetProperty(u => u.IconId, user.IconId)
                     .SetProperty(u => u.Description, user.Description)
                     .SetProperty(u => u.CreatedOn, user.CreatedOn)
-                    .SetProperty(u => u.HashPassword, user.HashPassword)
+                    .SetProperty(u => u.PasswordHash, user.PasswordHash)
                     .SetProperty(u => u.WasOnline, user.WasOnline)
                 );
 
@@ -168,8 +168,8 @@ public class UsersRepository : IUsersRepository
 
         return _context.Users.AnyAsync(u =>
             u.Id == user.Id &&
-            u.Username == user.Username &&
+            u.Name == user.Name &&
-            u.HashPassword == user.HashPassword
+            u.PasswordHash == user.PasswordHash
         );
     }
 
@@ -180,7 +180,7 @@ public class UsersRepository : IUsersRepository
 
     public Task<bool> ExistsUsername(string username)
     {
-        return _context.Users.AnyAsync(u => u.Username == username);
+        return _context.Users.AnyAsync(u => u.Name == username);
     }
 
 }