Whoa boy rust is a problem child

secert-hitler/src/controller/state/mockroom.rs

@@ -0,0 +1,134 @@
+use super::room::Room;
+use super::event::Event;
+
+use rand::{self, Rng};
+use rand::distributions::Alphanumeric;
+
+#[derive(Clone, Debug)]
+pub struct MockRoom {
+   last: String,
+   room_id: String,
+   events: Vec<Event>,
+}
+
+impl MockRoom {
+   pub fn create() -> MockRoom {
+      MockRoom::join(rands()) 
+   }
+
+   pub fn join(room_id: String) -> MockRoom {
+      MockRoom {
+         last: "".to_string(),
+         room_id: room_id,
+         events: vec![],
+      }
+   }
+
+   pub fn room(&self) -> impl Room {
+      self.clone()
+   }
+}
+
+impl Room for MockRoom {
+   fn sync(&mut self) -> Vec<Event> {
+      let mut unseen: Vec<Event> = vec![];
+      let mut last = self.last.clone();
+      for e in &self.events {
+         if e.next == self.last {
+            unseen.clear();
+         } else {
+            unseen.push(e.clone());
+            last = e.next.clone();
+         }
+      }
+      self.last = last;
+      return unseen;
+   }
+
+   fn send(&mut self, message: String) -> Result<&str, &str> {
+      let e = Event{
+         sender: rands(),
+         next: rands(),
+         body: message,
+      };
+      self.events.push(e);
+      Ok("ok")
+   }
+
+   fn room_id(&self) -> String {
+      self.room_id.clone()
+   }
+}
+
+pub fn rands() -> String {
+   rand::thread_rng()
+      .sample_iter(&Alphanumeric)
+      .take(10)
+      .collect::<String>()
+}
+
+#[cfg(test)]
+mod tests {
+   use super::Room;
+   use super::MockRoom;
+   use super::Event;
+   use super::rands;
+
+   fn _dummy() -> MockRoom {
+      let mut r = MockRoom::create();
+      r.last = "1".to_string();
+      r.events = vec![];
+      for i in 0..5 {
+         r.events.push(Event{
+            sender: i.to_string(), 
+            next: i.to_string(), 
+            body: i.to_string(),
+         });
+      }
+      r
+   }
+
+   #[test]
+   fn randstest() {
+      let a = rands();
+      let b = rands();
+      assert!(a != b, "a == {} == b == {}", a, b);
+   }
+
+   #[test]
+   fn create() {
+      let mut r: MockRoom = MockRoom::create();
+      println!("{:?}", r.sync());
+   }
+
+   #[test]
+   fn join() {
+      let rid = "a".to_string();
+      let r: MockRoom = MockRoom::join(rid.to_string());
+      assert!(r.room_id == rid);
+   }
+
+   #[test]
+   fn sync() {
+      let mut r = _dummy();
+      let events = r.sync();
+      assert!(events.len() == 3, "want {}, got {}: {:?}", 3, events.len(), events);
+      assert!(events[0].sender == "2");
+      assert!(events[0].body == "2");
+      assert!(events[0].next == "2");
+      assert!(r.last == "4", "want last==4, got {}", r.last);
+   }
+
+   #[test]
+   fn send() {
+      let mut r = _dummy();
+      let message = "message".to_string();
+      r.sync();
+      assert!(r.send(message.clone()).ok().unwrap() == "ok");
+      assert!(r.last == "4");
+      let events = r.sync();
+      assert!(events.len() == 1);
+      assert!(events[0].body == message, "want {}, got {}: {:?}", message, events[0].body, events);
+      assert!(r.last != "4");
+   }
+}