dirsql 0.3.57__tar.gz → 0.3.58__tar.gz

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

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dirsql
-Version: 0.3.57
+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.57 → 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.57"
+version = "0.3.58"
 edition.workspace = true
 publish = false
 readme = "README.md"

{dirsql-0.3.57 → 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": 1783105847,
+  "ran_at": 1783118080,
   "exit_code": 0,
-  "commit": "d94d40b0448b03171f2e8ffd60635575da1353d5"
+  "commit": "b45791b9ad04fbac360618f3ff885e5f84a8289e"
 }

{dirsql-0.3.57 → 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.57 → 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.57 → 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:?}");
+    }
 }