finish apply and test runner

skyzh · skyzh · commit ab9f0411d4e4 · 2022-06-09T21:22:09.000+08:00
Signed-off-by: Alex Chi &lt;iskyzh@gmail.com&gt;
diff --git a/.gitignore b/.gitignore
@@ -1,2 +1,3 @@
 /target
 /Cargo.lock
+rust-toolchain
diff --git a/Cargo.toml b/Cargo.toml
@@ -8,13 +8,18 @@ readme = "README.md"
 homepage = "https://github.com/risinglightdb/sqlplannertest-rs"
 repository = "https://github.com/risinglightdb/sqlplannertest-rs"
 keywords = ["sql", "database", "planner", "cli"]
-
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-async-trait = "0.1"
 anyhow = "1"
+async-trait = "0.1"
+glob = "0.3"
+libtest-mimic = "0.4"
 serde = { version = "1.0", features = ["derive"] }
 serde_yaml = "0.8"
-tokio = { version = "1", features = ["rt"] }
-libtest-mimic = "0.4"
+similar = "2"
+tokio = { version = "1", features = ["rt", "fs"] }
+console = "0.15"
+
+[workspace]
+members = ["naivedb"]
diff --git a/README.md b/README.md
@@ -41,3 +41,21 @@ Basically, it is like:
 
 And it will generate a file describing the result. Developers can diff the regression
 test result to see what have been changed throughout the process.
+
+## NaiveDB
+
+The naive database system for testing sqlplannertest.
+
+**Update the test cases**
+
+```
+cargo run -p naivedb --bin apply
+```
+
+**Verify the test cases**
+
+```
+cargo test -p naivedb
+# or use nextest
+cargo nextest run -p naivedb
+```
diff --git a/naivedb/Cargo.toml b/naivedb/Cargo.toml
@@ -0,0 +1,15 @@
+[package]
+name = "naivedb"
+version = "0.1.0"
+edition = "2021"
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+async-trait = "0.1"
+sqlplannertest = { path = ".." }
+anyhow = "1"
+tokio = { version = "1", features = ["rt", "rt-multi-thread", "macros", "fs"] }
+
+[[test]]
+name = "plannertest"
+harness = false
diff --git a/naivedb/src/bin/apply.rs b/naivedb/src/bin/apply.rs
@@ -0,0 +1,13 @@
+use std::path::Path;
+
+use anyhow::Result;
+
+#[tokio::main]
+async fn main() -> Result<()> {
+    sqlplannertest::planner_test_apply(
+        Path::new(env!("CARGO_MANIFEST_DIR")).join("tests"),
+        || async { Ok(naivedb::NaiveDb::new()) },
+    )
+    .await?;
+    Ok(())
+}
diff --git a/naivedb/src/lib.rs b/naivedb/src/lib.rs
@@ -0,0 +1,18 @@
+use anyhow::Result;
+use async_trait::async_trait;
+
+#[derive(Default)]
+pub struct NaiveDb {}
+
+impl NaiveDb {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+#[async_trait]
+impl sqlplannertest::PlannerTestRunner for NaiveDb {
+    async fn run(&mut self, _test_case: &sqlplannertest::ParsedTestCase) -> Result<String> {
+        Ok("hello, world!".to_string())
+    }
+}
diff --git a/naivedb/tests/1.sql b/naivedb/tests/1.sql
@@ -0,0 +1,15 @@
+-----
+CREATE TABLE t1(v1 int);
+
+hello, world!
+
+-----
+CREATE TABLE t2(v2 int);
+
+hello, world!
+
+-----
+SELECT * FROM t1, t2 WHERE t1.v1 = t2.v2;
+
+hello, world!
+
diff --git a/naivedb/tests/1.yml b/naivedb/tests/1.yml
@@ -0,0 +1,13 @@
+- id: sql1
+  sql: |
+    CREATE TABLE t1(v1 int);
+- id: sql2
+  sql: |
+    CREATE TABLE t2(v2 int);
+- sql: |
+    SELECT * FROM t1, t2 WHERE t1.v1 = t2.v2;
+  desc: Test whether join works correctly.
+  before: ["*sql1", "*sql2", "CREATE TABLE t3(v3 int);"]
+  test:
+  - logical
+  - physical
diff --git a/naivedb/tests/2.sql b/naivedb/tests/2.sql
@@ -0,0 +1,15 @@
+-----
+CREATE TABLE t1(v1 int);
+
+hello, world!
+
+-----
+CREATE TABLE t2(v2 int);
+
+hello, world!
+
+-----
+SELECT * FROM t1, t2 WHERE t1.v1 = t2.v2;
+
+hello, world!
+
diff --git a/naivedb/tests/2.yml b/naivedb/tests/2.yml
@@ -0,0 +1,13 @@
+- id: sql1
+  sql: |
+    CREATE TABLE t1(v1 int);
+- id: sql2
+  sql: |
+    CREATE TABLE t2(v2 int);
+- sql: |
+    SELECT * FROM t1, t2 WHERE t1.v1 = t2.v2;
+  desc: Test whether join works correctly.
+  before: ["*sql1", "*sql2", "CREATE TABLE t3(v3 int);"]
+  test:
+  - logical
+  - physical
diff --git a/naivedb/tests/plannertest.rs b/naivedb/tests/plannertest.rs
@@ -0,0 +1,11 @@
+use std::path::Path;
+
+use anyhow::Result;
+
+fn main() -> Result<()> {
+    sqlplannertest::planner_test_runner(
+        Path::new(env!("CARGO_MANIFEST_DIR")).join("tests"),
+        || async { Ok(naivedb::NaiveDb::new()) },
+    )?;
+    Ok(())
+}
diff --git a/rustfmt.toml b/rustfmt.toml
@@ -0,0 +1,10 @@
+comment_width = 120
+format_code_in_doc_comments = true
+format_macro_bodies = true
+format_macro_matchers = true
+normalize_comments = true
+normalize_doc_attributes = true
+imports_granularity = "Module"
+group_imports = "StdExternalCrate"
+reorder_imports = true
+wrap_comments = true
diff --git a/src/apply.rs b/src/apply.rs
@@ -1,5 +1,55 @@
-use anyhow::Result;
+use std::future::Future;
+use std::path::Path;
 
-pub async fn planner_test_apply() -> Result<()> {
+use anyhow::{anyhow, Context, Result};
+
+use crate::{discover_tests, parse_test_cases, ParsedTestCase, PlannerTestRunner, TestCase};
+
+pub async fn planner_test_apply<F, Ft, R>(path: impl AsRef<Path>, runner_fn: F) -> Result<()>
+where
+    F: Fn() -> Ft + Send + Sync + 'static,
+    Ft: Future<Output = Result<R>> + Send,
+    R: PlannerTestRunner,
+{
+    let tests = discover_tests(path)?;
+    let mut test_discovered = false;
+    for entry in tests {
+        test_discovered = true;
+        let path = entry.context("failed to read glob entry")?;
+        let filename = path.file_name().context("unable to extract filename")?;
+        let testname = filename.to_str().context("unable to convert to string")?;
+        let mut runner = runner_fn().await?;
+        let testcases = tokio::fs::read(&path).await?;
+        let testcases: Vec<TestCase> = serde_yaml::from_slice(&testcases)?;
+        let testcases = parse_test_cases(testcases)?;
+        let mut generated_result = String::new();
+        println!("{}", testname);
+        for testcase in testcases {
+            let runner_result = runner.run(&testcase).await?;
+            generate_result(&testcase, &runner_result, &mut generated_result)?;
+        }
+        let path = {
+            let mut path = path;
+            path.set_extension("sql");
+            path
+        };
+        tokio::fs::write(&path, generated_result).await?;
+    }
+    if !test_discovered {
+        return Err(anyhow!("no test discovered"));
+    }
+    Ok(())
+}
+
+/// Generate a text-based result based on test case and runner result
+pub fn generate_result(
+    testcase: &ParsedTestCase,
+    runner_result: &str,
+    mut r: impl std::fmt::Write,
+) -> Result<()> {
+    writeln!(r, "-----")?;
+    writeln!(r, "{}", testcase.sql)?;
+    writeln!(r, "{}", runner_result)?;
+    writeln!(r)?;
     Ok(())
 }
diff --git a/src/lib.rs b/src/lib.rs
@@ -2,12 +2,14 @@ mod apply;
 mod resolve_id;
 mod test_runner;
 
-use anyhow::Result;
+use std::path::Path;
+
+use anyhow::{Context, Result};
+pub use apply::planner_test_apply;
 use async_trait::async_trait;
+use glob::Paths;
 use resolve_id::resolve_testcase_id;
 use serde::{Deserialize, Serialize};
-
-pub use apply::planner_test_apply;
 pub use test_runner::planner_test_runner;
 
 /// Describing a test case.
@@ -25,6 +27,7 @@ pub struct TestCase {
 pub struct ParsedTestCase {
     pub id: Option<String>,
     pub desc: Option<String>,
+    pub sql: String,
     pub before_sql: Vec<String>,
     pub test: Vec<String>,
 }
@@ -36,10 +39,20 @@ pub trait PlannerTestRunner {
     async fn run(&mut self, test_case: &ParsedTestCase) -> Result<String>;
 }
 
-pub fn parse_test_case(test: Vec<TestCase>) -> Result<Vec<ParsedTestCase>> {
+pub fn parse_test_cases(test: Vec<TestCase>) -> Result<Vec<ParsedTestCase>> {
     resolve_testcase_id(test)
 }
 
+const SUFFIX: &str = ".yml";
+
+pub fn discover_tests(path: impl AsRef<Path>) -> Result<Paths> {
+    let pattern = format!("**/[!_]*{}", SUFFIX);
+    let path = path.as_ref().join(&pattern);
+    let path = path.to_str().context("non utf-8 path")?;
+    let paths = glob::glob(path).context("failed to discover test")?;
+    Ok(paths)
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -63,7 +76,7 @@ mod tests {
         "#
         .trim();
         let test_case: Vec<TestCase> = serde_yaml::from_str(x).unwrap();
-        let test_case = parse_test_case(test_case).unwrap();
+        let test_case = parse_test_cases(test_case).unwrap();
         assert_eq!(test_case.len(), 3);
         assert_eq!(test_case[2].before_sql.len(), 3);
         assert_eq!(
diff --git a/src/resolve_id.rs b/src/resolve_id.rs
@@ -53,6 +53,7 @@ pub fn resolve_testcase_id(testcases: Vec<TestCase>) -> Result<Vec<ParsedTestCas
                 before_sql: before_sql.unwrap_or_default(),
                 id: testcase.id,
                 desc: testcase.desc,
+                sql: testcase.sql,
                 test: testcase.test.unwrap_or_default(),
             })
         })
diff --git a/src/test_runner.rs b/src/test_runner.rs

Original file line number	Diff line number	Diff line change
`@@ -1,2 +1,3 @@`
`1`	`1`	`/target`
`2`	`2`	`/Cargo.lock`
	`3`	`+rust-toolchain`