Add some more tests

Author: Nacho Bonafonte

Sources/OpenTelemetrySdk/Metrics/Stable/Aggregation/AggregationResolver.swift renamed to Sources/OpenTelemetrySdk/Metrics/Stable/Aggregation/AggregationSelector.swift

@@ -5,7 +5,7 @@
 
 import Foundation
 
-public protocol Aggregation {
+public protocol Aggregation: AnyObject {
     func createAggregator(descriptor: InstrumentDescriptor, exemplarFilter: ExemplarFilter) -> StableAggregator
     func isCompatible(with descriptor: InstrumentDescriptor) -> Bool
 }

Sources/OpenTelemetrySdk/Metrics/Stable/Aggregation/AggregatorFactory.swift

@@ -25,12 +25,12 @@ public class DoubleExplicitBucketHistogramAggregator: StableAggregator {
             super.init(exemplarReservoir: exemplarReservoir)
         }
 
-        private var boundaries: [Double]
-        private var sum: Double
-        private var min: Double
-        private var max: Double
-        private var count: UInt64
-        private var counts: [Int]
+        internal var boundaries: [Double]
+        internal var sum: Double
+        internal var min: Double
+        internal var max: Double
+        internal var count: UInt64
+        internal var counts: [Int]
 
         override func doAggregateThenMaybeReset(startEpochNano: UInt64, endEpochNano: UInt64, attributes: [String: AttributeValue], exemplars: [ExemplarData], reset: Bool) -> PointData {
             lock.lock()
@@ -78,7 +78,7 @@ public class DoubleExplicitBucketHistogramAggregator: StableAggregator {
         }
     }
 
-    private let boundaries: [Double]
+    internal let boundaries: [Double]
     private let reservoirSupplier: () -> ExemplarReservoir
 
     public init(boundaries: [Double], reservoirSupplier: @escaping () -> ExemplarReservoir) {

Sources/OpenTelemetrySdk/Metrics/Stable/Aggregation/DoubleExplicitBucketHistogramAggregator.swift

@@ -10,7 +10,7 @@ public class ExplicitBucketHistogramAggregation: Aggregation {
     public private(set) static var DEFAULT_BOUNDARIES: [Double] = [0, 5, 10, 25, 50, 75, 100, 250, 500, 750, 1_000, 2_500, 5_000, 7_500]
     public private(set) static var instance = ExplicitBucketHistogramAggregation(bucketBoundaries: DEFAULT_BOUNDARIES)
 
-    private let bucketBoundaries: [Double]
+    internal let bucketBoundaries: [Double]
 
     init(bucketBoundaries: [Double]) {
         self.bucketBoundaries = bucketBoundaries

Sources/OpenTelemetrySdk/Metrics/Stable/Aggregation/ExplicitBucketHistogramAggregation.swift

@@ -0,0 +1,42 @@
+//
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+//
+
+import Foundation
+import OpenTelemetryApi
+
+import OpenTelemetryApi
+@testable import OpenTelemetrySdk
+import XCTest
+
+public class AggregationSelectorTests: XCTestCase {
+    func testGetDefaultAggregation() {
+        let selector = AggregationSelector()
+        let instrumentType = InstrumentType.counter
+        XCTAssert(selector.getDefaultAggregation(for: instrumentType) === Aggregations.defaultAggregation())
+    }
+
+    func testDefaultAggregationResolver() {
+        let resolver = AggregationSelector.defaultSelector()
+        let instrumentType = InstrumentType.histogram
+        XCTAssert(resolver(instrumentType) === Aggregations.defaultAggregation())
+    }
+
+    func testAggregationResolverForInstrumentType() {
+        let selector = AggregationSelector()
+        let instrumentType = InstrumentType.observableUpDownCounter
+        let aggregation = Aggregations.sum()
+        let resolver = selector.with(instrumentType: instrumentType, aggregation: aggregation)
+        XCTAssert(resolver(instrumentType) === aggregation)
+    }
+
+    func testAggregationResolverForDifferentInstrumentType() {
+        let selector = AggregationSelector()
+        let instrumentType = InstrumentType.observableCounter
+        let aggregation = Aggregations.sum()
+        let resolver = selector.with(instrumentType: instrumentType, aggregation: aggregation)
+        let instrumentType2 = InstrumentType.histogram
+        XCTAssert(resolver(instrumentType2) === Aggregations.defaultAggregation())
+    }
+}

Tests/OpenTelemetrySdkTests/Metrics/StableMetrics/Aggregation/AggregationSelectorTests.swift

@@ -0,0 +1,44 @@
+//
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+//
+
+import OpenTelemetryApi
+@testable import OpenTelemetrySdk
+import XCTest
+
+public class AggregationsTests: XCTestCase {
+    func testDropAggregation() {
+        XCTAssert(Aggregations.drop() === DropAggregation.instance)
+    }
+
+    func testDefaultAggregation() {
+        XCTAssert(Aggregations.defaultAggregation() === DefaultAggregation.instance)
+    }
+
+    func testSumAggregation() {
+        XCTAssert(Aggregations.sum() === SumAggregation.instance)
+    }
+
+    func testLastValueAggregation() {
+        XCTAssert(Aggregations.lastValue() === LastValueAggregation.instance)
+    }
+
+    func testExplicitBucketHistogramAggregation() {
+        XCTAssert(Aggregations.explicitBucketHistogram() === ExplicitBucketHistogramAggregation.instance)
+    }
+
+    func testExplicitBucketHistogramAggregationWithBuckets() {
+        let buckets = [0.0, 10.0, 20.0, 30.0]
+        let aggregation = Aggregations.explicitBucketHistogram(buckets: buckets) as? ExplicitBucketHistogramAggregation
+        XCTAssertEqual(aggregation?.bucketBoundaries, buckets)
+    }
+
+    func testBase2ExponentialBucketHistogram() {
+        // TODO: write test case
+    }
+
+    func testBase2ExponentialBucketHistogramWithMaxBucketsAndMaxScale() {
+        // TODO: write test case
+    }
+}

Tests/OpenTelemetrySdkTests/Metrics/StableMetrics/Aggregation/AggregationTests.swift

@@ -0,0 +1,105 @@
+//
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+//
+
+import OpenTelemetryApi
+@testable import OpenTelemetrySdk
+import XCTest
+
+class DoubleExplicitBucketHistogramAggregatorTests: XCTestCase {
+    // Test the creation of a new handle
+    func testCreateHandle() {
+        let aggregator = DoubleExplicitBucketHistogramAggregator(boundaries: [1.0, 2.0], reservoirSupplier: { ExemplarReservoir() })
+        let handle = aggregator.createHandle() as! DoubleExplicitBucketHistogramAggregator.Handle
+        XCTAssertEqual(handle.count, 0)
+        XCTAssertEqual(handle.sum, 0)
+        XCTAssertEqual(handle.min, Double.greatestFiniteMagnitude)
+        XCTAssertEqual(handle.max, -1)
+        XCTAssertEqual(handle.counts, [0, 0, 0])
+        XCTAssertEqual(handle.boundaries, [1.0, 2.0])
+    }
+
+    // Test the aggregation of double values
+    func testDoRecordDouble() {
+        let aggregator = DoubleExplicitBucketHistogramAggregator(boundaries: [1.0, 2.0], reservoirSupplier: { ExemplarReservoir() })
+        let handle = aggregator.createHandle() as! DoubleExplicitBucketHistogramAggregator.Handle
+        handle.recordDouble(value: 1.5)
+        handle.recordDouble(value: 2.5)
+
+        let pointData = handle.aggregateThenMaybeReset(startEpochNano: 0, endEpochNano: 1, attributes: [:], reset: false) as! HistogramPointData
+
+        XCTAssertEqual(pointData.sum, 4.0)
+        XCTAssertEqual(pointData.count, 2)
+        XCTAssertEqual(pointData.min, 1.5)
+        XCTAssertEqual(pointData.max, 2.5)
+        XCTAssertEqual(pointData.counts, [0, 1, 1])
+        XCTAssertEqual(pointData.boundaries, [1.0, 2.0])
+        XCTAssertEqual(pointData.hasMin, true)
+        XCTAssertEqual(pointData.hasMax, true)
+    }
+
+    // Test the aggregation of long values
+    func testDoRecordLong() {
+        let aggregator = DoubleExplicitBucketHistogramAggregator(boundaries: [1.0, 2.0], reservoirSupplier: { ExemplarReservoir() })
+        let handle = aggregator.createHandle()
+        handle.recordLong(value: 1)
+        handle.recordLong(value: 3)
+
+        let pointData = handle.aggregateThenMaybeReset(startEpochNano: 0, endEpochNano: 1, attributes: [:], reset: false) as! HistogramPointData
+
+        XCTAssertEqual(pointData.sum, 4.0)
+        XCTAssertEqual(pointData.count, 2)
+        XCTAssertEqual(pointData.min, 1.0)
+        XCTAssertEqual(pointData.max, 3.0)
+        XCTAssertEqual(pointData.counts, [1, 0, 1])
+        XCTAssertEqual(pointData.boundaries, [1.0, 2.0])
+        XCTAssertEqual(pointData.hasMin, true)
+        XCTAssertEqual(pointData.hasMax, true)
+    }
+
+    // Test the aggregation of double values and reset of the handle
+    func testAggregateThenMaybeReset() {
+        let aggregator = DoubleExplicitBucketHistogramAggregator(boundaries: [0.5, 1.0, 2.0], reservoirSupplier: { NoopExemplarReservoir() })
+        let handle = aggregator.createHandle()
+        handle.recordDouble(value: 1.5)
+        handle.recordDouble(value: 0.25)
+        handle.recordDouble(value: 0.75)
+
+        // Aggregate without resetting
+        let pointData = handle.aggregateThenMaybeReset(startEpochNano: 0, endEpochNano: 1000, attributes: [:], reset: false) as! HistogramPointData
+        XCTAssertEqual(pointData.sum, 2.5)
+        XCTAssertEqual(pointData.count, 3)
+        XCTAssertEqual(pointData.min, 0.25)
+        XCTAssertEqual(pointData.max, 1.5)
+        XCTAssertEqual(pointData.counts, [1, 1, 1, 0])
+
+        // Aggregate and reset
+        let pointData2 = handle.aggregateThenMaybeReset(startEpochNano: 0, endEpochNano: 1000, attributes: [:], reset: true) as! HistogramPointData
+        XCTAssertEqual(pointData2.sum, 2.5)
+        XCTAssertEqual(pointData2.count, 3)
+        XCTAssertEqual(pointData2.min, 0.25)
+        XCTAssertEqual(pointData2.max, 1.5)
+        XCTAssertEqual(pointData2.counts, [1, 1, 1, 0])
+
+        // Aggregate after reset
+        let pointData3 = handle.aggregateThenMaybeReset(startEpochNano: 0, endEpochNano: 1000, attributes: [:], reset: false) as! HistogramPointData
+        XCTAssertEqual(pointData3.sum, 0)
+        XCTAssertEqual(pointData3.count, 0)
+        XCTAssertEqual(pointData3.min, Double.greatestFiniteMagnitude)
+        XCTAssertEqual(pointData3.max, -1)
+        XCTAssertEqual(pointData3.counts, [0, 0, 0, 0])
+    }
+
+    func testDiff() {
+        // Initialize aggregator
+        let aggregator = DoubleExplicitBucketHistogramAggregator(boundaries: [1.0, 2.0, 3.0], reservoirSupplier: { NoopExemplarReservoir() })
+
+        // Create some dummy PointData objects
+        let previousCumulative = HistogramPointData(startEpochNanos: 0, endEpochNanos: 100, attributes: [:], exemplars: [], sum: 10.0, count: 1, min: 5.0, max: 5.0, boundaries: [], counts: [], hasMin: true, hasMax: true)
+        let currentCumulative = HistogramPointData(startEpochNanos: 0, endEpochNanos: 200, attributes: [:], exemplars: [], sum: 20.0, count: 2, min: 3.0, max: 7.0, boundaries: [], counts: [], hasMin: true, hasMax: true)
+
+        // Verify that the diff() method throws the expected error
+        XCTAssertThrowsError(try aggregator.diff(previousCumulative: previousCumulative, currentCumulative: currentCumulative))
+    }
+}

Tests/OpenTelemetrySdkTests/Metrics/StableMetrics/Aggregation/DoubleExplicitBucketHistogramAggregatorTests.swift

@@ -0,0 +1,35 @@
+//
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+//
+
+import Foundation
+import OpenTelemetryApi
+@testable import OpenTelemetrySdk
+import XCTest
+
+class ExplicitBucketHistogramAggregationTests: XCTestCase {
+    func testCreateAggregator() {
+        let boundaries: [Double] = [0, 10, 20, 30, 40]
+        let aggregation = ExplicitBucketHistogramAggregation(bucketBoundaries: boundaries)
+        let descriptor = InstrumentDescriptor(name: "test", description: "test", unit: "unit", type: .histogram, valueType: .double)
+        let exemplarFilter = AlwaysOnFilter()
+
+        let aggregator = aggregation.createAggregator(descriptor: descriptor, exemplarFilter: exemplarFilter) as! DoubleExplicitBucketHistogramAggregator
+
+        XCTAssertNotNil(aggregator)
+        XCTAssertEqual(aggregator.boundaries, boundaries)
+    }
+
+    func testIsCompatible() {
+        let aggregation = ExplicitBucketHistogramAggregation(bucketBoundaries: [0, 10, 20, 30, 40])
+
+        let compatibleDescriptor1 = InstrumentDescriptor(name: "test", description: "test", unit: "unit", type: .counter, valueType: .double)
+        let compatibleDescriptor2 = InstrumentDescriptor(name: "test", description: "test", unit: "unit", type: .histogram, valueType: .double)
+        let incompatibleDescriptor = InstrumentDescriptor(name: "test", description: "test", unit: "unit", type: .counter, valueType: .double)
+
+        XCTAssertTrue(aggregation.isCompatible(with: compatibleDescriptor1))
+        XCTAssertTrue(aggregation.isCompatible(with: compatibleDescriptor2))
+        XCTAssertFalse(aggregation.isCompatible(with: incompatibleDescriptor))
+    }
+}