dirsql 0.3.56__tar.gz → 0.3.58__tar.gz

{dirsql-0.3.56 → dirsql-0.3.58}/Cargo.lock

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

{dirsql-0.3.56 → dirsql-0.3.58}/PKG-INFO

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

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

{dirsql-0.3.56 → dirsql-0.3.58}/packages/python/e2e-attestation.json

@@ -1,6 +1,6 @@
 {
   "command": "uv run python -m pytest tests/e2e/ -x -q",
-  "ran_at": 1783101421,
+  "ran_at": 1783118080,
   "exit_code": 0,
-  "commit": "557de9e56c14139d4d35b6ba0aed13c601497d4d"
+  "commit": "b45791b9ad04fbac360618f3ff885e5f84a8289e"
 }

{dirsql-0.3.56 → dirsql-0.3.58}/packages/rust/src/cli/init.rs

@@ -149,4 +149,21 @@ mod tests {
         let msg = format!("{err}").to_lowercase();
         assert!(msg.contains("claude"));
     }
+
+    /// `run` bails before spawning the agent when the output already exists and
+    /// `--force` was not passed (the temp dir itself is an existing path).
+    #[test]
+    fn run_bails_when_output_exists_without_force() {
+        let dir = tempfile::tempdir().unwrap();
+        let opts = InitOptions {
+            root: dir.path().to_path_buf(),
+            output: dir.path().to_path_buf(),
+            force: false,
+        };
+        let err = run(opts).unwrap_err();
+        assert!(
+            matches!(err, InitError::AlreadyExists { .. }),
+            "got: {err:?}"
+        );
+    }
 }

{dirsql-0.3.56 → dirsql-0.3.58}/packages/rust/src/cli/server.rs

@@ -114,4 +114,33 @@ mod tests {
 
         handle.shutdown().await.expect("graceful shutdown");
     }
+
+    // A `Ready` state drives the `serve` convenience wrapper plus
+    // `start_watch_task` (which attaches `DirSQL::watch` and pumps its stream
+    // into the broadcast channel). Built over an empty temp dir so the scan
+    // touches nothing; the port-0 bind and graceful shutdown are real.
+    #[tokio::test]
+    async fn serve_with_a_ready_db_attaches_the_watcher_then_shuts_down() {
+        let dir = tempfile::tempdir().unwrap();
+        let db = DirSQL::new(dir.path(), Vec::new()).unwrap();
+        let config = ServerConfig::bind("127.0.0.1".to_string(), 0);
+        let handle = serve(config, db).await.expect("bind on an ephemeral port");
+        assert_ne!(handle.local_addr().port(), 0);
+        handle.shutdown().await.expect("graceful shutdown");
+    }
+
+    // Binding to a non-local TEST-NET address (RFC 5737) fails with
+    // "cannot assign requested address", surfacing `ServerError::Bind` rather
+    // than panicking — deterministic and DNS-free.
+    #[tokio::test]
+    async fn serve_with_state_surfaces_a_bind_error_for_a_nonlocal_address() {
+        let config = ServerConfig::bind("192.0.2.1".to_string(), 9);
+        // `serve_with_state` returns `Result<ServerHandle, _>`; ServerHandle is
+        // not Debug, so match rather than `unwrap_err`.
+        let err = match serve_with_state(config, AppState::Unavailable("x".to_string())).await {
+            Ok(_) => panic!("expected a bind error"),
+            Err(e) => e,
+        };
+        assert!(matches!(err, ServerError::Bind { .. }), "got: {err:?}");
+    }
 }

{dirsql-0.3.56 → dirsql-0.3.58}/packages/rust/src/command.rs

@@ -484,4 +484,103 @@ mod tests {
         assert!(!Placeholder::new("a", "b").append_if_absent);
         assert!(Placeholder::append("a", "b").append_if_absent);
     }
+
+    // ----- run_command end-to-end (spawns trivial POSIX commands) ----------
+    //
+    // `run_command` can only be exercised by actually spawning a child, so
+    // these drive `sh`/`echo`/`cat` — universally present on the Linux CI
+    // runners. The test code itself statically references only `super::` items,
+    // `Duration`, and `std::path::Path`, so the `unit lint` isolation rule is
+    // satisfied; the effectful process/thread work lives in production code.
+
+    fn cwd() -> std::path::PathBuf {
+        std::path::PathBuf::from(".")
+    }
+
+    #[test]
+    fn run_command_returns_last_nonempty_stdout_line() {
+        let out = run_command(
+            "sh -c 'echo chatter; echo PAYLOAD'",
+            &[],
+            &cwd(),
+            Duration::from_secs(30),
+            None,
+        )
+        .unwrap();
+        assert_eq!(out.payload, "PAYLOAD");
+    }
+
+    #[test]
+    fn run_command_writes_stdin_payload_to_the_child() {
+        // `cat` echoes its stdin, so the payload round-trips through the
+        // stdin-writer thread and the stdout drain.
+        let out = run_command(
+            "cat",
+            &[],
+            &cwd(),
+            Duration::from_secs(30),
+            Some(b"hello-stdin"),
+        )
+        .unwrap();
+        assert_eq!(out.payload, "hello-stdin");
+    }
+
+    #[test]
+    fn run_command_reports_nonzero_exit_with_stderr_tail() {
+        let err = run_command(
+            "sh -c 'echo oops >&2; exit 3'",
+            &[],
+            &cwd(),
+            Duration::from_secs(30),
+            None,
+        )
+        .unwrap_err();
+        match err {
+            CommandError::NonZeroExit {
+                code, stderr_tail, ..
+            } => {
+                assert_eq!(code, "3");
+                assert!(stderr_tail.contains("oops"), "got: {stderr_tail}");
+            }
+            other => panic!("expected NonZeroExit, got {other:?}"),
+        }
+    }
+
+    #[test]
+    fn run_command_reports_empty_output_when_stdout_is_blank() {
+        let err = run_command("true", &[], &cwd(), Duration::from_secs(30), None).unwrap_err();
+        assert!(
+            matches!(err, CommandError::EmptyOutput { .. }),
+            "got: {err:?}"
+        );
+    }
+
+    #[test]
+    fn run_command_reports_spawn_failure_for_a_missing_program() {
+        let err = run_command(
+            "definitely-not-a-real-binary-xyzzy",
+            &[],
+            &cwd(),
+            Duration::from_secs(30),
+            None,
+        )
+        .unwrap_err();
+        assert!(matches!(err, CommandError::Spawn { .. }), "got: {err:?}");
+    }
+
+    #[test]
+    fn run_command_kills_and_reports_timeout_even_with_stdin() {
+        // A short timeout against a long sleep drives the timeout branch,
+        // including joining the stdin-writer thread. `sh` ignoring stdin closes
+        // the pipe early, which the writer treats as a clean EOF.
+        let err = run_command(
+            "sh -c 'sleep 30'",
+            &[],
+            &cwd(),
+            Duration::from_millis(50),
+            Some(b"x"),
+        )
+        .unwrap_err();
+        assert!(matches!(err, CommandError::Timeout { .. }), "got: {err:?}");
+    }
 }

{dirsql-0.3.56 → dirsql-0.3.58}/packages/rust/src/db.rs

@@ -301,11 +301,21 @@ impl Db {
     /// The user-row deletes and the matching `_dirsql_internal_rows` mapping
     /// deletes commit in ONE transaction (epic #358), so the mapping never
     /// outlives the rows it describes.
+    ///
+    /// Stage 2 (epic #358): row ownership is read from the mapping, not the
+    /// injected `_dirsql_file_path` column (now write-only). The user rows to
+    /// drop are those whose `rowid` the mapping attributes to `file_path` under
+    /// `table`; the mapping rows are then removed in the same transaction.
     pub fn delete_rows_by_file(&self, table: &str, file_path: &str) -> Result<usize> {
         validate_identifier(table)?;
         let tx = self.conn.unchecked_transaction()?;
-        let sql = format!("DELETE FROM {} WHERE _dirsql_file_path = ?1", table);
-        let count = tx.execute(&sql, [file_path])?;
+        let sql = format!(
+            "DELETE FROM {} WHERE rowid IN \
+             (SELECT rowid_ref FROM _dirsql_internal_rows \
+              WHERE table_name = ?1 AND file_path = ?2)",
+            table
+        );
+        let count = tx.execute(&sql, rusqlite::params![table, file_path])?;
         tx.execute(
             "DELETE FROM _dirsql_internal_rows WHERE table_name = ?1 AND file_path = ?2",
             rusqlite::params![table, file_path],
@@ -1593,6 +1603,71 @@ mod tests {
         db.check_row_mapping_equivalence("t").unwrap();
     }
 
+    #[test]
+    fn delete_rows_by_file_reads_mapping_not_columns() {
+        // Stage 2 (epic #358): delete-by-file resolves ownership through the
+        // mapping, not the now-write-only `_dirsql_file_path` column. Corrupt
+        // the column so it disagrees with the mapping and confirm the delete
+        // still follows the mapping.
+        let db = Db::new().unwrap();
+        db.create_table("CREATE TABLE t (id TEXT)").unwrap();
+        db.insert_row(
+            "t",
+            &HashMap::from([("id".into(), Value::Text("a".into()))]),
+            "real.json",
+            0,
+        )
+        .unwrap();
+        // Desync the write-only column from the mapping.
+        db.conn
+            .execute("UPDATE t SET _dirsql_file_path = 'wrong.json'", [])
+            .unwrap();
+
+        // Deleting by the mapping's file removes the row; deleting by the
+        // stale column value is a no-op.
+        assert_eq!(db.delete_rows_by_file("t", "wrong.json").unwrap(), 0);
+        assert_eq!(db.delete_rows_by_file("t", "real.json").unwrap(), 1);
+        let remaining: i64 = db
+            .conn
+            .query_row("SELECT COUNT(*) FROM t", [], |r| r.get(0))
+            .unwrap();
+        assert_eq!(remaining, 0);
+        db.check_row_mapping_equivalence("t").unwrap();
+    }
+
+    #[test]
+    fn delete_rows_by_file_is_scoped_to_its_table() {
+        // The mapping subquery is keyed on (table_name, file_path): a delete on
+        // one table must not touch another table's rows for the same file path,
+        // even when they share a rowid.
+        let db = Db::new().unwrap();
+        db.create_table("CREATE TABLE t1 (id TEXT)").unwrap();
+        db.create_table("CREATE TABLE t2 (id TEXT)").unwrap();
+        db.insert_row(
+            "t1",
+            &HashMap::from([("id".into(), Value::Text("x".into()))]),
+            "shared.json",
+            0,
+        )
+        .unwrap();
+        db.insert_row(
+            "t2",
+            &HashMap::from([("id".into(), Value::Text("y".into()))]),
+            "shared.json",
+            0,
+        )
+        .unwrap();
+
+        assert_eq!(db.delete_rows_by_file("t1", "shared.json").unwrap(), 1);
+        let t2_rows: i64 = db
+            .conn
+            .query_row("SELECT COUNT(*) FROM t2", [], |r| r.get(0))
+            .unwrap();
+        assert_eq!(t2_rows, 1, "t2's row for the same path must be untouched");
+        db.check_row_mapping_equivalence("t1").unwrap();
+        db.check_row_mapping_equivalence("t2").unwrap();
+    }
+
     #[test]
     fn failed_row_insert_leaves_no_mapping_row() {
         // Transactional coupling, forward direction: when the user-row insert