More work on SeqBackgroundService, next step is tests for it.

Tests/Logging/SeqBackgroundServiceTest.cs

@@ -0,0 +1,74 @@
+using Autofac;
+using Core.Telemetry;
+using Microsoft.ApplicationInsights;
+using Microsoft.ApplicationInsights.Channel;
+using Microsoft.ApplicationInsights.DataContracts;
+using Core.Logging;
+
+namespace Tests.Logging
+{
+    [TestClass]
+    public class SeqBackgroundServiceTest : TestFixture
+    {
+        private IMessageChannel<ITelemetry> _messageChannel;
+        private SeqBackgroundService _service;
+        private CancellationTokenSource _cts;
+
+        [TestInitialize]
+        public void SetupThis()
+        {
+            _messageChannel = new MessageChannel();
+            var telemetryClient = Container.Resolve<TelemetryClient>();
+
+            var config = new SeqConfiguration("http://localhost:5341", null, "MSTEST");
+
+            var httpClient = new SeqHttpClient(config);
+            var logger = new SeqLogger(httpClient, Environment.MachineName, config);
+
+
+
+            _service = new SeqBackgroundService(telemetryClient, _messageChannel, logger);
+            _cts = new CancellationTokenSource();
+        }
+
+        [TestMethod]
+        public async Task Messages_ShouldBeProcessedFromQueue()
+        {
+            var processedMessages = new List<HttpRequestMessage>();
+
+            var serviceTask = _service.StartAsync(_cts.Token);
+
+            for (int i = 0; i < 5; i++)
+            {
+                var eventTelemetry = new EventTelemetry("SomeEvent");
+                await _messageChannel.Writer.WriteAsync(eventTelemetry);
+            }
+
+            // wait for processing
+            await Task.Delay(5000);
+
+            _cts.Cancel();
+            await _service.StopAsync(CancellationToken.None);
+
+
+            bool hasMoreMessages = await _messageChannel.Reader.WaitToReadAsync();
+            Assert.IsFalse(hasMoreMessages, "Queue should be empty after 5 seconds");
+        }
+
+        private class TestMessageHandler : HttpMessageHandler
+        {
+            protected override Task<HttpResponseMessage> SendAsync(
+                HttpRequestMessage request,
+                CancellationToken cancellationToken)
+            {
+                return Task.FromResult(new HttpResponseMessage(System.Net.HttpStatusCode.OK));
+            }
+        }
+
+        [TestCleanup]
+        public void Cleanup()
+        {
+            _cts?.Dispose();
+        }
+    }
+}

Tests/Logging/SeqLoggerTests.cs

@@ -0,0 +1,132 @@
+using Core.Logging;
+using Microsoft.ApplicationInsights.DataContracts;
+
+namespace Tests.Logging
+{
+    [TestClass]
+    public class SeqLoggerTests : TestFixture
+    {
+        private SeqLogger _logger;
+        private SeqHttpClient _httpClient;
+        private readonly string _testId;
+
+        public SeqLoggerTests()
+        {
+            _testId = Guid.NewGuid().ToString();
+            var config = new SeqConfiguration("http://localhost:5341", null, "MSTEST");
+            _httpClient = new SeqHttpClient(config);
+            _logger = new SeqLogger(_httpClient, Environment.MachineName, config);
+        }
+
+        [TestMethod]
+        public async Task LogTraceTelemetry_SendsCorrectDataWithErrorLevel()
+        {
+            // Arrange
+            var traceTelemetry = new TraceTelemetry
+            {
+                Message = "Test trace error message",
+                SeverityLevel = SeverityLevel.Error,
+                Timestamp = DateTimeOffset.UtcNow
+            };
+            traceTelemetry.Properties.Add("TestId", _testId);
+
+            // Act
+            await _logger.LogAsync(traceTelemetry);
+
+
+        }
+        [TestMethod]
+        public async Task LogTraceTelemetry_SendsCorrectDataWithWarningLevel()
+        {
+            // Arrange
+            var traceTelemetry = new TraceTelemetry
+            {
+                Message = "Test trace warning message",
+                SeverityLevel = SeverityLevel.Warning,
+                Timestamp = DateTimeOffset.UtcNow
+            };
+            traceTelemetry.Properties.Add("TestId", _testId);
+
+            // Act
+            await _logger.LogAsync(traceTelemetry);
+
+        }
+        [TestMethod]
+        public async Task LogEventTelemetry_SendsCorrectData()
+        {
+            // Arrange
+            var eventTelemetry = new EventTelemetry
+            {
+                Name = "Test Event",
+                Timestamp = DateTimeOffset.UtcNow
+            };
+            eventTelemetry.Properties.Add("TestId", _testId);
+            eventTelemetry.Metrics.Add("TestMetric", 42.0);
+
+            // Act
+            await _logger.LogAsync(eventTelemetry);
+        }
+
+        [TestMethod]
+        public async Task LogExceptionTelemetry_SendsCorrectData()
+        {
+            try
+            {
+                int t = 0;
+                var result = 10 / t;
+
+            }
+            catch (Exception e)
+            {
+
+                // Arrange
+                var exceptionTelemetry = new ExceptionTelemetry(e)
+                {
+                    Timestamp = DateTimeOffset.UtcNow
+                };
+                exceptionTelemetry.Properties.Add("TestId", _testId);
+
+                // Act
+                await _logger.LogAsync(exceptionTelemetry);
+            }
+        }
+
+        [TestMethod]
+        public async Task LogDependencyTelemetry_SendsCorrectData()
+        {
+            // Arrange
+            var dependencyTelemetry = new DependencyTelemetry
+            {
+                Name = "SQL Query",
+                Type = "SQL",
+                Target = "TestDB",
+                Success = true,
+                Duration = TimeSpan.FromMilliseconds(100),
+                Timestamp = DateTimeOffset.UtcNow
+            };
+            dependencyTelemetry.Properties.Add("TestId", _testId);
+
+            // Act
+            await _logger.LogAsync(dependencyTelemetry);
+        }
+
+        [TestMethod]
+        public async Task LogRequestTelemetry_SendsCorrectData()
+        {
+            // Arrange
+            var requestTelemetry = new RequestTelemetry
+            {
+                Name = "GET /api/test",
+                Success = true,
+                ResponseCode = "200",
+                Duration = TimeSpan.FromMilliseconds(50),
+                Url = new Uri("http://test.com/api/test"),
+                Timestamp = DateTimeOffset.UtcNow
+            };
+            requestTelemetry.Properties.Add("TestId", _testId);
+
+            // Act
+            await _logger.LogAsync(requestTelemetry);
+        }
+    }
+}