Merge pull request #2 from katanemo/further-abi-0.2.0-work

Add Stats testing functionality

Author: junr03

src/expectations.rs

@@ -86,6 +86,10 @@ pub struct Expect {
         Option<Duration>,
         Option<u32>,
     )>,
+    metrics_create: Vec<(i32, String)>,
+    metrics_increment: Vec<(i32, i64)>,
+    metrics_record: Vec<(i32, u64)>,
+    metrics_get: Vec<(i32, u64)>,
 }
 
 impl Expect {
@@ -106,6 +110,10 @@ impl Expect {
             add_header_map_value: vec![],
             send_local_response: vec![],
             http_call: vec![],
+            metrics_create: vec![],
+            metrics_increment: vec![],
+            metrics_record: vec![],
+            metrics_get: vec![],
         }
     }
 
@@ -571,4 +579,92 @@ impl Expect {
             }
         }
     }
+
+    pub fn set_expect_metric_create(&mut self, metric_type: i32, name: &str) {
+        self.expect_count += 1;
+        self.metrics_create.push((metric_type, name.to_string()));
+    }
+
+    pub fn get_expect_metric_create(&mut self, metric_type: i32, name: &str) {
+        match self.metrics_create.len() {
+            0 => {
+                if !self.allow_unexpected {
+                    self.expect_count -= 1;
+                }
+                set_status(ExpectStatus::Unexpected);
+            }
+            _ => {
+                self.expect_count -= 1;
+                let expected_metric_type = self.metrics_create.remove(0);
+                let expect_status = expected_metric_type == (metric_type, name.to_string());
+                set_expect_status(expect_status);
+            }
+        }
+    }
+
+    pub fn set_expect_metric_increment(&mut self, metric_id: i32, offset: i64) {
+        self.expect_count += 1;
+        self.metrics_increment.push((metric_id, offset));
+    }
+
+    pub fn get_expect_metric_increment(&mut self, metric_id: i32, offset: i64) {
+        match self.metrics_increment.len() {
+            0 => {
+                if !self.allow_unexpected {
+                    self.expect_count -= 1;
+                }
+                set_status(ExpectStatus::Unexpected);
+            }
+            _ => {
+                self.expect_count -= 1;
+                let expected_metric_increment_tuple = self.metrics_increment.remove(0);
+                let expect_status = expected_metric_increment_tuple == (metric_id, offset);
+                set_expect_status(expect_status);
+            }
+        }
+    }
+
+    pub fn set_expect_metric_record(&mut self, metric_id: i32, value: u64) {
+        self.expect_count += 1;
+        self.metrics_record.push((metric_id, value));
+    }
+
+    pub fn get_expect_metric_record(&mut self, metric_id: i32, value: u64) {
+        match self.metrics_record.len() {
+            0 => {
+                if !self.allow_unexpected {
+                    self.expect_count -= 1;
+                }
+                set_status(ExpectStatus::Unexpected);
+            }
+            _ => {
+                self.expect_count -= 1;
+                let expected_metric_record_tuple = self.metrics_record.remove(0);
+                let expect_status = expected_metric_record_tuple == (metric_id, value);
+                set_expect_status(expect_status);
+            }
+        }
+    }
+
+    pub fn set_expect_metric_get(&mut self, metric_id: i32, value: u64) {
+        self.expect_count += 1;
+        self.metrics_get.push((metric_id, value));
+    }
+
+    pub fn get_expect_metric_get(&mut self, metric_id: i32, value: u64) {
+        match self.metrics_get.len() {
+            0 => {
+                if !self.allow_unexpected {
+                    self.expect_count -= 1;
+                }
+                set_status(ExpectStatus::Unexpected);
+            }
+            _ => {
+                self.expect_count -= 1;
+                let expected_get_metric_tuple = self.metrics_get.remove(0);
+                let expect_status = expected_get_metric_tuple == (metric_id, value);
+                set_expect_status(expect_status);
+            }
+        }
+    }
 }

src/host_settings.rs

@@ -16,6 +16,8 @@ use crate::hostcalls::serial_utils::serialize_map;
 use crate::types::*;
 
 use std::collections::HashMap;
+use std::convert::TryFrom;
+use std::convert::TryInto;
 use std::time::Duration;
 
 // Global structure for handling default host behaviour (and high-level expectation setting)
@@ -48,6 +50,8 @@ pub struct HostSettings {
     tick_period_millis: Duration,
     header_map_pairs: HashMap<i32, Vec<(String, String)>>,
     buffer_bytes: HashMap<i32, Bytes>,
+    metrics_value: HashMap<i32, i64>,
+    metrics_ids: HashMap<String, i32>,
 }
 
 impl HostSettings {
@@ -59,6 +63,8 @@ impl HostSettings {
             tick_period_millis: Duration::new(0, 0),
             header_map_pairs: default_header_map_pairs(),
             buffer_bytes: default_buffer_bytes(),
+            metrics_value: HashMap::new(),
+            metrics_ids: HashMap::new(),
         }
     }
 
@@ -194,6 +200,32 @@ impl HostSettings {
         }
         self.header_map_pairs.insert(map_type, new_header_map);
     }
+
+    pub fn create_metric(&mut self, name: &str) -> i32 {
+        let metric_id: i32 = self.metrics_value.len().try_into().unwrap();
+        self.metrics_value.insert(metric_id, 0);
+        self.metrics_ids.insert(name.to_string(), metric_id);
+        metric_id
+    }
+
+    pub fn increment_metric(&mut self, metric_id: i32, offset: i64) {
+        let value = self.metrics_value.get_mut(&metric_id).unwrap();
+        *value += offset;
+    }
+
+    pub fn record_metric(&mut self, metric_id: i32, new_value: i64) {
+        let value = self.metrics_value.get_mut(&metric_id).unwrap();
+        *value = new_value;
+    }
+
+    pub fn get_metric(&self, metric_id: i32) -> u64 {
+        let value = *self.metrics_value.get(&metric_id).unwrap();
+        u64::try_from(value).unwrap()
+    }
+
+    pub fn get_metric_id(&self, name: &str) -> i32 {
+        *self.metrics_ids.get(name).unwrap()
+    }
 }
 
 // functions to retrieve default values