Whoa boy rust is a problem child

secert-hitler/src/config.rs

@@ -0,0 +1 @@
+pub static PORT:&str = ":8080";

secert-hitler/src/controller/gamemaster/gamemaster.rs

@@ -0,0 +1,23 @@
+#[derive(Debug)]
+pub struct GameMaster {
+   room_id: String,
+}
+
+impl GameMaster {
+   fn new() -> GameMaster {
+      GameMaster{
+         room_id: "hello".to_string(),
+      }
+   }
+}
+
+#[cfg(test)]
+mod tests {
+   use super::*;
+
+   #[test]
+   fn new() {
+      let gm = GameMaster::new();
+      println!("made: {:?}", gm);
+   }
+}

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

@@ -0,0 +1,19 @@
+#[derive(Clone, Debug)]
+pub struct Event {
+   pub sender: String,
+   pub body: String,
+   pub next: String,
+}
+
+#[cfg(test)]
+mod tests {
+   #[test]
+   fn event() {
+      let e = super::Event{
+         sender: "sender".to_string(),
+         body: "body".to_string(),
+         next: "next".to_string(),
+      };
+      println!("{:?}", e);
+   }
+}

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");
+   }
+}

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

@@ -0,0 +1,89 @@
+use super::rooms::Rooms;
+use super::room::Room;
+use super::mockroom::MockRoom;
+
+// #[derive(Clone, Debug)]
+pub struct MockRooms {
+   rooms: Vec<MockRoom>,
+}
+
+impl MockRooms {
+   pub fn new() -> MockRooms {
+      MockRooms {
+         rooms: vec![],
+      }
+   }
+}
+
+impl Rooms for MockRooms {
+   fn create(&mut self) -> Box<dyn Room> {
+      let room = MockRoom::create();
+      let _room = room.room();
+      self.rooms.push(room);
+      Box::new(_room)
+   }
+
+   fn join(&self, room_id: String) -> Result<Box<dyn Room>, &str> {
+      for r in &self.rooms {
+         if r.room_id() == room_id {
+            return Ok(Box::new(r.room()));
+         }
+      }
+      Err("not found")
+   }
+}
+
+#[cfg(test)]
+mod tests {
+   use super::MockRooms;
+   use super::MockRoom;
+   use super::Rooms;
+
+   fn _dummy() -> MockRooms {
+      let mut mrs = MockRooms::new();
+      for i in 0..5 {
+         let random = MockRoom::create();
+         mrs.rooms.push(random);
+         let joined = MockRoom::join(i.to_string());
+         mrs.rooms.push(joined);
+      }
+      assert!(mrs.rooms.len() == 10);
+      mrs
+   }
+
+   #[test]
+   fn mockrooms() {
+      let mrs = MockRooms::new();
+      assert!(mrs.rooms.len() == 0);
+   }
+
+   #[test]
+   fn create() {
+      let mut mrs = _dummy();
+      let was = mrs.rooms.len();
+      let _ = mrs.create();
+      let is = mrs.rooms.len();
+      assert!(was+1 == is, "was {} rooms, want {} rooms, got {} rooms", was, was+1, is);
+   }
+
+   #[test]
+   fn join_404() {
+      let mrs = _dummy();
+      let was = mrs.rooms.len();
+      let r = mrs.join("does not exist".to_string());
+      let is = mrs.rooms.len();
+      assert!(was == is, "was {} rooms, want {} rooms, got {} rooms", was, was+1, is);
+      assert!(!r.is_ok());
+   }
+
+   #[test]
+   fn join_found() {
+      let mrs = _dummy();
+      let was = mrs.rooms.len();
+      let r = mrs.join("0".to_string());
+      let is = mrs.rooms.len();
+      assert!(was == is, "was {} rooms, want {} rooms, got {} rooms", was, was+1, is);
+      assert!(r.is_ok());
+      assert!(r.ok().unwrap().room_id() == "0");
+   }
+}

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

@@ -0,0 +1,14 @@
+use super::event;
+
+pub trait Room {
+   fn sync(&mut self) -> Vec<event::Event>;
+   fn send(&mut self, message: String) -> Result<&str, &str>;
+   fn room_id(&self) -> String;
+}
+
+#[cfg(test)]
+mod tests {
+   #[test]
+   fn room() {
+   }
+}

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

@@ -0,0 +1,13 @@
+use super::room::Room;
+
+pub trait Rooms {
+   fn create(&mut self) -> Box<dyn Room>;
+   fn join(&self, room_id: String) -> Result<Box<dyn Room>, &str>;
+}
+
+#[cfg(test)]
+mod tests {
+   #[test]
+   fn rooms() {
+   }
+}

secert-hitler/src/main.rs

@@ -0,0 +1,11 @@
+mod config;
+#[path = "./controller/gamemaster/gamemaster.rs"] mod gamemaster;
+#[path = "./controller/state/event.rs"] mod event;
+#[path = "./controller/state/room.rs"] mod room;
+#[path = "./controller/state/rooms.rs"] mod rooms;
+#[path = "./controller/state/mockroom.rs"] mod mockroom;
+#[path = "./controller/state/mockrooms.rs"] mod mockrooms;
+
+fn main() {
+    println!("{}", config::PORT);
+}