Began implementing testing

Author: RPG-Alex

README.md

@@ -30,51 +30,40 @@ CREATE TABLE users (
 );
 ```
 A rudimentary implementation can be generated with:
-```rust,no_run
-use sql_docs::generate_docs_from_dir_no_deny;
-use std::path::Path;
+```rust
+use sql_docs::SqlDoc;
+use sql_docs::error::DocError;
+use std::{env, fs, path::Path};
 
-fn main() -> Result<(), sql_docs::DocError> {
-    // Directory containing your .sql files
-    let directory = "sql_dir";
-
-    // Extract table + column documentation
-    let docs = generate_docs_from_dir_no_deny(directory)?;
-
-    // Format and print each table and table's columns
-    for (path, sql_docs) in docs {
-        println!("File: {}", path.display());
-        for table in sql_docs.tables() {
-            println!("  Table: {}", table.name());
-            if let Some(doc) = table.doc() {
-                println!("    Comment: {}", doc);
-            }
-            println!("    Columns:");
-            for column in table.columns() {
-                println!("      - {}", column.name());
-                if let Some(col_doc) = column.doc() {
-                    println!("          {}", col_doc);
-                }
-            }
-        }
-    }
+fn main() -> Result<(), DocError> {
+    // tmp dir and file created for demonstration purposes
+    let base = env::temp_dir().join("tmp_dir");
+    let _ = fs::remove_dir_all(&base);
+    fs::create_dir_all(&base)?;
+    let example = base.join("example.sql");
+    fs::write(&example, r#"/* Table storing user accounts */
+    CREATE TABLE users (
+        /* Primary key for each user */
+        id INTEGER PRIMARY KEY,
+        -- The user's login name
+        username VARCHAR(255) NOT NULL,
+        /* User's email address */
+        email VARCHAR(255) UNIQUE NOT NULL
+    );"#)?;
 
+    // Extract table & column documentation
+    let docs = SqlDoc::from_path(&example).build()?;
+    // Verify that the table name is correct
+    assert_eq!(docs.tables().first().expect("hardcoded value").name(), "users");
+    // Verify extraction of table comment
+    assert_eq!(docs.tables().first().expect("hardcoded value").doc(), Some("Table storing user accounts"));
+    // Verify First Column name and comment
+    assert_eq!(docs.tables().first().expect("hardcoded value").columns().first().expect("hardcoded value").name(), "id");
+    assert_eq!(docs.tables().first().expect("hardcoded value").columns().first().expect("hardcoded value").doc(), Some("Primary key for each user"));
+    let _ = fs::remove_dir_all(&base);
     Ok(())
 }
 ```
-Which should output:
-```bash
-File: sql_dir/users.sql
-  Table: users
-    Comment: Table storing user accounts
-    Columns:
-      - id
-          Primary key for each user
-      - username
-          The user's login name
-      - email
-          User's email address
-```
 ## Use cases
 
 This crate is designed for generating documentation from SQL schemas by attaching comments to:

src/error.rs

@@ -86,3 +86,104 @@ impl From<ParserError> for DocError {
         Self::SqlParserError(e)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use sqlparser::parser::ParserError;
+
+    use crate::{
+        error::DocError, comments::CommentError
+    };
+
+    #[test]
+    fn test_doc_errors() {
+        use std::fs;
+
+        use crate::comments::Location;
+        let Err(io_error) = fs::read_dir("INVALID") else {
+            panic!("there should not be a directory called INVALID")
+        };
+        let io_error_str = io_error.to_string();
+        let read_error = DocError::FileReadError(io_error);
+        let expected_read_error = "file read error: ".to_owned() + &io_error_str;
+        assert!(read_error.to_string().contains(&expected_read_error));
+
+        let comment_error = DocError::CommentError(CommentError::UnmatchedMultilineCommentStart {
+            location: Location::default(),
+        });
+        let expected_comment_error =
+            "comment parse error: unmatched block comment start at line 1, column 1";
+        assert_eq!(comment_error.to_string(), expected_comment_error);
+
+        let sql_error = DocError::SqlParserError(ParserError::RecursionLimitExceeded);
+        let expected_sql_error = "SQL parse error sql parser error: recursion limit exceeded";
+        assert_eq!(sql_error.to_string(), expected_sql_error);
+    }
+
+    #[test]
+    fn test_doc_errors_from() {
+        use std::fs;
+
+        use crate::comments::Location;
+        let Err(io_error) = fs::read_dir("INVALID") else {
+            panic!("there should not be a directory called INVALID")
+        };
+        let io_kind = io_error.kind();
+        let doc_io_error = DocError::from(io_error);
+        match doc_io_error {
+            DocError::FileReadError(inner) => assert_eq!(inner.kind(), io_kind),
+            _ => panic!("expected instance of DocError::FileReadError"),
+        }
+
+        let comment_error =
+            CommentError::UnmatchedMultilineCommentStart { location: Location::default() };
+        let comment_error_str = comment_error.to_string();
+        let doc_comment_error: DocError = comment_error.into();
+        match doc_comment_error {
+            DocError::CommentError(inner) => assert_eq!(inner.to_string(), comment_error_str),
+            _ => panic!("expected instance of DocError::CommentError"),
+        }
+
+        let parser_error = ParserError::RecursionLimitExceeded;
+        let parser_error_str = parser_error.to_string();
+        let doc_parser_error: DocError = parser_error.into();
+        match doc_parser_error {
+            DocError::SqlParserError(inner) => assert_eq!(inner.to_string(), parser_error_str),
+            _ => panic!("expected instance of DocError::SqlParserError"),
+        }
+    }
+
+    #[test]
+    fn test_doc_error_source() {
+        use std::{error::Error, fs};
+
+        use crate::comments::Location;
+
+        let Err(io_err) = fs::read_dir("INVALID") else {
+            panic!("there should not be a directory called INVALID")
+        };
+        let io_err_str = io_err.to_string();
+        let doc_io = DocError::FileReadError(io_err);
+        let src = doc_io
+            .source()
+            .map_or_else(|| panic!("expected Some(source) for FileReadError"), |source| source);
+        assert_eq!(src.to_string(), io_err_str);
+
+        let comment =
+            CommentError::UnmatchedMultilineCommentStart { location: Location::default() };
+        let comment_str = comment.to_string();
+        let doc_comment = DocError::CommentError(comment);
+        let src = doc_comment
+            .source()
+            .map_or_else(|| panic!("expected Some(source) for CommentError"), |source| source);
+        assert_eq!(src.to_string(), comment_str);
+
+        let parser = ParserError::RecursionLimitExceeded;
+        let parser_str = parser.to_string();
+        let doc_parser = DocError::SqlParserError(parser);
+        let src = doc_parser
+            .source()
+            .map_or_else(|| panic!("expected Some(source) for SqlParserError"), |source| source);
+        assert_eq!(src.to_string(), parser_str);
+    }
+}

src/files.rs

@@ -188,7 +188,7 @@ mod tests {
     #[test]
     fn test_recursive_scan_finds_only_sql_files_recursively()
     -> Result<(), Box<dyn std::error::Error>> {
-        let base = env::temp_dir().join("recursive_scan_test");
+        let base = env::temp_dir().join("recursive_scan_test_sql");
         let _ = fs::remove_dir_all(&base);
         fs::create_dir_all(&base)?;
         let sub = base.join("subdir");
@@ -210,6 +210,30 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn test_recursive_dir_scan_errs() -> Result<(), Box<dyn std::error::Error>>{
+        let base = env::temp_dir().join("recursive_scan_test");
+        let _ = fs::remove_dir_all(&base);
+        fs::create_dir_all(&base)?;
+        let sub = base.join("subdir");
+        fs::create_dir_all(&sub)?;
+        let file1 = base.join("one.sql");
+        let file2 = sub.join("two.sql");
+        let non_sql1 = base.join("ignore.txt");
+        let non_sql2 = sub.join("README.md");
+        fs::File::create(&file1)?;
+        fs::File::create(&file2)?;
+        fs::File::create(&non_sql1)?;
+        fs::File::create(&non_sql2)?;
+        
+        let bad_path = Path::new("bad_path");
+        let bad_dir_scan = recursive_dir_scan(bad_path);
+        assert!(bad_dir_scan.is_err());
+
+        let _ = fs::remove_dir_all(&base);
+        Ok(()) 
+    }
+
     #[test]
     fn test_sql_file_list() -> Result<(), Box<dyn std::error::Error>> {
         let base = env::temp_dir().join("recursive_scan_test2");