From 97df1a8ece990ff1c656f995e04dfbc64a8924f8 Mon Sep 17 00:00:00 2001 From: Jeff Baskin Date: Tue, 23 Dec 2025 22:15:49 -0500 Subject: [PATCH] Cleaned up the testing. --- src/lib.rs | 17 +- src/main.rs | 9 +- src/message.rs | 438 ++++++++++++++++++++++++++++++------------------- 3 files changed, 285 insertions(+), 179 deletions(-) diff --git a/src/lib.rs b/src/lib.rs index 40e6e89..4046b25 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -1,15 +1,11 @@ mod message; use message::{ - Action, Addition, CalcValue, Calculation, Clock, CreateDoc, Delete, DocDef, DocFuncType, Field, - FieldType, Include, IndexType, Message, Name, NameType, Operand, Path, Queue, RegMsg, Register, - Session, Update, + Action, Addition, CalcValue, Calculation, Clock, CreateDoc, Field, FieldType, Include, Message, + Name, NameType, Operand, Path, Queue, RegMsg, Register, Session, }; pub use message::{MsgAction, Query}; -use std::{ - sync::mpsc::{channel, Receiver}, - time::Duration, -}; +use std::sync::mpsc::{channel, Receiver}; use uuid::Uuid; #[derive(Clone)] @@ -19,7 +15,7 @@ pub struct MoreThanText { impl MoreThanText { pub fn new() -> Self { - let mut queue = Queue::new(); + let queue = Queue::new(); Clock::start(queue.clone()); CreateDoc::start(queue.clone()); let session = Session::new(); @@ -62,8 +58,9 @@ impl MoreThanText { Ok(id) => { let mut query = Query::new(); let mut calc = Calculation::new(Operand::Equal); - calc.add_value(CalcValue::Existing(FieldType::Uuid)); - calc.add_value(id); + calc.add_value(CalcValue::Existing(FieldType::Uuid)) + .unwrap(); + calc.add_value(id).unwrap(); query.add(Name::english("id"), calc); query.into() } diff --git a/src/main.rs b/src/main.rs index 296035d..58b15c9 100644 --- a/src/main.rs +++ b/src/main.rs @@ -52,6 +52,7 @@ async fn create_app(state: MoreThanText) -> Router { .with_state(state) } +#[allow(dead_code)] #[derive(Clone)] struct SessionID(Uuid); @@ -82,21 +83,21 @@ where } async fn mtt_conn( - sess_id: SessionID, + _sess_id: SessionID, method: Method, path: Path>, state: State, - body: String, + _body: String, ) -> impl IntoResponse { let (tx, mut rx) = channel(1); - let action = match method { + let _action = match method { Method::GET => MsgAction::Query(Query::new()), //Method::GET => ActionType::Get, //Method::POST => ActionType::Add, //Method::PATCH => ActionType::Update, _ => unreachable!("reouter should prevent this"), }; - let doc = match path.get("document") { + let _doc = match path.get("document") { Some(result) => result.clone(), None => "root".to_string(), }; diff --git a/src/message.rs b/src/message.rs index b191eaf..bbb5a11 100644 --- a/src/message.rs +++ b/src/message.rs @@ -1,7 +1,7 @@ use chrono::prelude::*; use isolang::Language; use std::{ - collections::{HashMap, HashSet, VecDeque}, + collections::{HashMap, HashSet}, ops::{Add, AddAssign}, sync::{ mpsc::{channel, Receiver, Sender}, @@ -92,6 +92,7 @@ impl From<&MsgAction> for Action { } } +/* #[derive(Clone, Debug, Eq, Hash, PartialEq)] enum NameID { ID(Uuid), @@ -131,6 +132,7 @@ impl From<&NameID> for NameID { value.clone() } } +*/ #[derive(Clone, Debug)] pub enum MsgAction { @@ -400,7 +402,7 @@ mod messages { } #[test] - fn Can_make_reply_message() { + fn can_make_reply_message() { let name = Name::english("testing"); let msg = Message::new(name.clone(), Query::new()); let responce = Reply::new(); @@ -417,12 +419,11 @@ mod messages { } #[test] - fn Can_make_error_message() { + fn can_make_error_message() { let name = Name::english("testing"); let msg = Message::new(name.clone(), Query::new()); let err_msg = Uuid::new_v4().to_string(); let result = msg.response(MTTError::DocumentNotFound(err_msg.clone())); - assert_eq!(result.get_message_id(), msg.get_message_id()); match result.get_document_id() { NameType::Name(data) => assert_eq!(data, &name), @@ -512,7 +513,7 @@ mod includes { } #[derive(Clone, Debug, Eq, Hash, PartialEq)] -struct RouteID { +pub struct RouteID { action: Option, doc_type: Option, msg_id: Option, @@ -680,6 +681,7 @@ impl Name { Self::new(name, Language::from_639_1("en").unwrap()) } + #[allow(dead_code)] fn japanese(name: &str) -> Self { Self::new(name, Language::from_639_1("ja").unwrap()) } @@ -724,6 +726,7 @@ impl Names { Ok(id) } + /* fn add_translation(&mut self, name: Name, translation: Name) -> Result { let id = match self.get_id(&name) { Ok(data) => data.clone(), @@ -748,6 +751,7 @@ impl Names { None => Err(MTTError::NameInvalidID(id.clone())), } } + */ fn get_id(&self, name: NT) -> Result where @@ -799,9 +803,11 @@ impl Names { Ok(Route::new(path.msg_id.clone(), doc_id, path.action.clone())) } + /* fn is_empty(&self) -> bool { self.names.is_empty() } + */ } #[cfg(test)] @@ -823,12 +829,13 @@ mod names { let data = ["one", "two", "three", "four", "five"]; let mut ids: HashSet = HashSet::new(); for item in data.iter() { - let name = Name::english(item.clone()); + let name = Name::english(item); ids.insert(names.add_names([name].to_vec()).unwrap()); } assert_eq!(ids.len(), data.len()); } + /* #[test] fn does_id_return_name() { let mut names = Names::new(); @@ -848,10 +855,11 @@ mod names { assert_eq!(&names.get_id(name).unwrap(), id); } } + */ #[test] fn errors_on_name_not_found() { - let mut names = Names::new(); + let names = Names::new(); let name = Name::english("missing"); let result = names.get_id(&name); match result { @@ -863,6 +871,7 @@ mod names { } } + /* #[test] fn errors_on_bad_id() { let mut names = Names::new(); @@ -892,13 +901,14 @@ mod names { }, } } + */ #[test] fn errors_on_duplicate_names() { let mut names = Names::new(); let data = "test"; let name = Name::english(data); - let id = names.add_names([name.clone()].to_vec()); + names.add_names([name.clone()].to_vec()).unwrap(); let output = names.add_names([name.clone()].to_vec()); match output { Ok(_) => unreachable!( @@ -912,6 +922,7 @@ mod names { } } + /* #[test] fn allows_alternate_names() { let mut names = Names::new(); @@ -965,6 +976,7 @@ mod names { }, } } + */ #[test] fn convert_path_to_route_with_ids() { @@ -1006,7 +1018,7 @@ mod names { #[test] fn convert_path_with_no_document_to_route() { - let mut names = Names::new(); + let names = Names::new(); let msg_id = Uuid::new_v4(); let action = Action::Show; let path = Path::new( @@ -1022,7 +1034,7 @@ mod names { #[test] fn convert_path_to_route_all_documents() { - let mut names = Names::new(); + let names = Names::new(); let msg_id = Uuid::new_v4(); let action = Action::Query; let path = Path::new( @@ -1041,7 +1053,7 @@ mod names { #[test] fn convert_path_with_bad_id() { - let mut names = Names::new(); + let names = Names::new(); let msg_id = Uuid::new_v4(); let id = Uuid::new_v4(); let action = Action::Query; @@ -1061,7 +1073,7 @@ mod names { #[test] fn convert_path_with_bad_name() { - let mut names = Names::new(); + let names = Names::new(); let msg_id = Uuid::new_v4(); let name = Name::english("wrong"); let action = Action::Query; @@ -1275,6 +1287,7 @@ mod routes { } } +/* #[derive(Clone, Debug, Eq, PartialEq)] struct RouteRequest { msg_id: Include, @@ -1291,6 +1304,7 @@ impl RouteRequest { } } } +*/ struct RouteStorage { data: HashMap>, @@ -1376,7 +1390,7 @@ mod route_storeage { #[test] fn returns_empty_set_when_nothing_is_available() { - let mut routes = RouteStorage::new(); + let routes = RouteStorage::new(); let route = Route::new(Include::Just(Uuid::new_v4()), Include::All, Include::All); let result = routes.get(route); assert_eq!(result.len(), 0); @@ -1759,8 +1773,8 @@ mod queues { #[test] fn can_forward_message() { - let mut tester = TestQueue::new(); - let mut queue = tester.get_queue(); + let tester = TestQueue::new(); + let queue = tester.get_queue(); let msg = Message::new(Name::english("wiki"), Query::new()); queue.forward(tester.get_preset_id(), msg.clone()); let result = tester.get_preset_rx().recv_timeout(TIMEOUT).unwrap(); @@ -1797,8 +1811,8 @@ mod queues { #[test] fn document_names_have_unique_id() { - let mut tester = TestQueue::new(); - let mut queue = tester.get_queue(); + let tester = TestQueue::new(); + let queue = tester.get_queue(); let names = [ Name::english("one"), Name::english("two"), @@ -1832,8 +1846,8 @@ mod queues { #[test] fn does_name_id_get_updated() { - let mut tester = TestQueue::new(); - let mut queue = tester.get_queue(); + let tester = TestQueue::new(); + let queue = tester.get_queue(); let doc_name = Name::english("test"); let reg_msg = Register::new( tester.get_preset_id().clone(), @@ -1867,8 +1881,8 @@ mod queues { #[test] fn can_register_multiple_names_at_once() { - let mut tester = TestQueue::new(); - let mut queue = tester.get_queue(); + let tester = TestQueue::new(); + let queue = tester.get_queue(); let names = [Name::english("one"), Name::japanese("δΈ€")].to_vec(); let reg_msg = Register::new( tester.get_preset_id().clone(), @@ -1907,8 +1921,8 @@ mod queues { #[test] fn errors_on_duplicate_names() { - let mut tester = TestQueue::new(); - let mut queue = tester.get_queue(); + let tester = TestQueue::new(); + let queue = tester.get_queue(); let receiver = tester.get_preset_rx(); let doc_name = Name::english(Uuid::new_v4().to_string().as_str()); let reg_msg = Register::new( @@ -1940,7 +1954,7 @@ mod queues { #[test] fn can_register_routes() { let mut tester = TestQueue::new(); - let mut queue = tester.get_queue(); + let queue = tester.get_queue(); let names = [Name::english("task"), Name::english("recipe")]; for name in names.iter() { tester.add_document(name.clone()); @@ -1967,7 +1981,7 @@ mod queues { #[test] fn can_multiple_register_for_the_same_route() { let mut tester = TestQueue::new(); - let mut queue = tester.get_queue(); + let queue = tester.get_queue(); let names = [Name::english("task"), Name::english("recipe")]; let route_req = Path::new(Include::All, Include::All, Include::All); let reg_msg = RegMsg::AddRoute(route_req); @@ -1989,7 +2003,7 @@ mod queues { #[test] fn does_receiver_only_receives_the_message_once() { let mut tester = TestQueue::new(); - let mut queue = tester.get_queue(); + let queue = tester.get_queue(); let name = Name::english("something"); tester.add_document(name.clone()); let paths = [ @@ -2023,7 +2037,7 @@ mod queues { #[test] fn can_routing_be_based_on_message_id() { let mut tester = TestQueue::new(); - let mut queue = tester.get_queue(); + let queue = tester.get_queue(); let names = [Name::english("one"), Name::english("two")]; let mut inputs: HashMap = HashMap::new(); for name in names.iter() { @@ -2076,7 +2090,7 @@ mod queues { #[test] fn can_routing_be_based_on_document_name() { let mut tester = TestQueue::new(); - let mut queue = tester.get_queue(); + let queue = tester.get_queue(); let names = [Name::english("one"), Name::english("two")]; let mut inputs: HashMap = HashMap::new(); for name in names.iter() { @@ -2129,7 +2143,7 @@ mod queues { #[test] fn can_routing_be_based_on_action() { let mut tester = TestQueue::new(); - let mut queue = tester.get_queue(); + let queue = tester.get_queue(); let names = [Name::english("one"), Name::english("two")]; let paths = [ Path::new(Include::All, Include::All, Include::Just(Action::Reply)), @@ -2205,7 +2219,7 @@ mod queues { rx.recv_timeout(TIMEOUT).unwrap(); queue.remove_sender(&sender_id); let msg = Message::new(name, Query::new()); - queue.send(msg); + queue.send(msg).unwrap(); match rx.recv_timeout(TIMEOUT) { Err(err) => match err { RecvTimeoutError::Disconnected => {} @@ -2240,7 +2254,7 @@ impl CreateDoc { let id = queue.add_sender(tx); for route in routes.iter() { let regmsg = Register::new(id.clone(), RegMsg::AddRoute(route.clone())); - queue.send(Message::new(NameType::None, regmsg)); + queue.send(Message::new(NameType::None, regmsg)).unwrap(); rx.recv().unwrap(); } let doc = CreateDoc::new(queue, rx); @@ -2356,6 +2370,7 @@ impl Field { } } + #[allow(dead_code)] fn not_equal(&self, other: &Field) -> Field { if self.get_type() == other.get_type() { { self != other }.into() @@ -2776,7 +2791,7 @@ mod fieldsettings { #[test] fn returns_value_if_default_is_set() { let mut fset = FieldSetting::new(FieldType::StaticString); - fset.set_default(FieldType::StaticString); + fset.set_default(FieldType::StaticString).unwrap(); match fset.validate(&Field::None) { Ok(data) => assert_eq!(data, "".into()), Err(err) => unreachable!("got {:?}: should have gotten a value", err), @@ -2787,7 +2802,7 @@ mod fieldsettings { fn returns_default_value() { let mut fset = FieldSetting::new(FieldType::StaticString); let input = "fred"; - fset.set_default(input); + fset.set_default(input).unwrap(); match fset.validate(&Field::None) { Ok(data) => assert_eq!(data, input.into()), Err(err) => unreachable!("got {:?}: should have gotten a value", err), @@ -2799,9 +2814,9 @@ mod fieldsettings { let mut fset = FieldSetting::new(FieldType::DateTime); let duration = Duration::from_secs(3600); let mut calc = Calculation::new(Operand::Add); - calc.add_value(FieldType::DateTime); - calc.add_value(duration); - fset.set_default(calc); + calc.add_value(FieldType::DateTime).unwrap(); + calc.add_value(duration).unwrap(); + fset.set_default(calc).unwrap(); let start = Utc::now() + duration; let result = match fset.validate(&Field::None).unwrap() { Field::DateTime(data) => data, @@ -2835,6 +2850,7 @@ impl Addition { } } + #[allow(dead_code)] fn add_field(&mut self, name: NT, field: CV) where CV: Into, @@ -2843,6 +2859,7 @@ impl Addition { self.data.add_field(name, field); } + #[allow(dead_code)] fn get_field(&self, name: NT) -> &CalcValue where NT: Into, @@ -2850,6 +2867,7 @@ impl Addition { self.data.get_field(name) } + #[allow(dead_code)] fn get_document(&self) -> Document { self.data.clone() } @@ -3037,6 +3055,7 @@ impl DocDef { &self.field_names } + #[allow(dead_code)] fn get_field_names_mut(&mut self) -> &mut Names { &mut self.field_names } @@ -3056,6 +3075,7 @@ impl DocDef { } } + #[allow(dead_code)] fn get_field(&self, field_name: NT) -> Result<&FieldSetting, MTTError> where NT: Into, @@ -3067,6 +3087,7 @@ impl DocDef { Ok(self.fields.get(&id).unwrap()) } + #[allow(dead_code)] fn get_field_mut(&mut self, field_name: NT) -> Result<&mut FieldSetting, MTTError> where NT: Into, @@ -3120,6 +3141,7 @@ impl DocDef { Indexes::new(&self.indexes) } + #[allow(dead_code)] fn iter(&self) -> impl Iterator { self.fields.iter() } @@ -3172,10 +3194,10 @@ mod docdefs { let names = ["one", "two", "three"]; let field_type = FieldType::StaticString; for name in names.iter() { - docdef.add_field(Name::english(name.clone()), field_type.clone()); + docdef.add_field(Name::english(name), field_type.clone()); } for name in names.iter() { - let result = docdef.get_field(Name::english(name.clone())).unwrap(); + let result = docdef.get_field(Name::english(name)).unwrap(); match result.validate(&"".into()) { Ok(_) => {} Err(err) => unreachable!("got {:?}: should have been a value", err), @@ -3189,7 +3211,7 @@ mod docdefs { let mut docdef = DocDef::new(docname); let name = Name::english("defaultfunction"); docdef.add_field(name.clone(), FieldType::StaticString); - docdef.set_default(&name, FieldType::StaticString); + docdef.set_default(&name, FieldType::StaticString).unwrap(); match docdef.get_field(name).unwrap().validate(&Field::None) { Ok(data) => match data { Field::StaticString(result) => assert_eq!(result, ""), @@ -3340,6 +3362,7 @@ pub enum Operand { } impl Operand { + #[allow(dead_code)] fn validate(&self, x: &Field, y: &Field) -> bool { match self { Self::Equal => x == y, @@ -3602,8 +3625,8 @@ mod calcvalues { let duration = Duration::from_secs(300); let start = Utc::now() + duration; let mut calc = Calculation::new(Operand::Add); - calc.add_value(FieldType::DateTime); - calc.add_value(duration.clone()); + calc.add_value(FieldType::DateTime).unwrap(); + calc.add_value(duration.clone()).unwrap(); let result: CalcValue = calc.into(); let data = match result.get(&Field::None) { Field::DateTime(data) => data, @@ -3631,10 +3654,12 @@ impl Calculation { } } + #[allow(dead_code)] fn operation(&self) -> &Operand { &self.operation } + #[allow(dead_code)] fn get_fields(&self, existing: Field) -> Vec { let mut output = Vec::new(); for item in self.values.iter() { @@ -3677,6 +3702,7 @@ impl Calculation { Ok(()) } + #[allow(dead_code)] fn validate_value(&self, value: CV) -> Result<(), MTTError> where CV: Into, @@ -3796,8 +3822,8 @@ mod calculations { fn can_equal_true() { let mut calc = Calculation::new(Operand::Equal); let data: Field = Uuid::new_v4().into(); - calc.add_value(data.clone()); - calc.add_value(data.clone()); + calc.add_value(data.clone()).unwrap(); + calc.add_value(data.clone()).unwrap(); let expected: Field = true.into(); let result = calc.calculate(&Field::None); assert_eq!(result, expected); @@ -3808,8 +3834,8 @@ mod calculations { let mut calc = Calculation::new(Operand::Equal); let value1: Field = "fred".into(); let value2: Field = "barney".into(); - calc.add_value(value1); - calc.add_value(value2); + calc.add_value(value1).unwrap(); + calc.add_value(value2).unwrap(); let expected: Field = false.into(); let result = calc.calculate(&Field::None); assert_eq!(result, expected); @@ -3824,8 +3850,8 @@ mod calculations { ]; for (item, expected) in data.iter() { let mut calc = Calculation::new(Operand::GreaterThan); - calc.add_value(item.clone()); - calc.add_value(data[1].0.clone()); + calc.add_value(item.clone()).unwrap(); + calc.add_value(data[1].0.clone()).unwrap(); let result = calc.calculate(&Field::None); assert_eq!(&result, expected); } @@ -3840,8 +3866,8 @@ mod calculations { ]; for (item, expected) in data.iter() { let mut calc = Calculation::new(Operand::GreaterThanEqual); - calc.add_value(item.clone()); - calc.add_value(data[1].0.clone()); + calc.add_value(item.clone()).unwrap(); + calc.add_value(data[1].0.clone()).unwrap(); let result = calc.calculate(&Field::None); assert_eq!(&result, expected); } @@ -3856,8 +3882,8 @@ mod calculations { ]; for (item, expected) in data.iter() { let mut calc = Calculation::new(Operand::LessThan); - calc.add_value(item.clone()); - calc.add_value(data[1].0.clone()); + calc.add_value(item.clone()).unwrap(); + calc.add_value(data[1].0.clone()).unwrap(); let result = calc.calculate(&Field::None); assert_eq!(&result, expected); } @@ -3872,8 +3898,8 @@ mod calculations { ]; for (item, expected) in data.iter() { let mut calc = Calculation::new(Operand::LessThanEqual); - calc.add_value(item.clone()); - calc.add_value(data[1].0.clone()); + calc.add_value(item.clone()).unwrap(); + calc.add_value(data[1].0.clone()).unwrap(); let result = calc.calculate(&Field::None); assert_eq!(&result, expected); } @@ -3887,8 +3913,8 @@ mod calculations { let expected: Field = { value1 + value2 }.into(); let value1: Field = value1.into(); let value2: Field = value2.into(); - calc.add_value(value1.clone()); - calc.add_value(value2.clone()); + calc.add_value(value1.clone()).unwrap(); + calc.add_value(value2.clone()).unwrap(); let result = calc.calculate(&Field::None); assert_eq!( result, expected, @@ -3905,8 +3931,9 @@ mod calculations { let expected: Field = { value1 + value2 }.into(); let value1: Field = value1.into(); let value2: Field = value2.into(); - calc.add_value(value1.clone()); - calc.add_value(CalcValue::Existing(FieldType::Integer)); + calc.add_value(value1.clone()).unwrap(); + calc.add_value(CalcValue::Existing(FieldType::Integer)) + .unwrap(); let result = calc.calculate(&value2); assert_eq!( result, expected, @@ -3918,7 +3945,7 @@ mod calculations { #[test] fn returns_error_on_mismatch() { let mut calc = Calculation::new(Operand::Add); - calc.add_value(Uuid::nil()); + calc.add_value(Uuid::nil()).unwrap(); match calc.add_value("mismatch") { Ok(_) => unreachable!("should have returned an error"), Err(err) => match err { @@ -3953,6 +3980,7 @@ mod calculations { } } +#[allow(dead_code)] #[derive(Clone, Debug)] struct Operation { field_name: String, @@ -3960,6 +3988,7 @@ struct Operation { value: Field, } +#[allow(dead_code)] impl Operation { fn new(name: String, op: Operand, value: F) -> Self where @@ -3981,6 +4010,7 @@ impl Operation { } } +#[allow(dead_code)] #[derive(Clone, Debug)] enum QueryType { Query(Query), @@ -4018,6 +4048,7 @@ impl Query { self.data.insert(name.into(), operation); } + #[allow(dead_code)] fn get(&self, name: NT) -> Option where NT: Into, @@ -4028,6 +4059,7 @@ impl Query { } } + #[allow(dead_code)] fn field_ids(&self) -> HashSet<&NameType> { self.data.keys().collect() } @@ -4051,13 +4083,13 @@ mod queries { } let mut query = Query::new(); let mut calc = Calculation::new(Operand::Equal); - calc.add_value(data.clone()); + 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); + holder.add_value(data).unwrap(); assert_eq!(holder.calculate(&Field::None), expected); } None => unreachable!("should have returned a calculation"), @@ -4066,7 +4098,7 @@ mod queries { Some(op) => { let expected: Field = false.into(); let mut holder = op.clone(); - holder.add_value(bad_data); + holder.add_value(bad_data).unwrap(); assert_eq!(holder.calculate(&Field::None), expected); } None => unreachable!("should have returned a calculation"), @@ -4074,11 +4106,13 @@ mod queries { } } +#[allow(dead_code)] #[derive(Clone, Debug)] -struct Reply { +pub struct Reply { data: Vec, } +#[allow(dead_code)] impl Reply { fn new() -> Self { Self { data: Vec::new() } @@ -4128,7 +4162,7 @@ mod replies { reply.add(doc1); reply.add(doc2); let mut reply_iter = reply.iter(); - let mut result1 = reply_iter.next().unwrap(); + let result1 = reply_iter.next().unwrap(); match result1.get_field(&fieldname) { CalcValue::Value(data) => match data { Field::StaticString(output) => assert_eq!(output, "one"), @@ -4177,9 +4211,11 @@ impl InternalRecord { self.data.get(id) } + /* fn keys(&self) -> impl Iterator { self.data.keys() } + */ fn is_empty(&self) -> bool { self.data.is_empty() @@ -4226,9 +4262,11 @@ impl InternalRecords { self.data.contains_key(oid) } + /* fn is_empty(&self) -> bool { self.data.is_empty() } + */ fn len(&self) -> usize { self.data.len() @@ -4357,6 +4395,7 @@ impl Document { } } + #[allow(dead_code)] fn get_all(&self) -> Vec<(NameType, Field)> { let mut output = Vec::new(); for (key, value) in self.data.iter() { @@ -4369,11 +4408,14 @@ impl Document { self.data.iter() } + /* fn is_empty(&self) -> bool { self.data.is_empty() } + */ } +/* struct DocIter { storage: Vec<(NameType, Field)>, } @@ -4393,6 +4435,7 @@ impl Iterator for DocIter { self.storage.pop() } } +*/ #[cfg(test)] mod documents { @@ -4414,6 +4457,7 @@ mod documents { } } + #[test] fn can_add_uuid() { let mut add = Document::new(); let name = Name::english(Uuid::new_v4().to_string().as_str()); @@ -4552,6 +4596,7 @@ impl Index { Ok(()) } + #[allow(dead_code)] fn append(&mut self, index: &Self) { for (value, oids) in index.data.iter() { match self.data.get(value) { @@ -4566,6 +4611,7 @@ impl Index { } } + #[allow(dead_code)] fn get(&self, spec: &Operation) -> Vec { let mut output = Vec::new(); for (field, oids) in self.data.iter() { @@ -4633,6 +4679,7 @@ impl Indexes { self.data.keys().collect::>() } + /* fn get_index(&self, field_id: &Uuid) -> &Index { self.data.get(field_id).unwrap() } @@ -4646,6 +4693,7 @@ impl Indexes { self.data.get_mut(field_id).unwrap().append(index); } } + */ fn pull(&self, field_id: &Uuid, calc: &Calculation) -> Result, MTTError> { self.data.get(field_id).unwrap().pull(calc) @@ -4659,6 +4707,7 @@ impl Indexes { index.add(field, oid) } + #[allow(dead_code)] fn remove_from_index(&mut self, field_name: &Uuid, field: &Field, oid: &Oid) { let index = match self.data.get_mut(field_name) { Some(data) => data, @@ -4678,9 +4727,11 @@ impl Indexes { Ok(()) } + /* fn iter(&self) -> impl Iterator { self.data.iter() } + */ fn iter_mut(&mut self) -> impl Iterator { self.data.iter_mut() @@ -4720,7 +4771,7 @@ mod indexes { let fields = get_fields(count); let oids = get_oids(count); for i in 0..count { - index.add(fields[i].clone(), oids[i].clone()); + index.add(fields[i].clone(), oids[i].clone()).unwrap(); } for i in 0..count { let spec = Operation::new("stuff".to_string(), Operand::Equal, fields[i].clone()); @@ -4737,7 +4788,7 @@ mod indexes { let fields = get_fields(1); let oids = get_oids(count); for i in 0..count { - index.add(fields[0].clone(), oids[i].clone()); + index.add(fields[0].clone(), oids[i].clone()).unwrap(); } let spec = Operation::new("unimportant".to_string(), Operand::Equal, fields[0].clone()); let result = index.get(&spec); @@ -4755,7 +4806,7 @@ mod indexes { let fields = get_fields(1); let oids = get_oids(count); for i in 0..count { - index.add(fields[0].clone(), oids[i].clone()); + index.add(fields[0].clone(), oids[i].clone()).unwrap(); } index.remove(&fields[0], &oids[pos]); let spec = Operation::new("x".to_string(), Operand::Equal, fields[0].clone()); @@ -4768,7 +4819,7 @@ mod indexes { let mut index = Index::new(); let field: Field = Uuid::new_v4().into(); let oid = Oid::new(); - index.add(field.clone(), oid.clone()); + index.add(field.clone(), oid.clone()).unwrap(); index.remove(&field, &oid); assert_eq!(index.data.len(), 0); } @@ -4912,16 +4963,17 @@ impl DocumentFile { DocFuncType::Update => self.update(&msg), DocFuncType::ExistingQuery(action) => self.existing_query(&msg, action), DocFuncType::Trigger(action) => self.trigger(&msg, action), - _ => {} } } } } } + /* fn get_docdef(&self) -> &DocDef { &self.docdef } + */ fn validate(&self, field_name: NT, value: &Field) -> Result where @@ -4942,6 +4994,7 @@ impl DocumentFile { Ok(output) } + /* fn add_field_to_error(key: String, err: MTTError) -> MTTError { match err { MTTError::DocumentFieldMissing(_) => MTTError::DocumentFieldMissing(key), @@ -4964,6 +5017,7 @@ impl DocumentFile { let field_id = self.docdef.get_field_id(field_name).unwrap(); self.indexes.remove_from_index(&field_id, field, oid); } + */ fn add_document(&mut self, msg: &Message) { let addition = match msg.get_action() { @@ -5149,7 +5203,9 @@ impl DocumentFile { let old_rec = original.get(oid).unwrap(); for (field_id, index) in self.indexes.iter_mut() { index.remove(old_rec.get(field_id).unwrap(), oid); - index.add(new_rec.get(field_id).unwrap().clone(), oid.clone()); + index + .add(new_rec.get(field_id).unwrap().clone(), oid.clone()) + .unwrap(); } self.docs.insert(oid.clone(), new_rec.clone()); } @@ -5696,7 +5752,7 @@ mod document_files { queue.send(Message::new(doc_name.clone(), new_doc)).unwrap(); test_doc.get_receiver().recv_timeout(TIMEOUT).unwrap(); } - queue.send(Message::new(doc_name, Query::new())); + queue.send(Message::new(doc_name, Query::new())).unwrap(); let result = test_doc.get_receiver().recv_timeout(TIMEOUT).unwrap(); let action = result.get_action(); let mut entries: HashSet = (0..count).collect(); @@ -5759,10 +5815,12 @@ mod document_files { let queue = test_doc.get_queue(); let mut addition = Addition::new(); addition.add_field(Name::english("field0"), "string"); - queue.send(Message::new( - test_doc.get_docdef().get_document_names()[0].clone(), - addition, - )); + queue + .send(Message::new( + test_doc.get_docdef().get_document_names()[0].clone(), + addition, + )) + .unwrap(); let result = test_doc.get_receiver().recv_timeout(TIMEOUT).unwrap(); match result.get_action() { MsgAction::Error(err) => match err { @@ -5786,10 +5844,12 @@ mod document_files { let queue = test_doc.get_queue(); let mut addition = Addition::new(); addition.add_field(Name::english("field0"), 1); - queue.send(Message::new( - test_doc.get_docdef().get_document_names()[0].clone(), - addition, - )); + queue + .send(Message::new( + test_doc.get_docdef().get_document_names()[0].clone(), + addition, + )) + .unwrap(); let result = test_doc.get_receiver().recv_timeout(TIMEOUT).unwrap(); match result.get_action() { MsgAction::Error(err) => match err { @@ -5811,14 +5871,17 @@ mod document_files { test_doc.populate([i.into()].to_vec()); } let mut calc = Calculation::new(Operand::Equal); - calc.add_value(expected.clone()); - calc.add_value(CalcValue::Existing(FieldType::Integer)); + calc.add_value(expected.clone()).unwrap(); + calc.add_value(CalcValue::Existing(FieldType::Integer)) + .unwrap(); let mut query = Query::new(); query.add(Name::english("field0"), calc); - queue.send(Message::new( - test_doc.get_docdef().get_document_names()[0].clone(), - query, - )); + queue + .send(Message::new( + test_doc.get_docdef().get_document_names()[0].clone(), + query, + )) + .unwrap(); let result = test_doc.get_receiver().recv_timeout(TIMEOUT).unwrap(); let action = result.get_action(); match action { @@ -5845,16 +5908,18 @@ mod document_files { let queue = test_doc.get_queue(); test_doc.populate([1.into()].to_vec()); test_doc.populate([2.into()].to_vec()); - let mut query = Query::new(); let mut calc = Calculation::new(Operand::GreaterThan); - calc.add_value(CalcValue::Existing(FieldType::Integer)); - calc.add_value(1); + calc.add_value(CalcValue::Existing(FieldType::Integer)) + .unwrap(); + calc.add_value(1).unwrap(); let mut query = Query::new(); query.add(Name::english("field0"), calc); - queue.send(Message::new( - test_doc.get_docdef().get_document_names()[0].clone(), - query, - )); + queue + .send(Message::new( + test_doc.get_docdef().get_document_names()[0].clone(), + query, + )) + .unwrap(); let result = test_doc.get_receiver().recv_timeout(TIMEOUT).unwrap(); let action = result.get_action(); match action { @@ -5886,14 +5951,17 @@ mod document_files { test_doc.populate([data.into()].to_vec()); } let mut calc = Calculation::new(Operand::Equal); - calc.add_value(data.clone()); - calc.add_value(CalcValue::Existing(FieldType::Integer)); + calc.add_value(data.clone()).unwrap(); + calc.add_value(CalcValue::Existing(FieldType::Integer)) + .unwrap(); let mut query = Query::new(); query.add(Name::english("field0"), calc); - queue.send(Message::new( - test_doc.get_docdef().get_document_names()[0].clone(), - query, - )); + queue + .send(Message::new( + test_doc.get_docdef().get_document_names()[0].clone(), + query, + )) + .unwrap(); let result = test_doc.get_receiver().recv_timeout(TIMEOUT).unwrap(); let action = result.get_action(); match action { @@ -5929,12 +5997,14 @@ mod document_files { } let mut query = Query::new(); let mut calc = Calculation::new(Operand::Equal); - calc.add_value("a"); - calc.add_value(CalcValue::Existing(FieldType::StaticString)); + calc.add_value("a").unwrap(); + calc.add_value(CalcValue::Existing(FieldType::StaticString)) + .unwrap(); query.add(Name::english("field0"), calc); let mut calc = Calculation::new(Operand::Equal); - calc.add_value("b"); - calc.add_value(CalcValue::Existing(FieldType::StaticString)); + calc.add_value("b").unwrap(); + calc.add_value(CalcValue::Existing(FieldType::StaticString)) + .unwrap(); query.add(Name::english("field1"), calc); doc.send(query).unwrap(); let result = doc.get_receiver().recv_timeout(TIMEOUT).unwrap(); @@ -5958,8 +6028,12 @@ mod document_files { let mut doc = TestDocument::new([FieldType::StaticString, FieldType::StaticString].to_vec()); let docdef = doc.get_docdef_mut(); - docdef.add_index(&Name::english("field0"), IndexType::Index); - docdef.add_index(&Name::english("field1"), IndexType::Index); + docdef + .add_index(&Name::english("field0"), IndexType::Index) + .unwrap(); + docdef + .add_index(&Name::english("field1"), IndexType::Index) + .unwrap(); doc.start(standard_paths()); let values = [ ["a".into(), "a".into()].to_vec(), @@ -5972,12 +6046,14 @@ mod document_files { } let mut query = Query::new(); let mut calc = Calculation::new(Operand::Equal); - calc.add_value("a"); - calc.add_value(CalcValue::Existing(FieldType::StaticString)); + calc.add_value("a").unwrap(); + calc.add_value(CalcValue::Existing(FieldType::StaticString)) + .unwrap(); query.add(Name::english("field0"), calc); let mut calc = Calculation::new(Operand::Equal); - calc.add_value("b"); - calc.add_value(CalcValue::Existing(FieldType::StaticString)); + calc.add_value("b").unwrap(); + calc.add_value(CalcValue::Existing(FieldType::StaticString)) + .unwrap(); query.add(Name::english("field1"), calc); doc.send(query).unwrap(); let result = doc.get_receiver().recv_timeout(TIMEOUT).unwrap(); @@ -6001,7 +6077,9 @@ mod document_files { let mut doc = TestDocument::new([FieldType::StaticString, FieldType::StaticString].to_vec()); let docdef = doc.get_docdef_mut(); - docdef.add_index(&Name::english("field0"), IndexType::Index); + docdef + .add_index(&Name::english("field0"), IndexType::Index) + .unwrap(); doc.start(standard_paths()); let values = [ ["a".into(), "a".into()].to_vec(), @@ -6014,12 +6092,14 @@ mod document_files { } let mut query = Query::new(); let mut calc = Calculation::new(Operand::Equal); - calc.add_value("a"); - calc.add_value(CalcValue::Existing(FieldType::StaticString)); + calc.add_value("a").unwrap(); + calc.add_value(CalcValue::Existing(FieldType::StaticString)) + .unwrap(); query.add(Name::english("field0"), calc); let mut calc = Calculation::new(Operand::Equal); - calc.add_value("b"); - calc.add_value(CalcValue::Existing(FieldType::StaticString)); + calc.add_value("b").unwrap(); + calc.add_value(CalcValue::Existing(FieldType::StaticString)) + .unwrap(); query.add(Name::english("field1"), calc); doc.send(query).unwrap(); let result = doc.get_receiver().recv_timeout(TIMEOUT).unwrap(); @@ -6048,7 +6128,7 @@ mod document_files { let field_name = Name::english("wrong"); let mut query = Query::new(); let mut calc = Calculation::new(Operand::Equal); - calc.add_value("something"); + calc.add_value("something").unwrap(); query.add(field_name.clone(), calc); let msg = Message::new(doc_name, query); queue.send(msg).unwrap(); @@ -6064,13 +6144,15 @@ mod document_files { } #[test] + #[ignore = "may no longer be a valid test. should stop at add_value"] fn errors_on_bad_field_type() { let mut doc = TestDocument::new([FieldType::Uuid].to_vec()); doc.start(standard_paths()); doc.populate([Uuid::nil().into()].to_vec()); let mut calc = Calculation::new(Operand::Equal); - calc.add_value("notUUID"); - calc.add_value(CalcValue::Existing(FieldType::Uuid)); + calc.add_value("notUUID").unwrap(); + calc.add_value(CalcValue::Existing(FieldType::Uuid)) + .unwrap(); let mut query = Query::new(); query.add(Name::english("field0"), calc); doc.send(query).unwrap(); @@ -6088,11 +6170,12 @@ mod document_files { fn errors_on_bad_field_type_with_index() { let mut doc = TestDocument::new([FieldType::Uuid].to_vec()); doc.get_docdef_mut() - .add_index(&Name::english("field0"), IndexType::Index); + .add_index(&Name::english("field0"), IndexType::Index) + .unwrap(); doc.start(standard_paths()); doc.populate([Uuid::nil().into()].to_vec()); let mut calc = Calculation::new(Operand::Equal); - calc.add_value("notUUID"); + calc.add_value("notUUID").unwrap(); let mut query = Query::new(); query.add(Name::english("field0"), calc); doc.send(query).unwrap(); @@ -6113,7 +6196,9 @@ mod document_files { let mut docdef = DocDef::new(doc_name.clone()); let field_name = Name::english("holder"); docdef.add_field(field_name.clone(), FieldType::StaticString); - docdef.set_default(&field_name, FieldType::StaticString); + docdef + .set_default(&field_name, FieldType::StaticString) + .unwrap(); let mut test_doc: TestDocument = docdef.into(); test_doc.start(standard_paths()); let queue = test_doc.get_queue(); @@ -6141,7 +6226,7 @@ mod document_files { let mut docdef = DocDef::new(doc_name.clone()); let field_name = Name::english("id"); docdef.add_field(field_name.clone(), FieldType::Uuid); - docdef.set_default(&field_name, Uuid::nil()); + docdef.set_default(&field_name, Uuid::nil()).unwrap(); let mut test_doc: TestDocument = docdef.into(); test_doc.start(standard_paths()); let queue = test_doc.get_queue(); @@ -6169,7 +6254,7 @@ mod document_files { let mut docdef = DocDef::new(doc_name.clone()); let field_name = Name::english("id"); docdef.add_field(field_name.clone(), FieldType::Uuid); - docdef.set_default(&field_name, FieldType::Uuid); + docdef.set_default(&field_name, FieldType::Uuid).unwrap(); let mut test_doc: TestDocument = docdef.into(); test_doc.start(standard_paths()); let queue = test_doc.get_queue(); @@ -6341,7 +6426,7 @@ mod document_files { let new = "new"; let count = 5; let picked = 3; - for i in 0..count { + for _ in 0..count { doc.populate([picked.into(), old.into()].to_vec()); } let mut calc = Calculation::new(Operand::Equal); @@ -6435,7 +6520,8 @@ mod document_files { let mut test_doc = TestDocument::new([FieldType::Integer].to_vec()); test_doc .get_docdef_mut() - .add_index(&Name::english("field0"), IndexType::Unique); + .add_index(&Name::english("field0"), IndexType::Unique) + .unwrap(); test_doc.start(standard_paths()); let fname = Name::english("field0"); let old = 3; @@ -6487,7 +6573,8 @@ mod document_files { let mut test_doc = TestDocument::new([FieldType::Uuid, FieldType::Uuid].to_vec()); test_doc .get_docdef_mut() - .add_index(&f0name, IndexType::Unique); + .add_index(&f0name, IndexType::Unique) + .unwrap(); test_doc.start(standard_paths()); let f0data = Uuid::new_v4(); let f1bad_data = "NotUuid"; @@ -6519,18 +6606,19 @@ mod document_files { fn updating_unique_updates_index_entries() { let fname = Name::english("field0"); let mut doc = TestDocument::new([FieldType::StaticString].to_vec()); - doc.get_docdef_mut().add_index(&fname, IndexType::Unique); + doc.get_docdef_mut() + .add_index(&fname, IndexType::Unique) + .unwrap(); doc.start(standard_paths()); let old = "old"; let new = "new"; let fold: Field = old.into(); - let fnew: Field = new.into(); doc.populate([old.into()].to_vec()); let mut calc = Calculation::new(Operand::Equal); calc.add_value(CalcValue::Existing(FieldType::StaticString)) .unwrap(); - calc.add_value(old.clone()).unwrap(); + calc.add_value(old).unwrap(); let mut query = Query::new(); query.add(Name::english("field0"), calc); let mut update = Update::new(query); @@ -6570,7 +6658,9 @@ mod document_files { let f0name = Name::english("field0"); let f1name = Name::english("field1"); let mut doc = TestDocument::new([FieldType::Uuid, FieldType::StaticString].to_vec()); - doc.get_docdef_mut().add_index(&f0name, IndexType::Unique); + doc.get_docdef_mut() + .add_index(&f0name, IndexType::Unique) + .unwrap(); doc.start(standard_paths()); let count = 5; let data = "data"; @@ -6579,7 +6669,6 @@ mod document_files { ids.insert(Uuid::new_v4()); } let holder = ids.iter().last().unwrap().clone(); - let fholder: Field = holder.into(); ids.remove(&holder); for id in ids.iter() { doc.populate([id.clone().into(), data.into()].to_vec()); @@ -6662,11 +6751,12 @@ mod document_files { doc.start(standard_paths()); doc.populate([1.into()].to_vec()); let mut calc = Calculation::new(Operand::Equal); - calc.add_value(1); - calc.add_value(CalcValue::Existing(FieldType::Integer)); + calc.add_value(1).unwrap(); + calc.add_value(CalcValue::Existing(FieldType::Integer)) + .unwrap(); let mut query = Query::new(); query.add(&fname, calc); - let mut delete = Delete::new(query.clone()); + let delete = Delete::new(query.clone()); doc.send(delete).unwrap(); let result = doc.get_receiver().recv_timeout(TIMEOUT).unwrap(); let action = result.get_action(); @@ -6697,8 +6787,9 @@ mod document_files { let mut doc = TestDocument::new([FieldType::Integer].to_vec()); doc.start(standard_paths()); let mut calc = Calculation::new(Operand::Equal); - calc.add_value(CalcValue::Existing(FieldType::Integer)); - calc.add_value(1); + calc.add_value(CalcValue::Existing(FieldType::Integer)) + .unwrap(); + calc.add_value(1).unwrap(); let mut query = Query::new(); query.add(field_name.clone(), calc); let delete = Delete::new(query); @@ -6719,10 +6810,12 @@ mod document_files { let fname = Name::english("field0"); let value = 1; let mut doc = TestDocument::new([FieldType::Integer].to_vec()); - doc.get_docdef_mut().add_index(&fname, IndexType::Unique); + doc.get_docdef_mut() + .add_index(&fname, IndexType::Unique) + .unwrap(); doc.start(standard_paths()); doc.populate([value.into()].to_vec()); - doc.send(Delete::new(Query::new())); + doc.send(Delete::new(Query::new())).unwrap(); doc.get_receiver().recv_timeout(TIMEOUT).unwrap(); let mut addition = Addition::new(); addition.add_field(&fname, value.clone()); @@ -6746,8 +6839,9 @@ mod document_files { ); let mut update = Update::new(Query::new()); let mut calc = Calculation::new(Operand::Add); - calc.add_value(CalcValue::Existing(FieldType::Integer)); - calc.add_value(1); + calc.add_value(CalcValue::Existing(FieldType::Integer)) + .unwrap(); + calc.add_value(1).unwrap(); update .get_values_mut() .add_field(Name::english("field0"), calc); @@ -6796,8 +6890,9 @@ mod document_files { let doc_name = doc.get_docdef().get_document_names()[0].clone(); Clock::start(queue.clone()); let mut calc = Calculation::new(Operand::GreaterThan); - calc.add_value(CalcValue::Existing(FieldType::Integer)); - calc.add_value(1); + calc.add_value(CalcValue::Existing(FieldType::Integer)) + .unwrap(); + calc.add_value(1).unwrap(); let mut query = Query::new(); query.add(Name::english("field0"), calc); let delete = Delete::new(query.clone()); @@ -6895,7 +6990,9 @@ mod createdocs { fn register_paths(&self, paths: Vec) { for path in paths.iter() { let regmsg = Register::new(self.rx_id.clone(), RegMsg::AddRoute(path.clone())); - self.queue.send(Message::new(NameType::None, regmsg)); + self.queue + .send(Message::new(NameType::None, regmsg)) + .unwrap(); self.rx.recv_timeout(TIMEOUT).unwrap(); } } @@ -6910,7 +7007,7 @@ mod createdocs { ] .to_vec(); doc_creator.register_paths(paths); - let mut queue = doc_creator.get_queue(); + let queue = doc_creator.get_queue(); let rx = doc_creator.get_receiver(); let name = Name::english("project"); let msg1 = Message::new(NameType::None, MsgAction::Create(DocDef::new(name.clone()))); @@ -6948,7 +7045,7 @@ mod createdocs { )] .to_vec(); doc_creator.register_paths(paths); - let mut queue = doc_creator.get_queue(); + let queue = doc_creator.get_queue(); let rx = doc_creator.get_receiver(); let name = Name::english("duplicate"); let msg1 = Message::new(NameType::None, MsgAction::Create(DocDef::new(name.clone()))); @@ -6964,7 +7061,7 @@ mod createdocs { }, _ => unreachable!("got {:?}: should have been a reply.", result.get_action()), } - let mut router = queue.router.read().unwrap(); + let router = queue.router.read().unwrap(); assert_eq!( router.senders.len(), 3, @@ -6998,10 +7095,12 @@ impl Clock { fn listen(&self) { loop { - self.queue.send(Message::new( - Name::english("clock"), - MsgAction::OnUpdate(Records::new(Names::new())), - )); + self.queue + .send(Message::new( + Name::english("clock"), + MsgAction::OnUpdate(Records::new(Names::new())), + )) + .unwrap(); sleep(Duration::from_secs(1)); } } @@ -7061,12 +7160,14 @@ mod clocks { } } +#[allow(dead_code)] #[derive(Clone, Debug)] -struct MsgEntry { +pub struct MsgEntry { timestamp: DateTime, message: Message, } +#[allow(dead_code)] impl MsgEntry { fn new(msg: Message) -> Self { Self { @@ -7110,11 +7211,13 @@ mod msg_entries { } } +#[allow(dead_code)] #[derive(Clone, Debug)] struct MsgLogs { data: HashMap>, } +#[allow(dead_code)] impl MsgLogs { fn new() -> Self { Self { @@ -7193,12 +7296,14 @@ mod msg_logs { } } +#[allow(dead_code)] struct MessageLog { data: MsgLogs, queue: Queue, rx: Receiver, } +#[allow(dead_code)] impl MessageLog { fn new(queue: Queue, rx: Receiver) -> Self { Self { @@ -7258,7 +7363,7 @@ mod message_logs { let rmsg = Message::new(NameType::None, reg_msg); queue.send(rmsg.clone()).unwrap(); let name_result = rx.recv().unwrap(); - let name_id = match name_result.get_action() { + match name_result.get_action() { MsgAction::Register(data) => match data.get_msg() { RegMsg::DocumentNameID(data) => data, RegMsg::Error(err) => unreachable!("got {:?}, should have gotten data", err), @@ -7277,7 +7382,6 @@ mod message_logs { queue.send(Message::new(NameType::None, request)).unwrap(); rx.recv_timeout(TIMEOUT).unwrap(); let msg = Message::new(doc_name.clone(), Query::new()); - let start = Utc::now(); queue.send(msg.clone()).unwrap(); let log_msg = Message::new(NameType::None, msg.get_message_id()); queue.send(log_msg.clone()).unwrap(); @@ -7301,6 +7405,7 @@ impl Session { } } + #[allow(dead_code)] pub fn get_document_name(&self) -> &Name { &self.doc_name } @@ -7309,17 +7414,17 @@ impl Session { let mut docdef = DocDef::new(self.doc_name.clone()); let mut calc = Calculation::new(Operand::Add); - calc.add_value(FieldType::DateTime); - calc.add_value(Duration::from_hours(1)); + calc.add_value(FieldType::DateTime).unwrap(); + calc.add_value(Duration::from_hours(1)).unwrap(); let name_id = Name::english("id"); docdef.add_field(name_id.clone(), FieldType::Uuid); - docdef.set_default(&name_id, FieldType::Uuid); + docdef.set_default(&name_id, FieldType::Uuid).unwrap(); docdef.add_index(&name_id, IndexType::Unique).unwrap(); let name_expire = Name::english("expire"); docdef.add_field(name_expire.clone(), FieldType::DateTime); - docdef.set_default(&name_expire, calc.clone()); + docdef.set_default(&name_expire, calc.clone()).unwrap(); let mut update = Update::new(Query::new()); update @@ -7335,8 +7440,10 @@ impl Session { let mut delete_qry = Query::new(); let mut delete_calc = Calculation::new(Operand::LessThan); - delete_calc.add_value(FieldType::DateTime); - delete_calc.add_value(CalcValue::Existing(FieldType::DateTime)); + delete_calc.add_value(FieldType::DateTime).unwrap(); + delete_calc + .add_value(CalcValue::Existing(FieldType::DateTime)) + .unwrap(); delete_qry.add(name_expire.clone(), delete_calc); let delete = Delete::new(delete_qry); let clock_path = Path::new( @@ -7430,7 +7537,7 @@ mod sessions { fn creates_the_session_table() { let setup = Setup::new(); let queue = setup.get_queue(); - let mut session = Session::new(); + let session = Session::new(); assert_eq!(session.get_document_name(), &Name::english("session")); session.create(queue.clone()); let path = Path::new( @@ -7440,14 +7547,14 @@ mod sessions { ); let reg_msg = Register::new(setup.get_sender_id(), RegMsg::AddRoute(path)); queue.send(Message::new(NameType::None, reg_msg)).unwrap(); - let result = setup.recv().unwrap(); + setup.recv().unwrap(); } #[test] fn session_ids_are_unique() { let setup = Setup::new(); let queue = setup.get_queue(); - let mut session = Session::new(); + let session = Session::new(); session.create(queue.clone()); setup.register(); let count = 10; @@ -7478,7 +7585,7 @@ mod sessions { fn expire_default_is_an_hour_from_now() { let setup = Setup::new(); let queue = setup.get_queue(); - let mut session = Session::new(); + let session = Session::new(); session.create(queue.clone()); setup.register(); let msg = Message::new(session.get_document_name(), Addition::new()); @@ -7508,7 +7615,7 @@ mod sessions { fn session_ids_error_when_not_unique() { let setup = Setup::new(); let queue = setup.get_queue(); - let mut session = Session::new(); + let session = Session::new(); session.create(queue.clone()); setup.register(); let id = Uuid::new_v4(); @@ -7536,7 +7643,7 @@ mod sessions { fn expire_should_update_on_successful_query() { let setup = Setup::new(); let queue = setup.get_queue(); - let mut session = Session::new(); + let session = Session::new(); session.create(queue.clone()); setup.register(); let id = Uuid::new_v4(); @@ -7550,8 +7657,9 @@ mod sessions { setup.recv().unwrap(); let mut query = Query::new(); let mut calc = Calculation::new(Operand::Equal); - calc.add_value(CalcValue::Existing(FieldType::Uuid)); - calc.add_value(id); + calc.add_value(CalcValue::Existing(FieldType::Uuid)) + .unwrap(); + calc.add_value(id).unwrap(); query.add(Name::english("id"), calc.clone()); queue .send(Message::new(session.get_document_name(), query.clone())) @@ -7586,7 +7694,7 @@ mod sessions { fn clock_removes_expired_sessions() { let setup = Setup::new(); let queue = setup.get_queue(); - let mut session = Session::new(); + let session = Session::new(); session.create(queue.clone()); setup.register(); let id1 = Uuid::new_v4();