diff --git a/src/action.rs b/src/action.rs new file mode 100644 index 0000000..aff88fd --- /dev/null +++ b/src/action.rs @@ -0,0 +1,3 @@ +mod query; + +pub use query::Query; diff --git a/src/action/query.rs b/src/action/query.rs new file mode 100644 index 0000000..39b266c --- /dev/null +++ b/src/action/query.rs @@ -0,0 +1,81 @@ +use crate::{message::wrapper::Calculation, name::NameType}; +use std::collections::{HashMap, HashSet}; + +#[derive(Clone, Debug)] +pub struct Query { + data: HashMap, +} + +impl Query { + pub fn new() -> Self { + Self { + data: HashMap::new(), + } + } + + pub fn add(&mut self, name: NT, operation: Calculation) + where + NT: Into, + { + self.data.insert(name.into(), operation); + } + + #[allow(dead_code)] + fn get(&self, name: NT) -> Option + where + NT: Into, + { + match self.data.get(&name.into()) { + Some(calc) => Some(calc.clone()), + None => None, + } + } + + #[allow(dead_code)] + fn field_ids(&self) -> HashSet<&NameType> { + self.data.keys().collect() + } + + pub fn iter(&self) -> impl Iterator { + self.data.iter() + } +} + +#[cfg(test)] +mod queries { + use super::*; + use crate::{document::field::Field, message::wrapper::Operand, name::Name}; + use uuid::Uuid; + + #[test] + fn holds_calculation_to_run_query() { + let name = Name::english(Uuid::new_v4().to_string().as_str()); + let data = Uuid::new_v4(); + let mut bad_data = data.clone(); + while bad_data == data { + bad_data = Uuid::new_v4(); + } + let mut query = Query::new(); + let mut calc = Calculation::new(Operand::Equal); + calc.add_value(data.clone()).unwrap(); + query.add(name.clone(), calc); + match query.get(&name) { + Some(op) => { + let expected: Field = true.into(); + let mut holder = op.clone(); + holder.add_value(data).unwrap(); + assert_eq!(holder.calculate(&Field::None), expected); + } + None => unreachable!("should have returned a calculation"), + } + match query.get(&name) { + Some(op) => { + let expected: Field = false.into(); + let mut holder = op.clone(); + holder.add_value(bad_data).unwrap(); + assert_eq!(holder.calculate(&Field::None), expected); + } + None => unreachable!("should have returned a calculation"), + } + } +} diff --git a/src/document/clock.rs b/src/document/clock.rs index fcc1a39..c3c512f 100644 --- a/src/document/clock.rs +++ b/src/document/clock.rs @@ -29,7 +29,10 @@ impl Clock { } fn gen_message() -> Message { - Message::new(Clock::get_name(), MsgAction::OnUpdate(Records::new(Names::new()))) + Message::new( + Clock::get_name(), + MsgAction::OnUpdate(Records::new(Names::new())), + ) } pub fn get_path() -> Path { diff --git a/src/document/create.rs b/src/document/create.rs index 70a5987..5de713e 100644 --- a/src/document/create.rs +++ b/src/document/create.rs @@ -1,4 +1,5 @@ use crate::{ + action::Query, document::{ definition::{DocDef, DocFuncType}, field::Field, @@ -6,8 +7,8 @@ use crate::{ message::{ action::{Action, MsgAction}, wrapper::{ - CalcValue, Calculation, InternalRecord, InternalRecords, Message, Oid, Query, Records, - Reply, Update, + CalcValue, Calculation, InternalRecord, InternalRecords, Message, Oid, Records, Reply, + Update, }, }, mtterror::MTTError, diff --git a/src/document/definition.rs b/src/document/definition.rs index 1b8b02a..6681028 100644 --- a/src/document/definition.rs +++ b/src/document/definition.rs @@ -382,7 +382,7 @@ impl DocDef { #[cfg(test)] mod docdefs { use super::*; - use crate::message::wrapper::{Query, Update}; + use crate::{action::Query, message::wrapper::Update}; #[test] fn can_field_be_added() { diff --git a/src/document/field.rs b/src/document/field.rs index 248b735..a3bc8e3 100644 --- a/src/document/field.rs +++ b/src/document/field.rs @@ -435,6 +435,10 @@ impl Revision { fn new() -> Self { Self {} } + + fn revision(&self) -> isize { + 0 + } } #[cfg(test)] @@ -444,5 +448,6 @@ mod revisions { #[test] fn can_create_empty_revision() { let rev = Revision::new(); + assert_eq!(rev.revision(), 0); } } diff --git a/src/document/session.rs b/src/document/session.rs index 32a5784..68e5e13 100644 --- a/src/document/session.rs +++ b/src/document/session.rs @@ -1,4 +1,5 @@ use crate::{ + action::Query, document::{ clock::Clock, create::IndexType, @@ -7,7 +8,7 @@ use crate::{ }, message::{ action::Action, - wrapper::{CalcValue, Calculation, Delete, Message, Operand, Query, Update}, + wrapper::{CalcValue, Calculation, Delete, Message, Operand, Update}, }, name::{Name, NameType}, queue::{ @@ -88,10 +89,15 @@ impl Session { mod sessions { use super::*; use crate::{ - document::{clock::{Clock, clock_test_support::gen_clock_message}, create::CreateDoc, field::Field}, + action::Query, + document::{ + clock::{clock_test_support::gen_clock_message, Clock}, + create::CreateDoc, + field::Field, + }, message::{ action::MsgAction, - wrapper::{Addition, Query, Records}, + wrapper::{Addition, Records}, }, mtterror::MTTError, name::{Name, NameType, Names}, diff --git a/src/lib.rs b/src/lib.rs index 76ec6d4..37cdc07 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -1,21 +1,24 @@ -mod document; +pub mod action; +pub mod document; mod message; mod mtterror; mod name; mod queue; +use action::Query; use document::{ clock::Clock, create::CreateDoc, + definition::DocDef, field::{Field, FieldType}, session::Session, }; use message::{ action::{Action, MsgAction}, - wrapper::{Addition, CalcValue, Calculation, Message, Operand, Query}, + wrapper::{Addition, CalcValue, Calculation, Message, Operand}, }; pub use mtterror::MTTError; -use name::{Name, NameType}; +pub use name::{Name, NameType}; use queue::{ data_director::{Include, Path, RegMsg, Register}, router::Queue, @@ -30,6 +33,17 @@ mod support_tests { pub static TIMEOUT: Duration = Duration::from_millis(500); } +enum UserAction { + CreateDocument(DocDef), + Query(Query), +} + +impl From for UserAction { + fn from(value: DocDef) -> Self { + Self::CreateDocument(value) + } +} + #[derive(Clone)] pub struct MoreThanText { queue: Queue, @@ -105,6 +119,16 @@ impl MoreThanText { output } + pub fn request(&mut self, req: UA) + where + UA: Into, + { + } + + pub fn create_document(&mut self, docdef: DocDef) -> Result<(), MTTError> { + Ok(()) + } + pub fn get_document(&self, name: &str, id: &str) -> Result { if name == "page" { Ok("something".to_string()) diff --git a/src/message/action.rs b/src/message/action.rs index e0ab67b..ad5a1bc 100644 --- a/src/message/action.rs +++ b/src/message/action.rs @@ -1,8 +1,10 @@ use crate::{ + action::Query, document::definition::DocDef, - message::wrapper::{Addition, Delete, Query, Records, Reply, Update}, + message::wrapper::{Addition, Delete, Records, Reply, Update}, mtterror::MTTError, queue::data_director::Register, + UserAction, }; #[derive(Clone, Debug, Eq, Hash, PartialEq)] @@ -123,6 +125,15 @@ impl From for MsgAction { } } +impl From for MsgAction { + fn from(value: UserAction) -> Self { + match value { + UserAction::CreateDocument(data) => Self::Create(data), + UserAction::Query(data) => Self::Query(data), + } + } +} + #[cfg(test)] mod msgactions { use super::*; diff --git a/src/message/wrapper.rs b/src/message/wrapper.rs index 4510851..e053f80 100644 --- a/src/message/wrapper.rs +++ b/src/message/wrapper.rs @@ -1,4 +1,5 @@ use crate::{ + action::Query, document::field::{Field, FieldType}, message::action::MsgAction, mtterror::MTTError, @@ -1008,84 +1009,6 @@ impl From> for QueryType { } } -#[derive(Clone, Debug)] -pub struct Query { - data: HashMap, -} - -impl Query { - pub fn new() -> Self { - Self { - data: HashMap::new(), - } - } - - pub fn add(&mut self, name: NT, operation: Calculation) - where - NT: Into, - { - self.data.insert(name.into(), operation); - } - - #[allow(dead_code)] - fn get(&self, name: NT) -> Option - where - NT: Into, - { - match self.data.get(&name.into()) { - Some(calc) => Some(calc.clone()), - None => None, - } - } - - #[allow(dead_code)] - fn field_ids(&self) -> HashSet<&NameType> { - self.data.keys().collect() - } - - pub fn iter(&self) -> impl Iterator { - self.data.iter() - } -} - -#[cfg(test)] -mod queries { - use super::*; - use crate::name::Name; - - #[test] - fn holds_calculation_to_run_query() { - let name = Name::english(Uuid::new_v4().to_string().as_str()); - let data = Uuid::new_v4(); - let mut bad_data = data.clone(); - while bad_data == data { - bad_data = Uuid::new_v4(); - } - let mut query = Query::new(); - let mut calc = Calculation::new(Operand::Equal); - calc.add_value(data.clone()).unwrap(); - query.add(name.clone(), calc); - match query.get(&name) { - Some(op) => { - let expected: Field = true.into(); - let mut holder = op.clone(); - holder.add_value(data).unwrap(); - assert_eq!(holder.calculate(&Field::None), expected); - } - None => unreachable!("should have returned a calculation"), - } - match query.get(&name) { - Some(op) => { - let expected: Field = false.into(); - let mut holder = op.clone(); - holder.add_value(bad_data).unwrap(); - assert_eq!(holder.calculate(&Field::None), expected); - } - None => unreachable!("should have returned a calculation"), - } - } -} - #[allow(dead_code)] #[derive(Clone, Debug)] pub struct Reply { diff --git a/src/queue/router.rs b/src/queue/router.rs index a305043..7c8d5c9 100644 --- a/src/queue/router.rs +++ b/src/queue/router.rs @@ -96,11 +96,7 @@ impl Queue { #[cfg(test)] mod routers { use super::*; - use crate::{ - message::{action::MsgAction, wrapper::Query}, - name::Name, - support_tests::TIMEOUT, - }; + use crate::{action::Query, message::action::MsgAction, name::Name, support_tests::TIMEOUT}; use std::{ collections::HashSet, sync::mpsc::{Receiver, RecvTimeoutError}, diff --git a/tests/lib_document_test.rs b/tests/lib_document_test.rs index bc24e51..d9baaaa 100644 --- a/tests/lib_document_test.rs +++ b/tests/lib_document_test.rs @@ -1,19 +1,15 @@ -use morethantext::{MTTError, MoreThanText}; - -#[test] -fn get_home_page() { - let mtt = MoreThanText::new(); - match mtt.get_document("page", "home") { - Ok(_) => {} - Err(err) => assert!(false, "got error {:?}", err), - } -} +use morethantext::{ + action::Query, + document::{definition::DocDef, field::FieldType}, + MTTError, MoreThanText, Name, +}; +use uuid::Uuid; #[test] fn errors_on_missing_page() { let mtt = MoreThanText::new(); let doc_name = "missing"; - match mtt.get_document(doc_name, "home") { + match mtt.get_document(doc_name, "something") { Ok(data) => assert!(false, "got '{}', should have been not found error", data), Err(err) => match err { MTTError::DocumentNotFound(result) => assert_eq!(result, doc_name), @@ -21,3 +17,13 @@ fn errors_on_missing_page() { }, } } + +#[test] +fn can_create_document() { + let mut mtt = MoreThanText::new(); + let doc_name = Name::english(Uuid::new_v4().to_string().as_str()); + let mut docdef = DocDef::new(doc_name.clone()); + let field_name = Name::english(Uuid::new_v4().to_string().as_str()); + docdef.add_field(field_name.clone(), FieldType::Uuid); + mtt.request(docdef); +}