test: [torrust#1403] add more tests to metrics pkg

Author: josecelano

packages/metrics/.gitignore

@@ -0,0 +1 @@
+./.coverage

packages/metrics/README.md

@@ -6,6 +6,10 @@ A library with the metrics types used by the [Torrust Tracker](https://github.co
 
 [Crate documentation](https://docs.rs/torrust-tracker-metrics).
 
+## 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.
+
 ## License
 
 The project is licensed under the terms of the [GNU AFFERO GENERAL PUBLIC LICENSE](./LICENSE).

packages/metrics/src/counter.rs

@@ -1,8 +1,9 @@
+use derive_more::Display;
 use serde::{Deserialize, Serialize};
 
 use super::prometheus::PrometheusSerializable;
 
-#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, Display, Clone, Default, PartialEq, Serialize, Deserialize)]
 pub struct Counter(u64);
 
 impl Counter {
@@ -44,14 +45,37 @@ mod tests {
     use super::*;
 
     #[test]
-    fn test_counter() {
-        let mut counter = Counter::new(0);
+    fn it_should_be_created_from_integer_values() {
+        let counter = Counter::new(0);
         assert_eq!(counter.value(), 0);
+    }
 
-        counter.increment(5);
-        assert_eq!(counter.value(), 5);
+    #[test]
+    fn it_could_be_converted_from_u64() {
+        let counter: Counter = 42.into();
+        assert_eq!(counter.value(), 42);
+    }
+
+    #[test]
+    fn it_could_be_converted_into_u64() {
+        let counter = Counter::new(42);
+        let value: u64 = counter.into();
+        assert_eq!(value, 42);
+    }
 
-        counter.increment(3);
-        assert_eq!(counter.value(), 8);
+    #[test]
+    fn it_could_be_incremented() {
+        let mut counter = Counter::new(0);
+        counter.increment(1);
+        assert_eq!(counter.value(), 1);
+
+        counter.increment(2);
+        assert_eq!(counter.value(), 3);
+    }
+
+    #[test]
+    fn it_serializes_to_prometheus() {
+        let counter = Counter::new(42);
+        assert_eq!(counter.to_prometheus(), "42");
     }
 }

packages/metrics/src/gauge.rs

@@ -1,8 +1,9 @@
+use derive_more::Display;
 use serde::{Deserialize, Serialize};
 
 use super::prometheus::PrometheusSerializable;
 
-#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, Display, Clone, Default, PartialEq, Serialize, Deserialize)]
 pub struct Gauge(f64);
 
 impl Gauge {
@@ -46,14 +47,37 @@ mod tests {
     use super::*;
 
     #[test]
-    fn test_gauge() {
-        let mut gauge = Gauge::new(0.0);
+    fn it_should_be_created_from_integer_values() {
+        let gauge = Gauge::new(0.0);
         assert_relative_eq!(gauge.value(), 0.0);
+    }
 
-        gauge.set(5.5);
-        assert_relative_eq!(gauge.value(), 5.5);
+    #[test]
+    fn it_could_be_converted_from_u64() {
+        let gauge: Gauge = 42.0.into();
+        assert_relative_eq!(gauge.value(), 42.0);
+    }
+
+    #[test]
+    fn it_could_be_converted_into_i64() {
+        let gauge = Gauge::new(42.0);
+        let value: f64 = gauge.into();
+        assert_relative_eq!(value, 42.0);
+    }
+
+    #[test]
+    fn it_could_be_set() {
+        let mut gauge = Gauge::new(0.0);
+        gauge.set(1.0);
+        assert_relative_eq!(gauge.value(), 1.0);
+    }
+
+    #[test]
+    fn it_serializes_to_prometheus() {
+        let counter = Gauge::new(42.0);
+        assert_eq!(counter.to_prometheus(), "42");
 
-        gauge.set(3.3);
-        assert_relative_eq!(gauge.value(), 3.3);
+        let counter = Gauge::new(42.1);
+        assert_eq!(counter.to_prometheus(), "42.1");
     }
 }

packages/metrics/src/label/pair.rs

@@ -3,15 +3,27 @@ use crate::prometheus::PrometheusSerializable;
 
 pub type LabelPair = (LabelName, LabelValue);
 
-impl PrometheusSerializable for LabelPair {
+// Generic implementation for any tuple (A, B) where A and B implement PrometheusSerializable
+impl<A: PrometheusSerializable, B: PrometheusSerializable> PrometheusSerializable for (A, B) {
     fn to_prometheus(&self) -> String {
-        let (name, value) = self;
-        format!("{}=\"{}\"", name.to_prometheus(), value.to_prometheus())
+        format!("{}=\"{}\"", self.0.to_prometheus(), self.1.to_prometheus())
     }
 }
 
-impl PrometheusSerializable for (&LabelName, &LabelValue) {
-    fn to_prometheus(&self) -> String {
-        format!("{}=\"{}\"", self.0.to_prometheus(), self.1.to_prometheus())
+#[cfg(test)]
+mod tests {
+    mod serialization_of_label_pair_to_prometheus {
+        use super::super::LabelName;
+        use crate::label::LabelValue;
+        use crate::prometheus::PrometheusSerializable;
+
+        #[test]
+        fn test_label_pair_serialization_to_prometheus() {
+            let label_pair = (LabelName::new("label_name"), LabelValue::new("value"));
+            assert_eq!(label_pair.to_prometheus(), r#"label_name="value""#);
+
+            let label_pair = (&LabelName::new("label_name"), &LabelValue::new("value"));
+            assert_eq!(label_pair.to_prometheus(), r#"label_name="value""#);
+        }
     }
 }

packages/metrics/src/label/set.rs

@@ -12,21 +12,18 @@ pub struct LabelSet {
 }
 
 impl LabelSet {
+    /// Insert a new label pair or update the value of an existing label.
     pub fn upsert(&mut self, key: LabelName, value: LabelValue) {
         self.items.insert(key, value);
     }
-
-    pub fn iter(&self) -> impl Iterator<Item = (&LabelName, &LabelValue)> {
-        self.items.iter()
-    }
 }
 
 impl Display for LabelSet {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         let items = self
             .items
             .iter()
-            .map(|(key, value)| format!("{key}={value}"))
+            .map(|(key, value)| format!("{key}=\"{value}\""))
             .collect::<Vec<_>>()
             .join(",");
 
@@ -40,6 +37,30 @@ impl From<BTreeMap<LabelName, LabelValue>> for LabelSet {
     }
 }
 
+impl From<Vec<(&str, &str)>> for LabelSet {
+    fn from(vec: Vec<(&str, &str)>) -> Self {
+        let mut items = BTreeMap::new();
+
+        for (name, value) in vec {
+            items.insert(LabelName::new(name), LabelValue::new(value));
+        }
+
+        Self { items }
+    }
+}
+
+impl From<Vec<(String, String)>> for LabelSet {
+    fn from(vec: Vec<(String, String)>) -> Self {
+        let mut items = BTreeMap::new();
+
+        for (name, value) in vec {
+            items.insert(LabelName::new(&name), LabelValue::new(&value));
+        }
+
+        Self { items }
+    }
+}
+
 impl From<Vec<LabelPair>> for LabelSet {
     fn from(vec: Vec<LabelPair>) -> Self {
         let mut items = BTreeMap::new();
@@ -71,6 +92,26 @@ impl<const N: usize> From<[LabelPair; N]> for LabelSet {
     }
 }
 
+impl<const N: usize> From<[(String, String); N]> for LabelSet {
+    fn from(arr: [(String, String); N]) -> Self {
+        let values = arr
+            .iter()
+            .map(|(name, value)| (LabelName::new(name), LabelValue::new(value)))
+            .collect::<BTreeMap<_, _>>();
+        Self { items: values }
+    }
+}
+
+impl<const N: usize> From<[(&str, &str); N]> for LabelSet {
+    fn from(arr: [(&str, &str); N]) -> Self {
+        let values = arr
+            .iter()
+            .map(|(name, value)| (LabelName::new(name), LabelValue::new(value)))
+            .collect::<BTreeMap<_, _>>();
+        Self { items: values }
+    }
+}
+
 impl From<LabelPair> for LabelSet {
     fn from(label_pair: LabelPair) -> Self {
         let mut set = BTreeMap::new();
@@ -280,13 +321,20 @@ mod tests {
     #[test]
     fn it_should_alphabetically_order_labels_in_prometheus_format() {
         let label_set = LabelSet::from([
-            (LabelName::new("label_name_b"), LabelValue::new("label value b")),
-            (LabelName::new("label_name_a"), LabelValue::new("label value a")),
+            (LabelName::new("b_label_name"), LabelValue::new("b label value")),
+            (LabelName::new("a_label_name"), LabelValue::new("a label value")),
         ]);
 
         assert_eq!(
             label_set.to_prometheus(),
-            r#"{label_name_a="label value a",label_name_b="label value b"}"#
+            r#"{a_label_name="a label value",b_label_name="b label value"}"#
         );
     }
+
+    #[test]
+    fn it_should_allow_displaying() {
+        let label_set = LabelSet::from((LabelName::new("label_name"), LabelValue::new("label value")));
+
+        assert_eq!(label_set.to_string(), r#"{label_name="label value"}"#);
+    }
 }

packages/metrics/src/label/value.rs

@@ -18,3 +18,15 @@ impl PrometheusSerializable for LabelValue {
         self.0.clone()
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::label::value::LabelValue;
+    use crate::prometheus::PrometheusSerializable;
+
+    #[test]
+    fn it_serializes_to_prometheus() {
+        let label_value = LabelValue::new("value");
+        assert_eq!(label_value.to_prometheus(), "value");
+    }
+}

packages/metrics/src/lib.rs

@@ -6,4 +6,18 @@ pub mod metric_collection;
 pub mod prometheus;
 pub mod sample;
 pub mod sample_collection;
+pub mod thread_safe_metric_collection;
 pub mod unit;
+
+#[cfg(test)]
+mod tests {
+    /// It removes leading and trailing whitespace from each line, and empty lines.
+    pub fn format_prometheus_output(output: &str) -> String {
+        output
+            .lines()
+            .map(str::trim)
+            .filter(|line| !line.is_empty())
+            .collect::<Vec<_>>()
+            .join("\n")
+    }
+}

packages/metrics/src/metric/description.rs

@@ -10,3 +10,20 @@ impl MetricDescription {
         Self(name.to_owned())
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn it_should_be_created_from_a_string_reference() {
+        let metric = MetricDescription::new("Metric description");
+        assert_eq!(metric.0, "Metric description");
+    }
+
+    #[test]
+    fn it_should_be_displayed() {
+        let metric = MetricDescription::new("Metric description");
+        assert_eq!(metric.to_string(), "Metric description");
+    }
+}