test(syntax): keep the parse error position tests in their own file

test_fixes.rs grew past the 2,000-line limit once main's tests joined
it; the tests that check where a parse error points and what it says
move to test_parse_errors.rs.

Author: kvlonge

crates/sqlquack-syntax-snowflake/tests/parser.rs

@@ -8,6 +8,8 @@ mod test_fixes;
 mod test_located;
 #[path = "parser/test_lossless.rs"]
 mod test_lossless;
+#[path = "parser/test_parse_errors.rs"]
+mod test_parse_errors;
 #[path = "parser/test_scripting.rs"]
 mod test_scripting;
 #[path = "parser/test_snowflake_alter.rs"]

crates/sqlquack-syntax-snowflake/tests/parser/test_fixes.rs

@@ -1,12 +1,10 @@
 use serde_json::json;
 
-use sqlquack_syntax::{CallMode, Dialect, ParseOptions};
-use sqlquack_syntax_snowflake::parse_statements_with;
+use sqlquack_syntax::{CallMode, Dialect};
 
 use crate::helpers::{accepted, cast_targets, projection_at, statement_at, statements};
 use crate::test_types::{
-    AcceptanceTestCase, CastTargetTestCase, ParseErrorTestCase, ParseMessageTestCase,
-    ProjectionTestCase, StatementTestCase,
+    AcceptanceTestCase, CastTargetTestCase, ProjectionTestCase, StatementTestCase,
 };
 
 #[test]
@@ -1952,105 +1950,3 @@ fn given_a_keyword_lambda_parameter_when_parsing_duckdb_then_it_names_the_parame
         );
     }
 }
-
-#[test]
-fn given_group_or_order_by_after_an_operator_when_parsing_snowflake_then_the_error_is_at_the_clause(
-) {
-    let test_cases = [
-        ParseErrorTestCase {
-            description: "AND before GROUP BY on the next line fails at GROUP, not at BY",
-            sql: "SELECT customer_id, SUM(total) AS revenue\nFROM orders\nWHERE status = 'shipped' AND\nGROUP BY customer_id",
-            expected_error_at: Some("GROUP"),
-        },
-        ParseErrorTestCase {
-            description: "AND before ORDER BY on the same line fails at ORDER",
-            sql: "SELECT order_id FROM orders WHERE total > 1 AND ORDER BY order_id",
-            expected_error_at: Some("ORDER"),
-        },
-        ParseErrorTestCase {
-            description: "NOT before GROUP BY fails at GROUP",
-            sql: "SELECT status FROM orders WHERE NOT\ngroup by status",
-            expected_error_at: Some("group"),
-        },
-        ParseErrorTestCase {
-            description: "GROUP BY and ORDER BY after WHERE still parse",
-            sql: "SELECT status FROM orders WHERE total > 1\nGROUP BY status\nORDER BY status",
-            expected_error_at: None,
-        },
-        ParseErrorTestCase {
-            description: "a quoted GROUP column still parses",
-            sql: "SELECT \"GROUP\" FROM orders ORDER BY 1",
-            expected_error_at: None,
-        },
-    ];
-
-    for test_case in test_cases {
-        let error_at = parse_statements_with(
-            test_case.sql,
-            Dialect::Snowflake,
-            &ParseOptions::default(),
-            CallMode::Faithful,
-        )
-        .err()
-        .map(|error| {
-            let start = error.start().unwrap_or_default();
-            let end = error.end().unwrap_or_default();
-            test_case.sql.get(start..end).unwrap_or_default().to_owned()
-        });
-        assert_eq!(
-            error_at.as_deref(),
-            test_case.expected_error_at,
-            "{}",
-            test_case.description
-        );
-    }
-}
-
-#[test]
-fn given_a_statement_ending_where_an_expression_belongs_when_parsing_snowflake_then_the_error_names_what_is_missing(
-) {
-    let test_cases = [
-        ParseMessageTestCase {
-            description: "an empty WHERE asks for a condition",
-            sql: "SELECT * FROM orders WHERE",
-            expected_message: "Expected a condition after WHERE",
-        },
-        ParseMessageTestCase {
-            description: "an empty WHERE before a semicolon asks for a condition",
-            sql: "SELECT * FROM orders WHERE ;",
-            expected_message: "Expected a condition after WHERE",
-        },
-        ParseMessageTestCase {
-            description: "an empty HAVING asks for a condition",
-            sql: "SELECT status FROM orders GROUP BY status HAVING",
-            expected_message: "Expected a condition after HAVING",
-        },
-        ParseMessageTestCase {
-            description: "a join's empty ON asks for a condition",
-            sql: "SELECT 1 FROM orders o JOIN customers c ON",
-            expected_message: "Expected a condition after ON",
-        },
-        ParseMessageTestCase {
-            description: "a comparison with no right side asks for an expression",
-            sql: "SELECT 1 FROM orders WHERE total >",
-            expected_message: "Expected an expression after >",
-        },
-    ];
-
-    for test_case in test_cases {
-        let message = parse_statements_with(
-            test_case.sql,
-            Dialect::Snowflake,
-            &ParseOptions::default(),
-            CallMode::Faithful,
-        )
-        .err()
-        .map(|error| error.to_string())
-        .unwrap_or_default();
-        assert!(
-            message.contains(test_case.expected_message),
-            "{}: {message}",
-            test_case.description
-        );
-    }
-}

crates/sqlquack-syntax-snowflake/tests/parser/test_parse_errors.rs

@@ -0,0 +1,106 @@
+use sqlquack_syntax::{CallMode, Dialect, ParseOptions};
+use sqlquack_syntax_snowflake::parse_statements_with;
+
+use crate::test_types::{ParseErrorTestCase, ParseMessageTestCase};
+
+#[test]
+fn given_group_or_order_by_after_an_operator_when_parsing_snowflake_then_the_error_is_at_the_clause(
+) {
+    let test_cases = [
+        ParseErrorTestCase {
+            description: "AND before GROUP BY on the next line fails at GROUP, not at BY",
+            sql: "SELECT customer_id, SUM(total) AS revenue\nFROM orders\nWHERE status = 'shipped' AND\nGROUP BY customer_id",
+            expected_error_at: Some("GROUP"),
+        },
+        ParseErrorTestCase {
+            description: "AND before ORDER BY on the same line fails at ORDER",
+            sql: "SELECT order_id FROM orders WHERE total > 1 AND ORDER BY order_id",
+            expected_error_at: Some("ORDER"),
+        },
+        ParseErrorTestCase {
+            description: "NOT before GROUP BY fails at GROUP",
+            sql: "SELECT status FROM orders WHERE NOT\ngroup by status",
+            expected_error_at: Some("group"),
+        },
+        ParseErrorTestCase {
+            description: "GROUP BY and ORDER BY after WHERE still parse",
+            sql: "SELECT status FROM orders WHERE total > 1\nGROUP BY status\nORDER BY status",
+            expected_error_at: None,
+        },
+        ParseErrorTestCase {
+            description: "a quoted GROUP column still parses",
+            sql: "SELECT \"GROUP\" FROM orders ORDER BY 1",
+            expected_error_at: None,
+        },
+    ];
+
+    for test_case in test_cases {
+        let error_at = parse_statements_with(
+            test_case.sql,
+            Dialect::Snowflake,
+            &ParseOptions::default(),
+            CallMode::Faithful,
+        )
+        .err()
+        .map(|error| {
+            let start = error.start().unwrap_or_default();
+            let end = error.end().unwrap_or_default();
+            test_case.sql.get(start..end).unwrap_or_default().to_owned()
+        });
+        assert_eq!(
+            error_at.as_deref(),
+            test_case.expected_error_at,
+            "{}",
+            test_case.description
+        );
+    }
+}
+
+#[test]
+fn given_a_statement_ending_where_an_expression_belongs_when_parsing_snowflake_then_the_error_names_what_is_missing(
+) {
+    let test_cases = [
+        ParseMessageTestCase {
+            description: "an empty WHERE asks for a condition",
+            sql: "SELECT * FROM orders WHERE",
+            expected_message: "Expected a condition after WHERE",
+        },
+        ParseMessageTestCase {
+            description: "an empty WHERE before a semicolon asks for a condition",
+            sql: "SELECT * FROM orders WHERE ;",
+            expected_message: "Expected a condition after WHERE",
+        },
+        ParseMessageTestCase {
+            description: "an empty HAVING asks for a condition",
+            sql: "SELECT status FROM orders GROUP BY status HAVING",
+            expected_message: "Expected a condition after HAVING",
+        },
+        ParseMessageTestCase {
+            description: "a join's empty ON asks for a condition",
+            sql: "SELECT 1 FROM orders o JOIN customers c ON",
+            expected_message: "Expected a condition after ON",
+        },
+        ParseMessageTestCase {
+            description: "a comparison with no right side asks for an expression",
+            sql: "SELECT 1 FROM orders WHERE total >",
+            expected_message: "Expected an expression after >",
+        },
+    ];
+
+    for test_case in test_cases {
+        let message = parse_statements_with(
+            test_case.sql,
+            Dialect::Snowflake,
+            &ParseOptions::default(),
+            CallMode::Faithful,
+        )
+        .err()
+        .map(|error| error.to_string())
+        .unwrap_or_default();
+        assert!(
+            message.contains(test_case.expected_message),
+            "{}: {message}",
+            test_case.description
+        );
+    }
+}