dirsql 0.3.35__tar.gz → 0.3.37__tar.gz

{dirsql-0.3.35 → dirsql-0.3.37}/Cargo.lock

@@ -499,7 +499,7 @@ dependencies = [
 
 [[package]]
 name = "dirsql-py-ext"
-version = "0.3.35"
+version = "0.3.37"
 dependencies = [
  "dirsql",
  "pyo3",

{dirsql-0.3.35 → dirsql-0.3.37}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dirsql
-Version: 0.3.35
+Version: 0.3.37
 Requires-Dist: pytest>=8 ; extra == 'dev'
 Requires-Dist: pytest-describe>=2 ; extra == 'dev'
 Requires-Dist: pytest-asyncio>=0.23 ; extra == 'dev'

{dirsql-0.3.35 → dirsql-0.3.37}/packages/python/Cargo.toml

@@ -4,7 +4,7 @@ name = "dirsql-py-ext"
 # pypi/maturin handler can rewrite it via `write-version` before
 # `maturin build`. `pyproject.toml` declares `dynamic = ["version"]`
 # and maturin reads this field. Mirrors `packages/rust/Cargo.toml`.
-version = "0.3.35"
+version = "0.3.37"
 edition.workspace = true
 publish = false
 readme = "README.md"

dirsql-0.3.37/packages/python/e2e-attestation.json

@@ -0,0 +1,6 @@
+{
+  "command": "uv run python -m pytest tests/e2e -q",
+  "ran_at": 1782732207,
+  "exit_code": 0,
+  "commit": "6a2dcb8948ae61431b6357df46ce00e8848173ac"
+}

{dirsql-0.3.35/packages/python/tests/integration → dirsql-0.3.37/packages/python/tests/e2e}/interpret_subprocess.py

@@ -1,4 +1,4 @@
-"""Subprocess plumbing for the `dirsql interpret` integration tests.
+"""Subprocess plumbing for the `dirsql interpret` e2e tests.
 
 Kept in its own module (rather than `conftest.py` or inline in the
 test file) because these helpers are not pytest fixtures -- they are

{dirsql-0.3.35 → dirsql-0.3.37}/packages/rust/src/cli/mod.rs

@@ -160,7 +160,15 @@ pub enum ServerError {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use tempfile::TempDir;
+
+    // `From<DirSQL> for AppState` produces the `Ready` arm -- this is
+    // verified at the integration tier by `from_dirsql_yields_ready_state`
+    // in `tests/cli_integration.rs`, which builds a real `DirSQL` over a
+    // temp directory (so the initial scan runs) and asserts the public
+    // `AppState::Ready` variant. It lived here once but needed
+    // `std::fs::write` to populate the scanned directory, which the
+    // `testing-conventions` `unit lint` isolation rule forbids in a unit
+    // test (effectful std). The pure config-default test below stays inline.
 
     #[test]
     fn default_config_binds_localhost_7117_with_30s_timeout() {
@@ -169,35 +177,4 @@ mod tests {
         assert_eq!(cfg.port, 7117);
         assert_eq!(cfg.query_timeout, Duration::from_secs(30));
     }
-
-    #[test]
-    fn app_state_from_dirsql_is_ready() {
-        // `AppState: !Debug` (it wraps a `DirSQL`). Assert the `Ready` variant
-        // without a dead match arm by routing through `require_ready`, which
-        // returns `Ok` only for `Ready` -- a branch-free `.is_ok()` check.
-        let dir = TempDir::new().unwrap();
-        // Write a matching file so the extract closure runs during the initial
-        // scan (otherwise the closure body would be a dead coverage region).
-        std::fs::write(dir.path().join("a.txt"), b"").unwrap();
-        let db = DirSQL::with_ignore(
-            dir.path(),
-            vec![crate::Table::new(
-                "CREATE TABLE t (name TEXT)",
-                "*.txt",
-                |_| {
-                    vec![crate::Row::from_iter([(
-                        "name".to_string(),
-                        crate::Value::Text("x".into()),
-                    )])]
-                },
-            )],
-            Vec::<String>::new(),
-        )
-        .unwrap();
-        let state: AppState = db.into();
-        assert!(
-            router::require_ready(&state).is_ok(),
-            "From<DirSQL> must produce AppState::Ready",
-        );
-    }
 }

{dirsql-0.3.35 → dirsql-0.3.37}/packages/rust/src/cli/native_config.rs

@@ -296,7 +296,16 @@ fn json_to_value(v: serde_json::Value) -> Value {
 mod tests {
     use super::*;
     use std::io::Cursor;
-    use std::process::{Command, Stdio};
+
+    // The subprocess-driven tests (`InterpretHelper::from_child` against a
+    // real `bash`/`true` child, and the `build_dirsql` round-trips that
+    // spawn a fake helper and write real fixture files) live in
+    // `tests/native_config.rs`. They exercise effectful std
+    // (`std::process::Command`, `std::fs::write`) and so belong at the
+    // integration tier per the `testing-conventions` `unit lint` isolation
+    // rule. The pure wire-format tests below operate on in-memory
+    // `Cursor`/`Vec` streams and stay inline next to the private functions
+    // they cover.
 
     // -- parse_handshake -----------------------------------------------
 
@@ -511,160 +520,10 @@ mod tests {
     }
 
     // -- build_dirsql --------------------------------------------------
-
-    // -- InterpretHelper end-to-end (subprocess via bash) -------------
-
-    /// Spawn a fake helper that prints `handshake` once on stdout then
-    /// emits one canned response per line received on stdin (an infinite
-    /// loop until stdin closes). Returns the helper paired with the
-    /// parsed [`NativeConfig`]. Drives the production
-    /// `InterpretHelper::from_child` constructor so the post-spawn
-    /// plumbing is exercised by these tests.
-    fn spawn_fake_helper(
-        handshake: &str,
-        response_per_request: &str,
-    ) -> (Arc<InterpretHelper>, NativeConfig) {
-        let child = Command::new("bash")
-            .arg("-c")
-            .arg(format!(
-                "printf '%s\\n' '{handshake}'; while IFS= read -r line; do printf '%s\\n' '{response_per_request}'; done",
-            ))
-            .stdin(Stdio::piped())
-            .stdout(Stdio::piped())
-            .spawn()
-            .unwrap();
-        InterpretHelper::from_child(child).unwrap()
-    }
-
-    #[test]
-    fn build_dirsql_threads_persist_and_persist_path_into_the_builder() {
-        // Cover the `if config.persist` and `if let Some(p) = config.persist_path`
-        // branches in `build_dirsql`. A real persist build needs the cache file
-        // to live under root, so point persist_path at a path inside the
-        // tempdir and pass persist=true.
-        let tmp = tempfile::TempDir::new().unwrap();
-        std::fs::write(tmp.path().join("a.json"), b"{}").unwrap();
-        let cache_path = tmp.path().join(".dirsql/cache.db");
-
-        let handshake = format!(
-            r#"{{"type":"config","state":{{"root":"{}","tables":[{{"ddl":"CREATE TABLE papers (title TEXT)","glob":"*.json"}}],"persist":true,"persist_path":"{}"}}}}"#,
-            tmp.path().display(),
-            cache_path.display(),
-        );
-        let (helper, config) = spawn_fake_helper(
-            &handshake,
-            r#"{"type":"result","id":1,"ok":true,"rows":[{"title":"y"}]}"#,
-        );
-        assert!(config.persist);
-        assert_eq!(config.persist_path.as_ref().unwrap(), &cache_path);
-
-        let db = build_dirsql(helper, config).unwrap();
-        let rows = db.query("SELECT COUNT(*) AS n FROM papers").unwrap();
-        assert_eq!(rows[0].get("n"), Some(&Value::Integer(1)));
-        assert!(cache_path.exists(), "persist build should create the cache");
-    }
-
-    #[test]
-    fn build_dirsql_threads_extensions_into_the_builder() {
-        // A handshake whose `extensions` names a missing shared library must
-        // fail the build, proving the parsed extensions reach the core's
-        // load-at-startup path (enable -> load -> disable). (#229)
-        let tmp = tempfile::TempDir::new().unwrap();
-        std::fs::write(tmp.path().join("a.json"), b"{}").unwrap();
-
-        let handshake = format!(
-            r#"{{"type":"config","state":{{"root":"{}","tables":[{{"ddl":"CREATE TABLE papers (title TEXT)","glob":"*.json"}}],"extensions":[{{"path":"/nonexistent/dirsql-no-such-ext.so"}}]}}}}"#,
-            tmp.path().display(),
-        );
-        let (helper, config) = spawn_fake_helper(
-            &handshake,
-            r#"{"type":"result","id":1,"ok":true,"rows":[{"title":"y"}]}"#,
-        );
-        assert_eq!(config.extensions.len(), 1);
-        assert_eq!(
-            config.extensions[0].path,
-            PathBuf::from("/nonexistent/dirsql-no-such-ext.so"),
-        );
-
-        let err = match build_dirsql(helper, config) {
-            Ok(_) => panic!("expected build to fail on a missing extension"),
-            Err(e) => e,
-        };
-        assert!(err.contains("failed to load extension"), "got: {err}");
-    }
-
-    #[test]
-    fn build_dirsql_round_trip_with_fake_helper_invokes_extract_per_matched_file() {
-        // Create a tempdir with two matching files so the scan invokes
-        // `extract` twice — exercising the closure created inside
-        // `build_dirsql`, the `dispatch_extract` path through the
-        // helper's IO mutex, and end-to-end DDL/glob wiring.
-        let tmp = tempfile::TempDir::new().unwrap();
-        std::fs::write(tmp.path().join("a.json"), b"{}").unwrap();
-        std::fs::write(tmp.path().join("b.json"), b"{}").unwrap();
-
-        let handshake = format!(
-            r#"{{"type":"config","state":{{"root":"{}","tables":[{{"ddl":"CREATE TABLE papers (title TEXT)","glob":"*.json"}}]}}}}"#,
-            tmp.path().display(),
-        );
-        let (helper, config) = spawn_fake_helper(
-            &handshake,
-            r#"{"type":"result","id":1,"ok":true,"rows":[{"title":"x"}]}"#,
-        );
-
-        let db = build_dirsql(helper, config).unwrap();
-        let rows = db.query("SELECT COUNT(*) AS n FROM papers").unwrap();
-        assert_eq!(rows.len(), 1);
-        assert_eq!(rows[0].get("n"), Some(&Value::Integer(2)));
-    }
-
-    #[test]
-    fn helper_extract_round_trip_succeeds_against_a_fake_subprocess() {
-        let (helper, _config) = spawn_fake_helper(
-            r#"{"type":"config","state":{"root":"/tmp","tables":[{"ddl":"CREATE TABLE papers (title TEXT)","glob":"*"}]}}"#,
-            r#"{"type":"result","id":1,"ok":true,"rows":[{"title":"Alpha"}]}"#,
-        );
-
-        let rows = helper.extract("papers", "/x/a.json").unwrap();
-        assert_eq!(rows.len(), 1);
-        assert_eq!(rows[0].get("title"), Some(&Value::Text("Alpha".into())));
-
-        // Second request increments the id counter and still works against
-        // the canned response (the fake echoes the same line per request).
-        let rows2 = helper.extract("papers", "/x/b.json").unwrap();
-        assert_eq!(rows2.len(), 1);
-    }
-
-    #[test]
-    fn helper_from_child_errors_when_stdin_was_not_piped() {
-        // `Command::spawn` without `.stdin(Stdio::piped())` inherits the
-        // parent's stdin — `child.stdin.take()` returns `None`, driving
-        // the first `.ok_or_else` arm in `from_child`.
-        let child = Command::new("true").spawn().unwrap();
-        let err = match InterpretHelper::from_child(child) {
-            Ok(_) => panic!("expected error when stdin is not piped"),
-            Err(e) => e,
-        };
-        assert!(
-            err.contains("failed to capture interpret stdin"),
-            "got: {err}",
-        );
-    }
-
-    #[test]
-    fn helper_from_child_errors_when_stdout_was_not_piped() {
-        // Pipe stdin but leave stdout inherited — `child.stdout.take()`
-        // returns `None`, driving the second `.ok_or_else` arm.
-        let child = Command::new("true").stdin(Stdio::piped()).spawn().unwrap();
-        let err = match InterpretHelper::from_child(child) {
-            Ok(_) => panic!("expected error when stdout is not piped"),
-            Err(e) => e,
-        };
-        assert!(
-            err.contains("failed to capture interpret stdout"),
-            "got: {err}",
-        );
-    }
+    //
+    // The `build_dirsql` round-trips and the `InterpretHelper::from_child`
+    // success/error paths spawn a real subprocess (`bash`/`true`) and write
+    // real fixture files, so they live in `tests/native_config.rs`.
 
     /// A writer that fails every write with the given `io::ErrorKind`,
     /// used to exercise `dispatch_extract`'s IO-error arms.
@@ -720,64 +579,4 @@ mod tests {
         let err = dispatch_extract(&mut stdout, &mut stdin, 1, "t", "p").unwrap_err();
         assert!(err.contains("read from interpret"), "got: {err}");
     }
-
-    #[test]
-    fn helper_from_child_errors_when_subprocess_emits_no_handshake() {
-        // A subprocess that exits without writing anything drives
-        // `from_child` through to `parse_handshake`'s empty-line arm.
-        let child = Command::new("true")
-            .stdin(Stdio::piped())
-            .stdout(Stdio::piped())
-            .spawn()
-            .unwrap();
-        let err = match InterpretHelper::from_child(child) {
-            Ok(_) => panic!("expected error from empty-stdout subprocess"),
-            Err(e) => e,
-        };
-        assert!(
-            err.contains("exited before sending handshake"),
-            "got: {err}"
-        );
-    }
-
-    #[test]
-    fn build_dirsql_errors_when_ddl_has_no_table_name() {
-        // The DDL is rejected by `parse_table_name` before any extract
-        // closure is created, so the helper's IO is never touched. Use a
-        // real child (`true` exits cleanly) just to satisfy the
-        // `InterpretHelper` shape.
-        let mut child = Command::new("true")
-            .stdin(Stdio::piped())
-            .stdout(Stdio::piped())
-            .spawn()
-            .unwrap();
-        let stdin = child.stdin.take().unwrap();
-        let stdout = child.stdout.take().unwrap();
-        let helper = Arc::new(InterpretHelper {
-            _child: child,
-            io: Arc::new(Mutex::new(HelperIo {
-                stdin: BufWriter::new(stdin),
-                stdout: BufReader::new(stdout),
-            })),
-            next_id: AtomicU64::new(1),
-        });
-        let config = NativeConfig {
-            root: PathBuf::from("/tmp"),
-            tables: vec![HandshakeTable {
-                ddl: "NOT VALID DDL".into(),
-                glob: "*.json".into(),
-                strict: false,
-            }],
-            ignore: Vec::new(),
-            persist: false,
-            persist_path: None,
-            extensions: Vec::new(),
-        };
-        // `DirSQL` doesn't impl Debug, so we can't use `unwrap_err` directly.
-        let err = match build_dirsql(helper, config) {
-            Ok(_) => panic!("expected build_dirsql to fail on invalid DDL"),
-            Err(e) => e,
-        };
-        assert!(err.contains("could not parse table name"), "got: {err}");
-    }
 }

{dirsql-0.3.35 → dirsql-0.3.37}/packages/rust/src/cli/router.rs

@@ -167,15 +167,16 @@ pub(super) fn error_response(status: StatusCode, message: impl Into<String>) ->
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::db::DbError;
 
-    #[test]
-    fn classify_core_error_is_bad_request() {
-        // A SQLite-level failure is the client's fault (bad SQL), so it maps
-        // to 400 rather than a server error.
-        let err = DirSqlError::Core(DbError::SchemaMismatch("nope".into()));
-        assert_eq!(classify_query_error(&err), StatusCode::BAD_REQUEST);
-    }
+    // The `DirSqlError::Core => 400` arm of `classify_query_error` is
+    // exercised end-to-end at the integration tier by
+    // `post_query_malformed_sql_returns_400_not_500` in
+    // `tests/cli_integration.rs`, which posts malformed SQL to `/query` and
+    // asserts the 400. Constructing a `Core` value inline would require
+    // importing the first-party `crate::db::DbError`, which the
+    // `testing-conventions` `unit lint` isolation rule forbids (a unit test
+    // may reach only `super::` and pure `std`). The non-Core arm below is
+    // pure -- it builds a `super::DirSqlError::Lock` -- so it stays inline.
 
     #[test]
     fn classify_non_core_error_is_internal_server_error() {