fix(external-system-gateway): resolve ExternalSystemGateway-002/003 — apply HTTP call timeout, confirm CachedCall no double-dispatch

tests/ScadaLink.ExternalSystemGateway.Tests/ExternalSystemClientTests.cs

@@ -1,8 +1,10 @@
 using System.Net;
+using Microsoft.Data.Sqlite;
 using Microsoft.Extensions.Logging.Abstractions;
 using NSubstitute;
 using ScadaLink.Commons.Entities.ExternalSystems;
 using ScadaLink.Commons.Interfaces.Repositories;
+using ScadaLink.StoreAndForward;
 
 namespace ScadaLink.ExternalSystemGateway.Tests;
 
@@ -216,6 +218,116 @@ public class ExternalSystemClientTests
             () => client.DeliverBufferedAsync(BufferedCall("TestAPI", "failMethod")));
     }
 
+    // ── ExternalSystemGateway-003: CachedCall must not double-dispatch ──
+
+    [Fact]
+    public async Task CachedCall_TransientFailure_DoesNotImmediatelyRedispatchViaRegisteredHandler()
+    {
+        var system = new ExternalSystemDefinition("TestAPI", "https://api.example.com", "none") { Id = 1 };
+        var method = new ExternalSystemMethod("postData", "POST", "/post") { Id = 1, ExternalSystemDefinitionId = 1 };
+        _repository.GetAllExternalSystemsAsync(Arg.Any<CancellationToken>())
+            .Returns(new List<ExternalSystemDefinition> { system });
+        _repository.GetMethodsByExternalSystemIdAsync(1, Arg.Any<CancellationToken>())
+            .Returns(new List<ExternalSystemMethod> { method });
+
+        // The HTTP layer always fails transiently (500).
+        var httpClient = new HttpClient(new MockHttpMessageHandler(HttpStatusCode.InternalServerError, "boom"));
+        _httpClientFactory.CreateClient(Arg.Any<string>()).Returns(httpClient);
+
+        // A real S&F service with a registered delivery handler that counts invocations.
+        var dbName = $"EsgDoubleDispatch_{Guid.NewGuid():N}";
+        var connStr = $"Data Source={dbName};Mode=Memory;Cache=Shared";
+        using var keepAlive = new SqliteConnection(connStr);
+        keepAlive.Open();
+        var storage = new StoreAndForwardStorage(connStr, NullLogger<StoreAndForwardStorage>.Instance);
+        await storage.InitializeAsync();
+        var sfOptions = new StoreAndForwardOptions
+        {
+            DefaultRetryInterval = TimeSpan.FromMinutes(10),
+            RetryTimerInterval = TimeSpan.FromMinutes(10),
+        };
+        var sf = new StoreAndForwardService(storage, sfOptions, NullLogger<StoreAndForwardService>.Instance);
+
+        var handlerInvocations = 0;
+        sf.RegisterDeliveryHandler(
+            ScadaLink.Commons.Types.Enums.StoreAndForwardCategory.ExternalSystem,
+            _ => { Interlocked.Increment(ref handlerInvocations); return Task.FromResult(false); });
+
+        var client = new ExternalSystemClient(
+            _httpClientFactory, _repository,
+            NullLogger<ExternalSystemClient>.Instance,
+            storeAndForward: sf);
+
+        var result = await client.CachedCallAsync("TestAPI", "postData");
+
+        // The call already made one HTTP attempt; EnqueueAsync must NOT invoke the
+        // registered handler again synchronously (which would dispatch a 2nd request).
+        Assert.True(result.WasBuffered);
+        Assert.Equal(0, handlerInvocations);
+    }
+
+    // ── ExternalSystemGateway-002: per-system call timeout ──
+
+    [Fact]
+    public async Task Call_SlowSystem_TimesOutAsTransientErrorWithinConfiguredWindow()
+    {
+        var system = new ExternalSystemDefinition("TestAPI", "https://api.example.com", "none") { Id = 1 };
+        var method = new ExternalSystemMethod("getData", "GET", "/data") { Id = 1, ExternalSystemDefinitionId = 1 };
+        _repository.GetAllExternalSystemsAsync(Arg.Any<CancellationToken>())
+            .Returns(new List<ExternalSystemDefinition> { system });
+        _repository.GetMethodsByExternalSystemIdAsync(1, Arg.Any<CancellationToken>())
+            .Returns(new List<ExternalSystemMethod> { method });
+
+        // Handler that hangs far longer than the configured timeout and the test budget.
+        var httpClient = new HttpClient(new HangingHttpMessageHandler(TimeSpan.FromMinutes(10)));
+        _httpClientFactory.CreateClient(Arg.Any<string>()).Returns(httpClient);
+
+        // Configure a short timeout so the call must fail quickly.
+        var options = new ExternalSystemGatewayOptions { DefaultHttpTimeout = TimeSpan.FromMilliseconds(200) };
+        var client = new ExternalSystemClient(
+            _httpClientFactory, _repository,
+            NullLogger<ExternalSystemClient>.Instance,
+            options: Microsoft.Extensions.Options.Options.Create(options));
+
+        var sw = System.Diagnostics.Stopwatch.StartNew();
+        var result = await client.CallAsync("TestAPI", "getData");
+        sw.Stop();
+
+        Assert.False(result.Success);
+        Assert.Contains("Transient error", result.ErrorMessage);
+        Assert.Contains("Timeout", result.ErrorMessage);
+        // Must fail near the configured 200ms, well before HttpClient's default 100s.
+        Assert.True(sw.Elapsed < TimeSpan.FromSeconds(10),
+            $"Call took {sw.Elapsed}, expected to time out near the configured 200ms window");
+    }
+
+    [Fact]
+    public async Task Call_CallerCancellation_IsNotMisreportedAsTimeout()
+    {
+        var system = new ExternalSystemDefinition("TestAPI", "https://api.example.com", "none") { Id = 1 };
+        var method = new ExternalSystemMethod("getData", "GET", "/data") { Id = 1, ExternalSystemDefinitionId = 1 };
+        _repository.GetAllExternalSystemsAsync(Arg.Any<CancellationToken>())
+            .Returns(new List<ExternalSystemDefinition> { system });
+        _repository.GetMethodsByExternalSystemIdAsync(1, Arg.Any<CancellationToken>())
+            .Returns(new List<ExternalSystemMethod> { method });
+
+        var httpClient = new HttpClient(new HangingHttpMessageHandler(TimeSpan.FromMinutes(10)));
+        _httpClientFactory.CreateClient(Arg.Any<string>()).Returns(httpClient);
+
+        var options = new ExternalSystemGatewayOptions { DefaultHttpTimeout = TimeSpan.FromMinutes(5) };
+        var client = new ExternalSystemClient(
+            _httpClientFactory, _repository,
+            NullLogger<ExternalSystemClient>.Instance,
+            options: Microsoft.Extensions.Options.Options.Create(options));
+
+        using var cts = new CancellationTokenSource(TimeSpan.FromMilliseconds(200));
+
+        // Caller-initiated cancellation must surface as OperationCanceledException,
+        // not be swallowed as a transient timeout error.
+        await Assert.ThrowsAnyAsync<OperationCanceledException>(
+            () => client.CallAsync("TestAPI", "getData", cancellationToken: cts.Token));
+    }
+
     /// <summary>
     /// Test helper: mock HTTP message handler.
     /// </summary>
@@ -238,4 +350,20 @@ public class ExternalSystemClientTests
             });
         }
     }
+
+    /// <summary>
+    /// Test helper: an HTTP handler that hangs until cancelled (simulates a slow/hung system).
+    /// </summary>
+    private class HangingHttpMessageHandler : HttpMessageHandler
+    {
+        private readonly TimeSpan _delay;
+
+        public HangingHttpMessageHandler(TimeSpan delay) => _delay = delay;
+
+        protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
+        {
+            await Task.Delay(_delay, cancellationToken);
+            return new HttpResponseMessage(HttpStatusCode.OK) { Content = new StringContent("{}") };
+        }
+    }
 }