feat: Apply Unit Tests

LegalAssistant.AppService.sln

@@ -13,6 +13,10 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Web.Api", "src\Web.Api\Web.
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Domain", "src\Domain\Domain.csproj", "{0DA30A4D-944B-49F4-AEE5-E89DF7B7EC9A}"
 EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "tests", "tests", "{DE7D928F-5ECE-4A9F-A38A-D0140B0645B9}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "LegalAssistant.Application.UnitTests", "tests\Application.UnitTests\LegalAssistant.Application.UnitTests.csproj", "{F4E9F36A-78DC-4298-BC0C-E927119F84CC}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -38,11 +42,20 @@ Global
 		{0DA30A4D-944B-49F4-AEE5-E89DF7B7EC9A}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{0DA30A4D-944B-49F4-AEE5-E89DF7B7EC9A}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{0DA30A4D-944B-49F4-AEE5-E89DF7B7EC9A}.Release|Any CPU.Build.0 = Release|Any CPU
+		{F4E9F36A-78DC-4298-BC0C-E927119F84CC}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{F4E9F36A-78DC-4298-BC0C-E927119F84CC}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{F4E9F36A-78DC-4298-BC0C-E927119F84CC}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{F4E9F36A-78DC-4298-BC0C-E927119F84CC}.Release|Any CPU.Build.0 = Release|Any CPU
+		{4FA96436-FB36-4B91-97EE-C6D2DF8CEBDF}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{4FA96436-FB36-4B91-97EE-C6D2DF8CEBDF}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{4FA96436-FB36-4B91-97EE-C6D2DF8CEBDF}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{4FA96436-FB36-4B91-97EE-C6D2DF8CEBDF}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(NestedProjects) = preSolution
 		{44042BE8-3AF1-45B5-8719-2AFFDA30CF41} = {EDE5F5E1-80F9-4DCE-80B0-BFDBF36DC680}
 		{55A6D295-C238-464F-9729-3E9E9B4972B5} = {EDE5F5E1-80F9-4DCE-80B0-BFDBF36DC680}
 		{BB7A6132-5274-490D-A502-FCA2CF51BA94} = {EDE5F5E1-80F9-4DCE-80B0-BFDBF36DC680}
 		{0DA30A4D-944B-49F4-AEE5-E89DF7B7EC9A} = {EDE5F5E1-80F9-4DCE-80B0-BFDBF36DC680}
+		{F4E9F36A-78DC-4298-BC0C-E927119F84CC} = {DE7D928F-5ECE-4A9F-A38A-D0140B0645B9}
 	EndGlobalSection
 EndGlobal

tests/Application.UnitTests/Common/Behaviors/LoggingBehaviorTests.cs

@@ -0,0 +1,124 @@
+using Application.Common.Behaviors;
+using Domain.Common;
+using MediatR;
+using Microsoft.Extensions.Logging;
+
+namespace LegalAssistant.Application.UnitTests.Common.Behaviors;
+
+public class LoggingBehaviorTests
+{
+    private readonly Mock<ILogger<LoggingBehavior<TestRequest, Result>>> _loggerMock;
+    private readonly LoggingBehavior<TestRequest, Result> _behavior;
+
+    public class TestRequest : IRequest<Result>
+    {
+        public string Value { get; set; } = string.Empty;
+    }
+
+    public LoggingBehaviorTests()
+    {
+        _loggerMock = new Mock<ILogger<LoggingBehavior<TestRequest, Result>>>();
+        _behavior = new LoggingBehavior<TestRequest, Result>(_loggerMock.Object);
+    }
+
+    [Fact]
+    public async Task Handle_SuccessfulRequest_LogsStartAndCompletion()
+    {
+        // Arrange
+        var request = new TestRequest { Value = "test" };
+        var successResult = Result.Success();
+
+        RequestHandlerDelegate<Result> next = (ct) => Task.FromResult(successResult);
+
+        // Act
+        await _behavior.Handle(request, next, CancellationToken.None);
+
+        // Assert
+        _loggerMock.Verify(
+            x => x.Log(
+                LogLevel.Information,
+                It.IsAny<EventId>(),
+                It.Is<It.IsAnyType>((v, t) => v.ToString()!.Contains("Starting request")),
+                null,
+                It.IsAny<Func<It.IsAnyType, Exception?, string>>()),
+            Times.Once);
+
+        _loggerMock.Verify(
+            x => x.Log(
+                LogLevel.Information,
+                It.IsAny<EventId>(),
+                It.Is<It.IsAnyType>((v, t) => v.ToString()!.Contains("Completed request")),
+                null,
+                It.IsAny<Func<It.IsAnyType, Exception?, string>>()),
+            Times.Once);
+    }
+
+    [Fact]
+    public async Task Handle_FailedRequest_LogsWarning()
+    {
+        // Arrange
+        var request = new TestRequest { Value = "test" };
+        var failureResult = Result.Failure(Error.Validation("Test.Error", "Test error description"));
+
+        RequestHandlerDelegate<Result> next = (ct) => Task.FromResult(failureResult);        // Act
+        await _behavior.Handle(request, next, CancellationToken.None);
+
+        // Assert
+        _loggerMock.Verify(
+            x => x.Log(
+                LogLevel.Warning,
+                It.IsAny<EventId>(),
+                It.Is<It.IsAnyType>((v, t) => v.ToString()!.Contains("completed with failure")),
+                null,
+                It.IsAny<Func<It.IsAnyType, Exception?, string>>()),
+            Times.Once);
+    }
+
+    [Fact]
+    public async Task Handle_Request_MeasuresExecutionTime()
+    {
+        // Arrange
+        var request = new TestRequest { Value = "test" };
+        var successResult = Result.Success();
+
+        RequestHandlerDelegate<Result> next = async (ct) =>
+        {
+            await Task.Delay(100, ct); // Simulate work
+            return successResult;
+        };        // Act
+        await _behavior.Handle(request, next, CancellationToken.None);
+
+        // Assert
+        _loggerMock.Verify(
+            x => x.Log(
+                LogLevel.Information,
+                It.IsAny<EventId>(),
+                It.Is<It.IsAnyType>((v, t) => v.ToString()!.Contains("ms")),
+                null,
+                It.IsAny<Func<It.IsAnyType, Exception?, string>>()),
+            Times.AtLeastOnce);
+    }
+
+    [Fact]
+    public async Task Handle_Request_LogsRequestName()
+    {
+        // Arrange
+        var request = new TestRequest { Value = "test" };
+        var successResult = Result.Success();
+
+        RequestHandlerDelegate<Result> next = (ct) => Task.FromResult(successResult);
+
+        // Act
+        await _behavior.Handle(request, next, CancellationToken.None);
+
+        // Assert
+        _loggerMock.Verify(
+            x => x.Log(
+                It.IsAny<LogLevel>(),
+                It.IsAny<EventId>(),
+                It.Is<It.IsAnyType>((v, t) => v.ToString()!.Contains("TestRequest")),
+                null,
+                It.IsAny<Func<It.IsAnyType, Exception?, string>>()),
+            Times.AtLeast(2));
+    }
+}

tests/Application.UnitTests/Common/Behaviors/ValidationBehaviorTests.cs

@@ -0,0 +1,124 @@
+using Application.Common.Behaviors;
+using FluentValidation;
+using FluentValidation.Results;
+using MediatR;
+using ValidationException = Application.Common.Exceptions.ValidationException;
+
+namespace LegalAssistant.Application.UnitTests.Common.Behaviors;
+
+public class ValidationBehaviorTests
+{
+    public class TestRequest : IRequest<string>
+    {
+        public string Value { get; set; } = string.Empty;
+    }
+
+    public class TestRequestValidator : AbstractValidator<TestRequest>
+    {
+        public TestRequestValidator()
+        {
+            RuleFor(x => x.Value)
+                .NotEmpty().WithMessage("Value is required")
+                .MinimumLength(3).WithMessage("Value must be at least 3 characters");
+        }
+    }
+
+    [Fact]
+    public async Task Handle_NoValidators_ContinuesToNextBehavior()
+    {
+        // Arrange
+        var validators = Enumerable.Empty<IValidator<TestRequest>>();
+        var behavior = new ValidationBehavior<TestRequest, string>(validators);
+        var request = new TestRequest { Value = "test" };
+        var expectedResponse = "success";
+
+        RequestHandlerDelegate<string> next = (ct) => Task.FromResult(expectedResponse);
+
+        // Act
+        var response = await behavior.Handle(request, next, CancellationToken.None);
+
+        // Assert
+        response.Should().Be(expectedResponse);
+    }
+
+    [Fact]
+    public async Task Handle_ValidRequest_ContinuesToNextBehavior()
+    {
+        // Arrange
+        var validators = new List<IValidator<TestRequest>> { new TestRequestValidator() };
+        var behavior = new ValidationBehavior<TestRequest, string>(validators);
+        var request = new TestRequest { Value = "valid value" };
+        var expectedResponse = "success";
+
+        RequestHandlerDelegate<string> next = (ct) => Task.FromResult(expectedResponse);
+
+        // Act
+        var response = await behavior.Handle(request, next, CancellationToken.None);
+
+        // Assert
+        response.Should().Be(expectedResponse);
+    }
+
+    [Fact]
+    public async Task Handle_InvalidRequest_ThrowsValidationException()
+    {
+        // Arrange
+        var validators = new List<IValidator<TestRequest>> { new TestRequestValidator() };
+        var behavior = new ValidationBehavior<TestRequest, string>(validators);
+        var request = new TestRequest { Value = "" };
+
+        RequestHandlerDelegate<string> next = (ct) => Task.FromResult("success");
+
+        // Act
+        var act = async () => await behavior.Handle(request, next, CancellationToken.None);
+
+        // Assert
+        await act.Should().ThrowAsync<ValidationException>()
+            .Where(ex => ex.Errors.ContainsKey("Value"));
+    }
+
+    [Fact]
+    public async Task Handle_MultipleValidationErrors_ThrowsWithAllErrors()
+    {
+        // Arrange
+        var validators = new List<IValidator<TestRequest>> { new TestRequestValidator() };
+        var behavior = new ValidationBehavior<TestRequest, string>(validators);
+        var request = new TestRequest { Value = "ab" }; // Too short
+
+        RequestHandlerDelegate<string> next = (ct) => Task.FromResult("success");
+
+        // Act
+        var act = async () => await behavior.Handle(request, next, CancellationToken.None);
+
+        // Assert
+        await act.Should().ThrowAsync<ValidationException>()
+            .Where(ex => ex.Errors.Values.Any(msgs => msgs.Any(m => m.Contains("3 characters"))));
+    }
+
+    [Fact]
+    public async Task Handle_MultipleValidators_ValidatesWithAll()
+    {
+        // Arrange
+        var validator1 = new Mock<IValidator<TestRequest>>();
+        var validator2 = new Mock<IValidator<TestRequest>>();
+
+        validator1.Setup(v => v.ValidateAsync(It.IsAny<ValidationContext<TestRequest>>(), It.IsAny<CancellationToken>()))
+            .ReturnsAsync(new ValidationResult());
+
+        validator2.Setup(v => v.ValidateAsync(It.IsAny<ValidationContext<TestRequest>>(), It.IsAny<CancellationToken>()))
+            .ReturnsAsync(new ValidationResult());
+
+        var validators = new List<IValidator<TestRequest>> { validator1.Object, validator2.Object };
+        var behavior = new ValidationBehavior<TestRequest, string>(validators);
+        var request = new TestRequest { Value = "test" };
+
+        RequestHandlerDelegate<string> next = (ct) => Task.FromResult("success");
+
+        // Act
+        await behavior.Handle(request, next, CancellationToken.None);
+
+        // Assert
+        validator1.Verify(v => v.ValidateAsync(It.IsAny<ValidationContext<TestRequest>>(), It.IsAny<CancellationToken>()), Times.Once);
+        validator2.Verify(v => v.ValidateAsync(It.IsAny<ValidationContext<TestRequest>>(), It.IsAny<CancellationToken>()), Times.Once);
+    }
+}