add unit tests

Author: maximsemenov80

dotnet/src/Azure.Iot.Operations.Services/Observability/AkriObservabilityServiceStub.cs

@@ -2,10 +2,12 @@
 // Licensed under the MIT License.
 
 using Azure.Iot.Operations.Protocol;
+using Azure.Iot.Operations.Protocol.RPC;
+using Azure.Iot.Operations.Services.Observability.AkriObservabilityService;
 
 namespace Azure.Iot.Operations.Services.Observability;
 
-public class AkriObservabilityServiceStub : AkriObservabilityService.AkriObservabilityService.Client
+public class AkriObservabilityServiceStub : AkriObservabilityService.AkriObservabilityService.Client, IAkriObservabilityService
 {
     public AkriObservabilityServiceStub(
         ApplicationContext applicationContext,
@@ -16,4 +18,9 @@ public AkriObservabilityServiceStub(
             topicTokenMap)
     {
     }
+
+    public RpcCallAsync<PublishMetricsResponsePayload> PublishMetricsAsync(PublishMetricsRequestPayload request)
+    {
+        return base.PublishMetricsAsync(request);
+    }
 }

dotnet/src/Azure.Iot.Operations.Services/Observability/DefaultTimerFactory.cs

@@ -0,0 +1,12 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+namespace Azure.Iot.Operations.Services.Observability;
+
+public class DefaultTimerFactory : ITimerFactory
+{
+    public ITimer CreateTimer()
+    {
+        return new TimerWrapper();
+    }
+}

dotnet/src/Azure.Iot.Operations.Services/Observability/IAkriObservabilityService.cs

@@ -0,0 +1,12 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+namespace Azure.Iot.Operations.Services.Observability;
+
+using Protocol.RPC;
+using AkriObservabilityService;
+
+public interface IAkriObservabilityService
+{
+    RpcCallAsync<PublishMetricsResponsePayload> PublishMetricsAsync(PublishMetricsRequestPayload request);
+}

dotnet/src/Azure.Iot.Operations.Services/Observability/ITimer.cs

@@ -0,0 +1,10 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+namespace Azure.Iot.Operations.Services.Observability;
+
+public interface ITimer : IAsyncDisposable
+{
+    void Start(Func<CancellationToken, Task> callback, CancellationToken cancellationToken, TimeSpan dueTime, TimeSpan period);
+    Task StopAsync();
+}

dotnet/src/Azure.Iot.Operations.Services/Observability/ITimerFactory.cs

@@ -0,0 +1,9 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+namespace Azure.Iot.Operations.Services.Observability;
+
+public interface ITimerFactory
+{
+    ITimer CreateTimer();
+}

dotnet/src/Azure.Iot.Operations.Services/Observability/MetricsReporterService.cs

@@ -1,47 +1,45 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
+using Azure.Iot.Operations.Protocol.RPC;
 using Azure.Iot.Operations.Services.Observability.AkriObservabilityService;
 
 namespace Azure.Iot.Operations.Services.Observability;
 
 public class MetricsReporterService : IAsyncDisposable
 {
-    private readonly AkriObservabilityServiceStub _observabilityService;
+    private readonly IAkriObservabilityService _observabilityService;
     private readonly MetricsReporterOptions _options;
     private readonly CounterMetricCache _counterCache;
     private readonly GaugeMetricCache _gaugeCache;
     private readonly HistogramMetricCache _histogramCache;
-    private Timer? _reportingTimer;
+    private readonly ITimerFactory _timerFactory;
+    private ITimer? _reportingTimer;
     private bool _isDisposed;
     private readonly SemaphoreSlim _reportingSemaphore = new(1, 1);
 
     public MetricsReporterService(
-        AkriObservabilityServiceStub observabilityService,
-        MetricsReporterOptions? options = null)
+        IAkriObservabilityService observabilityService,
+        MetricsReporterOptions? options = null,
+        ITimerFactory? timerFactory = null)
     {
         _observabilityService = observabilityService ?? throw new ArgumentNullException(nameof(observabilityService));
         _options = options ?? new MetricsReporterOptions();
+        _timerFactory = timerFactory ?? new DefaultTimerFactory();
 
         _counterCache = new CounterMetricCache();
         _gaugeCache = new GaugeMetricCache();
         _histogramCache = new HistogramMetricCache();
     }
 
-    public async Task StartAsync(CancellationToken cancellationToken = default)
+    public void Start(CancellationToken cancellationToken = default)
     {
-        if (_reportingTimer != null)
-        {
-            throw new InvalidOperationException("MetricsReporterService has already been started.");
-        }
+        _reportingTimer = _timerFactory.CreateTimer();
 
-        _reportingTimer = new Timer(
-            async _ => await ReportMetricsAsync(cancellationToken),
-            null,
+        _reportingTimer.Start(async _ => await ReportMetricsAsync(cancellationToken),
+            cancellationToken,
             _options.ReportingInterval,
             _options.ReportingInterval);
-
-        await Task.CompletedTask;
     }
 
     public async Task StopAsync()
@@ -107,12 +105,13 @@ private async Task ReportMetricsAsync(CancellationToken cancellationToken)
             };
 
             // Only send if there are metrics to report
-            if (request.Metrics.CounterMetrics.Count > 0 || request.Metrics.GaugeMetrics.Count > 0 || request.Metrics.HistogramMetrics.Count > 0)
+            if (request.Metrics.CounterMetrics.Count > 0 ||
+                request.Metrics.GaugeMetrics.Count > 0 ||
+                request.Metrics.HistogramMetrics.Count > 0)
             {
                 try
                 {
-                    // Fire and forget
-                    var call = _observabilityService.PublishMetricsAsync(request);
+                    RpcCallAsync<PublishMetricsResponsePayload> response = _observabilityService.PublishMetricsAsync(request);
                 }
                 catch (Exception ex)
                 {

dotnet/src/Azure.Iot.Operations.Services/Observability/TimerWrapper.cs

@@ -0,0 +1,40 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+namespace Azure.Iot.Operations.Services.Observability
+{
+    public class TimerWrapper : ITimer
+    {
+        private Timer? _timer;
+        private bool _isDisposed;
+
+        public void Start(Func<CancellationToken, Task> callback, CancellationToken cancellationToken, TimeSpan dueTime, TimeSpan period)
+        {
+            _timer = new Timer(
+                async _ => await callback(CancellationToken.None),
+                null,
+                dueTime,
+                period);
+        }
+
+        public async Task StopAsync()
+        {
+            if (_timer != null)
+            {
+                await _timer.DisposeAsync();
+                _timer = null;
+            }
+        }
+
+        public async ValueTask DisposeAsync()
+        {
+            if (_isDisposed)
+            {
+                return;
+            }
+
+            await StopAsync();
+            _isDisposed = true;
+        }
+    }
+}

dotnet/test/Azure.Iot.Operations.Services.UnitTests/Observability/CachedCounterTests.cs

@@ -0,0 +1,142 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+using Azure.Iot.Operations.Services.Observability;
+using Xunit;
+
+namespace Azure.Iot.Operations.Services.UnitTests.Observability;
+
+public class CachedCounterTests
+{
+    private readonly string _name = "test_counter";
+
+    private readonly Dictionary<string, string> _labels = new()
+    {
+        { "service", "test" },
+        { "instance", "instance1" }
+    };
+
+    private readonly string _unit = "bytes";
+
+    [Fact]
+    public void Constructor_InitializesProperties()
+    {
+        // Arrange & Act
+        var counter = new CachedCounter(_name, _labels, _unit);
+
+        // Assert
+        Assert.Equal(_name, counter.Name);
+        Assert.Equal(_labels, counter.Labels);
+        Assert.Equal(_unit, counter.Unit);
+    }
+
+    [Fact]
+    public void Add_AddsOperationToQueue()
+    {
+        // Arrange
+        var counter = new CachedCounter(_name, _labels, _unit);
+        var value = 5.0;
+
+        // Act
+        counter.Add(value);
+
+        // Assert
+        var operations = counter.GetOperationsAndClear(10);
+        Assert.Single(operations);
+        Assert.Equal(value, operations[0].Value);
+        Assert.NotNull(operations[0].OperationId);
+        Assert.True(operations[0].Timestamp <= DateTime.UtcNow);
+        Assert.True(operations[0].Timestamp >= DateTime.UtcNow.AddMinutes(-1)); // Should be recent
+    }
+
+    [Fact]
+    public void Increment_AddsOperationWithValueOne()
+    {
+        // Arrange
+        var counter = new CachedCounter(_name, _labels, _unit);
+
+        // Act
+        counter.Increment();
+
+        // Assert
+        var operations = counter.GetOperationsAndClear(10);
+        Assert.Single(operations);
+        Assert.Equal(1.0, operations[0].Value);
+    }
+
+    [Fact]
+    public void MultipleOperations_AddedCorrectly()
+    {
+        // Arrange
+        var counter = new CachedCounter(_name, _labels, _unit);
+
+        // Act
+        counter.Add(3.0);
+        counter.Increment();
+        counter.Add(7.5);
+
+        // Assert
+        var operations = counter.GetOperationsAndClear(10);
+        Assert.Equal(3, operations.Count);
+        Assert.Equal(3.0, operations[0].Value);
+        Assert.Equal(1.0, operations[1].Value);
+        Assert.Equal(7.5, operations[2].Value);
+    }
+
+    [Fact]
+    public void GetOperationsAndClear_RespectsMaxCount()
+    {
+        // Arrange
+        var counter = new CachedCounter(_name, _labels, _unit);
+
+        // Add 5 operations
+        for (var i = 1; i <= 5; i++) counter.Add(i);
+
+        // Act - Get only 3 operations
+        var firstBatch = counter.GetOperationsAndClear(3);
+
+        // Assert
+        Assert.Equal(3, firstBatch.Count);
+        Assert.Equal(1.0, firstBatch[0].Value);
+        Assert.Equal(2.0, firstBatch[1].Value);
+        Assert.Equal(3.0, firstBatch[2].Value);
+
+        // Get remaining operations
+        var secondBatch = counter.GetOperationsAndClear(10);
+        Assert.Equal(2, secondBatch.Count);
+        Assert.Equal(4.0, secondBatch[0].Value);
+        Assert.Equal(5.0, secondBatch[1].Value);
+    }
+
+    [Fact]
+    public void GetOperationsAndClear_EmptiesQueue()
+    {
+        // Arrange
+        var counter = new CachedCounter(_name, _labels, _unit);
+        counter.Add(1.0);
+        counter.Add(2.0);
+
+        // Act
+        var operations = counter.GetOperationsAndClear(10);
+
+        // Assert
+        Assert.Equal(2, operations.Count);
+
+        // Verify queue is now empty
+        var emptyOperations = counter.GetOperationsAndClear(10);
+        Assert.Empty(emptyOperations);
+    }
+
+    [Fact]
+    public void GetOperationsAndClear_WithEmptyQueue_ReturnsEmptyList()
+    {
+        // Arrange
+        var counter = new CachedCounter(_name, _labels, _unit);
+
+        // Act
+        var operations = counter.GetOperationsAndClear(10);
+
+        // Assert
+        Assert.Empty(operations);
+    }
+}