Restructure solution layout by module

src/Notify/__Tests/StellaOps.Notify.Queue.Tests/RedisNotifyDeliveryQueueTests.cs

@@ -0,0 +1,197 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text.Json.Nodes;
+using System.Threading.Tasks;
+using DotNet.Testcontainers.Builders;
+using DotNet.Testcontainers.Containers;
+using DotNet.Testcontainers.Configurations;
+using FluentAssertions;
+using Microsoft.Extensions.Logging.Abstractions;
+using StackExchange.Redis;
+using StellaOps.Notify.Models;
+using StellaOps.Notify.Queue;
+using StellaOps.Notify.Queue.Redis;
+using Xunit;
+
+namespace StellaOps.Notify.Queue.Tests;
+
+public sealed class RedisNotifyDeliveryQueueTests : IAsyncLifetime
+{
+    private readonly RedisTestcontainer _redis;
+    private string? _skipReason;
+
+    public RedisNotifyDeliveryQueueTests()
+    {
+        var configuration = new RedisTestcontainerConfiguration();
+        _redis = new TestcontainersBuilder<RedisTestcontainer>()
+            .WithDatabase(configuration)
+            .Build();
+    }
+
+    public async Task InitializeAsync()
+    {
+        try
+        {
+            await _redis.StartAsync();
+        }
+        catch (Exception ex)
+        {
+            _skipReason = $"Redis-backed delivery tests skipped: {ex.Message}";
+        }
+    }
+
+    public async Task DisposeAsync()
+    {
+        if (_skipReason is not null)
+        {
+            return;
+        }
+
+        await _redis.DisposeAsync().AsTask();
+    }
+
+    [Fact]
+    public async Task Publish_ShouldDeduplicate_ByDeliveryId()
+    {
+        if (SkipIfUnavailable())
+        {
+            return;
+        }
+
+        var options = CreateOptions();
+        await using var queue = CreateQueue(options);
+
+        var delivery = TestData.CreateDelivery();
+        var message = new NotifyDeliveryQueueMessage(
+            delivery,
+            channelId: "channel-1",
+            channelType: NotifyChannelType.Slack);
+
+        var first = await queue.PublishAsync(message);
+        first.Deduplicated.Should().BeFalse();
+
+        var second = await queue.PublishAsync(message);
+        second.Deduplicated.Should().BeTrue();
+        second.MessageId.Should().Be(first.MessageId);
+    }
+
+    [Fact]
+    public async Task Release_Retry_ShouldRescheduleDelivery()
+    {
+        if (SkipIfUnavailable())
+        {
+            return;
+        }
+
+        var options = CreateOptions();
+        await using var queue = CreateQueue(options);
+
+        await queue.PublishAsync(new NotifyDeliveryQueueMessage(
+            TestData.CreateDelivery(),
+            channelId: "channel-retry",
+            channelType: NotifyChannelType.Teams));
+
+        var lease = (await queue.LeaseAsync(new NotifyQueueLeaseRequest("worker-retry", 1, TimeSpan.FromSeconds(1)))).Single();
+        lease.Attempt.Should().Be(1);
+
+        await lease.ReleaseAsync(NotifyQueueReleaseDisposition.Retry);
+
+        var retried = (await queue.LeaseAsync(new NotifyQueueLeaseRequest("worker-retry", 1, TimeSpan.FromSeconds(1)))).Single();
+        retried.Attempt.Should().Be(2);
+
+        await retried.AcknowledgeAsync();
+    }
+
+    [Fact]
+    public async Task Release_RetryBeyondMax_ShouldDeadLetter()
+    {
+        if (SkipIfUnavailable())
+        {
+            return;
+        }
+
+        var options = CreateOptions(static opts =>
+        {
+            opts.MaxDeliveryAttempts = 2;
+            opts.Redis.DeadLetterStreamName = "notify:deliveries:testdead";
+        });
+
+        await using var queue = CreateQueue(options);
+
+        await queue.PublishAsync(new NotifyDeliveryQueueMessage(
+            TestData.CreateDelivery(),
+            channelId: "channel-dead",
+            channelType: NotifyChannelType.Email));
+
+        var first = (await queue.LeaseAsync(new NotifyQueueLeaseRequest("worker-dead", 1, TimeSpan.FromSeconds(1)))).Single();
+        await first.ReleaseAsync(NotifyQueueReleaseDisposition.Retry);
+
+        var second = (await queue.LeaseAsync(new NotifyQueueLeaseRequest("worker-dead", 1, TimeSpan.FromSeconds(1)))).Single();
+        await second.ReleaseAsync(NotifyQueueReleaseDisposition.Retry);
+
+        await Task.Delay(100);
+
+        var mux = await ConnectionMultiplexer.ConnectAsync(_redis.ConnectionString);
+        var db = mux.GetDatabase();
+        var deadLetters = await db.StreamReadAsync(options.Redis.DeadLetterStreamName, "0-0");
+        deadLetters.Should().NotBeEmpty();
+    }
+
+    private RedisNotifyDeliveryQueue CreateQueue(NotifyDeliveryQueueOptions options)
+    {
+        return new RedisNotifyDeliveryQueue(
+            options,
+            options.Redis,
+            NullLogger<RedisNotifyDeliveryQueue>.Instance,
+            TimeProvider.System,
+            async config => (IConnectionMultiplexer)await ConnectionMultiplexer.ConnectAsync(config).ConfigureAwait(false));
+    }
+
+    private NotifyDeliveryQueueOptions CreateOptions(Action<NotifyDeliveryQueueOptions>? configure = null)
+    {
+        var opts = new NotifyDeliveryQueueOptions
+        {
+            Transport = NotifyQueueTransportKind.Redis,
+            DefaultLeaseDuration = TimeSpan.FromSeconds(1),
+            MaxDeliveryAttempts = 3,
+            RetryInitialBackoff = TimeSpan.FromMilliseconds(10),
+            RetryMaxBackoff = TimeSpan.FromMilliseconds(50),
+            ClaimIdleThreshold = TimeSpan.FromSeconds(1),
+            Redis = new NotifyRedisDeliveryQueueOptions
+            {
+                ConnectionString = _redis.ConnectionString,
+                StreamName = "notify:deliveries:test",
+                ConsumerGroup = "notify-delivery-tests",
+                IdempotencyKeyPrefix = "notify:deliveries:test:idemp:"
+            }
+        };
+
+        configure?.Invoke(opts);
+        return opts;
+    }
+
+    private bool SkipIfUnavailable()
+        => _skipReason is not null;
+
+    private static class TestData
+    {
+        public static NotifyDelivery CreateDelivery()
+        {
+            var now = DateTimeOffset.UtcNow;
+            return NotifyDelivery.Create(
+                deliveryId: Guid.NewGuid().ToString("n"),
+                tenantId: "tenant-1",
+                ruleId: "rule-1",
+                actionId: "action-1",
+                eventId: Guid.NewGuid(),
+                kind: "scanner.report.ready",
+                status: NotifyDeliveryStatus.Pending,
+                createdAt: now,
+                metadata: new Dictionary<string, string>
+                {
+                    ["integration"] = "tests"
+                });
+        }
+    }
+}