136 lines
3.3 KiB
Rust
136 lines
3.3 KiB
Rust
use crate::{
|
|
field::Field,
|
|
queue::{Message, QueueClient},
|
|
};
|
|
use std::sync::mpsc::{Receiver, Sender};
|
|
|
|
#[derive(Debug)]
|
|
pub struct Document {
|
|
session: Field,
|
|
content: Field,
|
|
}
|
|
|
|
impl Document {
|
|
pub fn new(session: Field, content: Field) -> Self {
|
|
Self {
|
|
session: session,
|
|
content: content,
|
|
}
|
|
}
|
|
|
|
/// Get the session id information.
|
|
pub fn get_session(&self) -> String {
|
|
self.session.to_string()
|
|
}
|
|
|
|
/// Get the requested content.
|
|
pub fn get_content(&self) -> String {
|
|
self.content.to_string()
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod documeents {
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn create_response() {
|
|
let id = "something";
|
|
let txt = "stuff";
|
|
let res = Document::new(id.into(), txt.into());
|
|
match res.session {
|
|
Field::Static(data) => assert_eq!(data, id),
|
|
_ => unreachable!("wrong field type"),
|
|
}
|
|
match res.content {
|
|
Field::Static(data) => assert_eq!(data, txt),
|
|
_ => unreachable!("wrong field type"),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn get_id_string() {
|
|
let id = "id";
|
|
let doc = "content";
|
|
let reply = Document::new(id.into(), doc.into());
|
|
assert_eq!(reply.get_session(), id);
|
|
assert_eq!(reply.get_content(), doc);
|
|
}
|
|
|
|
#[test]
|
|
fn get_id_content() {
|
|
let id = "session";
|
|
let doc = "stuff";
|
|
let reply = Document::new(id.into(), doc.into());
|
|
assert_eq!(reply.get_session(), id);
|
|
assert_eq!(reply.get_content(), doc);
|
|
}
|
|
}
|
|
|
|
pub struct DocumentBuilder {
|
|
_tx: Sender<Message>,
|
|
rx: Receiver<Message>,
|
|
}
|
|
|
|
impl QueueClient for DocumentBuilder {
|
|
fn new(tx: Sender<Message>, rx: Receiver<Message>) -> Self {
|
|
Self {
|
|
_tx: tx,
|
|
rx: rx,
|
|
}
|
|
}
|
|
|
|
fn get_receiver(&self) -> &Receiver<Message> {
|
|
&self.rx
|
|
}
|
|
|
|
fn listen(&self) {
|
|
let rx = self.get_receiver();
|
|
loop {
|
|
match rx.recv().unwrap() {
|
|
Message::Req(data) => {
|
|
//data.get_sender().send(Document::new("id".into(), "stuff".into())).unwrap();
|
|
let doc = Document::new("id".into(), "stuff".into());
|
|
data.send(doc);
|
|
},
|
|
_ => {},
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod builders {
|
|
use crate::request_test_data::request_root_document;
|
|
use std::sync::mpsc::{channel, TryRecvError};
|
|
use super::*;
|
|
|
|
fn run_service() -> (Sender<Message>, Receiver<Message>) {
|
|
let (tx, rx) = channel();
|
|
let service_tx: Sender<Message>;
|
|
DocumentBuilder::start(tx);
|
|
match rx.recv().unwrap() {
|
|
Message::Register(result) => service_tx = result,
|
|
_ => unreachable!("should register the service"),
|
|
}
|
|
(service_tx, rx)
|
|
}
|
|
|
|
#[test]
|
|
fn get_document() {
|
|
let (tx, rx) = run_service();
|
|
let (msg, msg_rx) = request_root_document();
|
|
tx.send(msg.into()).unwrap();
|
|
match rx.try_recv() {
|
|
Ok(_) => unreachable!("nothing should go back to the queue"),
|
|
Err(err) => {
|
|
match err {
|
|
TryRecvError::Empty => {},
|
|
_ => unreachable!("channel should still be open"),
|
|
}
|
|
},
|
|
}
|
|
msg_rx.recv().unwrap();
|
|
}
|
|
}
|