From ef48fde890c71da26b0ef6d52d797475b64b8cd2 Mon Sep 17 00:00:00 2001 From: Jeff Baskin Date: Wed, 15 Feb 2023 09:47:15 -0500 Subject: [PATCH] Finished out Entry's new and get functions. --- src/morethantext/cache.rs | 69 ++++++++++++++++++++++++++++++++++++--- 1 file changed, 65 insertions(+), 4 deletions(-) diff --git a/src/morethantext/cache.rs b/src/morethantext/cache.rs index 77b13a0..ddc25db 100644 --- a/src/morethantext/cache.rs +++ b/src/morethantext/cache.rs @@ -1,5 +1,5 @@ use super::{DBError, FileData, SessionData, Store}; -use async_std::{fs::write, path::Path}; +use async_std::{fs::{read, write}, path::Path}; use rand::{distributions::Alphanumeric, thread_rng, Rng}; use std::{ cell::Cell, @@ -94,6 +94,16 @@ impl Entry { async fn new(filename: String, data: DataType) -> Result { if Path::new(&filename).exists().await { return Err(DBError::new("entry already exists")); + } else { + let filepath = Path::new(&filename); + match write(filepath, data.to_bytes()).await { + Ok(_) => (), + Err(err) => { + let mut error = DBError::new("failed to write"); + error.add_source(err); + return Err(error); + } + } } Ok(Self { data: data, @@ -102,7 +112,12 @@ impl Entry { }) } + fn elapsed(&self) -> Duration { + self.last_used.get().elapsed() + } + async fn get(&self) -> Result { + self.last_used.set(Instant::now()); Ok(self.data.clone()) } } @@ -167,9 +182,9 @@ mod datatype_file { let mut store = Store::new(); let mut dt_store = DataType::new("store").unwrap(); let mut expected = dt_store.to_bytes(); - store.add("database", name, id); + store.add("database", name, id).unwrap(); expected.append(&mut store.to_bytes()); - dt_store.add("database", name, id); + dt_store.add("database", name, id).unwrap(); assert_eq!(dt_store.to_bytes(), expected); } @@ -224,8 +239,21 @@ mod datatype_file { #[cfg(test)] mod entry { use super::*; + use std::error::Error; use tempfile::tempdir; + #[async_std::test] + async fn get_elapsed_time() { + let dir = tempdir().unwrap(); + let data = DataType::new("store").unwrap(); + let filepath = dir.path().join("count"); + let filename = filepath.to_str().unwrap(); + let item = Entry::new(filename.to_string(), data).await.unwrap(); + assert!(Duration::from_secs(1) > item.elapsed(), "last_used should have been now."); + item.last_used.set(Instant::now() - Duration::from_secs(500)); + assert!(Duration::from_secs(499) < item.elapsed(), "The duration should have increased."); + } + #[async_std::test] async fn create() { let dir = tempdir().unwrap(); @@ -236,15 +264,36 @@ mod entry { let item = Entry::new(filename.to_string(), data.clone()) .await .unwrap(); + assert!(Duration::from_secs(1) > item.elapsed(), "last_used should have been now."); let output = item.get().await.unwrap(); assert_eq!( data.list(["database"].to_vec()).unwrap(), output.list(["database"].to_vec()).unwrap() ); + assert!(filepath.is_file(), "Should have created the entry file."); + let content = read(&filepath).await.unwrap(); + assert_eq!(content, data.to_bytes()); } #[async_std::test] - async fn no_over_writes() -> Result<(), DBError> { + async fn create_errors_on_bad_files() -> Result<(), DBError> { + let dir = tempdir().unwrap(); + let data = DataType::new("store").unwrap(); + let filepath = dir.path().join("bad").join("path"); + let filename = filepath.to_str().unwrap(); + match Entry::new(filename.to_string(), data).await { + Ok(_) => Err(DBError::new("bad file names should raise an error")), + Err(err) => { + assert_eq!(err.to_string(), "failed to write"); + assert!(err.source().is_some(), "Must include the source error."); + assert!(err.source().unwrap().to_string().contains("could not write to file")); + Ok(()) + } + } + } + + #[async_std::test] + async fn create_does_not_over_writes() -> Result<(), DBError> { let dir = tempdir().unwrap(); let id = "wicked"; let file = dir.path().join(id); @@ -263,6 +312,18 @@ mod entry { } } } + + #[async_std::test] + async fn get_updates_last_used() { + let dir = tempdir().unwrap(); + let data = DataType::new("store").unwrap(); + let filepath = dir.path().join("holder"); + let filename = filepath.to_str().unwrap(); + let item = Entry::new(filename.to_string(), data).await.unwrap(); + item.last_used.set(Instant::now() - Duration::from_secs(300)); + item.get().await.unwrap(); + assert!(Duration::from_secs(1) > item.elapsed(), "last_used should have been reset."); + } } #[cfg(test)]