dirsql 0.3.11__tar.gz → 0.3.12__tar.gz

{dirsql-0.3.11 → dirsql-0.3.12}/Cargo.lock

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

{dirsql-0.3.11 → dirsql-0.3.12}/PKG-INFO

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

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

{dirsql-0.3.11 → dirsql-0.3.12}/packages/rust/src/cli/mod.rs

@@ -145,3 +145,48 @@ pub enum ServerError {
     #[error("server task panicked: {0}")]
     Join(#[from] JoinError),
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use tempfile::TempDir;
+
+    #[test]
+    fn default_config_binds_localhost_7117_with_30s_timeout() {
+        let cfg = ServerConfig::default();
+        assert_eq!(cfg.host, "localhost");
+        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.11 → dirsql-0.3.12}/packages/rust/src/cli/router.rs

@@ -163,3 +163,51 @@ pub(super) fn error_response(status: StatusCode, message: impl Into<String>) ->
     );
     resp
 }
+
+#[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);
+    }
+
+    #[test]
+    fn classify_non_core_error_is_internal_server_error() {
+        // Lock/watch/config failures are server-side faults -> 500. This drives
+        // the `_ =>` arm of `classify_query_error`.
+        let err = DirSqlError::Lock("poisoned".into());
+        assert_eq!(
+            classify_query_error(&err),
+            StatusCode::INTERNAL_SERVER_ERROR
+        );
+    }
+
+    #[test]
+    fn require_ready_returns_503_response_when_unavailable() {
+        // The degraded state yields an error `Response` (rendered as 503 by
+        // the HTTP layer) instead of a `DirSQL` handle.
+        let state = AppState::Unavailable("config failed to load".into());
+        // `DirSQL` isn't `Debug`, so go through `.err()` (which drops the Ok
+        // value) rather than `expect_err`.
+        let resp = require_ready(&state)
+            .err()
+            .expect("Unavailable must not yield a db");
+        assert_eq!(resp.status(), StatusCode::SERVICE_UNAVAILABLE);
+    }
+
+    #[test]
+    fn error_response_sets_json_content_type() {
+        let resp = error_response(StatusCode::BAD_REQUEST, "boom");
+        assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
+        assert_eq!(
+            resp.headers().get(header::CONTENT_TYPE).unwrap(),
+            "application/json"
+        );
+    }
+}

{dirsql-0.3.11 → dirsql-0.3.12}/packages/rust/src/cli/serialize.rs

@@ -168,11 +168,42 @@ mod tests {
         );
     }
 
+    #[test]
+    fn delete_event_emits_expected_shape() {
+        let mut row: Row = HashMap::new();
+        row.insert("id".into(), CellValue::Text("gone".into()));
+        let event = RowEvent::Delete {
+            table: "posts".into(),
+            row,
+            file_path: "posts/a.json".into(),
+        };
+        let parsed: Value = serde_json::from_str(&event_to_json(&event)).unwrap();
+        assert_eq!(parsed.get("action").and_then(Value::as_str), Some("delete"));
+        assert_eq!(parsed.get("table").and_then(Value::as_str), Some("posts"));
+        assert_eq!(
+            parsed.get("file_path").and_then(Value::as_str),
+            Some("posts/a.json"),
+        );
+        assert_eq!(
+            parsed.pointer("/row/id").and_then(Value::as_str),
+            Some("gone")
+        );
+        assert!(parsed.get("old_row").unwrap().is_null());
+    }
+
     #[test]
     fn null_cell_becomes_json_null() {
         assert!(cell_to_json(&CellValue::Null).is_null());
     }
 
+    #[test]
+    fn blob_cell_becomes_hex_string() {
+        // The Blob arm of `cell_to_json` hex-encodes the bytes into a JSON
+        // string (BLOB columns aren't representable as JSON literals).
+        let json = cell_to_json(&CellValue::Blob(vec![0xde, 0xad, 0xbe, 0xef]));
+        assert_eq!(json.as_str(), Some("deadbeef"));
+    }
+
     #[test]
     fn non_finite_real_becomes_json_null() {
         assert!(cell_to_json(&CellValue::Real(f64::NAN)).is_null());

{dirsql-0.3.11 → dirsql-0.3.12}/packages/rust/src/config.rs

@@ -192,10 +192,8 @@ ignore = ["*.tmp"]
     fn invalid_toml_returns_error() {
         let toml = "this is not valid toml [[[";
         let err = load_config_str(toml).unwrap_err();
-        match err {
-            ConfigError::Toml(_) => {}
-            other => panic!("expected Toml error, got: {}", other),
-        }
+        // Single-line `matches!` pins the variant without a dead fallback arm.
+        assert!(matches!(err, ConfigError::Toml(_)), "got: {err:?}");
     }
 
     #[test]
@@ -229,10 +227,8 @@ glob = "*.csv"
     #[test]
     fn load_config_missing_file_returns_io_error() {
         let err = load_config(Path::new("/nonexistent/.dirsql.toml")).unwrap_err();
-        match err {
-            ConfigError::Io(_) => {}
-            other => panic!("expected Io error, got: {}", other),
-        }
+        // Single-line `matches!` pins the variant without a dead fallback arm.
+        assert!(matches!(err, ConfigError::Io(_)), "got: {err:?}");
     }
 
     #[test]

{dirsql-0.3.11 → dirsql-0.3.12}/packages/rust/src/db.rs

@@ -538,32 +538,36 @@ mod tests {
     fn value_to_sql_null() {
         let v = Value::Null;
         let result = v.to_sql().unwrap();
-        assert!(matches!(
+        // Branch-free: compare against the expected value (`ToSqlOutput: PartialEq`)
+        // rather than `matches!`, whose `_ => false` arm is a dead region here.
+        assert_eq!(
             result,
             rusqlite::types::ToSqlOutput::Owned(rusqlite::types::Value::Null)
-        ));
+        );
     }
 
     #[test]
     fn value_to_sql_integer() {
         let v = Value::Integer(42);
         let result = v.to_sql().unwrap();
-        assert!(matches!(
+        // Branch-free: see `value_to_sql_null` -- compare values directly.
+        assert_eq!(
             result,
             rusqlite::types::ToSqlOutput::Owned(rusqlite::types::Value::Integer(42))
-        ));
+        );
     }
 
     #[test]
     fn value_to_sql_real() {
         let v = Value::Real(1.5);
         let result = v.to_sql().unwrap();
-        match result {
-            rusqlite::types::ToSqlOutput::Owned(rusqlite::types::Value::Real(f)) => {
-                assert!((f - 1.5).abs() < f64::EPSILON);
-            }
-            _ => panic!("expected Real"),
-        }
+        // Branch-free: `ToSqlOutput` derives `PartialEq`, so compare against
+        // the exact expected value instead of a `match` with a dead `_` arm.
+        // 1.5 is exactly representable in f64, so equality is precise here.
+        assert_eq!(
+            result,
+            rusqlite::types::ToSqlOutput::Owned(rusqlite::types::Value::Real(1.5))
+        );
     }
 
     #[test]
@@ -789,4 +793,46 @@ mod tests {
         let deleted = db.delete_rows_by_file("t", "nonexistent.json").unwrap();
         assert_eq!(deleted, 0);
     }
+
+    // --- Error path: Db::open on an unopenable path ---
+
+    #[test]
+    fn open_on_unopenable_path_returns_error() {
+        // A path inside a directory that does not exist cannot be created by
+        // SQLite, so `Connection::open` fails and the `?` propagates the
+        // rusqlite error through the `#[from]` conversion. (`Db` is not
+        // `Debug`; `.map(|_| ())` discards the Ok payload so `unwrap_err`
+        // works without a dead `Ok => panic!` arm that coverage would flag.)
+        let err = Db::open(Path::new("/nonexistent-dir-xyz/sub/cache.db"))
+            .map(|_| ())
+            .unwrap_err();
+        assert!(matches!(err, DbError::Sqlite(_)), "got: {err}");
+    }
+
+    // --- Error path: create_table with a syntactically-valid-looking DDL
+    // (has a closing paren so it passes inject_tracking_columns) but invalid
+    // SQL, so the failure happens at conn.execute rather than the injector ---
+
+    #[test]
+    fn create_table_invalid_sql_with_paren_fails_at_execute() {
+        let db = Db::new().unwrap();
+        let err = db
+            .create_table("CREATE TABLE (this is not valid)")
+            .unwrap_err();
+        assert!(matches!(err, DbError::Sqlite(_)), "got: {err}");
+    }
+
+    // --- Error path: normalize_row when the underlying table lookup fails.
+    // A table name containing whitespace makes the PRAGMA prepare fail, so
+    // get_table_columns errors and normalize_row's `?` propagates. ---
+
+    #[test]
+    fn normalize_row_propagates_column_lookup_error() {
+        let db = Db::new().unwrap();
+        let row = HashMap::from([("id".into(), Value::Text("1".into()))]);
+        let err = db
+            .normalize_row("bad name with spaces", &row, false)
+            .unwrap_err();
+        assert!(matches!(err, DbError::Sqlite(_)), "got: {err}");
+    }
 }

{dirsql-0.3.11 → dirsql-0.3.12}/packages/rust/src/differ.rs

@@ -297,12 +297,16 @@ mod tests {
             .collect();
         assert_eq!(deletes.len(), 3);
         assert_eq!(inserts.len(), 1);
-        assert!(events.iter().all(|e| match e {
-            RowEvent::Insert { file_path, .. }
-            | RowEvent::Update { file_path, .. }
-            | RowEvent::Delete { file_path, .. } => file_path == "t.jsonl",
-            RowEvent::Error { .. } => false,
-        }));
+        // Branch-free attribution check: every variant's Debug rendering
+        // includes its `file_path` field, so asserting on that string covers
+        // all variants without a `match` whose `Update`/`Error` arms this test
+        // never reaches (those arms would be dead coverage regions).
+        assert!(
+            events
+                .iter()
+                .all(|e| format!("{e:?}").contains("file_path: \"t.jsonl\"")),
+            "every event must be attributed to t.jsonl: {events:?}"
+        );
     }
 
     // --- Full replace on heavy modification ---