init HistoryTests

EnvelopeGenerator.Tests.Application/HistoryTests.cs

@@ -0,0 +1,123 @@
+using EnvelopeGenerator.Application;
+using EnvelopeGenerator.Application.Histories.Commands;
+using EnvelopeGenerator.Application.Histories.Queries;
+using EnvelopeGenerator.Domain;
+using EnvelopeGenerator.Infrastructure;
+using MediatR;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+
+namespace EnvelopeGenerator.Tests.Application;
+
+[TestFixture]
+public class HistoryTests
+{
+    private IHost _host;
+
+    private IServiceProvider Provider => _host.Services;
+
+    [SetUp]
+    public void Setup()
+    {
+        _host = Host.CreateDefaultBuilder()
+            .ConfigureAppConfiguration((context, config) =>
+            {
+                // add appsettings.json
+                config.SetBasePath(Directory.GetCurrentDirectory());
+                config.AddJsonFile("appsettings.json", optional: false, reloadOnChange: true);
+            })
+            .ConfigureServices((context, services) =>
+            {
+                IConfiguration configuration = context.Configuration;
+
+                // add Application and Infrastructure services
+#pragma warning disable CS0618
+                services.AddEnvelopeGeneratorServices(configuration);
+                services.AddEnvelopeGeneratorInfrastructureServices(
+                    (sp, options) => options.UseInMemoryDatabase("EnvelopeGeneratorTestDb"),
+                    context.Configuration
+                );
+#pragma warning restore CS0618
+            })
+            .Build();
+    }
+
+    [TearDown]
+    public void TearDown()
+    {
+        _host.Dispose();
+    }
+
+    private async Task<TResponse> Send<TResponse>(IRequest<TResponse> request)
+    {
+        var mediator = Provider.GetRequiredService<IMediator>();
+        return await mediator.Send(request);
+    }
+
+    [Test]
+    public async Task CreateHistory_And_ReadHistory_Should_Work()
+    {
+        // Arrange
+        var createCmd = new CreateHistoryCommand
+        {
+            EnvelopeId = 1,
+            UserReference = "UserA",
+            Status = Constants.EnvelopeStatus.EnvelopeCreated,
+            Comment = "First create"
+        };
+
+        // Act
+        var id = await Send(createCmd);
+
+        // Assert
+        Assert.That(id, Is.Not.Null);
+
+        // ReadHistory sorgusu
+        var query = new ReadHistoryQuery(1);
+        var result = await Send(query);
+
+        Assert.That(result, Is.Not.Empty);
+    }
+
+    [Test]
+    public async Task ReadHistory_Should_Filter_By_Status()
+    {
+        // Arrange
+        var createCmd1 = new CreateHistoryCommand
+        {
+            EnvelopeId = 2,
+            UserReference = "UserX",
+            Status = Constants.EnvelopeStatus.EnvelopeCreated
+        };
+
+        var createCmd2 = new CreateHistoryCommand
+        {
+            EnvelopeId = 2,
+            UserReference = "UserX",
+            Status = Constants.EnvelopeStatus.EnvelopePartlySigned
+        };
+
+        await Send(createCmd1);
+        await Send(createCmd2);
+
+        // Act
+        var result = await Send(new ReadHistoryQuery(2, Constants.EnvelopeStatus.EnvelopePartlySigned));
+
+        // Assert
+        Assert.That(result, Has.Exactly(1).Items);
+        Assert.That(result, Has.All.Matches<EnvelopeGenerator.Application.Dto.EnvelopeHistory.EnvelopeHistoryDto>(
+            r => r.Status == Constants.EnvelopeStatus.EnvelopePartlySigned));
+    }
+
+    [Test]
+    public async Task ReadHistory_Should_Return_Empty_When_No_Record()
+    {
+        // Act
+        var result = await Send(new ReadHistoryQuery(999));
+
+        // Assert
+        Assert.That(result, Is.Empty);
+    }
+}