test(analyser): generate tests with new-lintrule script and add testing suite (#203)

* test(analyser): add debug_test

* format

* test adjustments

* nest deeper

* with group folder

* adjust that too

* ok ok

* checkout that…

* dafuq it works

* formatting

* more format?

* nope

Author: juleswritescode

Cargo.lock

@@ -78,11 +78,8 @@ pglt_type_resolver          = { path = "./crates/pglt_type_resolver", version =
 pglt_typecheck              = { path = "./crates/pglt_typecheck", version = "0.0.0" }
 pglt_workspace              = { path = "./crates/pglt_workspace", version = "0.0.0" }
 
-pglt_test_utils = { path = "./crates/pglt_test_utils" }
+pglt_test_macros = { path = "./crates/pglt_test_macros" }
+pglt_test_utils  = { path = "./crates/pglt_test_utils" }
 # parser = { path = "./crates/parser", version = "0.0.0" }
 # sql_parser = { path = "./crates/sql_parser", version = "0.0.0" }
 # sql_parser_codegen = { path = "./crates/sql_parser_codegen", version = "0.0.0" }
-
-
-[profile.dev.package]
-insta.opt-level = 3

Cargo.toml

@@ -18,5 +18,7 @@ pglt_query_ext = { workspace = true }
 serde          = { workspace = true }
 
 [dev-dependencies]
+insta            = { version = "1.42.1" }
 pglt_diagnostics = { workspace = true }
+pglt_test_macros = { workspace = true }
 termcolor        = { workspace = true }

crates/pglt_analyser/Cargo.toml

@@ -0,0 +1,109 @@
+use core::slice;
+use std::{fmt::Write, fs::read_to_string, path::Path};
+
+use pglt_analyse::{AnalyserOptions, AnalysisFilter, RuleDiagnostic, RuleFilter};
+use pglt_analyser::{Analyser, AnalyserConfig, AnalyserContext};
+use pglt_console::StdDisplay;
+use pglt_diagnostics::PrintDiagnostic;
+
+pglt_test_macros::gen_tests! {
+  "tests/specs/**/*.sql",
+  crate::rule_test
+}
+
+fn rule_test(full_path: &'static str, _: &str, _: &str) {
+    let input_file = Path::new(full_path);
+
+    let (group, rule, fname) = parse_test_path(input_file);
+
+    let rule_filter = RuleFilter::Rule(group.as_str(), rule.as_str());
+    let filter = AnalysisFilter {
+        enabled_rules: Some(slice::from_ref(&rule_filter)),
+        ..Default::default()
+    };
+
+    let query =
+        read_to_string(full_path).expect(format!("Failed to read file: {} ", full_path).as_str());
+
+    let ast = pglt_query_ext::parse(&query).expect("failed to parse SQL");
+    let options = AnalyserOptions::default();
+    let analyser = Analyser::new(AnalyserConfig {
+        options: &options,
+        filter,
+    });
+
+    let results = analyser.run(AnalyserContext { root: &ast });
+
+    let mut snapshot = String::new();
+    write_snapshot(&mut snapshot, query.as_str(), results.as_slice());
+
+    insta::with_settings!({
+        prepend_module_to_snapshot => false,
+        snapshot_path => input_file.parent().unwrap(),
+    }, {
+        insta::assert_snapshot!(fname, snapshot);
+    });
+
+    let expectation = Expectation::from_file(&query);
+    expectation.assert(results.as_slice());
+}
+
+fn parse_test_path(path: &Path) -> (String, String, String) {
+    let mut comps: Vec<&str> = path
+        .components()
+        .into_iter()
+        .map(|c| c.as_os_str().to_str().unwrap())
+        .collect();
+
+    let fname = comps.pop().unwrap();
+    let rule = comps.pop().unwrap();
+    let group = comps.pop().unwrap();
+
+    (group.into(), rule.into(), fname.into())
+}
+
+fn write_snapshot(snapshot: &mut String, query: &str, diagnostics: &[RuleDiagnostic]) {
+    writeln!(snapshot, "# Input").unwrap();
+    writeln!(snapshot, "```").unwrap();
+    writeln!(snapshot, "{query}").unwrap();
+    writeln!(snapshot, "```").unwrap();
+    writeln!(snapshot).unwrap();
+
+    if !diagnostics.is_empty() {
+        writeln!(snapshot, "# Diagnostics").unwrap();
+        for diagnostic in diagnostics {
+            let printer = PrintDiagnostic::simple(diagnostic);
+
+            writeln!(snapshot, "{}", StdDisplay(printer)).unwrap();
+            writeln!(snapshot).unwrap();
+        }
+    }
+}
+
+enum Expectation {
+    NoDiagnostics,
+    AnyDiagnostics,
+}
+
+impl Expectation {
+    fn from_file(content: &str) -> Self {
+        for line in content.lines() {
+            if line.contains("expect-no-diagnostics") {
+                return Self::NoDiagnostics;
+            }
+        }
+
+        Self::AnyDiagnostics
+    }
+
+    fn assert(&self, diagnostics: &[RuleDiagnostic]) {
+        match self {
+            Self::NoDiagnostics => {
+                if !diagnostics.is_empty() {
+                    panic!("This test should not have any diagnostics.");
+                }
+            }
+            _ => {}
+        }
+    }
+}

crates/pglt_analyser/tests/rules_tests.rs

@@ -0,0 +1,2 @@
+alter table test
+drop column id;

crates/pglt_analyser/tests/specs/safety/banDropColumn/basic.sql

@@ -0,0 +1,16 @@
+---
+source: crates/pglt_analyser/tests/rules_tests.rs
+expression: snapshot
+---
+# Input
+```
+alter table test
+drop column id;
+```
+
+# Diagnostics
+lint/safety/banDropColumn ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × Dropping a column may break existing clients.
+  
+  i You can leave the column as nullable or delete the column once queries no longer select or modify the column.

crates/pglt_analyser/tests/specs/safety/banDropColumn/basic.sql.snap

@@ -0,0 +1,3 @@
+alter table users
+alter column id
+drop not null;

crates/pglt_analyser/tests/specs/safety/banDropNotNull/basic.sql

@@ -0,0 +1,17 @@
+---
+source: crates/pglt_analyser/tests/rules_tests.rs
+expression: snapshot
+---
+# Input
+```
+alter table users
+alter column id
+drop not null;
+```
+
+# Diagnostics
+lint/safety/banDropNotNull ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × Dropping a NOT NULL constraint may break existing clients.
+  
+  i Consider using a marker value that represents NULL. Alternatively, create a new table allowing NULL values, copy the data from the old table, and create a view that filters NULL values.

crates/pglt_analyser/tests/specs/safety/banDropNotNull/basic.sql.snap

@@ -1,7 +1,30 @@
-use crate::fmt::{Display, Formatter};
+use termcolor::NoColor;
+
+use crate::fmt::{Display, Formatter, Termcolor};
 use crate::{markup, Markup};
 use std::io;
 
+/// Adapter type providing a std::fmt::Display implementation for any type that
+/// implements pglt_console::fmt::Display.
+pub struct StdDisplay<T: Display>(pub T);
+
+impl<T> std::fmt::Display for StdDisplay<T>
+where
+    T: Display,
+{
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let mut buffer: Vec<u8> = Vec::new();
+        let mut termcolor = Termcolor(NoColor::new(&mut buffer));
+        let mut formatter = Formatter::new(&mut termcolor);
+
+        self.0.fmt(&mut formatter).map_err(|_| std::fmt::Error)?;
+
+        let content = String::from_utf8(buffer).map_err(|_| std::fmt::Error)?;
+
+        f.write_str(content.as_str())
+    }
+}
+
 /// It displays a type that implements [std::fmt::Display]
 pub struct DebugDisplay<T>(pub T);
 

crates/pglt_console/src/utils.rs

@@ -0,0 +1,22 @@
+
+[package]
+authors.workspace    = true
+categories.workspace = true
+description          = "<DESCRIPTION>"
+edition.workspace    = true
+homepage.workspace   = true
+keywords.workspace   = true
+license.workspace    = true
+name                 = "pglt_test_macros"
+repository.workspace = true
+version              = "0.0.0"
+
+[lib]
+proc-macro = true
+
+[dependencies]
+globwalk         = { version = "0.9.1" }
+proc-macro-error = { version = "1.0.4" }
+proc-macro2      = { version = '1.0.93' }
+quote            = { workspace = true }
+syn              = { workspace = true }