notesmachine/server/nm-store/src/lib.rs

110 lines
3.9 KiB
Rust
Raw Normal View History

mod errors;
2020-11-03 02:32:01 +00:00
// mod reference_parser;
mod store;
mod store_private;
mod structs;
pub use crate::errors::NoteStoreError;
pub use crate::store::NoteStore;
2020-11-03 02:32:01 +00:00
pub use crate::structs::{RawZettle};
#[cfg(test)]
mod tests {
use super::*;
use chrono;
use tokio;
async fn fresh_inmemory_database() -> NoteStore {
let storagepool = NoteStore::new("sqlite://:memory:").await;
assert!(storagepool.is_ok(), "{:?}", storagepool);
let storagepool = storagepool.unwrap();
let reset = storagepool.reset_database().await;
assert!(reset.is_ok(), "{:?}", reset);
storagepool
}
2020-11-03 02:32:01 +00:00
// Request for the page by slug. If the page exists, return it.
// If the page doesn't, return NotFound
//
#[tokio::test(threaded_scheduler)]
async fn fetching_unfound_page_by_slug_works() {
let storagepool = fresh_inmemory_database().await;
let foundkasten = storagepool.get_kasten_by_slug("nonexistent-kasten").await.unwrap();
assert_eq!(foundkasten.len(), 0, "{:?}", foundkasten);
}
2020-10-06 15:01:25 +00:00
// Request for the page by title. If the page exists, return it.
// If the page doesn't exist, create it then return it anyway.
// There should be at least one note, the root note.
#[tokio::test(threaded_scheduler)]
2020-10-06 15:01:25 +00:00
async fn fetching_unfound_page_by_title_works() {
let title = "Nonexistent Page";
2020-10-13 03:43:49 +00:00
let now = chrono::Utc::now();
let storagepool = fresh_inmemory_database().await;
2020-11-03 02:32:01 +00:00
let newpageresult = storagepool.get_kasten_by_title(&title).await;
assert!(newpageresult.is_ok(), "{:?}", newpageresult);
2020-11-03 02:32:01 +00:00
let newpage = newpageresult.unwrap();
2020-11-03 02:32:01 +00:00
assert_eq!(newpage.content, title, "{:?}", newpage.content);
assert_eq!(newpage.id, "nonexistent-page");
2020-10-13 03:43:49 +00:00
2020-11-03 02:32:01 +00:00
assert_eq!(newpage.children.len(), 0);
assert_eq!(newpage.kind, "page");
2020-10-13 03:43:49 +00:00
assert!((newpage.creation_date - now).num_minutes() < 1);
assert!((newpage.updated_date - now).num_minutes() < 1);
assert!((newpage.lastview_date - now).num_minutes() < 1);
assert!(newpage.deleted_date.is_none());
}
2020-11-03 02:32:01 +00:00
//
// fn make_new_note(content: &str) -> structs::NewNote {
// structs::NewNoteBuilder::default()
// .content(content.to_string())
// .build()
// .unwrap()
// }
//
// #[tokio::test(threaded_scheduler)]
// async fn can_nest_notes() {
// let title = "Nonexistent Page";
// let storagepool = fresh_inmemory_database().await;
// let newpageresult = storagepool.get_page_by_title(&title).await;
// let newpage = newpageresult.unwrap();
//
// let root = &newnotes[0];
//
// let note1 = make_new_note("1");
// let note1_uuid = storagepool.insert_nested_note(&note1, &root.uuid, 0).await;
// assert!(note1_uuid.is_ok(), "{:?}", note1_uuid);
// let note1_uuid = note1_uuid.unwrap();
//
// let note2 = make_new_note("2");
// let note2_uuid = storagepool.insert_nested_note(&note2, &root.uuid, 0).await;
// assert!(note2_uuid.is_ok(), "{:?}", note2_uuid);
// let note2_uuid = note2_uuid.unwrap();
//
// let note3 = make_new_note("3");
// let note3_uuid = storagepool.insert_nested_note(&note3, &note1_uuid, 0).await;
// assert!(note3_uuid.is_ok(), "{:?}", note3_uuid);
// let _note3_uuid = note3_uuid.unwrap();
//
// let note4 = make_new_note("4");
// let note4_uuid = storagepool.insert_nested_note(&note4, &note2_uuid, 0).await;
// assert!(note4_uuid.is_ok(), "{:?}", note4_uuid);
// let _note4_uuid = note4_uuid.unwrap();
//
// let newpageresult = storagepool.get_page_by_title(&title).await;
// let (newpage, newnotes) = newpageresult.unwrap();
//
// assert_eq!(newpage.title, title, "{:?}", newpage.title);
// assert_eq!(newpage.slug, "nonexistent-page");
//
// assert_eq!(newnotes.len(), 5);
// assert_eq!(newnotes[0].notetype, "root");
// assert_eq!(newpage.note_id, newnotes[0].id);
// }
}