[FSSDK-12148] test addition

Author: junaed-optimizely

OptimizelySDK.Tests/EventTests/HttpClientEventDispatcher45Test.cs

@@ -0,0 +1,214 @@
+/*
+ * Copyright 2026, Optimizely
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#if !NET35 && !NET40
+using System;
+using System.Collections.Generic;
+using System.Net;
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+using Moq;
+using NUnit.Framework;
+using OptimizelySDK.Event;
+using OptimizelySDK.Event.Dispatcher;
+using OptimizelySDK.Logger;
+
+namespace OptimizelySDK.Tests.EventTests
+{
+    [TestFixture]
+    public class HttpClientEventDispatcher45Test
+    {
+        [SetUp]
+        public void Setup()
+        {
+            _mockLogger = new Mock<ILogger>();
+            _mockLogger.Setup(l => l.Log(It.IsAny<LogLevel>(), It.IsAny<string>()));
+            _requestTimestamps = new List<DateTime>();
+        }
+
+        private Mock<ILogger> _mockLogger;
+        private List<DateTime> _requestTimestamps;
+        
+        [Test]
+        public void DispatchEvent_Success_SingleAttempt()
+        {
+            var handler = new MockHttpMessageHandler(HttpStatusCode.OK);
+            var httpClient = new HttpClient(handler);
+            var dispatcher = new HttpClientEventDispatcher45(httpClient)
+            {
+                Logger = _mockLogger.Object,
+            };
+            var logEvent = CreateLogEvent();
+
+            dispatcher.DispatchEvent(logEvent);
+            Thread.Sleep(500); // Wait for async dispatch
+
+            Assert.AreEqual(1, handler.RequestCount);
+            _mockLogger.Verify(l => l.Log(LogLevel.ERROR, It.IsAny<string>()), Times.Never);
+        }
+
+        [Test]
+        public void DispatchEvent_ServerError500_RetriesThreeTimes()
+        {
+            var handler = new MockHttpMessageHandler(HttpStatusCode.InternalServerError);
+            var httpClient = new HttpClient(handler);
+            var dispatcher = new HttpClientEventDispatcher45(httpClient)
+            {
+                Logger = _mockLogger.Object,
+            };
+            var logEvent = CreateLogEvent();
+
+            dispatcher.DispatchEvent(logEvent);
+            Thread.Sleep(1500);
+
+            Assert.AreEqual(3, handler.RequestCount);
+            _mockLogger.Verify(
+                l => l.Log(LogLevel.ERROR, It.Is<string>(s => s.Contains("3 attempt(s)"))),
+                Times.Once);
+        }
+
+        [Test]
+        public void DispatchEvent_ClientError400_NoRetry()
+        {
+            var handler = new MockHttpMessageHandler(HttpStatusCode.BadRequest);
+            var httpClient = new HttpClient(handler);
+            var dispatcher = new HttpClientEventDispatcher45(httpClient)
+            {
+                Logger = _mockLogger.Object,
+            };
+            var logEvent = CreateLogEvent();
+
+            dispatcher.DispatchEvent(logEvent);
+            Thread.Sleep(500);
+
+            Assert.AreEqual(1, handler.RequestCount);
+            _mockLogger.Verify(l => l.Log(LogLevel.ERROR, It.IsAny<string>()), Times.Once);
+        }
+
+        [Test]
+        public void DispatchEvent_SucceedsOnSecondAttempt_StopsRetrying()
+        {
+            var handler = new MockHttpMessageHandler(new[]
+            {
+                HttpStatusCode.InternalServerError,
+                HttpStatusCode.OK,
+            });
+            var httpClient = new HttpClient(handler);
+            var dispatcher = new HttpClientEventDispatcher45(httpClient)
+            {
+                Logger = _mockLogger.Object,
+            };
+            var logEvent = CreateLogEvent();
+
+            dispatcher.DispatchEvent(logEvent);
+            Thread.Sleep(1000);
+
+            Assert.AreEqual(2, handler.RequestCount);
+            _mockLogger.Verify(l => l.Log(LogLevel.ERROR, It.IsAny<string>()), Times.Never);
+        }
+
+        [Test]
+        public void DispatchEvent_ExponentialBackoff_VerifyTiming()
+        {
+            var handler =
+                new MockHttpMessageHandler(HttpStatusCode.InternalServerError, _requestTimestamps);
+            var httpClient = new HttpClient(handler);
+            var dispatcher = new HttpClientEventDispatcher45(httpClient)
+            {
+                Logger = _mockLogger.Object,
+            };
+            var logEvent = CreateLogEvent();
+
+            dispatcher.DispatchEvent(logEvent);
+            Thread.Sleep(1500); // Wait for all retries
+
+            Assert.AreEqual(3, _requestTimestamps.Count);
+
+            // First retry after ~200ms
+            var firstDelay = (_requestTimestamps[1] - _requestTimestamps[0]).TotalMilliseconds;
+            Assert.That(firstDelay, Is.GreaterThanOrEqualTo(180).And.LessThan(350),
+                $"First retry delay was {firstDelay}ms, expected ~200ms");
+
+            // Second retry after ~400ms
+            var secondDelay = (_requestTimestamps[2] - _requestTimestamps[1]).TotalMilliseconds;
+            Assert.That(secondDelay, Is.GreaterThanOrEqualTo(380).And.LessThan(550),
+                $"Second retry delay was {secondDelay}ms, expected ~400ms");
+        }
+
+        private static LogEvent CreateLogEvent()
+        {
+            return new LogEvent(
+                "https://logx.optimizely.com/v1/events",
+                new Dictionary<string, object>
+                {
+                    { "accountId", "12345" },
+                    { "visitors", new object[] { } },
+                },
+                "POST",
+                new Dictionary<string, string>());
+        }
+
+        /// <summary>
+        ///     Mock HTTP message handler for testing.
+        /// </summary>
+        private class MockHttpMessageHandler : HttpMessageHandler
+        {
+            private readonly HttpStatusCode[] _statusCodes;
+            private readonly List<DateTime> _timestamps;
+            private int _currentIndex;
+
+            public MockHttpMessageHandler(HttpStatusCode statusCode,
+                List<DateTime> timestamps = null
+            )
+                : this(new[] { statusCode }, timestamps) { }
+
+            public MockHttpMessageHandler(HttpStatusCode[] statusCodes,
+                List<DateTime> timestamps = null
+            )
+            {
+                _statusCodes = statusCodes;
+                _timestamps = timestamps;
+                _currentIndex = 0;
+            }
+
+            public int RequestCount { get; private set; }
+
+            protected override Task<HttpResponseMessage> SendAsync(
+                HttpRequestMessage request,
+                CancellationToken cancellationToken
+            )
+            {
+                RequestCount++;
+                _timestamps?.Add(DateTime.Now);
+
+                var statusCode = _currentIndex < _statusCodes.Length ?
+                    _statusCodes[_currentIndex] :
+                    _statusCodes[_statusCodes.Length - 1];
+
+                _currentIndex++;
+
+                var response = new HttpResponseMessage(statusCode)
+                {
+                    Content = new StringContent("{}"),
+                };
+
+                return Task.FromResult(response);
+            }
+        }
+    }
+}
+#endif

OptimizelySDK.Tests/OptimizelySDK.Tests.csproj

@@ -101,6 +101,7 @@
     <Compile Include="EventTests\DefaultEventDispatcherTest.cs"/>
     <Compile Include="EventTests\EventBuilderTest.cs"/>
     <Compile Include="EventTests\ForwardingEventProcessorTest.cs"/>
+    <Compile Include="EventTests\HttpClientEventDispatcher45Test.cs"/>
     <Compile Include="EventTests\LogEventTest.cs"/>
     <Compile Include="EventTests\TestEventDispatcher.cs"/>
     <Compile Include="EventTests\TestForwardingEventDispatcher.cs"/>

OptimizelySDK/Event/Dispatcher/HttpClientEventDispatcher45.cs

@@ -28,16 +28,29 @@ namespace OptimizelySDK.Event.Dispatcher
     public class HttpClientEventDispatcher45 : IEventDispatcher
     {
         /// <summary>
-        ///     HTTP client object.
+        ///     Default shared HTTP client instance for all dispatchers.
         /// </summary>
-        private static readonly HttpClient Client;
+        private static readonly HttpClient DefaultClient = new HttpClient();
 
         /// <summary>
-        ///     Constructor for initializing static members.
+        ///     HTTP client instance used by this dispatcher.
         /// </summary>
-        static HttpClientEventDispatcher45()
+        private readonly HttpClient _client;
+
+        /// <summary>
+        ///     Default constructor using the shared static HttpClient.
+        /// </summary>
+        public HttpClientEventDispatcher45() : this(null)
+        {
+        }
+
+        /// <summary>
+        ///     Constructor allowing injection of a custom HttpClient for testing.
+        /// </summary>
+        /// <param name="httpClient">Custom HttpClient instance, or null to use the default shared instance.</param>
+        internal HttpClientEventDispatcher45(HttpClient httpClient)
         {
-            Client = new HttpClient();
+            _client = httpClient ?? DefaultClient;
         }
 
         public ILogger Logger { get; set; } = new DefaultLogger();
@@ -85,7 +98,7 @@ private async Task DispatchEventAsync(LogEvent logEvent)
                         }
                     }
 
-                    response = await Client.SendAsync(request).ConfigureAwait(false);
+                    response = await _client.SendAsync(request).ConfigureAwait(false);
                     response.EnsureSuccessStatusCode();
 
                     // Success - exit the retry loop