test coverage grown to 100% function coverage

Author: RPG-Alex

src/comments.rs

@@ -9,7 +9,7 @@ use crate::ast::ParsedSqlFile;
 
 /// Structure for holding a location in the file. Assumes file is first split by
 /// lines and then split by characters (column)
-#[derive(Debug, Eq, PartialEq, PartialOrd)]
+#[derive(Clone, Debug, Eq, PartialEq, PartialOrd)]
 pub struct Location {
     line: u64,
     column: u64,
@@ -46,7 +46,7 @@ impl Default for Location {
 }
 
 /// A structure for holding the span of comments found
-#[derive(Debug, Eq, PartialEq)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub struct Span {
     start: Location,
     end: Location,
@@ -104,7 +104,7 @@ impl CommentKind {
 }
 
 /// Structure for containing the [`CommentKind`] and the [`Span`] for a comment
-#[derive(Debug, Eq, PartialEq)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub struct Comment {
     kind: CommentKind,
     span: Span,
@@ -184,37 +184,6 @@ impl std::error::Error for CommentError {}
 /// Alias for comment results that may return a [`CommentError`]
 pub type CommentResult<T> = Result<T, CommentError>;
 
-/// Structure that holds the comment along with its location in the file
-pub struct CommentWithSpan {
-    comment: Comment,
-    span: Span,
-}
-
-impl CommentWithSpan {
-    /// Method for creating a new [`CommentWithSpan`] from the comment
-    /// [`String`] and the [`Span`]
-    ///
-    /// # Parameters
-    /// - the comment as a [`String`]
-    /// - the span of the comment as a [`Span`]
-    #[must_use]
-    pub const fn new(comment: Comment, span: Span) -> Self {
-        Self { comment, span }
-    }
-
-    /// Getter method for retrieving the comment content
-    #[must_use]
-    pub const fn comment(&self) -> &Comment {
-        &self.comment
-    }
-
-    /// Getter method for retrieving the [`Span`] of the comment
-    #[must_use]
-    pub const fn span(&self) -> &Span {
-        &self.span
-    }
-}
-
 /// Structure for holding all comments found in the document
 #[derive(Debug, Eq, PartialEq)]
 pub struct Comments {
@@ -602,3 +571,37 @@ fn multiline_comment_spans_are_correct() {
         "end column should be after start column for primary key multiline comment",
     );
 }
+
+#[test]
+fn test_comment_error() {
+    let unterminated = CommentError::UnterminatedMultiLineComment { start: Location::default() };
+    let location = Location { line: 1, column: 1 };
+    let expected = format!(
+        "unterminated block comment with start at line {}, column {}",
+        location.line(),
+        location.column()
+    );
+    assert_eq!(unterminated.to_string(), expected);
+}
+
+#[test]
+fn test_comments() {
+    let comment_vec = vec![
+        Comment::new(
+            CommentKind::SingleLine("a comment".to_string()),
+            Span { start: Location::new(1, 1), end: Location::new(1, 12) },
+        ),
+        Comment::new(
+            CommentKind::SingleLine("a second comment".to_string()),
+            Span { start: Location::new(1, 1), end: Location::new(2, 19) },
+        ),
+    ];
+    let length = comment_vec.len();
+    let comments = Comments::new(comment_vec.clone());
+    assert!(comments.comments().len() == length);
+    for (i, comment) in comments.comments().iter().enumerate() {
+        assert_eq!(comment.kind().comment(), comment_vec[i].kind().comment());
+        assert_eq!(comment.span().start(), comment_vec[i].span().start());
+        assert_eq!(comment.span().end(), comment_vec[i].span().end());
+    }
+}

src/docs.rs

@@ -188,7 +188,6 @@ mod tests {
 
             match file.file().path().to_str().unwrap() {
                 "sql_files/with_single_line_comments.sql" => {
-                    dbg!("testing with single line comments");
                     let expected = SqlDocs::new(vec![
                         TableDoc::new(
                             "users".to_string(),
@@ -234,7 +233,6 @@ mod tests {
                     assert_eq!(docs, expected);
                 }
                 "sql_files/with_multiline_comments.sql" => {
-                    dbg!("testing with multiline comments");
                     let expected = SqlDocs::new(vec![
                         TableDoc::new(
                             "users".to_string(),
@@ -294,7 +292,6 @@ mod tests {
                     assert_eq!(docs, expected);
                 }
                 "sql_files/with_mixed_comments.sql" => {
-                    dbg!("testing with mixed comments");
                     // Mixed should still produce the same final docs as the pure single-line
                     // version.
                     let expected = SqlDocs::new(vec![
@@ -342,7 +339,6 @@ mod tests {
                     assert_eq!(docs, expected);
                 }
                 "sql_files/without_comments.sql" => {
-                    dbg!("testing with no comments");
                     let expected = SqlDocs::new(vec![
                         TableDoc::new(
                             "users".to_string(),
@@ -378,5 +374,4 @@ mod tests {
             }
         }
     }
-
 }

src/files.rs

@@ -303,7 +303,5 @@ mod tests {
 
         let bad_file_list = SqlFileSet::new(Path::new(invalid_dir), None);
         assert!(bad_file_list.is_err())
-
     }
 }
-

src/lib.rs

@@ -7,6 +7,7 @@
 use core::fmt;
 use std::{
     error,
+    fmt::Debug,
     path::{Path, PathBuf},
 };
 
@@ -37,7 +38,7 @@ pub enum DocError {
 impl fmt::Display for DocError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            Self::FileReadError(error) => write!(f, "file read error:{error}"),
+            Self::FileReadError(error) => write!(f, "file read error: {error}"),
             Self::CommentError(comment_error) => {
                 write!(f, "comment parse error: {comment_error}")
             }
@@ -199,3 +200,83 @@ fn test_with_no_deny_list_from_files() {
         }
     }
 }
+#[test]
+fn test_doc_errors() {
+    use std::fs;
+
+    use crate::comments::Location;
+    let invalid_dir = "INVALID";
+    let io_error = fs::read_dir(invalid_dir).unwrap_err();
+    let io_error_str = io_error.to_string();
+    let read_error = DocError::FileReadError(io_error);
+    let expected_read_error = "file read error: ".to_owned().to_string() + &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 invalid_dir = "INVALID";
+    let io_error = fs::read_dir(invalid_dir).unwrap_err();
+    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 io_err = fs::read_dir("INVALID").unwrap_err();
+    let io_err_str = io_err.to_string();
+    let doc_io = DocError::FileReadError(io_err);
+    let src = doc_io.source().expect("expected Some(source) for FileReadError");
+    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().expect("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().expect("expected Some(source) for SqlParserError");
+    assert_eq!(src.to_string(), parser_str);
+}