Sloppy update.

src/main.rs

@@ -13,14 +13,14 @@ use settings::Settings;
 #[async_std::main]
 async fn main() -> tide::Result<()> {
     let sett = Settings::new().unwrap();
-    let app = app_setup().await;
+    let app = app_setup(sett.data_dir.as_str()).await;
     app.listen(format!("{}:{}", sett.address, sett.port))
         .await?;
     Ok(())
 }
 
-async fn app_setup() -> tide::Server<MoreThanText> {
-    let db = MoreThanText::new().await;
+async fn app_setup(data_dir: &str) -> tide::Server<MoreThanText> {
+    let db = MoreThanText::new(data_dir).await.unwrap();
     let mut app = tide::with_state(db);
     app.at("/").get(home);
     app.with(
@@ -48,11 +48,13 @@ async fn home(_req: Request<MoreThanText>) -> tide::Result {
 #[cfg(test)]
 mod server_app {
     use super::*;
+    use tempfile::tempdir;
     use tide_testing::TideTestingExt;
 
     #[async_std::test]
     async fn home_page_available() {
-        let app = app_setup().await;
+        let dir = tempdir().unwrap();
+        let app = app_setup(dir.path().to_str().unwrap()).await;
         let response = app.get("/").await.unwrap();
         assert_eq!(response.status(), StatusCode::Ok);
     }

src/morethantext/mod.rs

@@ -1,135 +1,66 @@
 pub mod error;
+use async_std::{fs::create_dir, path::Path};
 
-use async_std::sync::{Arc, RwLock};
 use error::DBError;
-use std::collections::HashMap;
+
+const DATA: &str = "data";
 
 #[derive(Clone)]
-pub struct MoreThanText {
-    databases: Arc<RwLock<HashMap<String, Database>>>,
-}
+pub struct MoreThanText;
 
 impl MoreThanText {
-    pub async fn new() -> Self {
-        Self {
-            databases: Arc::new(RwLock::new(HashMap::new())),
-        }
-    }
-
-    async fn create_database(&self, name: &str) -> Result<(), DBError> {
-        let mut databases = self.databases.write().await;
-        match databases.get(name) {
-            Some(_) => Err(DBError::new("duplicate database name")),
-            None => {
-                let db = Database::new().await;
-                databases.insert(name.to_string(), db);
-                Ok(())
-            }
-        }
-    }
-
-    async fn use_database(&self, name: &str) -> Result<Database, DBError> {
-        let databases = self.databases.read().await;
-        match databases.get(name) {
-            Some(db) => Ok(db.clone()),
-            None => Err(DBError::new("database name not found")),
-        }
-    }
-}
-
-#[derive(Clone)]
-struct Database;
-
-impl Database {
-    async fn new() -> Self {
-        Self {}
-    }
-
-    async fn add_table(&self, _name: &str) {}
-}
-
-#[cfg(test)]
-mod engine_functions {
-    use super::*;
-
-    #[async_std::test]
-    async fn create_database() {
-        let mtt = MoreThanText::new().await;
-        mtt.create_database("smith").await.unwrap();
-    }
-
-    #[async_std::test]
-    async fn database_names_must_be_unique() -> Result<(), DBError> {
-        let mtt = MoreThanText::new().await;
-        let msg = "duplicate database name";
-        mtt.create_database("john").await.unwrap();
-        match mtt.create_database("john").await {
-            Ok(_) => Err(DBError::new("Duplicate names should cause error")),
-            Err(err) => {
-                if err.to_string() == msg {
-                    Ok(())
-                } else {
-                    Err(DBError::new(format!(
-                        "incorrect err message: got: '{}' want: '{}'",
-                        err.to_string(),
-                        msg
-                    )))
+    pub async fn new(dir: &str) -> Result<Self, DBError> {
+        let data_dir = Path::new(dir).join(DATA);
+        if !data_dir.is_dir().await {
+            match create_dir(data_dir).await {
+                Ok(_) => (),
+                Err(err) => {
+                    let mut error = DBError::new("failed to initialize");
+                    error.add_source(err);
+                    return Err(error);
                 }
             }
         }
-    }
-
-    #[async_std::test]
-    async fn use_database() -> Result<(), DBError> {
-        let mtt = MoreThanText::new().await;
-        let dbname = "Johnson";
-        mtt.create_database(dbname).await.unwrap();
-        mtt.use_database(dbname).await.unwrap();
-        Ok(())
-    }
-
-    #[async_std::test]
-    async fn use_missing_database() -> Result<(), DBError> {
-        let error = "database name not found";
-        let mtt = MoreThanText::new().await;
-        match mtt.use_database("ssmith").await {
-            Ok(_) => Err(DBError::new("Should raise database missing error")),
-            Err(err) => {
-                if err.to_string() == error {
-                    Ok(())
-                } else {
-                    Err(DBError::new(format!(
-                        "Incorrect error message: Got '{}' Want '{}'",
-                        err.to_string(),
-                        error
-                    )))
-                }
-            }
-        }
-    }
-
-    #[async_std::test]
-    async fn create_get_table() {
-        let db = "thedatabase";
-        let mtt = MoreThanText::new().await;
-        mtt.create_database(db).await.unwrap();
-        let dbase = mtt.use_database(db).await.unwrap();
-        dbase.add_table("melvin").await;
+        Ok(Self {})
     }
 }
 
 #[cfg(test)]
-mod database_functions {
+mod init {
     use super::*;
+    use std::error::Error;
+    use tempfile::tempdir;
 
     #[async_std::test]
-    async fn new_database() {
-        Database::new().await;
+    async fn create_data_dir() {
+        let dir = tempdir().unwrap();
+        MoreThanText::new(dir.path().to_str().unwrap())
+            .await
+            .unwrap();
+        let data_dir = dir.path().join(DATA);
+        assert!(data_dir.is_dir(), "Did not create the data directory.");
+        dir.close().unwrap();
     }
 
     #[async_std::test]
-    async fn new_table() {
-        let db = Database::new().await;
-        db.add_table("fred").await;
+    async fn existing_data_dir() {
+        let dir = tempdir().unwrap();
+        let data_dir = dir.path().join(DATA);
+        create_dir(data_dir).await.unwrap();
+        MoreThanText::new(dir.path().to_str().unwrap())
+            .await
+            .unwrap();
+        dir.close().unwrap();
+    }
+
+    #[async_std::test]
+    async fn bad_data_dir() {
+        match MoreThanText::new("kljsdgfhslkfrh").await {
+            Ok(_) => assert!(false, "This test should fail to create a data directory"),
+            Err(err) => {
+                assert_eq!(err.to_string(), "failed to initialize");
+                assert!(err.source().is_some(), "Must include the source error.");
+            }
+        };
     }
 }

src/morethantext/old-mod3.rs

@@ -0,0 +1,153 @@
+pub mod error;
+
+use async_std::sync::{Arc, RwLock};
+use error::DBError;
+use std::collections::HashMap;
+
+#[derive(Clone)]
+pub struct MoreThanText {
+    databases: Arc<RwLock<HashMap<String, Database>>>,
+}
+
+impl MoreThanText {
+    pub async fn new() -> Self {
+        Self {
+            databases: Arc::new(RwLock::new(HashMap::new())),
+        }
+    }
+
+    async fn create_database(&self, name: &str) -> Result<(), DBError> {
+        let mut databases = self.databases.write().await;
+        match databases.get(name) {
+            Some(_) => Err(DBError::new("duplicate database name")),
+            None => {
+                let db = Database::new().await;
+                databases.insert(name.to_string(), db);
+                Ok(())
+            }
+        }
+    }
+
+    async fn use_database(&self, name: &str) -> Result<Database, DBError> {
+        let databases = self.databases.read().await;
+        match databases.get(name) {
+            Some(db) => Ok(db.clone()),
+            None => Err(DBError::new("database name not found")),
+        }
+    }
+}
+
+#[derive(Clone)]
+struct Database;
+
+impl Database {
+    async fn new() -> Self {
+        Self {}
+    }
+
+    async fn add_table(&self, _name: &str) {}
+}
+
+struct Table;
+
+impl Table {
+    async fn new() -> Self {
+        Self {}
+    }
+}
+
+#[cfg(test)]
+mod engine_functions {
+    use super::*;
+
+    #[async_std::test]
+    async fn create_database() {
+        let mtt = MoreThanText::new().await;
+        mtt.create_database("smith").await.unwrap();
+    }
+
+    #[async_std::test]
+    async fn database_names_must_be_unique() -> Result<(), DBError> {
+        let mtt = MoreThanText::new().await;
+        let msg = "duplicate database name";
+        mtt.create_database("john").await.unwrap();
+        match mtt.create_database("john").await {
+            Ok(_) => Err(DBError::new("Duplicate names should cause error")),
+            Err(err) => {
+                if err.to_string() == msg {
+                    Ok(())
+                } else {
+                    Err(DBError::new(format!(
+                        "incorrect err message: got: '{}' want: '{}'",
+                        err.to_string(),
+                        msg
+                    )))
+                }
+            }
+        }
+    }
+
+    #[async_std::test]
+    async fn use_database() -> Result<(), DBError> {
+        let mtt = MoreThanText::new().await;
+        let dbname = "Johnson";
+        mtt.create_database(dbname).await.unwrap();
+        mtt.use_database(dbname).await.unwrap();
+        Ok(())
+    }
+
+    #[async_std::test]
+    async fn use_missing_database() -> Result<(), DBError> {
+        let error = "database name not found";
+        let mtt = MoreThanText::new().await;
+        match mtt.use_database("ssmith").await {
+            Ok(_) => Err(DBError::new("Should raise database missing error")),
+            Err(err) => {
+                if err.to_string() == error {
+                    Ok(())
+                } else {
+                    Err(DBError::new(format!(
+                        "Incorrect error message: Got '{}' Want '{}'",
+                        err.to_string(),
+                        error
+                    )))
+                }
+            }
+        }
+    }
+
+    #[async_std::test]
+    async fn create_get_table() {
+        let db = "thedatabase";
+        let mtt = MoreThanText::new().await;
+        mtt.create_database(db).await.unwrap();
+        let dbase = mtt.use_database(db).await.unwrap();
+        dbase.add_table("melvin").await;
+    }
+}
+
+#[cfg(test)]
+mod database_functions {
+    use super::*;
+
+    #[async_std::test]
+    async fn new_database() {
+        Database::new().await;
+    }
+
+    #[async_std::test]
+    async fn new_table() {
+        let db = Database::new().await;
+        db.add_table("fred").await;
+    }
+}
+
+#[cfg(test)]
+mod table_functions {
+    use super::*;
+
+    #[async_std::test]
+    async fn new_table() {
+        Table::new().await;
+    }
+}

src/settings.rs

@@ -1,18 +1,23 @@
 use config::{Config, ConfigError};
 use serde::Deserialize;
+use std::env::current_dir;
 
 #[derive(Debug, Deserialize)]
 //#[allow(unused)]
 pub struct Settings {
     pub address: String,
     pub port: u16,
+    pub data_dir: String,
 }
 
 impl Settings {
     pub fn new() -> Result<Self, ConfigError> {
+        let working_dir = current_dir().unwrap();
+        let data_dir = working_dir.to_str().unwrap();
         let s = Config::builder()
             .set_default("port", 9090)?
             .set_default("address", "127.0.0.1")?
+            .set_default("data_dir", data_dir)?
             .add_source(config::File::with_name("morethantext").required(false))
             .add_source(
                 config::Environment::with_prefix("MTT")
@@ -34,9 +39,12 @@ mod settings_tests {
     #[serial]
     fn defaults() {
         let set = Settings::new().unwrap();
+        let working_dir = current_dir().unwrap();
+        let data_dir = working_dir.to_str().unwrap();
         println!("{:?}", set);
         assert_eq!(set.port, 9090);
         assert_eq!(set.address, "127.0.0.1");
+        assert_eq!(set.data_dir, data_dir);
     }
 
     #[test]