test

wg-event-gen/src/gen.rs

@@ -73,3 +73,104 @@ pub(crate) fn gen_events(
         }
     }
 }
+
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use crate::listener::*;
+    use crate::*;
+    use std::cell::RefCell;
+    use std::collections::{HashMap, HashSet};
+    use std::env;
+    use std::fmt;
+    use std::io::prelude::*;
+    use std::io::{BufRead, BufReader, Error, ErrorKind, Result};
+    use std::net::SocketAddr;
+    use std::os::unix::net::UnixStream;
+    use std::path::PathBuf;
+    use std::{thread, time};
+
+    struct TestListener {
+        calls: RefCell<Vec<String>>,
+    }
+    impl TestListener {
+        fn new() -> TestListener {
+            Self::from(RefCell::new(vec![]))
+        }
+
+        fn from(calls: RefCell<Vec<String>>) -> TestListener {
+            TestListener { calls: calls }
+        }
+    }
+    impl EventListener for TestListener {
+        fn added<'a>(&self, peer: &'a Peer) {
+            self.calls
+                .borrow_mut()
+                .push(format!("add {}", peer.public_key));
+        }
+
+        fn connected<'a>(&self, peer: &'a Peer) {
+            self.calls
+                .borrow_mut()
+                .push(format!("con {}", peer.public_key));
+        }
+
+        fn disconnected<'a>(&self, peer: &'a Peer) {
+            self.calls
+                .borrow_mut()
+                .push(format!("dis {}", peer.public_key));
+        }
+
+        fn removed<'a>(&self, peer: &'a Peer) {
+            self.calls
+                .borrow_mut()
+                .push(format!("rem {}", peer.public_key));
+        }
+
+        fn roaming<'a>(&self, peer: &'a Peer, previous_addr: SocketAddr) {
+            self.calls
+                .borrow_mut()
+                .push(format!("rom {}", peer.public_key));
+        }
+    }
+
+    fn listeners() -> (Vec<Box<EventListener>>, RefCell<Vec<String>>) {
+        let calls: RefCell<Vec<String>> = RefCell::new(vec![]);
+        (
+            vec![
+                Box::new(TestListener::from(calls.clone())),
+                Box::new(LogListener),
+            ],
+            calls.clone(),
+        )
+    }
+
+    fn b2h(b: &str) -> String {
+        hex::encode(base64::decode(b).unwrap())
+    }
+
+    #[test]
+    fn connected() {
+        let bkey = "HhRgEL2xsnEIqThSTUKLGaTXusorM1MFdjSSYvzBynY=";
+        let key = b2h(bkey);
+        let prev: HashMap<String, Peer> = HashMap::new();
+        let mut cur: HashMap<String, Peer> = HashMap::new();
+        cur.insert(
+            key.clone(),
+            Peer::from_kv(&vec![
+                ("public_key".to_string(), key.clone()),
+                (
+                    "last_handshake_time_nsec".to_string(),
+                    (1000 * 1000 * 1).to_string(),
+                ),
+                ("endpoint".to_string(), "1.1.1.1:22222".to_string()),
+            ])
+            .unwrap(),
+        );
+        let (listeners, calls) = listeners();
+        gen_events(&cur, &prev, &listeners, time::Duration::from_secs(3));
+        assert_eq!(vec![["con", bkey].join(" ")], calls.borrow().clone());
+    }
+
+}