feat: add a code-free test setup for introspection-engine-tests

SQL -> introspected prisma schema. We expect better compile times and
fewer diffs due to meaningless changes in test setup after this.

It also makes it easy to add additional checks (introspected schemas are
valid, etc.) without adding or changing calls in tests.

The first test is the reproduction of a regression in indexes
introspection.

Author: tomhoule

Cargo.lock

@@ -1,14 +1,11 @@
+use super::Name;
+use crate::sampler::field_type::FieldType;
 use convert_case::{Case, Casing};
+use datamodel::dml::{self, WithDatabaseName, WithName};
 use introspection_connector::Warning;
 use mongodb_schema_describer::{IndexFieldProperty, IndexWalker};
 use std::collections::BTreeMap;
 
-use datamodel::dml::{self, WithDatabaseName, WithName};
-
-use crate::sampler::field_type::FieldType;
-
-use super::Name;
-
 /// Add described indices to the models.
 pub(super) fn add_to_models(
     models: &mut BTreeMap<String, dml::Model>,

introspection-engine/connectors/mongodb-introspection-connector/src/sampler/statistics/indices.rs

@@ -0,0 +1,47 @@
+use std::{env, fs, io::Write as _, path};
+
+const ROOT_DIR: &str = "tests/simple";
+
+fn main() {
+    println!("cargo:rerun-if-changed={}", ROOT_DIR);
+    println!("cargo:rerun-if-changed={}", file!());
+
+    let mut all_sql_files = Vec::new();
+    find_all_sql_files("", &mut all_sql_files);
+
+    let out_dir = env::var("OUT_DIR").unwrap();
+    let out_file_path = path::Path::new(&out_dir).join("simple_tests.rs");
+    let mut out_file = fs::File::create(out_file_path).unwrap();
+
+    for sql_file in &all_sql_files {
+        let test_name = sql_file.trim_start_matches('/').trim_end_matches(".sql");
+        let test_name = test_name.replace(&['/', '\\'], "_");
+        let file_path = sql_file.trim_start_matches('/');
+        writeln!(
+            out_file,
+            "#[test] fn {test_name}() {{ run_simple_test(\"{file_path}\"); }}"
+        )
+        .unwrap();
+    }
+}
+
+fn find_all_sql_files(prefix: &str, all_sql_files: &mut Vec<String>) {
+    let cargo_manifest_dir = env!("CARGO_MANIFEST_DIR");
+    for entry in fs::read_dir(format!("{cargo_manifest_dir}/{ROOT_DIR}/{prefix}")).unwrap() {
+        let entry = entry.unwrap();
+        let file_name = entry.file_name();
+        let file_name = file_name.to_str().unwrap();
+        let entry_path = format!("{}/{}", prefix, file_name);
+        let file_type = entry.file_type().unwrap();
+
+        if file_name == "." || file_name == ".." {
+            continue;
+        }
+
+        if file_type.is_file() {
+            all_sql_files.push(entry_path);
+        } else if file_type.is_dir() {
+            find_all_sql_files(&entry_path, all_sql_files);
+        }
+    }
+}

introspection-engine/introspection-engine-tests/build.rs

@@ -0,0 +1,57 @@
+use introspection_engine_tests::test_api::TestApi;
+use std::{fs, io::Write as _, path};
+use test_setup::{runtime::run_with_thread_local_runtime as tok, TestApiArgs};
+
+const TESTS_ROOT: &str = concat!(env!("CARGO_MANIFEST_DIR"), "/tests/simple");
+
+fn run_simple_test(test_file_path: &str) {
+    let file_path = path::Path::new(TESTS_ROOT).join(test_file_path);
+    let text = std::fs::read_to_string(&file_path).unwrap();
+
+    let tags = {
+        let first_line = text.lines().next().expect("Expected file not to be empty.");
+        let expected_tags_prefix = "-- tags=";
+        assert!(
+            first_line.starts_with(expected_tags_prefix),
+            "The first line of a simple test must start with \"{}\"",
+            expected_tags_prefix
+        );
+        let tags = first_line.trim_start_matches(expected_tags_prefix);
+        test_setup::tags_from_comma_separated_list(tags)
+    };
+
+    let test_api_args = TestApiArgs::new("run_simple_test", &[]);
+
+    if test_setup::should_skip_test(&test_api_args, tags, Default::default(), Default::default()) {
+        return;
+    }
+
+    let api = tok(TestApi::new(test_api_args));
+    tok(api.raw_cmd(&text));
+    let introspected = tok(api.introspect()).unwrap_or_else(|err| panic!("{}", err));
+
+    let last_comment_idx = text
+        .match_indices("\n/*\n")
+        .last()
+        .map(|(idx, _)| idx)
+        .unwrap_or(text.len() - 1);
+
+    let last_comment = text[last_comment_idx..]
+        .trim_start_matches("\n/*\n")
+        .trim_end_matches("*/\n");
+
+    if last_comment == introspected {
+        return; // success!
+    }
+
+    if std::env::var("UPDATE_EXPECT").is_ok() {
+        let mut file = fs::File::create(&file_path).unwrap(); // truncate
+        let setup_sql = &text[..last_comment_idx];
+        writeln!(file, "{setup_sql}\n/*\n{introspected}*/").unwrap();
+        return;
+    }
+
+    test_setup::panic_with_diff(last_comment, &introspected);
+}
+
+include!(concat!(env!("OUT_DIR"), "/simple_tests.rs"));

introspection-engine/introspection-engine-tests/tests/simple.rs

@@ -0,0 +1,45 @@
+-- tags=CockroachDb
+
+CREATE TABLE communication_channels (
+    id bigint NOT NULL,
+    path character varying(255) NOT NULL,
+    path_type character varying(255) DEFAULT 'email'::character varying NOT NULL,
+    position integer,
+    user_id bigint NOT NULL,
+    pseudonym_id bigint,
+    bounce_count integer DEFAULT 0,
+    confirmation_code character varying(255)
+);
+
+/*
+now create the indexes with expression columns
+*/
+
+CREATE INDEX index_communication_channels_on_path_and_path_type ON communication_channels (lower((path)::text), path_type);
+CREATE UNIQUE INDEX index_communication_channels_on_user_id_and_path_and_path_type ON communication_channels (user_id, lower((path)::text), path_type);
+CREATE INDEX index_communication_channels_on_confirmation_code ON communication_channels (confirmation_code);
+
+/*
+generator client {
+  provider = "prisma-client-js"
+}
+
+datasource db {
+  provider = "cockroachdb"
+  url      = "env(TEST_DATABASE_URL)"
+}
+
+model communication_channels {
+  id                BigInt
+  path              String  @db.String(255)
+  path_type         String  @default("email") @db.String(255)
+  position          Int?
+  user_id           BigInt
+  pseudonym_id      BigInt?
+  bounce_count      Int?    @default(0)
+  confirmation_code String? @db.String(255)
+
+  @@unique([user_id, path_type], map: "index_communication_channels_on_user_id_and_path_and_path_type")
+  @@index([confirmation_code, path_type], map: "index_communication_channels_on_confirmation_code")
+}
+*/

introspection-engine/introspection-engine-tests/tests/simple/cockroach_index_with_expression_column.sql

@@ -1,4 +1,4 @@
-//! PSL — Prisma Schema Language
+//! # PSL — Prisma Schema Language
 //!
 //! This crate is responsible for parsing, validating, formatting and rendering a PSL documents.
 //!
@@ -27,13 +27,9 @@ pub use crate::{
 pub use datamodel_connector;
 pub use diagnostics;
 pub use dml;
-pub use parser_database;
-pub use parser_database::is_reserved_type_name;
+pub use parser_database::{self, is_reserved_type_name};
 
-use self::{
-    render::RenderParams,
-    validate::{validate, DatasourceLoader, GeneratorLoader},
-};
+use self::validate::{validate, DatasourceLoader, GeneratorLoader};
 use crate::common::preview_features::PreviewFeature;
 use diagnostics::Diagnostics;
 use enumflags2::BitFlags;
@@ -193,7 +189,7 @@ fn load_sources(
 pub fn render_datamodel_to_string(datamodel: &dml::Datamodel, configuration: Option<&Configuration>) -> String {
     let datasource = configuration.and_then(|c| c.datasources.first());
     let mut out = String::new();
-    render::render_datamodel(RenderParams { datasource, datamodel }, &mut out);
+    render::render_datamodel(render::RenderParams { datasource, datamodel }, &mut out);
     reformat(&out, DEFAULT_INDENT_WIDTH).expect("Internal error: failed to reformat introspected schema")
 }
 
@@ -205,7 +201,7 @@ pub fn render_datamodel_and_config_to_string(
     let mut out = String::new();
     let datasource = config.datasources.first();
     render::render_configuration(config, &mut out);
-    render::render_datamodel(RenderParams { datasource, datamodel }, &mut out);
+    render::render_datamodel(render::RenderParams { datasource, datamodel }, &mut out);
     reformat(&out, DEFAULT_INDENT_WIDTH).expect("Internal error: failed to reformat introspected schema")
 }
 

libs/datamodel/core/src/lib.rs

@@ -1,4 +1,3 @@
-mod common;
 mod datasource_loader;
 mod generator_loader;
 mod validation_pipeline;

libs/datamodel/core/src/validate.rs

@@ -1,7 +1,10 @@
 use crate::{
-    ast::WithSpan, common::preview_features::GENERATOR, configuration::Generator, diagnostics::*,
-    validate::common::parse_and_validate_preview_features, StringFromEnvVar,
+    ast::WithSpan,
+    common::preview_features::{FeatureMap, PreviewFeature, GENERATOR},
+    configuration::{Generator, StringFromEnvVar},
+    diagnostics::*,
 };
+use itertools::Itertools;
 use parser_database::{ast, ValueListValidator, ValueValidator};
 use std::{collections::HashMap, convert::TryFrom};
 
@@ -145,3 +148,40 @@ impl GeneratorLoader {
         })
     }
 }
+
+fn parse_and_validate_preview_features(
+    preview_features: Vec<String>,
+    feature_map: &FeatureMap,
+    span: ast::Span,
+    diagnostics: &mut Diagnostics,
+) -> Vec<PreviewFeature> {
+    let mut features = vec![];
+
+    for feature_str in preview_features {
+        let feature_opt = PreviewFeature::parse_opt(&feature_str);
+        match feature_opt {
+            Some(feature) if feature_map.is_deprecated(&feature) => {
+                features.push(feature);
+                diagnostics.push_warning(DatamodelWarning::new_feature_deprecated(&feature_str, span));
+            }
+
+            Some(feature) if !feature_map.is_valid(&feature) => {
+                diagnostics.push_error(DatamodelError::new_preview_feature_not_known_error(
+                    &feature_str,
+                    feature_map.active_features().iter().map(ToString::to_string).join(", "),
+                    span,
+                ))
+            }
+
+            Some(feature) => features.push(feature),
+
+            None => diagnostics.push_error(DatamodelError::new_preview_feature_not_known_error(
+                &feature_str,
+                feature_map.active_features().iter().map(ToString::to_string).join(", "),
+                span,
+            )),
+        }
+    }
+
+    features
+}

libs/datamodel/core/src/validate/common.rs

@@ -1,16 +1,15 @@
+use super::{database_name::validate_db_name, names::Names};
 use crate::{
     ast::{self, WithName},
     diagnostics::DatamodelError,
     validate::validation_pipeline::context::Context,
 };
 use itertools::Itertools;
-use std::fmt;
-
-use super::{database_name::validate_db_name, names::Names};
 use parser_database::{
     walkers::{ModelWalker, RelationFieldWalker, RelationName},
     ReferentialAction,
 };
+use std::fmt;
 
 struct Fields<'db> {
     fields: &'db [ast::FieldId],

libs/datamodel/core/src/validate/generator_loader.rs

@@ -4,10 +4,9 @@ version = "0.1.0"
 authors = ["Tom Houlé <[email protected]>"]
 edition = "2021"
 
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
 [dependencies]
 connection-string = "0.1.10"
+dissimilar = "1.0.3"
 enumflags2 = "0.7"
 once_cell = "1.3.1"
 tokio = { version = "1.0", optional = true, features = ["rt-multi-thread"] }

libs/datamodel/core/src/validate/validation_pipeline/validations/relation_fields.rs

@@ -0,0 +1,30 @@
+#[track_caller]
+pub fn panic_with_diff(expected: &str, found: &str) {
+    let chunks = dissimilar::diff(expected, found);
+    let diff = format_chunks(chunks);
+    panic!(
+        r#"
+Snapshot comparison failed. Run the test again with UPDATE_EXPECT=1 in the environment to update the snapshot.
+
+===== EXPECTED ====
+{expected}
+====== FOUND ======
+{found}
+======= DIFF ======
+{diff}
+        "#
+    );
+}
+
+fn format_chunks(chunks: Vec<dissimilar::Chunk<'_>>) -> String {
+    let mut buf = String::new();
+    for chunk in chunks {
+        let formatted = match chunk {
+            dissimilar::Chunk::Equal(text) => text.into(),
+            dissimilar::Chunk::Delete(text) => format!("\x1b[41m{}\x1b[0m", text),
+            dissimilar::Chunk::Insert(text) => format!("\x1b[42m{}\x1b[0m", text),
+        };
+        buf.push_str(&formatted);
+    }
+    buf
+}