dirsql 0.3.66__tar.gz → 0.3.69__tar.gz

{dirsql-0.3.66 → dirsql-0.3.69}/Cargo.lock

@@ -500,7 +500,7 @@ dependencies = [
 
 [[package]]
 name = "dirsql-py-ext"
-version = "0.3.66"
+version = "0.3.69"
 dependencies = [
  "dirsql",
  "pyo3",

{dirsql-0.3.66 → dirsql-0.3.69}/PKG-INFO

@@ -1,14 +1,6 @@
 Metadata-Version: 2.4
 Name: dirsql
-Version: 0.3.66
-Requires-Dist: pytest>=8 ; extra == 'dev'
-Requires-Dist: pytest-describe>=2 ; extra == 'dev'
-Requires-Dist: pytest-asyncio>=0.23 ; extra == 'dev'
-Requires-Dist: pytest-cov>=5 ; extra == 'dev'
-Requires-Dist: ruff>=0.4 ; extra == 'dev'
-Requires-Dist: maturin>=1.0 ; extra == 'dev'
-Requires-Dist: ty==0.0.42 ; extra == 'dev'
-Provides-Extra: dev
+Version: 0.3.69
 Summary: Ephemeral SQL index over a local directory
 Keywords: sql,filesystem,directory,sqlite,index
 Author: Kevin Scott

{dirsql-0.3.66 → dirsql-0.3.69}/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.66"
+version = "0.3.69"
 edition.workspace = true
 publish = false
 readme = "README.md"

{dirsql-0.3.66 → dirsql-0.3.69}/packages/python/e2e-attestation.json

@@ -1,6 +1,6 @@
 {
   "command": "uv run python -m pytest tests/e2e/ -x -q",
-  "ran_at": 1783215074,
+  "ran_at": 1783257990,
   "exit_code": 0,
-  "commit": "c5d752734907f27497b28b3448bad19247c3482e"
+  "commit": "cb8d663ecb72a808f4ab99589af16949e9449f3b"
 }

{dirsql-0.3.66 → dirsql-0.3.69}/packages/python/src/lib.rs

@@ -257,57 +257,93 @@ mod python {
         PyRuntimeError::new_err(e.to_string())
     }
 
-    fn row_event_to_py(py: Python<'_>, event: &RowEvent) -> PyResult<PyRowEvent> {
-        Ok(match event {
+    /// Pure, GIL-free intermediate for a row event. [`row_event_to_plain`]
+    /// builds it from a core [`RowEvent`] (unit-testable without a Python
+    /// interpreter); [`row_event_to_py`] then marshals it into the
+    /// Python-facing [`PyRowEvent`] (the GIL step). Splitting the two keeps the
+    /// variant -> action / field-selection mapping testable at the unit tier,
+    /// mirroring the napi binding's pure `row_event_to_js`. The value-level
+    /// `Row -> PyDict` conversion stays GIL-bound (binding-tier covered).
+    struct PlainRowEvent {
+        table: Option<String>,
+        action: &'static str,
+        row: Option<Row>,
+        old_row: Option<Row>,
+        error: Option<String>,
+        file_path: String,
+    }
+
+    fn row_event_to_plain(event: &RowEvent) -> PlainRowEvent {
+        match event {
             RowEvent::Insert {
                 table,
                 row,
                 file_path,
-            } => PyRowEvent {
+            } => PlainRowEvent {
                 table: Some(table.clone()),
-                action: "insert".to_string(),
-                row: Some(value_row_to_py_dict(py, row)?),
+                action: "insert",
+                row: Some(row.clone()),
                 old_row: None,
                 error: None,
-                file_path: Some(file_path.clone()),
+                file_path: file_path.clone(),
             },
             RowEvent::Update {
                 table,
                 old_row,
                 new_row,
                 file_path,
-            } => PyRowEvent {
+            } => PlainRowEvent {
                 table: Some(table.clone()),
-                action: "update".to_string(),
-                row: Some(value_row_to_py_dict(py, new_row)?),
-                old_row: Some(value_row_to_py_dict(py, old_row)?),
+                action: "update",
+                row: Some(new_row.clone()),
+                old_row: Some(old_row.clone()),
                 error: None,
-                file_path: Some(file_path.clone()),
+                file_path: file_path.clone(),
             },
             RowEvent::Delete {
                 table,
                 row,
                 file_path,
-            } => PyRowEvent {
+            } => PlainRowEvent {
                 table: Some(table.clone()),
-                action: "delete".to_string(),
-                row: Some(value_row_to_py_dict(py, row)?),
+                action: "delete",
+                row: Some(row.clone()),
                 old_row: None,
                 error: None,
-                file_path: Some(file_path.clone()),
+                file_path: file_path.clone(),
             },
             RowEvent::Error {
                 table,
                 file_path,
                 error,
-            } => PyRowEvent {
+            } => PlainRowEvent {
                 table: table.clone(),
-                action: "error".to_string(),
+                action: "error",
                 row: None,
                 old_row: None,
                 error: Some(error.clone()),
-                file_path: Some(file_path.to_string_lossy().to_string()),
+                file_path: file_path.to_string_lossy().to_string(),
             },
+        }
+    }
+
+    fn row_event_to_py(py: Python<'_>, event: &RowEvent) -> PyResult<PyRowEvent> {
+        let plain = row_event_to_plain(event);
+        Ok(PyRowEvent {
+            table: plain.table,
+            action: plain.action.to_string(),
+            row: plain
+                .row
+                .as_ref()
+                .map(|r| value_row_to_py_dict(py, r))
+                .transpose()?,
+            old_row: plain
+                .old_row
+                .as_ref()
+                .map(|r| value_row_to_py_dict(py, r))
+                .transpose()?,
+            error: plain.error,
+            file_path: Some(plain.file_path),
         })
     }
 
@@ -381,4 +417,84 @@ mod python {
         m.add_class::<PyRowEvent>()?;
         Ok(())
     }
+
+    #[cfg(test)]
+    mod tests {
+        use super::*;
+
+        fn one_row() -> HashMap<String, Value> {
+            HashMap::from([("k".to_string(), Value::Integer(7))])
+        }
+
+        #[test]
+        fn plain_insert_maps_row_and_action() {
+            let p = row_event_to_plain(&RowEvent::Insert {
+                table: "t".into(),
+                row: one_row(),
+                file_path: "/f".into(),
+            });
+            assert_eq!(p.action, "insert");
+            assert_eq!(p.table.as_deref(), Some("t"));
+            assert_eq!(
+                p.row.as_ref().and_then(|r| r.get("k")),
+                Some(&Value::Integer(7))
+            );
+            assert!(p.old_row.is_none());
+            assert!(p.error.is_none());
+            assert_eq!(p.file_path, "/f");
+        }
+
+        #[test]
+        fn plain_update_carries_old_and_new() {
+            let mut new = one_row();
+            new.insert("k".to_string(), Value::Integer(9));
+            let p = row_event_to_plain(&RowEvent::Update {
+                table: "t".into(),
+                old_row: one_row(),
+                new_row: new,
+                file_path: "/f".into(),
+            });
+            assert_eq!(p.action, "update");
+            assert_eq!(
+                p.row.as_ref().and_then(|r| r.get("k")),
+                Some(&Value::Integer(9))
+            );
+            assert_eq!(
+                p.old_row.as_ref().and_then(|r| r.get("k")),
+                Some(&Value::Integer(7))
+            );
+        }
+
+        #[test]
+        fn plain_delete_has_row_no_old() {
+            let p = row_event_to_plain(&RowEvent::Delete {
+                table: "t".into(),
+                row: one_row(),
+                file_path: "/f".into(),
+            });
+            assert_eq!(p.action, "delete");
+            assert!(p.row.is_some());
+            assert!(p.old_row.is_none());
+        }
+
+        #[test]
+        fn plain_error_has_no_row_and_optional_table() {
+            let p = row_event_to_plain(&RowEvent::Error {
+                table: None,
+                file_path: std::path::PathBuf::from("/f"),
+                error: "boom".into(),
+            });
+            assert_eq!(p.action, "error");
+            assert!(p.table.is_none());
+            assert!(p.row.is_none());
+            assert!(p.old_row.is_none());
+            assert_eq!(p.error.as_deref(), Some("boom"));
+            assert_eq!(p.file_path, "/f");
+        }
+
+        #[test]
+        fn extract_error_displays_inner() {
+            assert_eq!(ExtractError("bad".to_string()).to_string(), "bad");
+        }
+    }
 }

{dirsql-0.3.66 → dirsql-0.3.69}/packages/rust/src/cli/init.rs

@@ -166,4 +166,46 @@ mod tests {
             "got: {err:?}"
         );
     }
+
+    // The spawn / non-zero-exit / write failure arms of `run` require actually
+    // invoking `claude` and touching the filesystem, so they are exercised at
+    // the e2e tier. Their `Display` renderings, however, are pure and covered
+    // here (the values are constructed inline, no process or fs I/O).
+
+    #[test]
+    fn spawn_error_display_mentions_spawn() {
+        let err = InitError::Spawn(std::io::Error::new(
+            std::io::ErrorKind::PermissionDenied,
+            "denied",
+        ));
+        let msg = format!("{err}");
+        assert!(msg.contains("failed to spawn"), "got: {msg}");
+        assert!(msg.contains("denied"), "got: {msg}");
+    }
+
+    #[test]
+    fn write_error_display_names_the_path_and_source() {
+        let err = InitError::Write {
+            path: PathBuf::from("/tmp/out.toml"),
+            source: std::io::Error::other("disk full"),
+        };
+        let msg = format!("{err}");
+        assert!(msg.contains("/tmp/out.toml"), "got: {msg}");
+        assert!(msg.contains("disk full"), "got: {msg}");
+    }
+
+    #[test]
+    fn invalid_utf8_error_display_mentions_utf8() {
+        // A non-UTF8 byte sequence yields the `FromUtf8Error` that `#[from]`
+        // converts into `InitError::InvalidUtf8`.
+        let utf8_err = String::from_utf8(vec![0xff, 0xfe]).unwrap_err();
+        let err: InitError = utf8_err.into();
+        let msg = format!("{err}");
+        assert!(msg.contains("non-UTF8"), "got: {msg}");
+    }
+
+    // NOTE: `InitError::ClaudeFailed`'s `Display` is not unit-tested -- building
+    // it needs an `ExitStatus`, and `std::process::ExitStatus::from_raw` is
+    // effectful std the unit-isolation lint (`no-out-of-module-call`) forbids.
+    // Its rendering is covered end-to-end at the e2e tier instead.
 }

{dirsql-0.3.66 → dirsql-0.3.69}/packages/rust/src/cli/mod.rs

@@ -330,4 +330,26 @@ mod tests {
         assert_eq!(pq.command, "reshape {args}");
         assert_eq!(pq.config_dir, PathBuf::from("/proj"));
     }
+
+    #[test]
+    fn with_query_timeout_overrides_the_default() {
+        // The builder replaces the 30s default with the supplied timeout and
+        // leaves the rest of the config untouched.
+        let cfg = ServerConfig::bind("127.0.0.1", 8080).with_query_timeout(Duration::from_secs(5));
+        assert_eq!(cfg.query_timeout, Duration::from_secs(5));
+        assert_eq!(cfg.host, "127.0.0.1");
+        assert_eq!(cfg.port, 8080);
+    }
+
+    #[test]
+    fn app_state_from_string_builds_the_unavailable_arm() {
+        // `String -> AppState` yields the degraded arm carrying the diagnostic
+        // verbatim (the `/query`/`/events` 503 body). `AppState` isn't `Debug`,
+        // so match rather than assert on a rendering.
+        let state: AppState = "config failed to load".to_string().into();
+        match state {
+            AppState::Unavailable(reason) => assert_eq!(reason, "config failed to load"),
+            AppState::Ready(_) => panic!("String must map to the Unavailable arm"),
+        }
+    }
 }

{dirsql-0.3.66 → dirsql-0.3.69}/packages/rust/src/cli/router.rs

@@ -356,4 +356,38 @@ mod tests {
             "application/json"
         );
     }
+
+    // `parse_sql_body` is the no-`pre-query` request path: it is pure (serde
+    // only), so it is unit-tested here directly rather than through the async
+    // `handle_query` handler (which needs a live server and is covered at the
+    // integration tier).
+
+    #[test]
+    fn parse_sql_body_returns_trimmed_sql() {
+        // Surrounding whitespace is stripped; the inner SQL is returned as-is.
+        let sql = parse_sql_body(r#"{"sql": "  SELECT 1  "}"#).expect("valid body");
+        assert_eq!(sql, "SELECT 1");
+    }
+
+    #[test]
+    fn parse_sql_body_rejects_malformed_json() {
+        // A body that isn't JSON fails at the serde step -> 400.
+        let resp = parse_sql_body("not json").expect_err("malformed JSON must be rejected");
+        assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
+    }
+
+    #[test]
+    fn parse_sql_body_rejects_whitespace_only_sql() {
+        // A present-but-blank `sql` trims to empty -> 400 (the `Some(_)` arm,
+        // and the `false` side of the `!s.is_empty()` guard).
+        let resp = parse_sql_body(r#"{"sql": "   "}"#).expect_err("empty sql must be rejected");
+        assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
+    }
+
+    #[test]
+    fn parse_sql_body_rejects_missing_sql_field() {
+        // Valid JSON object with no `sql` key -> the `None` arm -> 400.
+        let resp = parse_sql_body("{}").expect_err("missing sql must be rejected");
+        assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
+    }
 }

{dirsql-0.3.66 → dirsql-0.3.69}/pyproject.toml

@@ -19,7 +19,13 @@ repository = "https://github.com/thekevinscott/dirsql"
 keywords = ["sql", "filesystem", "directory", "sqlite", "index"]
 readme = "README.md"
 
-[project.optional-dependencies]
+# Dev/test dependencies live in a PEP 735 dependency-group (not a
+# `[project.optional-dependencies]` extra) so a plain `uv sync` installs them
+# by default -- the reusable testing-conventions coverage/mutation jobs run
+# `uv sync` with no `--extra`, and our colocated suite needs pytest-describe /
+# pytest-asyncio to collect at all. Every in-repo flow is uv-based and now uses
+# plain `uv sync`; the old `pip install .[dev]` extra is intentionally dropped.
+[dependency-groups]
 dev = [
     "pytest>=8",
     "pytest-describe>=2",