Nit additions to Metrics tests

Author: cijothomas

opentelemetry-sdk/src/metrics/mod.rs

@@ -181,6 +181,10 @@ mod tests {
             counter.add(100, &[KeyValue::new("A", v.to_string())]);
         }
 
+        // Empty attributes is specially treated and does not count towards the limit.
+        counter.add(3, &[]);
+        counter.add(3, &[]);
+
         // All of the below will now go into overflow.
         counter.add(100, &[KeyValue::new("A", "foo")]);
         counter.add(100, &[KeyValue::new("A", "another")]);
@@ -189,13 +193,26 @@ mod tests {
 
         let sum = test_context.get_aggregation::<data::Sum<u64>>("my_counter", None);
 
-        // Expecting 2001 metric points. (2000 + 1 overflow)
-        assert_eq!(sum.data_points.len(), 2001);
+        // Expecting 2002 metric points. (2000 + 1 overflow + Empty attributes)
+        assert_eq!(sum.data_points.len(), 2002);
 
         let data_point =
             find_datapoint_with_key_value(&sum.data_points, "otel.metric.overflow", "true")
                 .expect("overflow point expected");
         assert_eq!(data_point.value, 300);
+
+        // TODO: This is relying on the current behavior of the SDK that 0th
+        // point is empty attributes, but it is not guaranteed to be the case in
+        // the future.
+        let empty_attrs_data_point = &sum.data_points[0];
+        assert!(
+            empty_attrs_data_point.attributes.is_empty(),
+            "Non-empty attribute set"
+        );
+        assert_eq!(
+            empty_attrs_data_point.value, 6,
+            "Empty attributes value should be 3+3=6"
+        );
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
@@ -763,9 +780,9 @@ mod tests {
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
-    async fn counter_aggregation_attribute_order() {
+    async fn counter_aggregation_attribute_order_sorted_first() {
         // Run this test with stdout enabled to see output.
-        // cargo test counter_aggregation_attribute_order --features=testing -- --nocapture
+        // cargo test counter_aggregation_attribute_order_sorted_first --features=testing -- --nocapture
 
         // Arrange
         let mut test_context = TestContext::new(Temporality::Delta);
@@ -774,14 +791,80 @@ mod tests {
         // Act
         // Add the same set of attributes in different order. (they are expected
         // to be treated as same attributes)
+        // start with sorted order
+        counter.add(
+            1,
+            &[
+                KeyValue::new("A", "a"),
+                KeyValue::new("B", "b"),
+                KeyValue::new("C", "c"),
+            ],
+        );
+        counter.add(
+            1,
+            &[
+                KeyValue::new("A", "a"),
+                KeyValue::new("C", "c"),
+                KeyValue::new("B", "b"),
+            ],
+        );
         counter.add(
             1,
             &[
+                KeyValue::new("B", "b"),
                 KeyValue::new("A", "a"),
+                KeyValue::new("C", "c"),
+            ],
+        );
+        counter.add(
+            1,
+            &[
+                KeyValue::new("B", "b"),
+                KeyValue::new("C", "c"),
+                KeyValue::new("A", "a"),
+            ],
+        );
+        counter.add(
+            1,
+            &[
+                KeyValue::new("C", "c"),
                 KeyValue::new("B", "b"),
+                KeyValue::new("A", "a"),
+            ],
+        );
+        counter.add(
+            1,
+            &[
                 KeyValue::new("C", "c"),
+                KeyValue::new("A", "a"),
+                KeyValue::new("B", "b"),
             ],
         );
+        test_context.flush_metrics();
+
+        let sum = test_context.get_aggregation::<data::Sum<u64>>("my_counter", None);
+
+        // Expecting 1 time-series.
+        assert_eq!(sum.data_points.len(), 1);
+
+        // validate the sole datapoint
+        let data_point1 = &sum.data_points[0];
+        assert_eq!(data_point1.value, 6);
+    }
+
+    #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
+    async fn counter_aggregation_attribute_order_unsorted_first() {
+        // Run this test with stdout enabled to see output.
+        // cargo test counter_aggregation_attribute_order_unsorted_first --features=testing -- --nocapture
+
+        // Arrange
+        let mut test_context = TestContext::new(Temporality::Delta);
+        let counter = test_context.u64_counter("test", "my_counter", None);
+
+        // Act
+        // Add the same set of attributes in different order. (they are expected
+        // to be treated as same attributes)
+        // start with unsorted order
         counter.add(
             1,
             &[
@@ -790,6 +873,14 @@ mod tests {
                 KeyValue::new("B", "b"),
             ],
         );
+        counter.add(
+            1,
+            &[
+                KeyValue::new("A", "a"),
+                KeyValue::new("B", "b"),
+                KeyValue::new("C", "c"),
+            ],
+        );
         counter.add(
             1,
             &[