142 lines
3.0 KiB
Rust
142 lines
3.0 KiB
Rust
use super::room::Room;
|
|
use super::event::Event;
|
|
|
|
use rand::{self, Rng};
|
|
use rand::distributions::Alphanumeric;
|
|
use crossbeam_channel::{unbounded, Receiver, Sender};
|
|
|
|
#[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()
|
|
}
|
|
}
|
|
|
|
impl Drop for MockRoom {
|
|
fn drop(&mut self) {
|
|
println!("not impl");
|
|
}
|
|
}
|
|
|
|
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");
|
|
}
|
|
}
|