Removed old code.
Some checks failed
Gitea Actions Demo / Explore-Gitea-Actions (push) Failing after 1s
Some checks failed
Gitea Actions Demo / Explore-Gitea-Actions (push) Failing after 1s
This commit is contained in:
348
src/document.rs
348
src/document.rs
@@ -1,348 +0,0 @@
|
||||
use crate::{
|
||||
queue::{Message, MsgType, Queue},
|
||||
ActionType, ErrorType,
|
||||
};
|
||||
use serde_json::Value;
|
||||
use std::{
|
||||
collections::HashMap,
|
||||
sync::mpsc::{channel, Receiver},
|
||||
thread::spawn,
|
||||
};
|
||||
|
||||
const RESPONDS_TO: [MsgType; 1] = [MsgType::DocumentRequest];
|
||||
|
||||
struct Table;
|
||||
|
||||
impl Table {
|
||||
fn new() -> Self {
|
||||
Self {}
|
||||
}
|
||||
|
||||
fn add_column(&self) {}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tables {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn create_table() {
|
||||
let tbl = Table::new();
|
||||
tbl.add_column();
|
||||
}
|
||||
}
|
||||
|
||||
pub struct Document {
|
||||
data: HashMap<String, String>,
|
||||
queue: Queue,
|
||||
rx: Receiver<Message>,
|
||||
}
|
||||
|
||||
impl Document {
|
||||
fn new(queue: Queue, rx: Receiver<Message>) -> Self {
|
||||
let mut data = HashMap::new();
|
||||
data.insert("root".to_string(), "Something goes here.".to_string());
|
||||
Self {
|
||||
data: data,
|
||||
queue: queue,
|
||||
rx: rx,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn start(queue: Queue) {
|
||||
let (tx, rx) = channel();
|
||||
let mut document = Document::new(queue, rx);
|
||||
document.queue.add(tx, RESPONDS_TO.to_vec());
|
||||
spawn(move || {
|
||||
document.listen();
|
||||
});
|
||||
}
|
||||
|
||||
fn listen(&mut self) {
|
||||
loop {
|
||||
let msg = self.rx.recv().unwrap();
|
||||
match msg.get_data("action") {
|
||||
Some(action_field) => {
|
||||
let action = action_field.to_action().unwrap();
|
||||
match action {
|
||||
ActionType::Add | ActionType::Update => self.add(action, msg),
|
||||
_ => self.get(msg),
|
||||
}
|
||||
}
|
||||
None => self.get(msg),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn add(&mut self, action: ActionType, msg: Message) {
|
||||
let name = msg.get_data("name").unwrap().to_string();
|
||||
match self.data.get(&name) {
|
||||
Some(_) => match action {
|
||||
ActionType::Add => {
|
||||
self.queue
|
||||
.send(msg.reply_with_error(ErrorType::DocumentAlreadyExists))
|
||||
.unwrap();
|
||||
return;
|
||||
}
|
||||
ActionType::Update => {}
|
||||
_ => unreachable!("listen should prevent anything else"),
|
||||
},
|
||||
None => match action {
|
||||
ActionType::Add => {}
|
||||
ActionType::Update => {
|
||||
self.queue
|
||||
.send(msg.reply_with_error(ErrorType::DocumentNotFound))
|
||||
.unwrap();
|
||||
return;
|
||||
}
|
||||
_ => unreachable!("listen should prevent anything else"),
|
||||
},
|
||||
}
|
||||
let doc: Value = match serde_json::from_str(&msg.get_data("doc").unwrap().to_string()) {
|
||||
Ok(value) => value,
|
||||
Err(_) => {
|
||||
self.queue
|
||||
.send(msg.reply_with_error(ErrorType::DocumentInvalidRequest))
|
||||
.unwrap();
|
||||
return;
|
||||
}
|
||||
};
|
||||
let reply = match doc["template"].as_str() {
|
||||
Some(content) => {
|
||||
self.data.insert(name, content.to_string());
|
||||
msg.reply(MsgType::ActionOk)
|
||||
}
|
||||
None => msg.reply_with_error(ErrorType::DocumentInvalidRequest),
|
||||
};
|
||||
self.queue.send(reply).unwrap();
|
||||
}
|
||||
|
||||
fn get(&self, msg: Message) {
|
||||
let name = match msg.get_data("name") {
|
||||
Some(doc) => doc.to_string(),
|
||||
None => "root".to_string(),
|
||||
};
|
||||
let reply = match self.data.get(&name) {
|
||||
Some(data) => {
|
||||
let mut holder = msg.reply(MsgType::Document);
|
||||
holder.add_data("doc", data.clone());
|
||||
holder
|
||||
}
|
||||
None => msg.reply_with_error(ErrorType::DocumentNotFound),
|
||||
};
|
||||
self.queue.send(reply).unwrap();
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
pub mod documents {
|
||||
use super::*;
|
||||
use serde_json::json;
|
||||
use std::time::Duration;
|
||||
use uuid::Uuid;
|
||||
|
||||
const TIMEOUT: Duration = Duration::from_millis(500);
|
||||
|
||||
fn setup_document() -> (Queue, Receiver<Message>) {
|
||||
let queue = Queue::new();
|
||||
let (tx, rx) = channel();
|
||||
queue.add(
|
||||
tx,
|
||||
[MsgType::ActionOk, MsgType::Document, MsgType::Error].to_vec(),
|
||||
);
|
||||
Document::start(queue.clone());
|
||||
(queue, rx)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn start_service() {
|
||||
let (queue, rx) = setup_document();
|
||||
let id = Uuid::new_v4();
|
||||
let mut msg = Message::new(MsgType::DocumentRequest);
|
||||
msg.add_data("sess_id", id.clone());
|
||||
queue.send(msg.clone()).unwrap();
|
||||
let reply = rx.recv_timeout(TIMEOUT).unwrap();
|
||||
assert_eq!(reply.get_id(), msg.get_id());
|
||||
match reply.get_msg_type() {
|
||||
MsgType::Document => {}
|
||||
_ => unreachable!("got {:?} should have gotten document", msg.get_msg_type()),
|
||||
}
|
||||
assert!(reply.get_data("doc").is_some());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn no_existing_document() {
|
||||
let (queue, rx) = setup_document();
|
||||
let name = format!("name-{}", Uuid::new_v4());
|
||||
let mut msg = Message::new(MsgType::DocumentRequest);
|
||||
msg.add_data("name", name.clone());
|
||||
queue.send(msg.clone()).unwrap();
|
||||
let reply = rx.recv_timeout(TIMEOUT).unwrap();
|
||||
assert_eq!(reply.get_id(), msg.get_id());
|
||||
match reply.get_msg_type() {
|
||||
MsgType::Error => {}
|
||||
_ => unreachable!("got {:?}: shoud have been error", reply.get_msg_type()),
|
||||
}
|
||||
match reply.get_data("error_type") {
|
||||
Some(err) => match err.to_error_type().unwrap() {
|
||||
ErrorType::DocumentNotFound => {}
|
||||
_ => unreachable!("got {:?}: should have been document not found'", err),
|
||||
},
|
||||
None => unreachable!("should contain error type"),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn root_always_exists() {
|
||||
let (queue, rx) = setup_document();
|
||||
let mut msg = Message::new(MsgType::DocumentRequest);
|
||||
msg.add_data("name", "root");
|
||||
queue.send(msg).unwrap();
|
||||
let reply = rx.recv_timeout(TIMEOUT).unwrap();
|
||||
match reply.get_msg_type() {
|
||||
MsgType::Document => {}
|
||||
_ => unreachable!(
|
||||
"Got '{:?}': should have been a document",
|
||||
reply.get_msg_type()
|
||||
),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn add_new_document() {
|
||||
let (queue, rx) = setup_document();
|
||||
let name = format!("name-{}", Uuid::new_v4());
|
||||
let content = format!("content-{}", Uuid::new_v4());
|
||||
let input = json!({
|
||||
"template": content.clone()
|
||||
});
|
||||
let mut msg1 = Message::new(MsgType::DocumentRequest);
|
||||
msg1.add_data("name", name.clone());
|
||||
msg1.add_data("action", ActionType::Add);
|
||||
msg1.add_data("doc", input.to_string());
|
||||
queue.send(msg1.clone()).unwrap();
|
||||
let reply1 = rx.recv_timeout(TIMEOUT).unwrap();
|
||||
assert_eq!(reply1.get_id(), msg1.get_id());
|
||||
match reply1.get_msg_type() {
|
||||
MsgType::ActionOk => {}
|
||||
_ => unreachable!(
|
||||
"got {:?}: should have received action ok",
|
||||
reply1.get_msg_type()
|
||||
),
|
||||
}
|
||||
let mut msg2 = Message::new(MsgType::DocumentRequest);
|
||||
msg2.add_data("name", name.clone());
|
||||
msg2.add_data("action", ActionType::Get);
|
||||
queue.send(msg2.clone()).unwrap();
|
||||
let reply2 = rx.recv_timeout(TIMEOUT).unwrap();
|
||||
assert_eq!(reply2.get_id(), msg2.get_id());
|
||||
match reply2.get_msg_type() {
|
||||
MsgType::Document => {}
|
||||
_ => unreachable!(
|
||||
"got {:?}: should have received document",
|
||||
reply2.get_msg_type()
|
||||
),
|
||||
}
|
||||
assert_eq!(reply2.get_data("doc").unwrap().to_string(), content);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn add_does_not_overwrite_existing() {
|
||||
let (queue, rx) = setup_document();
|
||||
let mut holder = Message::new(MsgType::DocumentRequest);
|
||||
holder.add_data("name", "root");
|
||||
holder.add_data("action", ActionType::Get);
|
||||
queue.send(holder.clone()).unwrap();
|
||||
let binding = rx.recv_timeout(TIMEOUT).unwrap();
|
||||
let expected = binding.get_data("doc").unwrap();
|
||||
let input = json!({
|
||||
"template": format!("content-{}", Uuid::new_v4())
|
||||
});
|
||||
let mut msg = Message::new(MsgType::DocumentRequest);
|
||||
msg.add_data("name", "root");
|
||||
msg.add_data("action", ActionType::Add);
|
||||
msg.add_data("doc", input.to_string());
|
||||
queue.send(msg.clone()).unwrap();
|
||||
let reply = rx.recv_timeout(TIMEOUT).unwrap();
|
||||
assert_eq!(reply.get_id(), msg.get_id());
|
||||
match reply.get_msg_type() {
|
||||
MsgType::Error => {}
|
||||
_ => unreachable!(
|
||||
"got '{:?}': should have received document",
|
||||
reply.get_msg_type()
|
||||
),
|
||||
}
|
||||
match reply.get_data("error_type") {
|
||||
Some(err) => match err.to_error_type().unwrap() {
|
||||
ErrorType::DocumentAlreadyExists => {}
|
||||
_ => unreachable!("got {:?}: should have been document not found'", err),
|
||||
},
|
||||
None => unreachable!("should contain error type"),
|
||||
}
|
||||
queue.send(holder).unwrap();
|
||||
let binding = rx.recv_timeout(TIMEOUT).unwrap();
|
||||
let result = binding.get_data("doc").unwrap();
|
||||
assert_eq!(result.to_string(), expected.to_string());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn invalid_json() {
|
||||
let inputs = ["Invalid json request.", "{}"];
|
||||
let (queue, rx) = setup_document();
|
||||
for input in inputs.into_iter() {
|
||||
let mut msg = Message::new(MsgType::DocumentRequest);
|
||||
msg.add_data("action", ActionType::Add);
|
||||
msg.add_data("name", "doc");
|
||||
msg.add_data("doc", input);
|
||||
queue.send(msg.clone()).unwrap();
|
||||
let reply = match rx.recv_timeout(TIMEOUT) {
|
||||
Ok(data) => data,
|
||||
Err(err) => {
|
||||
assert!(false, "got '{}' with the following json: '{}'", err, input);
|
||||
Message::new(MsgType::Error)
|
||||
}
|
||||
};
|
||||
assert_eq!(reply.get_id(), msg.get_id());
|
||||
match reply.get_msg_type() {
|
||||
MsgType::Error => {}
|
||||
_ => unreachable!(
|
||||
"got '{:?}': should have received document",
|
||||
reply.get_msg_type()
|
||||
),
|
||||
}
|
||||
match reply.get_data("error_type") {
|
||||
Some(err) => match err.to_error_type().unwrap() {
|
||||
ErrorType::DocumentInvalidRequest => {}
|
||||
_ => unreachable!("got {:?}: should have been bad request'", err),
|
||||
},
|
||||
None => unreachable!("should contain error type"),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn patch_nonexistant_page() {
|
||||
let (queue, rx) = setup_document();
|
||||
let input = json!({
|
||||
"template": "Sothing here"
|
||||
});
|
||||
let mut msg = Message::new(MsgType::DocumentRequest);
|
||||
msg.add_data("action", ActionType::Update);
|
||||
msg.add_data("name", "something");
|
||||
msg.add_data("doc", input.to_string());
|
||||
queue.send(msg.clone()).unwrap();
|
||||
let reply = rx.recv_timeout(TIMEOUT).unwrap();
|
||||
assert_eq!(reply.get_id(), msg.get_id());
|
||||
match reply.get_msg_type() {
|
||||
MsgType::Error => {}
|
||||
_ => unreachable!("got {:?}: shoud have been error", reply.get_msg_type()),
|
||||
}
|
||||
match reply.get_data("error_type") {
|
||||
Some(err) => match err.to_error_type().unwrap() {
|
||||
ErrorType::DocumentNotFound => {}
|
||||
_ => unreachable!("got {:?}: should have been document not found'", err),
|
||||
},
|
||||
None => unreachable!("should contain error type"),
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user