Increased Code Coverage for errors.rs

Author: RPG-Alex

src/comments.rs

@@ -437,7 +437,7 @@ mod tests {
                 .path()
                 .file_name()
                 .and_then(|s| s.to_str())
-                .map_or_else(|| panic!("test file name should be valid UTF-8"), |val| val);
+                .unwrap_or_else(|| panic!("test file name should be valid UTF-8"));
 
             match filename {
                 "with_single_line_comments.sql" => {

src/docs.rs

@@ -259,12 +259,10 @@ mod tests {
         let tables = vec![table_doc];
         let sql_doc = SqlFileDoc::new(tables);
         let sql_doc_val =
-            sql_doc.tables().first().map_or_else(|| panic!("unable to find tables"), |val| val);
+            sql_doc.tables().first().unwrap_or_else(|| panic!("unable to find table"));
         assert_eq!(sql_doc_val.name(), "user");
-        let sql_doc_val_column = sql_doc_val
-            .columns()
-            .first()
-            .map_or_else(|| panic!("unable to find columns"), |val| val);
+        let sql_doc_val_column =
+            sql_doc_val.columns().first().unwrap_or_else(|| panic!("unable to find columns"));
         assert_eq!(sql_doc_val_column.name(), "id");
     }
 
@@ -285,7 +283,7 @@ mod tests {
                 .path()
                 .file_name()
                 .and_then(|s| s.to_str())
-                .map_or_else(|| panic!("unable to find file name"), |val| val);
+                .unwrap_or_else(|| panic!("unable to find file name"));
 
             match filename {
                 "with_single_line_comments.sql" | "with_mixed_comments.sql" => {
@@ -423,4 +421,11 @@ mod tests {
 
         docs
     }
+
+    #[test]
+    fn test_doc() {
+        let col_doc = ColumnDoc::new("test".to_string(), Some("comment".to_string()));
+        assert_eq!(col_doc.doc(), Some("comment"));
+        assert_eq!(col_doc.name(), "test");
+    }
 }

src/error.rs

@@ -91,7 +91,7 @@ impl From<ParserError> for DocError {
 mod tests {
     use sqlparser::parser::ParserError;
 
-    use crate::{comments::CommentError, error::DocError};
+    use crate::{comments::CommentError, docs::TableDoc, error::DocError};
 
     #[test]
     fn test_doc_errors() {
@@ -120,9 +120,8 @@ mod tests {
 
     #[test]
     fn test_doc_errors_from() {
-        use std::fs;
-
         use crate::comments::Location;
+        use std::fs;
         let Err(io_error) = fs::read_dir("INVALID") else {
             panic!("there should not be a directory called INVALID")
         };
@@ -162,9 +161,8 @@ mod tests {
         };
         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);
+        let src =
+            doc_io.source().unwrap_or_else(|| panic!("expected Some(source) for FileReadError"));
         assert_eq!(src.to_string(), io_err_str);
 
         let comment =
@@ -173,15 +171,52 @@ mod tests {
         let doc_comment = DocError::CommentError(comment);
         let src = doc_comment
             .source()
-            .map_or_else(|| panic!("expected Some(source) for CommentError"), |source| source);
+            .unwrap_or_else(|| panic!("expected Some(source) for CommentError"));
         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);
+            .unwrap_or_else(|| panic!("expected Some(source) for SqlParserError"));
         assert_eq!(src.to_string(), parser_str);
     }
+
+    fn table_doc_for_test(name: &str) -> TableDoc {
+        TableDoc::new(None, name.to_string(), None, vec![])
+    }
+    #[test]
+    fn test_doc_error_display_invalid_object_name() {
+        let e =
+            DocError::InvalidObjectName { message: "bad object".to_string(), line: 12, column: 34 };
+        assert_eq!(e.to_string(), "bad object at line 12, column 34");
+    }
+
+    #[test]
+    fn test_doc_error_display_table_not_found() {
+        let e = DocError::TableNotFound { name: "users".to_string() };
+        assert_eq!(e.to_string(), "Table not found in SqlDoc: users");
+    }
+
+    #[test]
+    fn test_doc_error_display_duplicate_tables_found() {
+        let t1 = table_doc_for_test("dup_table");
+        let t2 = table_doc_for_test("dup_table");
+        let e = DocError::DuplicateTablesFound { tables: vec![t1, t2] };
+        let s = e.to_string();
+        assert!(s.contains("Duplicate tables found:"));
+        assert!(s.contains("dup_table"), "output was: {s}");
+    }
+
+    #[test]
+    fn test_doc_error_source_none_for_non_wrapped_variants() {
+        use std::error::Error as _;
+        let invalid = DocError::InvalidObjectName { message: "x".to_string(), line: 1, column: 1 };
+        assert!(invalid.source().is_none());
+        let not_found = DocError::TableNotFound { name: "x".to_string() };
+        assert!(not_found.source().is_none());
+        let dup = DocError::DuplicateTablesFound { tables: vec![] };
+        assert!(dup.source().is_none());
+    }
 }

src/sql_doc.rs

@@ -11,7 +11,7 @@ use crate::{
 };
 
 /// Structure for Sql Documentation, built from [`TableDoc`] and
-#[derive(Debug, Eq, PartialEq)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub struct SqlDoc {
     /// Holds the [`Vec`] of all tables found in all specified files.
     tables: Vec<TableDoc>,
@@ -205,7 +205,8 @@ mod tests {
     use crate::{
         SqlDoc,
         docs::{ColumnDoc, SqlFileDoc, TableDoc},
-        error::DocError, sql_doc::SqlDocBuilder,
+        error::DocError,
+        sql_doc::SqlDocBuilder,
     };
 
     #[test]
@@ -441,11 +442,11 @@ mod tests {
     #[test]
     fn test_sql_builder_deny_from_path() {
         let actual_builder = SqlDoc::from_path("path").deny("path1").deny("path2").retain_files();
-        let expected_builder = SqlDocBuilder{
+        let expected_builder = SqlDocBuilder {
             source: crate::sql_doc::SqlFileDocSource::File(PathBuf::from("path")),
             deny: vec!["path1".to_string(), "path2".to_string()],
-            retain_files: true
-            };
+            retain_files: true,
+        };
         assert_eq!(actual_builder, expected_builder);
     }
     #[test]
@@ -457,10 +458,19 @@ mod tests {
         let sample = sample_sql();
         let (contents, expected): (Vec<_>, Vec<_>) = sample.into_iter().unzip();
         fs::write(&file, contents.join(""))?;
-        let sql_doc = SqlDoc::from_path(&file).build()?;
-        let sql_doc_deny = SqlDoc::from_dir(&base).deny(file.to_str().map_or_else(|| panic!("could not find path"), |val| val)).retain_files().build()?;
+        let sql_doc = SqlDoc::from_path(&file).retain_files().build()?;
+        let sql_doc_deny = SqlDoc::from_dir(&base)
+            .deny(file.to_str().unwrap_or_else(|| panic!("unable to find file val")))
+            .retain_files()
+            .build()?;
         let doc_deny = SqlDoc::new(vec![], Some(vec![]));
-        let doc = SqlDoc::new(expected.into_iter().flat_map(SqlDoc::into_tables).collect(), None);
+        let doc = SqlDoc::new(
+            expected.clone().into_iter().flat_map(SqlDoc::into_tables).collect(),
+            Some(vec![(
+                file,
+                SqlFileDoc::new(expected.into_iter().flat_map(SqlDoc::into_tables).collect()),
+            )]),
+        );
         assert_eq!(sql_doc, doc);
         assert_eq!(sql_doc_deny, doc_deny);
         let _ = fs::remove_dir_all(&base);