Move Rust tests to separate files for consistency with JavaScript

- Create rust/tests/ directory with separate test files:
  - claude_tests.rs (20 tests)
  - gemini_tests.rs (25 tests)
  - agent_tests.rs (18 tests)
  - codex_tests.rs (15 tests)
  - opencode_tests.rs (13 tests)
  - tools_tests.rs (12 tests)
  - streaming_tests.rs (17 tests)
  - lib_tests.rs (10 tests)
- Remove embedded #[cfg(test)] mod tests from source files
- All 173 Rust tests pass, matching JavaScript test structure
- Follows the same pattern as js/test/*.test.mjs files

Co-Authored-By: Claude Opus 4.5 <[email protected]>

Author: konard

rust/src/lib.rs

@@ -331,75 +331,4 @@ pub fn agent(options: AgentOptions) -> Result<Agent, String> {
     Agent::new(options)
 }
 
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_agent_throws_without_tool() {
-        let options = AgentOptions {
-            working_directory: "/tmp/test".to_string(),
-            ..Default::default()
-        };
-        let result = agent(options);
-        assert!(result.is_err());
-        if let Err(e) = result {
-            assert!(e.contains("tool is required"));
-        }
-    }
-
-    #[test]
-    fn test_agent_throws_without_working_directory() {
-        let options = AgentOptions {
-            tool: "claude".to_string(),
-            ..Default::default()
-        };
-        let result = agent(options);
-        assert!(result.is_err());
-        if let Err(e) = result {
-            assert!(e.contains("working_directory is required"));
-        }
-    }
-
-    #[test]
-    fn test_agent_throws_for_screen_without_name() {
-        let options = AgentOptions {
-            tool: "claude".to_string(),
-            working_directory: "/tmp/test".to_string(),
-            isolation: "screen".to_string(),
-            ..Default::default()
-        };
-        let result = agent(options);
-        assert!(result.is_err());
-        if let Err(e) = result {
-            assert!(e.contains("screen_name is required"));
-        }
-    }
-
-    #[test]
-    fn test_agent_throws_for_docker_without_name() {
-        let options = AgentOptions {
-            tool: "claude".to_string(),
-            working_directory: "/tmp/test".to_string(),
-            isolation: "docker".to_string(),
-            ..Default::default()
-        };
-        let result = agent(options);
-        assert!(result.is_err());
-        if let Err(e) = result {
-            assert!(e.contains("container_name is required"));
-        }
-    }
-
-    #[test]
-    fn test_agent_creates_with_valid_options() {
-        let options = AgentOptions {
-            tool: "claude".to_string(),
-            working_directory: "/tmp/test".to_string(),
-            isolation: "none".to_string(),
-            ..Default::default()
-        };
-        let result = agent(options);
-        assert!(result.is_ok());
-    }
-}
+// Tests are in rust/tests/lib_tests.rs

rust/src/streaming/mod.rs

@@ -22,19 +22,4 @@ pub fn create_input_stream(compact: bool) -> JsonInputStream {
     JsonInputStream::new(compact)
 }
 
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_create_output_stream() {
-        let stream = create_output_stream();
-        assert_eq!(stream.get_messages().len(), 0);
-    }
-
-    #[test]
-    fn test_create_input_stream() {
-        let stream = create_input_stream(true);
-        assert_eq!(stream.size(), 0);
-    }
-}
+// Tests are in rust/tests/streaming_tests.rs

rust/src/streaming/ndjson.rs

@@ -76,73 +76,4 @@ pub fn stringify_ndjson(values: &[Value], compact: bool) -> String {
         .collect()
 }
 
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use serde_json::json;
-
-    #[test]
-    fn test_parse_ndjson_line_valid_object() {
-        let result = parse_ndjson_line(r#"{"type":"message"}"#);
-        assert_eq!(result, Some(json!({"type": "message"})));
-    }
-
-    #[test]
-    fn test_parse_ndjson_line_valid_array() {
-        let result = parse_ndjson_line("[1, 2, 3]");
-        assert_eq!(result, Some(json!([1, 2, 3])));
-    }
-
-    #[test]
-    fn test_parse_ndjson_line_empty() {
-        assert_eq!(parse_ndjson_line(""), None);
-        assert_eq!(parse_ndjson_line("   "), None);
-    }
-
-    #[test]
-    fn test_parse_ndjson_line_non_json() {
-        assert_eq!(parse_ndjson_line("hello world"), None);
-        assert_eq!(parse_ndjson_line("123"), None);
-    }
-
-    #[test]
-    fn test_parse_ndjson_line_invalid_json() {
-        assert_eq!(parse_ndjson_line("{invalid}"), None);
-    }
-
-    #[test]
-    fn test_parse_ndjson_line_trims_whitespace() {
-        let result = parse_ndjson_line(r#"  {"type":"message"}  "#);
-        assert_eq!(result, Some(json!({"type": "message"})));
-    }
-
-    #[test]
-    fn test_stringify_ndjson_line_object() {
-        let value = json!({"type": "message"});
-        let result = stringify_ndjson_line(&value, true);
-        assert_eq!(result, "{\"type\":\"message\"}\n");
-    }
-
-    #[test]
-    fn test_stringify_ndjson_line_null() {
-        let value = Value::Null;
-        let result = stringify_ndjson_line(&value, true);
-        assert_eq!(result, "");
-    }
-
-    #[test]
-    fn test_parse_ndjson() {
-        let data = "{\"a\":1}\n{\"b\":2}\n";
-        let result = parse_ndjson(data);
-        assert_eq!(result.len(), 2);
-        assert_eq!(result[0], json!({"a": 1}));
-        assert_eq!(result[1], json!({"b": 2}));
-    }
-
-    #[test]
-    fn test_stringify_ndjson() {
-        let values = vec![json!({"a": 1}), json!({"b": 2})];
-        let result = stringify_ndjson(&values, true);
-        assert_eq!(result, "{\"a\":1}\n{\"b\":2}\n");
-    }
-}
+// Tests are in rust/tests/streaming_tests.rs

rust/src/tools/agent.rs

@@ -288,49 +288,4 @@ impl Default for AgentTool {
     }
 }
 
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_map_model_to_id_with_alias() {
-        assert_eq!(map_model_to_id("grok"), "opencode/grok-code");
-        assert_eq!(map_model_to_id("sonnet"), "anthropic/claude-3-5-sonnet");
-    }
-
-    #[test]
-    fn test_build_args_with_model() {
-        let options = AgentBuildOptions {
-            model: Some("grok".to_string()),
-            ..Default::default()
-        };
-        let args = build_args(&options);
-        assert!(args.contains(&"--model".to_string()));
-        assert!(args.contains(&"opencode/grok-code".to_string()));
-    }
-
-    #[test]
-    fn test_extract_usage_from_step_finish() {
-        let output = r#"{"type":"step_finish","part":{"tokens":{"input":100,"output":50},"cost":0}}
-{"type":"step_finish","part":{"tokens":{"input":200,"output":75},"cost":0}}"#;
-        let usage = extract_usage(output);
-        assert_eq!(usage.input_tokens, 300);
-        assert_eq!(usage.output_tokens, 125);
-        assert_eq!(usage.step_count, 2);
-    }
-
-    #[test]
-    fn test_detect_errors_finds_error() {
-        let output = r#"{"type":"error","message":"Something went wrong"}"#;
-        let result = detect_errors(output);
-        assert!(result.has_error);
-        assert_eq!(result.error_type, Some("error".to_string()));
-    }
-
-    #[test]
-    fn test_detect_errors_normal_output() {
-        let output = r#"{"type":"step_finish","part":{}}"#;
-        let result = detect_errors(output);
-        assert!(!result.has_error);
-    }
-}
+// Tests are in rust/tests/agent_tests.rs

rust/src/tools/claude.rs

@@ -289,170 +289,4 @@ impl Default for ClaudeTool {
     }
 }
 
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_map_model_to_id_with_alias() {
-        assert_eq!(map_model_to_id("sonnet"), "claude-sonnet-4-5-20250929");
-        assert_eq!(map_model_to_id("opus"), "claude-opus-4-5-20251101");
-        assert_eq!(map_model_to_id("haiku"), "claude-haiku-4-5-20251001");
-    }
-
-    #[test]
-    fn test_map_model_to_id_with_full_id() {
-        assert_eq!(
-            map_model_to_id("claude-3-opus-20240229"),
-            "claude-3-opus-20240229"
-        );
-    }
-
-    #[test]
-    fn test_build_args_with_prompt() {
-        let options = ClaudeBuildOptions {
-            prompt: Some("Hello".to_string()),
-            ..Default::default()
-        };
-        let args = build_args(&options);
-        assert!(args.contains(&"--prompt".to_string()));
-        assert!(args.contains(&"Hello".to_string()));
-    }
-
-    #[test]
-    fn test_build_args_with_model() {
-        let options = ClaudeBuildOptions {
-            model: Some("sonnet".to_string()),
-            ..Default::default()
-        };
-        let args = build_args(&options);
-        assert!(args.contains(&"--model".to_string()));
-        assert!(args.contains(&"claude-sonnet-4-5-20250929".to_string()));
-    }
-
-    #[test]
-    fn test_parse_output_ndjson() {
-        let output = "{\"type\":\"message\",\"content\":\"Hello\"}\n{\"type\":\"done\"}";
-        let messages = parse_output(output);
-        assert_eq!(messages.len(), 2);
-        assert_eq!(messages[0]["type"], "message");
-        assert_eq!(messages[1]["type"], "done");
-    }
-
-    #[test]
-    fn test_extract_session_id() {
-        let output = "{\"session_id\":\"abc123\"}\n{\"type\":\"done\"}";
-        let session_id = extract_session_id(output);
-        assert_eq!(session_id, Some("abc123".to_string()));
-    }
-
-    // New capability tests (issue #3)
-    #[test]
-    fn test_build_args_always_includes_dangerously_skip_permissions() {
-        // dangerously_skip_permissions is always enabled and not configurable
-        let options = ClaudeBuildOptions::new();
-        let args = build_args(&options);
-        assert!(args.contains(&"--dangerously-skip-permissions".to_string()));
-
-        // Even with default options, it should still be included
-        let default_options = ClaudeBuildOptions::default();
-        let default_args = build_args(&default_options);
-        assert!(default_args.contains(&"--dangerously-skip-permissions".to_string()));
-    }
-
-    #[test]
-    fn test_build_args_uses_stream_json_format() {
-        let options = ClaudeBuildOptions {
-            json: true,
-            ..Default::default()
-        };
-        let args = build_args(&options);
-        assert!(args.contains(&"--output-format".to_string()));
-        assert!(args.contains(&"stream-json".to_string()));
-        assert!(!args.contains(&"json".to_string())); // Should not contain plain 'json'
-    }
-
-    #[test]
-    fn test_build_args_with_fallback_model() {
-        let options = ClaudeBuildOptions {
-            model: Some("opus".to_string()),
-            fallback_model: Some("sonnet".to_string()),
-            ..Default::default()
-        };
-        let args = build_args(&options);
-        assert!(args.contains(&"--model".to_string()));
-        assert!(args.contains(&"claude-opus-4-5-20251101".to_string()));
-        assert!(args.contains(&"--fallback-model".to_string()));
-        assert!(args.contains(&"claude-sonnet-4-5-20250929".to_string()));
-    }
-
-    #[test]
-    fn test_build_args_with_append_system_prompt() {
-        let options = ClaudeBuildOptions {
-            append_system_prompt: Some("Extra instructions".to_string()),
-            ..Default::default()
-        };
-        let args = build_args(&options);
-        assert!(args.contains(&"--append-system-prompt".to_string()));
-        assert!(args.contains(&"Extra instructions".to_string()));
-    }
-
-    #[test]
-    fn test_build_args_with_session_management() {
-        let options = ClaudeBuildOptions {
-            session_id: Some("123e4567-e89b-12d3-a456-426614174000".to_string()),
-            resume: Some("abc123".to_string()),
-            fork_session: true,
-            ..Default::default()
-        };
-        let args = build_args(&options);
-        assert!(args.contains(&"--session-id".to_string()));
-        assert!(args.contains(&"123e4567-e89b-12d3-a456-426614174000".to_string()));
-        assert!(args.contains(&"--resume".to_string()));
-        assert!(args.contains(&"abc123".to_string()));
-        assert!(args.contains(&"--fork-session".to_string()));
-    }
-
-    #[test]
-    fn test_build_args_with_verbose() {
-        let options = ClaudeBuildOptions {
-            verbose: true,
-            ..Default::default()
-        };
-        let args = build_args(&options);
-        assert!(args.contains(&"--verbose".to_string()));
-    }
-
-    #[test]
-    fn test_build_args_with_json_input() {
-        let options = ClaudeBuildOptions {
-            json_input: true,
-            ..Default::default()
-        };
-        let args = build_args(&options);
-        assert!(args.contains(&"--input-format".to_string()));
-        assert!(args.contains(&"stream-json".to_string()));
-    }
-
-    #[test]
-    fn test_build_args_with_replay_user_messages() {
-        let options = ClaudeBuildOptions {
-            replay_user_messages: true,
-            ..Default::default()
-        };
-        let args = build_args(&options);
-        assert!(args.contains(&"--replay-user-messages".to_string()));
-    }
-
-    #[test]
-    fn test_claude_tool_supports_new_capabilities() {
-        let tool = ClaudeTool::default();
-        assert!(tool.supports_json_input);
-        assert!(tool.supports_append_system_prompt);
-        assert!(tool.supports_fork_session);
-        assert!(tool.supports_session_id);
-        assert!(tool.supports_fallback_model);
-        assert!(tool.supports_verbose);
-        assert!(tool.supports_replay_user_messages);
-    }
-}
+// Tests are in rust/tests/claude_tests.rs