ok

Author: juleswritescode

crates/pglt_analyse/src/rule.rs

@@ -263,6 +263,11 @@ impl RuleDiagnostic {
     pub fn advices(&self) -> &RuleAdvice {
         &self.rule_advice
     }
+
+    /// Will return the rule's category name as defined via `define_categories! { .. }`.
+    pub fn get_category_name(&self) -> &'static str {
+        self.category.name()
+    }
 }
 
 #[derive(Debug, Clone, Eq)]

crates/pglt_analyser/tests/rules_tests.rs

@@ -11,6 +11,17 @@ pglt_test_macros::gen_tests! {
   crate::rule_test
 }
 
+mod testibear {
+    pglt_test_macros::gen_tests! {
+      "tests/specs/**/*.sql",
+      crate::printer
+    }
+}
+
+fn printer(fp: &'static str, expected: &str, dir: &str) {
+    println!("{fp}\n{expected}\n{dir}");
+}
+
 fn rule_test(full_path: &'static str, _: &str, _: &str) {
     let input_file = Path::new(full_path);
 
@@ -34,15 +45,15 @@ fn rule_test(full_path: &'static str, _: &str, _: &str) {
 
     let results = analyser.run(AnalyserContext { root: &ast });
 
-    let mut snapshot = String::new();
-    write_snapshot(&mut snapshot, query.as_str(), results.as_slice());
+    // 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);
-    });
+    // 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());
@@ -83,14 +94,25 @@ fn write_snapshot(snapshot: &mut String, query: &str, diagnostics: &[RuleDiagnos
 enum Expectation {
     NoDiagnostics,
     AnyDiagnostics,
+    OnlyOne(String),
 }
 
 impl Expectation {
     fn from_file(content: &str) -> Self {
         for line in content.lines() {
-            if line.contains("expect-no-diagnostics") {
+            if line.contains("expect_no_diagnostics") {
                 return Self::NoDiagnostics;
             }
+
+            if line.contains("expect_only_") {
+                let kind = line
+                    .splitn(3, "_")
+                    .last()
+                    .expect("Use pattern: `-- expect_only_<category>`")
+                    .trim();
+
+                return Self::OnlyOne(kind.into());
+            }
         }
 
         Self::AnyDiagnostics
@@ -103,7 +125,20 @@ impl Expectation {
                     panic!("This test should not have any diagnostics.");
                 }
             }
-            _ => {}
+            Self::OnlyOne(category) => {
+                let found_kinds = diagnostics
+                    .iter()
+                    .map(|d| d.get_category_name())
+                    .collect::<Vec<&str>>()
+                    .join(", ");
+
+                if diagnostics.len() != 1 || diagnostics[0].get_category_name() != category {
+                    panic!(
+                        "This test should only have one diagnostic of kind: {category}\nReceived: {found_kinds}"
+                    );
+                }
+            }
+            Self::AnyDiagnostics => {}
         }
     }
 }

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

@@ -1,2 +1,3 @@
+-- expect_only_lint/safety/banDropColumn
 alter table test
 drop column id;

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

@@ -0,0 +1,18 @@
+---
+source: crates/pglt_analyser/tests/rules_tests.rs
+assertion_line: 44
+expression: snapshot
+---
+# Input
+```
+-- expect-only-safety/banDropColumn
+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/banDropNotNull/basic.sql

@@ -1,3 +1,4 @@
+-- expect_only_lint/safety/banDropNotNull
 alter table users
 alter column id
 drop not null;

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

@@ -0,0 +1,19 @@
+---
+source: crates/pglt_analyser/tests/rules_tests.rs
+assertion_line: 44
+expression: snapshot
+---
+# Input
+```
+-- expect-only-bullshit
+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_test_macros/README.md

@@ -0,0 +1,63 @@
+# Tests macros
+
+Macros to help auto-generate tests based on files.
+
+## Usage
+
+Pass a glob pattern that'll identify your files and a test-function that'll run for each file. The glob pattern has to start at the root of your crate.
+
+You can add a `.expected.` file next to your test file. Its path will be passed to your test function so you can outcome-based assertions. (Alternatively, write snapshot tests.)
+
+Given the following file structure:
+
+```txt
+crate/
+|-- src/
+|-- tests/
+    |-- queries/
+        |-- test.sql
+        |-- test.expected.sql
+    |-- querytest.rs
+```
+
+You can generate tests like so:
+
+```rust
+  // crate/tests/querytest.rs
+
+  tests_macros::gen_tests!{
+    "tests/queries/*.sql",
+    crate::run_test  // use `crate::` if the linter complains.
+  }
+
+  fn run_test(
+    test_path: &str,  // absolute path on the machine
+    expected_path: &str, // absolute path of .expected file
+    test_dir: &str // absolute path of the test file's parent
+  ) {
+      // your logic
+  }
+```
+
+Test name is the "snake case" version of the file name.
+this will generate the following for each file:
+
+```rust
+#[test]
+pub fn somefilename()
+{
+    let test_file = "<crate's cargo.toml full path>/tests/sometest.txt";
+    let test_expected_file = "<crate's cargo.toml full path>/tests/sometest.expected.txt";
+    run_test(test_file, test_expected_file);
+}
+```
+
+## Pitfalls
+
+- If you use a Rust-keyword as a file name, this'll result in invalid syntax for the generated tests.
+- All files of the glob-pattern must (currently) be `.sql` files.
+- The macro will wrap your tests in a `mod tests { .. }` module. If you need multiple generations, wrap them in modules like so: ```mod some_test { tests_macros::gen_tests! { .. } }`.
+
+## How to run
+
+Simply run your `cargo test` commands as usual.

crates/pglt_test_macros/src/lib.rs

@@ -197,38 +197,50 @@ struct Variables {
 impl TryFrom<PathBuf> for Variables {
     type Error = &'static str;
 
-    fn try_from(path: PathBuf) -> Result<Self, Self::Error> {
-        let test_name = path
+    fn try_from(mut path: PathBuf) -> Result<Self, Self::Error> {
+        let test_name: String = path
             .file_stem()
             .ok_or("Cannot get file stem.")?
             .to_str()
-            .ok_or("Cannot convert file stem to string.")?;
+            .ok_or("Cannot convert file stem to string.")?
+            .into();
 
-        let ext = path
+        let ext: String = path
             .extension()
             .ok_or("Cannot get extension.")?
             .to_str()
-            .ok_or("Cannot convert extension to string.")?;
+            .ok_or("Cannot convert extension to string.")?
+            .into();
         assert_eq!(ext, "sql", "Expected .sql extension but received: {}", ext);
 
-        let test_dir = path
+        let test_dir: String = path
             .parent()
             .ok_or("Cannot get parent directory.")?
             .to_str()
-            .ok_or("Cannot convert parent directory to string.")?;
+            .ok_or("Cannot convert parent directory to string.")?
+            .into();
 
-        let test_fullpath = path.to_str().ok_or("Cannot convert path to string.")?;
+        let test_fullpath: String = path
+            .as_os_str()
+            .to_str()
+            .ok_or("Cannot convert file stem to string.")?
+            .into();
+
+        path.set_extension(OsStr::new(""));
 
-        let mut without_ext = test_fullpath.to_string();
-        without_ext.pop();
+        let without_ext: String = path
+            .as_os_str()
+            .to_str()
+            .ok_or("Cannot convert file stem to string.")?
+            .into();
 
         let test_expected_fullpath = format!("{}.expected.{}", without_ext, ext);
 
         Ok(Variables {
-            test_name: test_name.into(),
-            test_fullpath: test_fullpath.into(),
-            test_expected_fullpath: test_expected_fullpath.into(),
-            test_dir: test_dir.into(),
+            test_name,
+            test_fullpath,
+            test_expected_fullpath,
+            test_dir,
         })
     }
 }