Addition Tests for MessageRepository

+ MessagesValidator tests

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

@@ -0,0 +1,66 @@
+using AutoFixture;
+using Govor.Core.Infrastructure.Validators;
+using Govor.Core.Models;
+using Govor.Data;
+using Govor.Data.Repositories;
+using Microsoft.EntityFrameworkCore;
+
+namespace Govor.API.Tests.IntegrationTests.EF.Repositories;
+
+[TestFixture]
+public class MessagesRepositoryTests
+{
+    private Fixture _fixture;
+    private DbContextOptions<GovorDbContext> _options;
+    private readonly IObjectValidator<Message> _messageValidator = new MessageValidator();
+
+    [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;
+    }
+
+    [Test]
+    public async Task Given_NotEmptySetDb_When_GetAllMessages_Then_ReturnAllMessages()
+    {
+        // Arrange
+        var random = new Random();
+        var messages = _fixture.CreateMany<Message>(random.Next(2, 10)).ToList();
+
+        await using var context = new GovorDbContext(_options);
+        var messagesRepository = new MessagesRepository(context, _messageValidator);
+
+        context.Messages.AddRange(messages);
+        await context.SaveChangesAsync();
+
+        // Act 
+
+        var result = await messagesRepository.GetAllAsync();
+
+        // Assert 
+        Assert.That(result, Is.Not.Null);
+        Assert.That(result.Count, Is.EqualTo(messages.Count));
+        Assert.That(result.Select(u => u.Id), Is.EquivalentTo(messages.Select(u => u.Id)));
+        Assert.That(result.Select(u => u.SentAt), Is.EquivalentTo(messages.Select(u => u.SentAt)));
+        Assert.That(result.Select(r => r.SenderId), Is.EquivalentTo(messages.Select(u => u.SenderId)));
+        Assert.That(result.Select(r => r.RecipientId), Is.EquivalentTo(messages.Select(u => u.RecipientId)));
+        Assert.That(result.Select(r => r.RecipientType), Is.EquivalentTo(messages.Select(u => u.RecipientType)));
+    }
+    
+    [Test]
+    public void Given_EmptySetDb_When_GetAllMessages_Should_Throw_NotFoundException()
+    {
+        
+    }
+}

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

@@ -1,7 +1,121 @@
+using AutoFixture;
+using Govor.Core.Infrastructure.Validators;
+using Govor.Core.Models;
+
 namespace Govor.API.Tests.UnitTests.Infrastructure.Validators;
 
 [TestFixture]
 public class MessageValidatorTests
 {
+    private IObjectValidator<Message> _messageValidator;
+    private Fixture _fixture;
 
+    public MessageValidatorTests()
+    {
+        _messageValidator = new MessageValidator();
+        
+        _fixture = new Fixture();
+
+        _fixture.Behaviors
+            .OfType<ThrowingRecursionBehavior>()
+            .ToList()
+            .ForEach(b => _fixture.Behaviors.Remove(b));
+
+        _fixture.Behaviors.Add(new OmitOnRecursionBehavior());
+    }
+    
+    [Test]
+    public void Given_NullMessage_When_Validate_Should_Throw_InvalidObjectException()
+    {
+        // Act & Assert 
+        Assert.ThrowsAsync<InvalidObjectException<Message>>(async () => _messageValidator.Validate(default));
+    }
+    
+    [Test]
+    public void Given_NullMessage_When_TryValidate_Then_Returns_False()
+    {
+        // Act & Assert 
+        Assert.That(_messageValidator.TryValidate(default), Is.False);
+    }
+    
+    [Test]
+    public void Given_EmptyIdMessage_When_Validate_Should_Throw_InvalidObjectException()
+    {
+        // Arrange
+        Message message = _fixture.Create<Message>();
+        message.Id = Guid.Empty;
+        
+        // Act & Assert 
+        Assert.ThrowsAsync<InvalidObjectException<Message>>(async () => _messageValidator.Validate(message));
+        Assert.That(_messageValidator.TryValidate(message), Is.False);
+    }
+    
+    [Test]
+    public void Given_EmptySenderIdMessage_When_Validate_Should_Throw_InvalidObjectException()
+    {
+        // Arrange
+        Message message = _fixture.Create<Message>();
+        message.SenderId = Guid.Empty;
+        
+        // Act & Assert 
+        Assert.ThrowsAsync<InvalidObjectException<Message>>(async () => _messageValidator.Validate(message));
+        Assert.That(_messageValidator.TryValidate(message), Is.False);
+    }
+    
+    [Test]
+    public void Given_EmptyRecipientIdMessage_When_Validate_Should_Throw_InvalidObjectException()
+    {
+        // Arrange
+        Message message = _fixture.Create<Message>();
+        message.RecipientId = Guid.Empty;
+        
+        // Act & Assert 
+        Assert.ThrowsAsync<InvalidObjectException<Message>>(async () => _messageValidator.Validate(message));
+        Assert.That(_messageValidator.TryValidate(message), Is.False);
+    }
+
+    [Test]
+    public void Given_EmptyEncryptedMessage_When_Validate_Should_Throw_InvalidObjectException()
+    {
+        // Arrange
+        Message message = _fixture.Create<Message>();
+        message.EncryptedContent = string.Empty;
+        
+        Assert.ThrowsAsync<InvalidObjectException<Message>>(async () => _messageValidator.Validate(message));
+        Assert.That(_messageValidator.TryValidate(message), Is.False);
+    }
+
+    [Test]
+    public void Given_IsEditAndEmptyEditeTimeMessage_When_Validate_Should_Throw_InvalidObjectException()
+    {
+        // Arrange
+        Message message = _fixture.Create<Message>();
+        message.IsEdited = true;
+        message.EditedAt = DateTime.MinValue;
+        
+        Assert.ThrowsAsync<InvalidObjectException<Message>>(async () => _messageValidator.Validate(message));
+        Assert.That(_messageValidator.TryValidate(message), Is.False);
+    }
+
+    [Test]
+    public void Given_EmptySentAtMessage_When_Validate_Should_Throw_InvalidObjectException()
+    {
+        // Arrange
+        Message message = _fixture.Create<Message>();
+        message.SentAt = DateTime.MinValue;
+        
+        Assert.ThrowsAsync<InvalidObjectException<Message>>(async () => _messageValidator.Validate(message));
+        Assert.That(_messageValidator.TryValidate(message), Is.False);
+    }
+
+    [Test]
+    public void Given_ValidMessage_When_Validate_Then_Should_NotThrow()
+    {
+        // Arrange
+        Message message = _fixture.Create<Message>();
+        
+        // Act & Assert 
+        Assert.DoesNotThrowAsync(async () => _messageValidator.Validate(message));
+        Assert.That(_messageValidator.TryValidate(message), Is.True);
+    }
 }

Govor.Core/Infrastructure/Validators/MessageValidator.cs

@@ -20,8 +20,8 @@ public class MessageValidator : IObjectValidator<Message>
                 throw new ArgumentException("Encrypted content cannot be empty", nameof(message.EncryptedContent));
             if(message.IsEdited && message.EditedAt == DateTime.MinValue)
                 throw new ArgumentException("Edited at time cannot be empty", nameof(message.EditedAt));
-            if (message.EditedAt == DateTime.MinValue)
+            if (message.SentAt == DateTime.MinValue)
-                throw new ArgumentException("Edited at time cannot be empty", nameof(message.EditedAt));
+                throw new ArgumentException("Sent at time cannot be empty", nameof(message.EditedAt));
         }
         catch (Exception ex)
         {