Migrate all testing code to prost

Signed-off-by: Folyd <[email protected]>

Author: Folyd

src/counter.rs

@@ -343,9 +343,9 @@ mod tests {
         assert_eq!(mfs.len(), 1);
 
         let mf = mfs.pop().unwrap();
-        let m = mf.get_metric().get(0).unwrap();
-        assert_eq!(m.get_label().len(), 2);
-        assert_eq!(m.get_counter().get_value() as u64, 43);
+        let m = mf.metric.get(0).unwrap();
+        assert_eq!(m.label.len(), 2);
+        assert_eq!(m.counter.as_ref().unwrap().value.unwrap_or(0.0) as u64, 43);
 
         counter.reset();
         assert_eq!(counter.get() as u64, 0);
@@ -363,9 +363,9 @@ mod tests {
         assert_eq!(mfs.len(), 1);
 
         let mf = mfs.pop().unwrap();
-        let m = mf.get_metric().get(0).unwrap();
-        assert_eq!(m.get_label().len(), 0);
-        assert_eq!(m.get_counter().get_value() as u64, 12);
+        let m = mf.metric.get(0).unwrap();
+        assert_eq!(m.label.len(), 0);
+        assert_eq!(m.counter.as_ref().unwrap().value.unwrap_or(0.0) as u64, 12);
 
         counter.reset();
         assert_eq!(counter.get() as u64, 0);

src/encoder/mod.rs

@@ -67,7 +67,7 @@ mod tests {
         let mut mfs = cv.collect();
 
         // Empty name
-        (&mut mfs[0]).clear_name();
+        (&mut mfs[0]).name.take();
         check_metric_family(&mfs[0]).unwrap_err();
         pb_encoder.encode(&mfs, &mut writer).unwrap_err();
         assert_eq!(writer.len(), 0);
@@ -94,7 +94,7 @@ mod tests {
         let mut mfs = cv.collect();
 
         // Empty name
-        (&mut mfs[0]).clear_name();
+        (&mut mfs[0]).name.take();
         check_metric_family(&mfs[0]).unwrap_err();
         text_encoder.encode(&mfs, &mut writer).unwrap_err();
         assert_eq!(writer.len(), 0);

src/encoder/text.rs

@@ -401,7 +401,7 @@ test_histogram_count{a="1"} 1
         let mut metric_family = MetricFamily::default();
         metric_family.name = Some("test_summary".to_string());
         metric_family.help = Some("This is a test summary statistic".to_string());
-        metric_family.r#type = Some(MetricType::Summary);
+        metric_family.r#type = Some(MetricType::Summary.into());
 
         let mut summary = Summary::default();
         summary.sample_count = Some(5.0 as u64);

src/gauge.rs

@@ -188,9 +188,9 @@ mod tests {
         assert_eq!(mfs.len(), 1);
 
         let mf = mfs.pop().unwrap();
-        let m = mf.get_metric().get(0).unwrap();
-        assert_eq!(m.get_label().len(), 2);
-        assert_eq!(m.get_gauge().get_value() as u64, 42);
+        let m = mf.metric.get(0).unwrap();
+        assert_eq!(m.label.len(), 2);
+        assert_eq!(m.gauge.as_ref().unwrap().value.unwrap_or(0.0) as u64, 42);
     }
 
     #[test]

src/histogram.rs

@@ -1236,12 +1236,12 @@ mod tests {
         assert_eq!(mfs.len(), 1);
 
         let mf = mfs.pop().unwrap();
-        let m = mf.get_metric().get(0).unwrap();
-        assert_eq!(m.get_label().len(), 2);
-        let proto_histogram = m.get_histogram();
-        assert_eq!(proto_histogram.get_sample_count(), 3);
-        assert!(proto_histogram.get_sample_sum() >= 1.5);
-        assert_eq!(proto_histogram.get_bucket().len(), DEFAULT_BUCKETS.len());
+        let m = mf.metric.get(0).unwrap();
+        assert_eq!(m.label.len(), 2);
+        let proto_histogram = m.histogram.as_ref().unwrap();
+        assert_eq!(proto_histogram.sample_count.unwrap_or(0), 3);
+        assert!(proto_histogram.sample_sum.unwrap_or(0.0) >= 1.5);
+        assert_eq!(proto_histogram.bucket.len(), DEFAULT_BUCKETS.len());
 
         let buckets = vec![1.0, 2.0, 3.0];
         let opts = HistogramOpts::new("test2", "test help").buckets(buckets.clone());
@@ -1250,12 +1250,12 @@ mod tests {
         assert_eq!(mfs.len(), 1);
 
         let mf = mfs.pop().unwrap();
-        let m = mf.get_metric().get(0).unwrap();
-        assert_eq!(m.get_label().len(), 0);
-        let proto_histogram = m.get_histogram();
-        assert_eq!(proto_histogram.get_sample_count(), 0);
-        assert!((proto_histogram.get_sample_sum() - 0.0) < EPSILON);
-        assert_eq!(proto_histogram.get_bucket().len(), buckets.len())
+        let m = mf.metric.get(0).unwrap();
+        assert_eq!(m.label.len(), 0);
+        let proto_histogram = m.histogram.as_ref().unwrap();
+        assert_eq!(proto_histogram.sample_count.unwrap_or(0), 0);
+        assert!((proto_histogram.sample_sum.unwrap_or(0.0) - 0.0) < EPSILON);
+        assert_eq!(proto_histogram.bucket.len(), buckets.len())
     }
 
     #[test]
@@ -1400,12 +1400,12 @@ mod tests {
         histogram.observe(1.0);
 
         let m = histogram.metric();
-        assert_eq!(m.get_label().len(), labels.len());
+        assert_eq!(m.label.len(), labels.len());
 
-        let proto_histogram = m.get_histogram();
-        assert_eq!(proto_histogram.get_sample_count(), 1);
-        assert!((proto_histogram.get_sample_sum() - 1.0) < EPSILON);
-        assert_eq!(proto_histogram.get_bucket().len(), buckets.len())
+        let proto_histogram = m.histogram.unwrap();
+        assert_eq!(proto_histogram.sample_count.unwrap_or(0), 1);
+        assert!((proto_histogram.sample_sum.unwrap_or(0.0) - 1.0) < EPSILON);
+        assert_eq!(proto_histogram.bucket.len(), buckets.len())
     }
 
     #[test]
@@ -1418,9 +1418,9 @@ mod tests {
 
         let check = |count, sum| {
             let m = histogram.metric();
-            let proto_histogram = m.get_histogram();
-            assert_eq!(proto_histogram.get_sample_count(), count);
-            assert!((proto_histogram.get_sample_sum() - sum) < EPSILON);
+            let proto_histogram = m.histogram.unwrap();
+            assert_eq!(proto_histogram.sample_count.unwrap_or(0), count);
+            assert!((proto_histogram.sample_sum.unwrap_or(0.0) - sum) < EPSILON);
         };
 
         local.observe(1.0);
@@ -1452,10 +1452,10 @@ mod tests {
         local_vec.remove_label_values(&["v1", "v2"]).unwrap_err();
 
         let check = |count, sum| {
-            let ms = vec.collect()[0].take_metric();
-            let proto_histogram = ms[0].get_histogram();
-            assert_eq!(proto_histogram.get_sample_count(), count);
-            assert!((proto_histogram.get_sample_sum() - sum) < EPSILON);
+            let ms = &vec.collect()[0].metric;
+            let proto_histogram = &ms[0].histogram.as_ref().unwrap();
+            assert_eq!(proto_histogram.sample_count.unwrap_or(0), count);
+            assert!((proto_histogram.sample_sum.unwrap_or(0.0) - sum) < EPSILON);
         };
 
         {
@@ -1509,13 +1509,13 @@ mod tests {
         let mut cumulative_count = 0;
         let mut sample_sum = 0;
         for _ in 0..1_000_000 {
-            let metric = &histogram.collect()[0].take_metric()[0];
-            let proto = metric.get_histogram();
+            let metric = &histogram.collect()[0].metric[0];
+            let proto = metric.histogram.as_ref().unwrap();
 
-            sample_count = proto.get_sample_count();
-            sample_sum = proto.get_sample_sum() as u64;
+            sample_count = proto.sample_count.unwrap_or(0);
+            sample_sum = proto.sample_sum.unwrap_or(0.0) as u64;
             // There is only one bucket thus the `[0]`.
-            cumulative_count = proto.get_bucket()[0].get_cumulative_count();
+            cumulative_count = proto.bucket[0].cumulative_count.unwrap_or(0);
 
             if sample_count != cumulative_count {
                 break;

src/metrics.rs

@@ -221,8 +221,8 @@ mod tests {
 
     fn new_label_pair(name: &str, value: &str) -> LabelPair {
         let mut l = LabelPair::default();
-        l.set_name(name.to_owned());
-        l.set_value(value.to_owned());
+        l.name = Some(name.to_owned());
+        l.value = Some(value.to_owned());
         l
     }
 

src/registry.rs

@@ -416,9 +416,9 @@ mod tests {
 
         let mfs = r.gather();
         assert_eq!(mfs.len(), 3);
-        assert_eq!(mfs[0].get_name(), "test_2_counter");
-        assert_eq!(mfs[1].get_name(), "test_a_counter");
-        assert_eq!(mfs[2].get_name(), "test_b_counter");
+        assert_eq!(mfs[0].name, Some("test_2_counter".into()));
+        assert_eq!(mfs[1].name, Some("test_a_counter".into()));
+        assert_eq!(mfs[2].name, Some("test_b_counter".into()));
 
         let r = Registry::new();
         let opts = Opts::new("test", "test help")
@@ -470,12 +470,12 @@ mod tests {
 
         let mfs = r.gather();
         assert_eq!(mfs.len(), 1);
-        let ms = mfs[0].get_metric();
+        let ms = &mfs[0].metric;
         assert_eq!(ms.len(), 4);
-        assert_eq!(ms[0].get_counter().get_value() as u64, 2);
-        assert_eq!(ms[1].get_counter().get_value() as u64, 1);
-        assert_eq!(ms[2].get_counter().get_value() as u64, 3);
-        assert_eq!(ms[3].get_counter().get_value() as u64, 4);
+        assert_eq!(ms[0].counter.as_ref().unwrap().value.unwrap() as u64, 2);
+        assert_eq!(ms[1].counter.as_ref().unwrap().value.unwrap() as u64, 1);
+        assert_eq!(ms[2].counter.as_ref().unwrap().value.unwrap() as u64, 3);
+        assert_eq!(ms[3].counter.as_ref().unwrap().value.unwrap() as u64, 4);
     }
 
     #[test]
@@ -488,7 +488,7 @@ mod tests {
 
         let mfs = r.gather();
         assert_eq!(mfs.len(), 1);
-        assert_eq!(mfs[0].get_name(), "common_prefix_test_a_counter");
+        assert_eq!(mfs[0].name, Some("common_prefix_test_a_counter".into()));
     }
 
     #[test]
@@ -508,19 +508,19 @@ mod tests {
 
         let mfs = r.gather();
         assert_eq!(mfs.len(), 2);
-        assert_eq!(mfs[0].get_name(), "test_a_counter");
-        assert_eq!(mfs[1].get_name(), "test_vec");
+        assert_eq!(mfs[0].name, Some("test_a_counter".into()));
+        assert_eq!(mfs[1].name, Some("test_vec".into()));
 
         let mut needle = proto::LabelPair::default();
-        needle.set_name("tkey".to_string());
-        needle.set_value("tvalue".to_string());
-        let metrics = mfs[0].get_metric();
+        needle.name = Some("tkey".to_string());
+        needle.value = Some("tvalue".to_string());
+        let metrics = &mfs[0].metric;
         for m in metrics {
-            assert!(m.get_label().contains(&needle));
+            assert!(m.label.contains(&needle));
         }
-        let metrics = mfs[1].get_metric();
+        let metrics = &mfs[1].metric;
         for m in metrics {
-            assert!(m.get_label().contains(&needle));
+            assert!(m.label.contains(&needle));
         }
     }
 

src/vec.rs

@@ -425,10 +425,13 @@ mod tests {
         labels.insert("c", "a");
         let c = vec.get_metric_with(&labels).unwrap();
         let m = c.metric();
-        let label_pairs = m.get_label();
+        let label_pairs = m.label;
         assert_eq!(label_pairs.len(), labels.len());
         for lp in label_pairs.iter() {
-            assert_eq!(lp.get_value(), labels[lp.get_name()]);
+            assert_eq!(
+                lp.value.as_ref().unwrap(),
+                labels[lp.name.as_ref().unwrap().as_str()]
+            );
         }
     }
 }