test: [#1446] add more tests to metrics package

Author: josecelano

packages/metrics/.gitignore

@@ -1 +1 @@
-./.coverage
+.coverage

packages/metrics/README.md

@@ -6,6 +6,28 @@ A library with the metrics types used by the [Torrust Tracker](https://github.co
 
 [Crate documentation](https://docs.rs/torrust-tracker-metrics).
 
+## Testing
+
+Run coverage report:
+
+```console
+cargo llvm-cov --package torrust-tracker-metrics 
+```
+
+Generate LCOV report with `llvm-cov` (for Visual Studio Code extension):
+
+```console
+mkdir -p ./.coverage
+cargo llvm-cov --package torrust-tracker-metrics  --lcov --output-path=./.coverage/lcov.info
+```
+
+Generate HTML report with `llvm-cov`:
+
+```console
+mkdir -p ./.coverage
+cargo llvm-cov --package torrust-tracker-metrics  --html --output-dir ./.coverage
+```
+
 ## Acknowledgements
 
 We copied some parts like units or function names and signatures from the crate [metrics](https://crates.io/crates/metrics) because we wanted to make it compatible as much as possible with it. In the future, we may consider using the `metrics` crate directly instead of maintaining our own version.

packages/metrics/cSpell.json

@@ -0,0 +1,19 @@
+{
+    "words": [
+        "cloneable",
+        "formatjson",
+        "Gibibytes",
+        "Kibibytes",
+        "Mebibytes",
+        "ñaca",
+        "rstest",
+        "subsec",
+        "Tebibytes",
+        "thiserror"
+    ],
+    "enableFiletypes": [
+        "dockerfile",
+        "shellscript",
+        "toml"
+    ]
+}

packages/metrics/src/aggregate.rs

@@ -26,3 +26,118 @@ impl From<AggregateValue> for f64 {
         value.0
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use approx::assert_relative_eq;
+
+    use super::*;
+
+    #[test]
+    fn it_should_be_created_with_new() {
+        let value = AggregateValue::new(42.5);
+        assert_relative_eq!(value.value(), 42.5);
+    }
+
+    #[test]
+    fn it_should_return_the_inner_value() {
+        let value = AggregateValue::new(123.456);
+        assert_relative_eq!(value.value(), 123.456);
+    }
+
+    #[test]
+    fn it_should_handle_zero_value() {
+        let value = AggregateValue::new(0.0);
+        assert_relative_eq!(value.value(), 0.0);
+    }
+
+    #[test]
+    fn it_should_handle_negative_values() {
+        let value = AggregateValue::new(-42.5);
+        assert_relative_eq!(value.value(), -42.5);
+    }
+
+    #[test]
+    fn it_should_handle_infinity() {
+        let value = AggregateValue::new(f64::INFINITY);
+        assert_relative_eq!(value.value(), f64::INFINITY);
+    }
+
+    #[test]
+    fn it_should_handle_nan() {
+        let value = AggregateValue::new(f64::NAN);
+        assert!(value.value().is_nan());
+    }
+
+    #[test]
+    fn it_should_be_created_from_f64() {
+        let value: AggregateValue = 42.5.into();
+        assert_relative_eq!(value.value(), 42.5);
+    }
+
+    #[test]
+    fn it_should_convert_to_f64() {
+        let value = AggregateValue::new(42.5);
+        let f64_value: f64 = value.into();
+        assert_relative_eq!(f64_value, 42.5);
+    }
+
+    #[test]
+    fn it_should_be_displayable() {
+        let value = AggregateValue::new(42.5);
+        assert_eq!(value.to_string(), "42.5");
+    }
+
+    #[test]
+    fn it_should_be_debuggable() {
+        let value = AggregateValue::new(42.5);
+        let debug_string = format!("{value:?}");
+        assert_eq!(debug_string, "AggregateValue(42.5)");
+    }
+
+    #[test]
+    fn it_should_be_cloneable() {
+        let value = AggregateValue::new(42.5);
+        let cloned_value = value;
+        assert_eq!(value, cloned_value);
+    }
+
+    #[test]
+    fn it_should_be_copyable() {
+        let value = AggregateValue::new(42.5);
+        let copied_value = value;
+        assert_eq!(value, copied_value);
+    }
+
+    #[test]
+    fn it_should_support_equality_comparison() {
+        let value1 = AggregateValue::new(42.5);
+        let value2 = AggregateValue::new(42.5);
+        let value3 = AggregateValue::new(43.0);
+
+        assert_eq!(value1, value2);
+        assert_ne!(value1, value3);
+    }
+
+    #[test]
+    fn it_should_handle_special_float_values_in_equality() {
+        let nan1 = AggregateValue::new(f64::NAN);
+        let nan2 = AggregateValue::new(f64::NAN);
+        let infinity = AggregateValue::new(f64::INFINITY);
+        let neg_infinity = AggregateValue::new(f64::NEG_INFINITY);
+
+        // NaN is not equal to itself in IEEE 754
+        assert_ne!(nan1, nan2);
+        assert_eq!(infinity, AggregateValue::new(f64::INFINITY));
+        assert_eq!(neg_infinity, AggregateValue::new(f64::NEG_INFINITY));
+        assert_ne!(infinity, neg_infinity);
+    }
+
+    #[test]
+    fn it_should_handle_conversion_roundtrip() {
+        let original_value = 42.5;
+        let aggregate_value = AggregateValue::from(original_value);
+        let converted_back: f64 = aggregate_value.into();
+        assert_relative_eq!(original_value, converted_back);
+    }
+}

packages/metrics/src/counter.rs

@@ -107,4 +107,160 @@ mod tests {
         let counter = Counter::new(42);
         assert_eq!(counter.to_prometheus(), "42");
     }
+
+    #[test]
+    fn it_could_be_converted_from_u32() {
+        let counter: Counter = 42u32.into();
+        assert_eq!(counter.value(), 42);
+    }
+
+    #[test]
+    fn it_could_be_converted_from_i32() {
+        let counter: Counter = 42i32.into();
+        assert_eq!(counter.value(), 42);
+    }
+
+    #[test]
+    fn it_should_return_primitive_value() {
+        let counter = Counter::new(123);
+        assert_eq!(counter.primitive(), 123);
+    }
+
+    #[test]
+    fn it_should_handle_zero_value() {
+        let counter = Counter::new(0);
+        assert_eq!(counter.value(), 0);
+        assert_eq!(counter.primitive(), 0);
+    }
+
+    #[test]
+    fn it_should_handle_large_values() {
+        let counter = Counter::new(u64::MAX);
+        assert_eq!(counter.value(), u64::MAX);
+    }
+
+    #[test]
+    fn it_should_handle_u32_max_conversion() {
+        let counter: Counter = u32::MAX.into();
+        assert_eq!(counter.value(), u64::from(u32::MAX));
+    }
+
+    #[test]
+    fn it_should_handle_i32_max_conversion() {
+        let counter: Counter = i32::MAX.into();
+        assert_eq!(counter.value(), i32::MAX as u64);
+    }
+
+    #[test]
+    fn it_should_handle_negative_i32_conversion() {
+        let counter: Counter = (-42i32).into();
+        #[allow(clippy::cast_sign_loss)]
+        let expected = (-42i32) as u64;
+        assert_eq!(counter.value(), expected);
+    }
+
+    #[test]
+    fn it_should_handle_i32_min_conversion() {
+        let counter: Counter = i32::MIN.into();
+        #[allow(clippy::cast_sign_loss)]
+        let expected = i32::MIN as u64;
+        assert_eq!(counter.value(), expected);
+    }
+
+    #[test]
+    fn it_should_handle_large_increments() {
+        let mut counter = Counter::new(100);
+        counter.increment(1000);
+        assert_eq!(counter.value(), 1100);
+
+        counter.increment(u64::MAX - 1100);
+        assert_eq!(counter.value(), u64::MAX);
+    }
+
+    #[test]
+    fn it_should_support_multiple_absolute_operations() {
+        let mut counter = Counter::new(0);
+
+        counter.absolute(100);
+        assert_eq!(counter.value(), 100);
+
+        counter.absolute(50);
+        assert_eq!(counter.value(), 50);
+
+        counter.absolute(0);
+        assert_eq!(counter.value(), 0);
+    }
+
+    #[test]
+    fn it_should_be_displayable() {
+        let counter = Counter::new(42);
+        assert_eq!(counter.to_string(), "42");
+
+        let counter = Counter::new(0);
+        assert_eq!(counter.to_string(), "0");
+    }
+
+    #[test]
+    fn it_should_be_debuggable() {
+        let counter = Counter::new(42);
+        let debug_string = format!("{counter:?}");
+        assert_eq!(debug_string, "Counter(42)");
+    }
+
+    #[test]
+    fn it_should_be_cloneable() {
+        let counter = Counter::new(42);
+        let cloned_counter = counter.clone();
+        assert_eq!(counter, cloned_counter);
+        assert_eq!(counter.value(), cloned_counter.value());
+    }
+
+    #[test]
+    fn it_should_support_equality_comparison() {
+        let counter1 = Counter::new(42);
+        let counter2 = Counter::new(42);
+        let counter3 = Counter::new(43);
+
+        assert_eq!(counter1, counter2);
+        assert_ne!(counter1, counter3);
+    }
+
+    #[test]
+    fn it_should_have_default_value() {
+        let counter = Counter::default();
+        assert_eq!(counter.value(), 0);
+    }
+
+    #[test]
+    fn it_should_handle_conversion_roundtrip() {
+        let original_value = 12345u64;
+        let counter = Counter::from(original_value);
+        let converted_back: u64 = counter.into();
+        assert_eq!(original_value, converted_back);
+    }
+
+    #[test]
+    fn it_should_handle_u32_conversion_roundtrip() {
+        let original_value = 12345u32;
+        let counter = Counter::from(original_value);
+        assert_eq!(counter.value(), u64::from(original_value));
+    }
+
+    #[test]
+    fn it_should_handle_i32_conversion_roundtrip() {
+        let original_value = 12345i32;
+        let counter = Counter::from(original_value);
+        #[allow(clippy::cast_sign_loss)]
+        let expected = original_value as u64;
+        assert_eq!(counter.value(), expected);
+    }
+
+    #[test]
+    fn it_should_serialize_large_values_to_prometheus() {
+        let counter = Counter::new(u64::MAX);
+        assert_eq!(counter.to_prometheus(), u64::MAX.to_string());
+
+        let counter = Counter::new(0);
+        assert_eq!(counter.to_prometheus(), "0");
+    }
 }