tests(all): add preliminary tests

Author: omarabid

src/backends/mod.rs

@@ -9,7 +9,7 @@ use crate::Result;
 use std::fmt::Debug;
 
 /// Backend State 
-#[derive(Clone, Copy, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq)]
 pub enum State {
     Uninitialized,
     Ready,

src/error.rs

@@ -11,7 +11,7 @@ use thiserror::Error;
 pub type Result<T> = std::result::Result<T, PyroscopeError>;
 
 /// Error type of Pyroscope
-#[derive(Error, Debug)]
+#[derive(Error, Debug, PartialEq)]
 pub struct PyroscopeError {
     pub msg: String,
 }

src/timer/sleep.rs

@@ -6,7 +6,10 @@
 
 use crate::Result;
 
-use std::sync::{mpsc::Sender, Arc, Mutex};
+use std::sync::{
+    mpsc::{channel, Receiver, Sender},
+    Arc, Mutex,
+};
 use std::time::Duration;
 use std::{thread, thread::JoinHandle};
 

src/utils.rs

@@ -30,13 +30,12 @@ pub fn merge_tags_with_app_name(
 }
 
 #[cfg(test)]
-mod tests {
+mod merge_tags_with_app_name_tests {
     use std::collections::HashMap;
 
     use crate::utils::merge_tags_with_app_name;
 
     #[test]
-
     fn merge_tags_with_app_name_with_tags() {
         let mut tags = HashMap::new();
         tags.insert("env".to_string(), "staging".to_string());
@@ -63,3 +62,18 @@ pub fn check_err<T: Ord + Default>(num: T) -> Result<T> {
     }
     Ok(num)
 }
+
+#[cfg(test)]
+mod check_err_tests {
+    use crate::utils::check_err;
+
+    #[test]
+    fn check_err_success() {
+        assert_eq!(check_err(1).unwrap(), 1)
+    }
+
+    #[test]
+    fn check_err_error() {
+        assert!(check_err(-1).is_err())
+    }
+}

tests/agent.rs

@@ -0,0 +1,38 @@
+use pyroscope::pyroscope::PyroscopeConfig;
+
+#[test]
+fn test_PyroscopeConfig_new() {
+    let config = PyroscopeConfig::new("http://localhost:8080", "myapp");
+    assert_eq!(config.url, "http://localhost:8080");
+    assert_eq!(config.application_name, "myapp");
+    assert_eq!(config.sample_rate, 100i32);
+    assert_eq!(config.tags.len(), 0);
+}
+
+#[test]
+fn test_PyroscopeConfig_sample_rate() {
+    let config = PyroscopeConfig::new("http://localhost:8080", "myapp").sample_rate(10);
+    assert_eq!(config.sample_rate, 10i32);
+}
+
+#[test]
+fn test_PyroscopeConfig_tags_empty() {
+    let config = PyroscopeConfig::new("http://localhost:8080", "myapp");
+    assert_eq!(config.tags.len(), 0);
+}
+
+#[test]
+fn test_PyroscopeConfig_tags() {
+    let config = PyroscopeConfig::new("http://localhost:8080", "myapp").tags(&[("tag", "value")]);
+    assert_eq!(config.tags.len(), 1);
+    assert_eq!(config.tags.get("tag"), Some(&"value".to_owned()));
+}
+
+#[test]
+fn test_PyroscopeConfig_tags_multiple() {
+    let config = PyroscopeConfig::new("http://localhost:8080", "myapp")
+        .tags(&[("tag1", "value1"), ("tag2", "value2")]);
+    assert_eq!(config.tags.len(), 2);
+    assert_eq!(config.tags.get("tag1"), Some(&"value1".to_owned()));
+    assert_eq!(config.tags.get("tag2"), Some(&"value2".to_owned()));
+}

tests/backends.rs

@@ -0,0 +1,6 @@
+use pyroscope::backends::{State};
+
+#[test]
+fn test_state_default() {
+    assert_eq!(State::default(), State::Uninitialized);
+}

tests/session.rs

@@ -0,0 +1,57 @@
+use pyroscope::{
+    pyroscope::PyroscopeConfig,
+    session::{Session, SessionManager, SessionSignal},
+    PyroscopeError,
+};
+use std::{
+    collections::HashMap,
+    sync::mpsc::{sync_channel, Receiver, SyncSender},
+    thread,
+    thread::JoinHandle,
+};
+
+#[test]
+fn test_session_manager_new() {
+    let session_manager = SessionManager::new().unwrap();
+    assert!(session_manager.handle.is_some());
+}
+
+#[test]
+fn test_session_manager_push_kill() {
+    let session_manager = SessionManager::new().unwrap();
+    session_manager.push(SessionSignal::Kill).unwrap();
+    assert_eq!(session_manager.handle.unwrap().join().unwrap().unwrap(), ());
+}
+
+#[test]
+fn test_session_new() {
+    let config = PyroscopeConfig {
+        url: "http://localhost:8080".to_string(),
+        application_name: "test".to_string(),
+        tags: HashMap::new(),
+        sample_rate: 100,
+    };
+
+    let report = vec![1, 2, 3];
+
+    let session = Session::new(1950, config, report).unwrap();
+
+    assert_eq!(session.from, 1940);
+    assert_eq!(session.until, 1950);
+}
+
+#[test]
+fn test_session_send_error() {
+    let config = PyroscopeConfig {
+        url: "http://invalid_url".to_string(),
+        application_name: "test".to_string(),
+        tags: HashMap::new(),
+        sample_rate: 100,
+    };
+
+    let report = vec![1, 2, 3];
+
+    let session = Session::new(1950, config, report).unwrap();
+
+    // TODO: to figure this out
+}

tests/timer-epoll.rs

@@ -0,0 +1,85 @@
+#[cfg(target_os = "linux")]
+mod tests {
+    use pyroscope::timer::epoll::{
+        epoll_create1, epoll_ctl, epoll_wait, timerfd_create, timerfd_settime,
+    };
+
+    #[test]
+    fn test_timerfd_create() {
+        let timer_fd = timerfd_create(libc::CLOCK_REALTIME, libc::TFD_NONBLOCK).unwrap();
+        assert!(timer_fd > 0);
+    }
+
+    #[test]
+    fn test_timerfd_settime() {
+        let mut new_value = libc::itimerspec {
+            it_interval: libc::timespec {
+                tv_sec: 10,
+                tv_nsec: 0,
+            },
+            it_value: libc::timespec {
+                tv_sec: 0,
+                tv_nsec: 0,
+            },
+        };
+
+        let mut old_value = libc::itimerspec {
+            it_interval: libc::timespec {
+                tv_sec: 0,
+                tv_nsec: 0,
+            },
+            it_value: libc::timespec {
+                tv_sec: 0,
+                tv_nsec: 0,
+            },
+        };
+
+        let timer_fd = timerfd_create(libc::CLOCK_REALTIME, libc::TFD_NONBLOCK).unwrap();
+        let void = timerfd_settime(
+            timer_fd,
+            libc::TFD_TIMER_ABSTIME,
+            &mut new_value,
+            &mut old_value,
+        )
+        .unwrap();
+        assert!(void == ());
+    }
+
+    #[test]
+    fn test_epoll_create1() {
+        let epoll_fd = epoll_create1(0).unwrap();
+        assert!(epoll_fd > 0);
+    }
+
+    #[test]
+    fn test_epoll_ctl() {
+        let mut event = libc::epoll_event {
+            events: libc::EPOLLIN as u32,
+            u64: 1,
+        };
+
+        let epoll_fd = epoll_create1(0).unwrap();
+        let timer_fd = timerfd_create(libc::CLOCK_REALTIME, libc::TFD_NONBLOCK).unwrap();
+        let void = epoll_ctl(epoll_fd, libc::EPOLL_CTL_ADD, timer_fd, &mut event).unwrap();
+        assert!(void == ());
+    }
+
+    #[test]
+    fn test_epoll_wait() {
+        let mut event = libc::epoll_event {
+            events: libc::EPOLLIN as u32,
+            u64: 1,
+        };
+
+        let epoll_fd = epoll_create1(0).unwrap();
+        let timer_fd = timerfd_create(libc::CLOCK_REALTIME, libc::TFD_NONBLOCK).unwrap();
+        epoll_ctl(epoll_fd, libc::EPOLL_CTL_ADD, timer_fd, &mut event).unwrap();
+
+        let mut events = vec![libc::epoll_event { events: 0, u64: 0 }];
+
+        // Expire in 1ms
+        let void = epoll_wait(epoll_fd, events.as_mut_ptr(), 1, 1).unwrap();
+
+        assert!(void == ());
+    }
+}

tests/timer.rs

@@ -0,0 +1,26 @@
+use pyroscope::timer::Timer;
+
+#[test]
+fn test_timer() {
+    // Initialize Timer
+    let mut timer = Timer::default().initialize().unwrap();
+
+    // Attach a listener
+    let (tx, rx) = std::sync::mpsc::channel();
+    timer.attach_listener(tx).unwrap();
+
+    // Wait for event (should arrive in 10s)
+    let recv: u64 = rx.recv().unwrap();
+
+    // Get current time
+    let now = std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)
+        .unwrap()
+        .as_secs();
+
+    // Check that recv and now are within 10s of each other
+    assert!(recv - now < 10);
+
+    // Check that recv is divisible by 10
+    assert!(recv % 10 == 0);
+}