+5

.config/nextest.toml

reviewed

··· 1 1 + [profile.default] 2 2 + fail-fast = false 3 3 + 4 4 + [profile.ci] 5 5 + fail-fast = true

+27

.github/workflows/test.yml

reviewed

··· 1 1 + name: Test 2 2 + 3 3 + on: 4 4 + push: 5 5 + branches: [main] 6 6 + pull_request: 7 7 + branches: [main] 8 8 + 9 9 + jobs: 10 10 + test: 11 11 + runs-on: ubuntu-22.04 12 12 + steps: 13 13 + - uses: actions/checkout@v4 14 14 + 15 15 + - name: Install protoc 16 16 + uses: arduino/setup-protoc@v3 17 17 + with: 18 18 + repo-token: ${{ secrets.GITHUB_TOKEN }} 19 19 + 20 20 + - name: Add wasm32-wasip2 target 21 21 + run: rustup target add wasm32-wasip2 22 22 + 23 23 + - name: Install cargo-nextest 24 24 + uses: taiki-e/install-action@nextest 25 25 + 26 26 + - name: Run tests 27 27 + run: cargo nextest run --workspace --profile ci

+3

Cargo.lock

reviewed

··· 1094 1094 "ein_plugin", 1095 1095 "serde", 1096 1096 "serde_json", 1097 1097 + "tempfile", 1097 1098 "wit-bindgen 0.53.1", 1098 1099 ] 1099 1100 ··· 1160 1161 "ein_plugin", 1161 1162 "serde", 1162 1163 "serde_json", 1164 1164 + "tempfile", 1163 1165 "wit-bindgen 0.53.1", 1164 1166 ] 1165 1167 ··· 1171 1173 "ein_plugin", 1172 1174 "serde", 1173 1175 "serde_json", 1176 1176 + "tempfile", 1174 1177 "wit-bindgen 0.53.1", 1175 1178 ] 1176 1179

+329 -1

crates/ein-agent/src/agents.rs

reviewed

··· 520 520 use std::sync::Mutex; 521 521 522 522 use async_trait::async_trait; 523 523 - use ein_core::types::{Choice, CompletionResponse, ToolDef, ToolResult}; 523 523 + use ein_core::types::{Choice, CompletionResponse, ToolDef, ToolResult, Usage}; 524 524 525 525 use super::*; 526 526 ··· 691 691 let _ = agent.chat("user message").await.unwrap(); 692 692 693 693 assert_eq!(*tool.called_arg.lock().unwrap(), "test_val".to_string()); 694 694 + } 695 695 + 696 696 + // --------------------------------------------------------------------------- 697 697 + // Shared test helpers 698 698 + // --------------------------------------------------------------------------- 699 699 + 700 700 + fn tool_msg(id: &str, content: impl Into<String>) -> Message { 701 701 + Message { 702 702 + role: Role::Tool, 703 703 + content: Some(content.into()), 704 704 + tool_call_id: Some(id.to_string()), 705 705 + tool_calls: None, 706 706 + } 707 707 + } 708 708 + 709 709 + fn user_msg(content: impl Into<String>) -> Message { 710 710 + Message { 711 711 + role: Role::User, 712 712 + content: Some(content.into()), 713 713 + tool_calls: None, 714 714 + tool_call_id: None, 715 715 + } 716 716 + } 717 717 + 718 718 + fn system_msg(content: impl Into<String>) -> Message { 719 719 + Message { 720 720 + role: Role::System, 721 721 + content: Some(content.into()), 722 722 + tool_calls: None, 723 723 + tool_call_id: None, 724 724 + } 725 725 + } 726 726 + 727 727 + fn stop_response(content: &str) -> CompletionResponse { 728 728 + CompletionResponse { 729 729 + choices: vec![Choice { 730 730 + index: None, 731 731 + finish_reason: FinishReason::Stop, 732 732 + message: Message { 733 733 + role: Role::Assistant, 734 734 + content: Some(content.to_string()), 735 735 + tool_calls: None, 736 736 + tool_call_id: None, 737 737 + }, 738 738 + }], 739 739 + usage: None, 740 740 + error: None, 741 741 + } 742 742 + } 743 743 + 744 744 + // --------------------------------------------------------------------------- 745 745 + // truncate_old_tool_results — tested directly (private method, same file) 746 746 + // --------------------------------------------------------------------------- 747 747 + 748 748 + const TEST_THRESHOLD: usize = 50; 749 749 + const TEST_WINDOW: usize = 2; 750 750 + 751 751 + #[test] 752 752 + fn truncate_old_tool_results_replaces_large_stale_content() { 753 753 + let large = "x".repeat(TEST_THRESHOLD + 1); 754 754 + let history = vec![ 755 755 + tool_msg("t1", &large), 756 756 + tool_msg("t2", &large), 757 757 + user_msg("recent 1"), 758 758 + user_msg("recent 2"), 759 759 + ]; 760 760 + 761 761 + let mut agent = Agent::builder(basic_test_client()) 762 762 + .num_recent_messages(TEST_WINDOW) 763 763 + .max_tool_result_chars(TEST_THRESHOLD) 764 764 + .with_message_history(history) 765 765 + .build(); 766 766 + 767 767 + agent.truncate_old_tool_results(); 768 768 + 769 769 + let msgs = agent.messages(); 770 770 + assert!( 771 771 + msgs[0].content.as_deref().unwrap_or("").starts_with("[Tool result truncated:"), 772 772 + "old large tool result must be truncated" 773 773 + ); 774 774 + assert!( 775 775 + msgs[1].content.as_deref().unwrap_or("").starts_with("[Tool result truncated:"), 776 776 + "old large tool result must be truncated" 777 777 + ); 778 778 + assert_eq!(msgs[2].content.as_deref(), Some("recent 1")); 779 779 + assert_eq!(msgs[3].content.as_deref(), Some("recent 2")); 780 780 + } 781 781 + 782 782 + #[test] 783 783 + fn truncate_old_tool_results_keeps_recent_messages_intact() { 784 784 + let large = "x".repeat(TEST_THRESHOLD + 1); 785 785 + // All 3 messages are within the window of 3 — none should be truncated. 786 786 + let history = vec![ 787 787 + tool_msg("t1", &large), 788 788 + tool_msg("t2", &large), 789 789 + tool_msg("t3", &large), 790 790 + ]; 791 791 + 792 792 + let mut agent = Agent::builder(basic_test_client()) 793 793 + .num_recent_messages(3) 794 794 + .max_tool_result_chars(TEST_THRESHOLD) 795 795 + .with_message_history(history) 796 796 + .build(); 797 797 + 798 798 + agent.truncate_old_tool_results(); 799 799 + 800 800 + for msg in agent.messages() { 801 801 + assert!( 802 802 + !msg.content.as_deref().unwrap_or("").starts_with("[Tool result truncated:"), 803 803 + "recent messages must not be truncated" 804 804 + ); 805 805 + } 806 806 + } 807 807 + 808 808 + #[test] 809 809 + fn truncate_old_tool_results_ignores_non_tool_messages() { 810 810 + let large = "x".repeat(TEST_THRESHOLD + 1); 811 811 + let history = vec![ 812 812 + user_msg(&large), 813 813 + system_msg(&large), 814 814 + tool_msg("t1", "small"), 815 815 + ]; 816 816 + 817 817 + let mut agent = Agent::builder(basic_test_client()) 818 818 + .num_recent_messages(TEST_WINDOW) 819 819 + .max_tool_result_chars(TEST_THRESHOLD) 820 820 + .with_message_history(history) 821 821 + .build(); 822 822 + 823 823 + agent.truncate_old_tool_results(); 824 824 + 825 825 + let msgs = agent.messages(); 826 826 + assert_eq!(msgs[0].content.as_deref(), Some(large.as_str()), "User must not be truncated"); 827 827 + assert_eq!(msgs[1].content.as_deref(), Some(large.as_str()), "System must not be truncated"); 828 828 + } 829 829 + 830 830 + #[test] 831 831 + fn truncate_old_tool_results_skips_content_at_threshold() { 832 832 + // content length == threshold is NOT truncated (condition is strictly >) 833 833 + let at_threshold = "x".repeat(TEST_THRESHOLD); 834 834 + let history = vec![ 835 835 + tool_msg("t1", &at_threshold), 836 836 + user_msg("recent 1"), 837 837 + user_msg("recent 2"), 838 838 + ]; 839 839 + 840 840 + let mut agent = Agent::builder(basic_test_client()) 841 841 + .num_recent_messages(TEST_WINDOW) 842 842 + .max_tool_result_chars(TEST_THRESHOLD) 843 843 + .with_message_history(history) 844 844 + .build(); 845 845 + 846 846 + agent.truncate_old_tool_results(); 847 847 + 848 848 + assert_eq!( 849 849 + agent.messages()[0].content.as_deref(), 850 850 + Some(at_threshold.as_str()), 851 851 + "content exactly at threshold must not be truncated" 852 852 + ); 853 853 + } 854 854 + 855 855 + // --------------------------------------------------------------------------- 856 856 + // compact_history 857 857 + // --------------------------------------------------------------------------- 858 858 + 859 859 + #[tokio::test] 860 860 + async fn compact_history_returns_empty_when_no_user_messages() { 861 861 + let mut agent = Agent::builder(basic_test_client()) 862 862 + .with_message_history(vec![system_msg("you are helpful")]) 863 863 + .build(); 864 864 + 865 865 + let result = agent.compact_history().await.unwrap(); 866 866 + assert_eq!(result, "", "nothing to compact without user messages"); 867 867 + } 868 868 + 869 869 + #[tokio::test] 870 870 + async fn compact_history_replaces_history_with_system_plus_summary() { 871 871 + let summary = "Goals discussed, files modified, current state."; 872 872 + let mut agent = Agent::builder(BasicTestModelClient { 873 873 + response: stop_response(summary), 874 874 + }) 875 875 + .with_message_history(vec![system_msg("sys"), user_msg("do stuff")]) 876 876 + .build(); 877 877 + 878 878 + let returned = agent.compact_history().await.unwrap(); 879 879 + assert_eq!(returned, summary); 880 880 + 881 881 + let msgs = agent.messages(); 882 882 + assert_eq!(msgs.len(), 2, "original system + new summary system"); 883 883 + assert!(matches!(msgs[0].role, Role::System)); 884 884 + assert_eq!(msgs[0].content.as_deref(), Some("sys")); 885 885 + assert!(matches!(msgs[1].role, Role::System)); 886 886 + assert!(msgs[1].content.as_deref().unwrap_or("").contains(summary)); 887 887 + } 888 888 + 889 889 + #[tokio::test] 890 890 + async fn compact_history_broadcasts_content_delta_event() { 891 891 + use std::sync::Arc; 892 892 + 893 893 + let summary = "Detailed summary."; 894 894 + let captured: Arc<Mutex<Vec<AgentEvent>>> = Arc::new(Mutex::new(Vec::new())); 895 895 + let cap = captured.clone(); 896 896 + 897 897 + let mut agent = Agent::builder(BasicTestModelClient { 898 898 + response: stop_response(summary), 899 899 + }) 900 900 + .with_event_handler(move |event| { 901 901 + let cap = cap.clone(); 902 902 + async move { cap.lock().unwrap().push(event); } 903 903 + }) 904 904 + .with_message_history(vec![user_msg("do stuff")]) 905 905 + .build(); 906 906 + 907 907 + agent.compact_history().await.unwrap(); 908 908 + 909 909 + let events = captured.lock().unwrap(); 910 910 + let deltas: Vec<&str> = events 911 911 + .iter() 912 912 + .filter_map(|e| { 913 913 + if let AgentEvent::ContentDelta(t) = e { Some(t.as_str()) } else { None } 914 914 + }) 915 915 + .collect(); 916 916 + assert_eq!(deltas, vec![summary]); 917 917 + } 918 918 + 919 919 + // --------------------------------------------------------------------------- 920 920 + // chat error paths 921 921 + // --------------------------------------------------------------------------- 922 922 + 923 923 + #[tokio::test] 924 924 + async fn chat_returns_error_on_api_error_response() { 925 925 + let mut agent = Agent::builder(BasicTestModelClient { 926 926 + response: CompletionResponse { 927 927 + choices: vec![], 928 928 + usage: None, 929 929 + error: Some(serde_json::json!({"message": "insufficient credits"})), 930 930 + }, 931 931 + }) 932 932 + .build(); 933 933 + 934 934 + let err = agent.chat("prompt").await.unwrap_err(); 935 935 + assert!(matches!(err, AgentError::ModelClient(_))); 936 936 + assert!(err.to_string().contains("insufficient credits")); 937 937 + } 938 938 + 939 939 + #[tokio::test] 940 940 + async fn chat_returns_error_on_unsupported_finish_reason() { 941 941 + let mut agent = Agent::builder(BasicTestModelClient { 942 942 + response: CompletionResponse { 943 943 + choices: vec![Choice { 944 944 + index: None, 945 945 + finish_reason: FinishReason::Unsupported, 946 946 + message: Message { 947 947 + role: Role::Assistant, 948 948 + content: None, 949 949 + tool_calls: None, 950 950 + tool_call_id: None, 951 951 + }, 952 952 + }], 953 953 + usage: None, 954 954 + error: None, 955 955 + }, 956 956 + }) 957 957 + .build(); 958 958 + 959 959 + let err = agent.chat("prompt").await.unwrap_err(); 960 960 + assert!(matches!(err, AgentError::UnsupportedFinishReason(_))); 961 961 + } 962 962 + 963 963 + // --------------------------------------------------------------------------- 964 964 + // Token usage events and clear 965 965 + // --------------------------------------------------------------------------- 966 966 + 967 967 + #[tokio::test] 968 968 + async fn chat_emits_token_usage_event() { 969 969 + use std::sync::Arc; 970 970 + 971 971 + let captured: Arc<Mutex<Vec<AgentEvent>>> = Arc::new(Mutex::new(Vec::new())); 972 972 + let cap = captured.clone(); 973 973 + 974 974 + let mut agent = Agent::builder(BasicTestModelClient { 975 975 + response: CompletionResponse { 976 976 + choices: vec![Choice { 977 977 + index: None, 978 978 + finish_reason: FinishReason::Stop, 979 979 + message: Message { 980 980 + role: Role::Assistant, 981 981 + content: Some("done".to_string()), 982 982 + tool_calls: None, 983 983 + tool_call_id: None, 984 984 + }, 985 985 + }], 986 986 + usage: Some(Usage { 987 987 + prompt_tokens: 10, 988 988 + completion_tokens: 5, 989 989 + total_tokens: 15, 990 990 + }), 991 991 + error: None, 992 992 + }, 993 993 + }) 994 994 + .with_event_handler(move |event| { 995 995 + let cap = cap.clone(); 996 996 + async move { cap.lock().unwrap().push(event); } 997 997 + }) 998 998 + .build(); 999 999 + 1000 1000 + agent.chat("hello").await.unwrap(); 1001 1001 + 1002 1002 + let events = captured.lock().unwrap(); 1003 1003 + let usage = events.iter().find_map(|e| { 1004 1004 + if let AgentEvent::TokenUsage { prompt_tokens, completion_tokens, total_tokens } = e { 1005 1005 + Some((*prompt_tokens, *completion_tokens, *total_tokens)) 1006 1006 + } else { 1007 1007 + None 1008 1008 + } 1009 1009 + }); 1010 1010 + assert_eq!(usage, Some((10, 5, 15)), "TokenUsage event must carry correct totals"); 1011 1011 + } 1012 1012 + 1013 1013 + #[tokio::test] 1014 1014 + async fn clear_messages_empties_history() { 1015 1015 + let mut agent = Agent::builder(basic_test_client()) 1016 1016 + .with_message_history(vec![system_msg("sys"), user_msg("hello")]) 1017 1017 + .build(); 1018 1018 + 1019 1019 + assert!(!agent.messages().is_empty()); 1020 1020 + agent.clear_messages(); 1021 1021 + assert!(agent.messages().is_empty()); 694 1022 } 695 1023 }

+163

crates/ein-core/src/types.rs

reviewed

··· 262 262 } 263 263 } 264 264 } 265 265 + 266 266 + #[cfg(test)] 267 267 + mod tests { 268 268 + use super::*; 269 269 + 270 270 + // --------------------------------------------------------------------------- 271 271 + // ToolFunctionBuilder 272 272 + // --------------------------------------------------------------------------- 273 273 + 274 274 + #[test] 275 275 + fn builder_produces_function_tool_def() { 276 276 + let tool = ToolDef::function("my_tool", "does a thing").build(); 277 277 + assert!(matches!(tool, ToolDef::Function { .. })); 278 278 + } 279 279 + 280 280 + #[test] 281 281 + fn builder_required_param_appears_in_required_array() { 282 282 + let tool = ToolDef::function("t", "d") 283 283 + .param("req_param", "string", "a required param", true) 284 284 + .build(); 285 285 + 286 286 + let ToolDef::Function { function } = tool; 287 287 + let ToolFunctionParams::Object { required, .. } = &function.parameters; 288 288 + assert!(required.contains(&"req_param".to_string())); 289 289 + } 290 290 + 291 291 + #[test] 292 292 + fn builder_optional_param_absent_from_required_array() { 293 293 + let tool = ToolDef::function("t", "d") 294 294 + .param("opt_param", "string", "an optional param", false) 295 295 + .build(); 296 296 + 297 297 + let ToolDef::Function { function } = tool; 298 298 + let ToolFunctionParams::Object { required, .. } = &function.parameters; 299 299 + assert!(!required.contains(&"opt_param".to_string())); 300 300 + } 301 301 + 302 302 + #[test] 303 303 + fn builder_param_appears_in_properties() { 304 304 + let tool = ToolDef::function("t", "d") 305 305 + .param("my_arg", "integer", "an arg", true) 306 306 + .build(); 307 307 + 308 308 + let ToolDef::Function { function } = tool; 309 309 + let ToolFunctionParams::Object { properties, .. } = &function.parameters; 310 310 + assert!(properties.props().contains_key("my_arg")); 311 311 + } 312 312 + 313 313 + #[test] 314 314 + fn builder_serializes_to_openai_schema_shape() { 315 315 + let tool = ToolDef::function("bash", "run a shell command") 316 316 + .param("command", "string", "the command to run", true) 317 317 + .build(); 318 318 + 319 319 + let v = serde_json::to_value(&tool).unwrap(); 320 320 + assert_eq!(v["type"], "function"); 321 321 + assert_eq!(v["function"]["name"], "bash"); 322 322 + assert_eq!(v["function"]["parameters"]["type"], "object"); 323 323 + assert_eq!( 324 324 + v["function"]["parameters"]["properties"]["command"]["type"], 325 325 + "string" 326 326 + ); 327 327 + assert_eq!(v["function"]["parameters"]["required"][0], "command"); 328 328 + } 329 329 + 330 330 + // --------------------------------------------------------------------------- 331 331 + // Message serialization 332 332 + // --------------------------------------------------------------------------- 333 333 + 334 334 + #[test] 335 335 + fn message_round_trips_for_each_role() { 336 336 + for role in [Role::System, Role::User, Role::Assistant, Role::Tool] { 337 337 + let msg = Message { 338 338 + role: role.clone(), 339 339 + content: Some("hello".to_string()), 340 340 + tool_calls: None, 341 341 + tool_call_id: None, 342 342 + }; 343 343 + let json = serde_json::to_string(&msg).unwrap(); 344 344 + let decoded: Message = serde_json::from_str(&json).unwrap(); 345 345 + assert_eq!(decoded.role, role); 346 346 + assert_eq!(decoded.content.as_deref(), Some("hello")); 347 347 + } 348 348 + } 349 349 + 350 350 + #[test] 351 351 + fn message_omits_none_fields_from_json() { 352 352 + let msg = Message { 353 353 + role: Role::User, 354 354 + content: Some("hi".to_string()), 355 355 + tool_calls: None, 356 356 + tool_call_id: None, 357 357 + }; 358 358 + let v = serde_json::to_value(&msg).unwrap(); 359 359 + assert!(!v.as_object().unwrap().contains_key("tool_calls")); 360 360 + assert!(!v.as_object().unwrap().contains_key("tool_call_id")); 361 361 + } 362 362 + 363 363 + // --------------------------------------------------------------------------- 364 364 + // FinishReason 365 365 + // --------------------------------------------------------------------------- 366 366 + 367 367 + #[test] 368 368 + fn finish_reason_unknown_value_deserializes_as_unsupported() { 369 369 + let json = r#""length""#; 370 370 + let reason: FinishReason = serde_json::from_str(json).unwrap(); 371 371 + assert!(matches!(reason, FinishReason::Unsupported)); 372 372 + } 373 373 + 374 374 + #[test] 375 375 + fn finish_reason_known_values_round_trip() { 376 376 + for (s, expected) in [ 377 377 + ("\"stop\"", FinishReason::Stop), 378 378 + ("\"tool_calls\"", FinishReason::ToolCalls), 379 379 + ] { 380 380 + let reason: FinishReason = serde_json::from_str(s).unwrap(); 381 381 + assert!(matches!( 382 382 + (reason, expected), 383 383 + (FinishReason::Stop, FinishReason::Stop) 384 384 + | (FinishReason::ToolCalls, FinishReason::ToolCalls) 385 385 + )); 386 386 + } 387 387 + } 388 388 + 389 389 + // --------------------------------------------------------------------------- 390 390 + // CompletionRequest / CompletionResponse 391 391 + // --------------------------------------------------------------------------- 392 392 + 393 393 + #[test] 394 394 + fn completion_request_round_trips() { 395 395 + let req = CompletionRequest { 396 396 + model: "gpt-4o".to_string(), 397 397 + max_tokens: 1024, 398 398 + messages: vec![Message { 399 399 + role: Role::User, 400 400 + content: Some("hello".to_string()), 401 401 + tool_calls: None, 402 402 + tool_call_id: None, 403 403 + }], 404 404 + tools: vec![], 405 405 + }; 406 406 + let json = serde_json::to_string(&req).unwrap(); 407 407 + let decoded: CompletionRequest = serde_json::from_str(&json).unwrap(); 408 408 + assert_eq!(decoded.model, "gpt-4o"); 409 409 + assert_eq!(decoded.max_tokens, 1024); 410 410 + assert_eq!(decoded.messages.len(), 1); 411 411 + } 412 412 + 413 413 + #[test] 414 414 + fn completion_response_error_field_round_trips() { 415 415 + let resp = CompletionResponse { 416 416 + choices: vec![], 417 417 + usage: None, 418 418 + error: Some(serde_json::json!({"message": "insufficient credits"})), 419 419 + }; 420 420 + let json = serde_json::to_string(&resp).unwrap(); 421 421 + let decoded: CompletionResponse = serde_json::from_str(&json).unwrap(); 422 422 + assert_eq!( 423 423 + decoded.error.unwrap()["message"], 424 424 + "insufficient credits" 425 425 + ); 426 426 + } 427 427 + }

+92

crates/ein-tui/src/connection.rs

reviewed

··· 237 237 Ok(resp.into_inner()) 238 238 } 239 239 240 240 + // --------------------------------------------------------------------------- 241 241 + // Tests 242 242 + // --------------------------------------------------------------------------- 243 243 + 244 244 + #[cfg(test)] 245 245 + mod tests { 246 246 + use std::collections::HashMap; 247 247 + 248 248 + use super::*; 249 249 + use crate::config::{ClientConfig, PluginConfig}; 250 250 + 251 251 + #[test] 252 252 + fn to_proto_maps_basic_fields() { 253 253 + let cfg = ClientConfig { 254 254 + allowed_paths: vec!["/home/user".to_string()], 255 255 + allowed_hosts: vec!["openrouter.ai".to_string()], 256 256 + model_client_name: "ein_openrouter".to_string(), 257 257 + plugin_configs: HashMap::new(), 258 258 + }; 259 259 + 260 260 + let proto = to_proto_session_config(&cfg, "sess-123".to_string()); 261 261 + 262 262 + assert_eq!(proto.allowed_paths, vec!["/home/user"]); 263 263 + assert_eq!(proto.allowed_hosts, vec!["openrouter.ai"]); 264 264 + assert_eq!(proto.model_client_name, "ein_openrouter"); 265 265 + assert_eq!(proto.session_id, "sess-123"); 266 266 + } 267 267 + 268 268 + #[test] 269 269 + fn to_proto_empty_plugin_configs_produces_empty_map() { 270 270 + let proto = to_proto_session_config(&ClientConfig::default(), "id".to_string()); 271 271 + assert!(proto.plugin_configs.is_empty()); 272 272 + } 273 273 + 274 274 + #[test] 275 275 + fn to_proto_serializes_plugin_params_as_json() { 276 276 + let mut params = HashMap::new(); 277 277 + params.insert("api_key".to_string(), serde_json::json!("sk-test")); 278 278 + params.insert("model".to_string(), serde_json::json!("my-model")); 279 279 + 280 280 + let mut plugin_configs = HashMap::new(); 281 281 + plugin_configs.insert( 282 282 + "ein_openrouter".to_string(), 283 283 + PluginConfig { params, ..Default::default() }, 284 284 + ); 285 285 + 286 286 + let cfg = ClientConfig { plugin_configs, ..Default::default() }; 287 287 + let proto = to_proto_session_config(&cfg, "id".to_string()); 288 288 + 289 289 + let pc = &proto.plugin_configs["ein_openrouter"]; 290 290 + let parsed: serde_json::Value = serde_json::from_str(&pc.params_json).unwrap(); 291 291 + assert_eq!(parsed["api_key"].as_str().unwrap(), "sk-test"); 292 292 + assert_eq!(parsed["model"].as_str().unwrap(), "my-model"); 293 293 + } 294 294 + 295 295 + #[test] 296 296 + fn to_proto_maps_plugin_allowed_paths_and_hosts() { 297 297 + let mut plugin_configs = HashMap::new(); 298 298 + plugin_configs.insert( 299 299 + "Bash".to_string(), 300 300 + PluginConfig { 301 301 + allowed_paths: vec!["/tmp".to_string()], 302 302 + allowed_hosts: vec!["example.com".to_string()], 303 303 + params: HashMap::new(), 304 304 + }, 305 305 + ); 306 306 + 307 307 + let cfg = ClientConfig { plugin_configs, ..Default::default() }; 308 308 + let proto = to_proto_session_config(&cfg, "id".to_string()); 309 309 + 310 310 + let pc = &proto.plugin_configs["Bash"]; 311 311 + assert_eq!(pc.allowed_paths, vec!["/tmp"]); 312 312 + assert_eq!(pc.allowed_hosts, vec!["example.com"]); 313 313 + } 314 314 + 315 315 + #[test] 316 316 + fn to_proto_multiple_plugin_configs_all_present() { 317 317 + let mut plugin_configs = HashMap::new(); 318 318 + plugin_configs.insert("ein_openrouter".to_string(), PluginConfig::default()); 319 319 + plugin_configs.insert("Bash".to_string(), PluginConfig::default()); 320 320 + plugin_configs.insert("Read".to_string(), PluginConfig::default()); 321 321 + 322 322 + let cfg = ClientConfig { plugin_configs, ..Default::default() }; 323 323 + let proto = to_proto_session_config(&cfg, "id".to_string()); 324 324 + 325 325 + assert_eq!(proto.plugin_configs.len(), 3); 326 326 + assert!(proto.plugin_configs.contains_key("ein_openrouter")); 327 327 + assert!(proto.plugin_configs.contains_key("Bash")); 328 328 + assert!(proto.plugin_configs.contains_key("Read")); 329 329 + } 330 330 + } 331 331 + 240 332 /// Opens a short-lived connection and deletes a session by ID. 241 333 /// 242 334 /// Returns `Ok(())` on success; errors are logged by the caller.

+219

crates/ein-tui/src/input.rs

reviewed

··· 846 846 assert_eq!(app.cumulative_tokens, 42); 847 847 } 848 848 } 849 849 + 850 850 + #[cfg(test)] 851 851 + mod key_events { 852 852 + use crossterm::event::{KeyCode, KeyEvent, KeyModifiers}; 853 853 + 854 854 + use crate::app::{DisplayMessage, test_helpers::make_app}; 855 855 + 856 856 + use super::*; 857 857 + 858 858 + fn key(code: KeyCode) -> KeyEvent { 859 859 + KeyEvent::new(code, KeyModifiers::NONE) 860 860 + } 861 861 + 862 862 + fn ctrl(code: KeyCode) -> KeyEvent { 863 863 + KeyEvent::new(code, KeyModifiers::CONTROL) 864 864 + } 865 865 + 866 866 + // --------------------------------------------------------------------------- 867 867 + // Ctrl-C and slash commands 868 868 + // --------------------------------------------------------------------------- 869 869 + 870 870 + #[tokio::test] 871 871 + async fn ctrl_c_always_quits() { 872 872 + let mut app = make_app("m"); 873 873 + let action = handle_key_event(&mut app, ctrl(KeyCode::Char('c'))).await; 874 874 + assert!(matches!(action, KeyAction::Quit)); 875 875 + } 876 876 + 877 877 + #[tokio::test] 878 878 + async fn exit_command_quits() { 879 879 + let mut app = make_app("m"); 880 880 + app.input = "/exit".to_string(); 881 881 + let action = handle_key_event(&mut app, key(KeyCode::Enter)).await; 882 882 + assert!(matches!(action, KeyAction::Quit)); 883 883 + } 884 884 + 885 885 + #[tokio::test] 886 886 + async fn new_command_returns_new_session() { 887 887 + let mut app = make_app("m"); 888 888 + app.input = "/new".to_string(); 889 889 + let action = handle_key_event(&mut app, key(KeyCode::Enter)).await; 890 890 + assert!(matches!(action, KeyAction::NewSession)); 891 891 + } 892 892 + 893 893 + #[tokio::test] 894 894 + async fn sessions_command_opens_picker() { 895 895 + let mut app = make_app("m"); 896 896 + app.input = "/sessions".to_string(); 897 897 + let action = handle_key_event(&mut app, key(KeyCode::Enter)).await; 898 898 + assert!(matches!(action, KeyAction::OpenSessionPicker)); 899 899 + } 900 900 + 901 901 + #[tokio::test] 902 902 + async fn plugins_command_opens_plugin_modal() { 903 903 + let mut app = make_app("m"); 904 904 + app.input = "/plugins".to_string(); 905 905 + let action = handle_key_event(&mut app, key(KeyCode::Enter)).await; 906 906 + assert!(matches!(action, KeyAction::OpenPluginModal)); 907 907 + } 908 908 + 909 909 + #[tokio::test] 910 910 + async fn unknown_slash_command_shows_error_message() { 911 911 + let mut app = make_app("m"); 912 912 + app.input = "/doesnotexist".to_string(); 913 913 + let action = handle_key_event(&mut app, key(KeyCode::Enter)).await; 914 914 + assert!(matches!(action, KeyAction::Continue)); 915 915 + assert!( 916 916 + app.messages.iter().any(|m| matches!(m, DisplayMessage::Error(_))), 917 917 + "unknown slash command must add an Error message" 918 918 + ); 919 919 + } 920 920 + 921 921 + #[tokio::test] 922 922 + async fn enter_with_empty_input_is_a_no_op() { 923 923 + let mut app = make_app("m"); 924 924 + let initial_msg_count = app.messages.len(); 925 925 + let action = handle_key_event(&mut app, key(KeyCode::Enter)).await; 926 926 + assert!(matches!(action, KeyAction::Continue)); 927 927 + assert_eq!(app.messages.len(), initial_msg_count); 928 928 + } 929 929 + 930 930 + // --------------------------------------------------------------------------- 931 931 + // Text input editing 932 932 + // --------------------------------------------------------------------------- 933 933 + 934 934 + #[tokio::test] 935 935 + async fn char_key_appends_to_input_and_advances_cursor() { 936 936 + let mut app = make_app("m"); 937 937 + let _ = handle_key_event(&mut app, key(KeyCode::Char('h'))).await; 938 938 + let _ = handle_key_event(&mut app, key(KeyCode::Char('i'))).await; 939 939 + assert_eq!(app.input, "hi"); 940 940 + assert_eq!(app.cursor_pos, 2); 941 941 + } 942 942 + 943 943 + #[tokio::test] 944 944 + async fn backspace_removes_last_char() { 945 945 + let mut app = make_app("m"); 946 946 + app.input = "hello".to_string(); 947 947 + app.cursor_pos = 5; 948 948 + let _ = handle_key_event(&mut app, key(KeyCode::Backspace)).await; 949 949 + assert_eq!(app.input, "hell"); 950 950 + assert_eq!(app.cursor_pos, 4); 951 951 + } 952 952 + 953 953 + #[tokio::test] 954 954 + async fn backspace_at_start_of_input_is_a_no_op() { 955 955 + let mut app = make_app("m"); 956 956 + app.input = "hi".to_string(); 957 957 + app.cursor_pos = 0; 958 958 + let _ = handle_key_event(&mut app, key(KeyCode::Backspace)).await; 959 959 + assert_eq!(app.input, "hi"); 960 960 + assert_eq!(app.cursor_pos, 0); 961 961 + } 962 962 + 963 963 + #[tokio::test] 964 964 + async fn enter_clears_input_after_command() { 965 965 + let mut app = make_app("m"); 966 966 + app.input = "/exit".to_string(); 967 967 + let _ = handle_key_event(&mut app, key(KeyCode::Enter)).await; 968 968 + // input was consumed (taken) by the Enter handler 969 969 + assert!(app.input.is_empty()); 970 970 + } 971 971 + 972 972 + // --------------------------------------------------------------------------- 973 973 + // Scrolling 974 974 + // --------------------------------------------------------------------------- 975 975 + 976 976 + #[tokio::test] 977 977 + async fn up_arrow_increments_scroll_offset_and_disables_autoscroll() { 978 978 + let mut app = make_app("m"); 979 979 + app.auto_scroll = true; 980 980 + app.scroll_offset = 0; 981 981 + let _ = handle_key_event(&mut app, key(KeyCode::Up)).await; 982 982 + assert_eq!(app.scroll_offset, 1); 983 983 + assert!(!app.auto_scroll); 984 984 + } 985 985 + 986 986 + #[tokio::test] 987 987 + async fn down_arrow_at_bottom_re_enables_autoscroll() { 988 988 + let mut app = make_app("m"); 989 989 + app.scroll_offset = 0; 990 990 + app.auto_scroll = false; 991 991 + let _ = handle_key_event(&mut app, key(KeyCode::Down)).await; 992 992 + assert!(app.auto_scroll); 993 993 + } 994 994 + 995 995 + #[tokio::test] 996 996 + async fn down_arrow_above_bottom_decrements_scroll_offset() { 997 997 + let mut app = make_app("m"); 998 998 + app.scroll_offset = 5; 999 999 + let _ = handle_key_event(&mut app, key(KeyCode::Down)).await; 1000 1000 + assert_eq!(app.scroll_offset, 4); 1001 1001 + } 1002 1002 + 1003 1003 + // --------------------------------------------------------------------------- 1004 1004 + // update_autocomplete 1005 1005 + // --------------------------------------------------------------------------- 1006 1006 + 1007 1007 + #[test] 1008 1008 + fn autocomplete_activates_for_slash_prefix() { 1009 1009 + let mut app = make_app("m"); 1010 1010 + app.input = "/ex".to_string(); 1011 1011 + update_autocomplete(&mut app); 1012 1012 + assert!(app.autocomplete_active); 1013 1013 + assert!(!app.autocomplete_matches.is_empty()); 1014 1014 + } 1015 1015 + 1016 1016 + #[test] 1017 1017 + fn autocomplete_slash_alone_matches_all_commands() { 1018 1018 + let mut app = make_app("m"); 1019 1019 + app.input = "/".to_string(); 1020 1020 + update_autocomplete(&mut app); 1021 1021 + assert!(app.autocomplete_active); 1022 1022 + assert_eq!(app.autocomplete_matches.len(), COMMANDS.len()); 1023 1023 + } 1024 1024 + 1025 1025 + #[test] 1026 1026 + fn autocomplete_deactivates_for_non_slash_input() { 1027 1027 + let mut app = make_app("m"); 1028 1028 + app.input = "hello".to_string(); 1029 1029 + app.autocomplete_active = true; 1030 1030 + app.autocomplete_matches = vec![0]; 1031 1031 + update_autocomplete(&mut app); 1032 1032 + assert!(!app.autocomplete_active); 1033 1033 + assert!(app.autocomplete_matches.is_empty()); 1034 1034 + } 1035 1035 + 1036 1036 + #[test] 1037 1037 + fn autocomplete_no_match_leaves_inactive() { 1038 1038 + let mut app = make_app("m"); 1039 1039 + app.input = "/zzz".to_string(); 1040 1040 + update_autocomplete(&mut app); 1041 1041 + assert!(!app.autocomplete_active); 1042 1042 + } 1043 1043 + 1044 1044 + // --------------------------------------------------------------------------- 1045 1045 + // char_to_byte_idx (private helper, accessible from same-file test module) 1046 1046 + // --------------------------------------------------------------------------- 1047 1047 + 1048 1048 + #[test] 1049 1049 + fn char_to_byte_idx_ascii() { 1050 1050 + assert_eq!(char_to_byte_idx("hello", 0), 0); 1051 1051 + assert_eq!(char_to_byte_idx("hello", 3), 3); 1052 1052 + assert_eq!(char_to_byte_idx("hello", 5), 5); 1053 1053 + } 1054 1054 + 1055 1055 + #[test] 1056 1056 + fn char_to_byte_idx_multibyte() { 1057 1057 + let s = "héllo"; // é is 2 bytes (U+00E9) 1058 1058 + assert_eq!(char_to_byte_idx(s, 0), 0); 1059 1059 + assert_eq!(char_to_byte_idx(s, 1), 1); // 'h' 1060 1060 + assert_eq!(char_to_byte_idx(s, 2), 3); // after 'é' (2 bytes) 1061 1061 + } 1062 1062 + 1063 1063 + #[test] 1064 1064 + fn char_to_byte_idx_past_end_returns_len() { 1065 1065 + assert_eq!(char_to_byte_idx("hi", 99), 2); 1066 1066 + } 1067 1067 + }

+3

packages/ein_edit/Cargo.toml

reviewed

··· 17 17 serde = { workspace = true } 18 18 serde_json = { workspace = true } 19 19 wit-bindgen = { workspace = true } 20 20 + 21 21 + [dev-dependencies] 22 22 + tempfile = "3"

+122

packages/ein_edit/src/lib.rs

reviewed

··· 78 78 79 79 #[cfg(target_arch = "wasm32")] 80 80 ein_plugin::export_tool!(EditTool); 81 81 + 82 82 + #[cfg(test)] 83 83 + mod tests { 84 84 + use super::*; 85 85 + use std::io::Write; 86 86 + use tempfile::NamedTempFile; 87 87 + 88 88 + fn tool() -> EditTool { 89 89 + EditTool::new() 90 90 + } 91 91 + 92 92 + fn call(path: &str, old: &str, new: &str) -> anyhow::Result<ToolResult> { 93 93 + let args = serde_json::json!({ 94 94 + "file_path": path, 95 95 + "old_string": old, 96 96 + "new_string": new, 97 97 + }) 98 98 + .to_string(); 99 99 + tool().call("id", &args) 100 100 + } 101 101 + 102 102 + fn write_temp(content: &str) -> NamedTempFile { 103 103 + let mut f = NamedTempFile::new().unwrap(); 104 104 + f.write_all(content.as_bytes()).unwrap(); 105 105 + f 106 106 + } 107 107 + 108 108 + // --------------------------------------------------------------------------- 109 109 + // Replacement behaviour 110 110 + // --------------------------------------------------------------------------- 111 111 + 112 112 + #[test] 113 113 + fn edit_replaces_first_occurrence_only() { 114 114 + let f = write_temp("hello world world"); 115 115 + let result = call(f.path().to_str().unwrap(), "world", "Rust").unwrap(); 116 116 + let on_disk = fs::read_to_string(f.path()).unwrap(); 117 117 + assert_eq!(on_disk, "hello Rust world"); 118 118 + assert!(result.content.contains("Successfully edited")); 119 119 + } 120 120 + 121 121 + #[test] 122 122 + fn edit_empty_new_string_deletes_matched_text() { 123 123 + let f = write_temp("remove_me keep"); 124 124 + call(f.path().to_str().unwrap(), "remove_me ", "").unwrap(); 125 125 + assert_eq!(fs::read_to_string(f.path()).unwrap(), "keep"); 126 126 + } 127 127 + 128 128 + #[test] 129 129 + fn edit_multiline_old_string_replaced_correctly() { 130 130 + let f = write_temp("line1\nline2\nline3\n"); 131 131 + call(f.path().to_str().unwrap(), "line1\nline2", "replaced").unwrap(); 132 132 + assert_eq!(fs::read_to_string(f.path()).unwrap(), "replaced\nline3\n"); 133 133 + } 134 134 + 135 135 + // --------------------------------------------------------------------------- 136 136 + // Metadata: start_line 137 137 + // --------------------------------------------------------------------------- 138 138 + 139 139 + #[test] 140 140 + fn edit_start_line_is_1_for_match_at_top() { 141 141 + let f = write_temp("target here\nother line\n"); 142 142 + let result = call(f.path().to_str().unwrap(), "target", "X").unwrap(); 143 143 + let meta = result.metadata.unwrap(); 144 144 + assert_eq!(meta["start_line"], 1); 145 145 + } 146 146 + 147 147 + #[test] 148 148 + fn edit_start_line_accounts_for_preceding_newlines() { 149 149 + let f = write_temp("line1\nline2\ntarget\nline4\n"); 150 150 + let result = call(f.path().to_str().unwrap(), "target", "X").unwrap(); 151 151 + let meta = result.metadata.unwrap(); 152 152 + assert_eq!(meta["start_line"], 3); 153 153 + } 154 154 + 155 155 + #[test] 156 156 + fn edit_multiline_start_line_is_line_of_first_character() { 157 157 + let f = write_temp("a\nb\nc\nd\n"); 158 158 + // old_string starts at line 2 159 159 + let result = call(f.path().to_str().unwrap(), "b\nc", "X").unwrap(); 160 160 + let meta = result.metadata.unwrap(); 161 161 + assert_eq!(meta["start_line"], 2); 162 162 + } 163 163 + 164 164 + // --------------------------------------------------------------------------- 165 165 + // Metadata: old_lines / new_lines 166 166 + // --------------------------------------------------------------------------- 167 167 + 168 168 + #[test] 169 169 + fn edit_metadata_contains_old_and_new_lines() { 170 170 + let f = write_temp("foo\nbar\nbaz\n"); 171 171 + let result = call(f.path().to_str().unwrap(), "bar", "qux").unwrap(); 172 172 + let meta = result.metadata.unwrap(); 173 173 + assert_eq!(meta["old_lines"], serde_json::json!(["bar"])); 174 174 + assert_eq!(meta["new_lines"], serde_json::json!(["qux"])); 175 175 + } 176 176 + 177 177 + #[test] 178 178 + fn edit_metadata_multiline_old_and_new_lines() { 179 179 + let f = write_temp("a\nb\nc\n"); 180 180 + let result = call(f.path().to_str().unwrap(), "a\nb", "x\ny\nz").unwrap(); 181 181 + let meta = result.metadata.unwrap(); 182 182 + assert_eq!(meta["old_lines"], serde_json::json!(["a", "b"])); 183 183 + assert_eq!(meta["new_lines"], serde_json::json!(["x", "y", "z"])); 184 184 + } 185 185 + 186 186 + // --------------------------------------------------------------------------- 187 187 + // Error cases 188 188 + // --------------------------------------------------------------------------- 189 189 + 190 190 + #[test] 191 191 + fn edit_returns_error_when_old_string_not_found() { 192 192 + let f = write_temp("hello world"); 193 193 + let err = call(f.path().to_str().unwrap(), "no such string", "x").unwrap_err(); 194 194 + assert!(err.to_string().contains("not found"), "got: {err}"); 195 195 + } 196 196 + 197 197 + #[test] 198 198 + fn edit_returns_error_for_missing_file() { 199 199 + let err = call("/nonexistent/path/file.txt", "x", "y").unwrap_err(); 200 200 + assert!(err.to_string().contains("No such file") || err.to_string().contains("os error")); 201 201 + } 202 202 + }

+207 -36

packages/ein_ollama/src/lib.rs

reviewed

··· 51 51 "http://localhost:11434/v1".to_string() 52 52 } 53 53 54 54 + fn inject_num_ctx(body: &mut serde_json::Value, num_ctx: Option<u32>) { 55 55 + if let Some(n) = num_ctx { 56 56 + body["options"] = serde_json::json!({ "num_ctx": n }); 57 57 + } 58 58 + } 59 59 + 60 60 + fn map_http_error(status: u16, body: &str, model: &str) -> Option<anyhow::Error> { 61 61 + match status { 62 62 + 401 => { 63 63 + let msg = extract_api_error(body).unwrap_or_else(|| "Unauthorized".to_owned()); 64 64 + Some(anyhow!( 65 65 + "{msg}\n\n\ 66 66 + Most local Ollama instances do not require authentication.\n\ 67 67 + If your deployment uses a bearer token, set it in \ 68 68 + ~/.ein/config.json under \ 69 69 + plugin_configs.ein_ollama.params.api_key" 70 70 + )) 71 71 + } 72 72 + 402 => { 73 73 + let msg = 74 74 + extract_api_error(body).unwrap_or_else(|| "Payment required".to_owned()); 75 75 + Some(anyhow!("{msg}")) 76 76 + } 77 77 + 404 => { 78 78 + let msg = 79 79 + extract_api_error(body).unwrap_or_else(|| "Model not found".to_owned()); 80 80 + Some(anyhow!( 81 81 + "{msg}\n\n\ 82 82 + The model may not be downloaded yet. Run:\n\ 83 83 + ollama pull {model}\n\ 84 84 + To list available models: ollama list" 85 85 + )) 86 86 + } 87 87 + s if !(200..300).contains(&s) => { 88 88 + let msg = extract_api_error(body).unwrap_or_else(|| format!("HTTP {s}")); 89 89 + Some(anyhow!("API error: {msg}")) 90 90 + } 91 91 + _ => None, 92 92 + } 93 93 + } 94 94 + 54 95 pub struct OllamaPlugin { 55 96 config: OllamaConfig, 56 97 } ··· 77 118 // Inject Ollama-specific options (e.g. num_ctx) alongside the standard 78 119 // fields if configured. 79 120 let mut body = serde_json::to_value(&req)?; 80 80 - if let Some(num_ctx) = self.config.num_ctx { 81 81 - eprintln!("[ollama] setting num_ctx={num_ctx}"); 82 82 - body["options"] = serde_json::json!({ "num_ctx": num_ctx }); 121 121 + if self.config.num_ctx.is_some() { 122 122 + eprintln!("[ollama] setting num_ctx={}", self.config.num_ctx.unwrap()); 83 123 } 124 124 + inject_num_ctx(&mut body, self.config.num_ctx); 84 125 85 126 let mut req_builder = HttpRequest::post(url); 86 127 if let Some(key) = &self.config.api_key { ··· 112 153 } 113 154 })?; 114 155 115 115 - match resp.status { 116 116 - 401 => { 117 117 - let msg = 118 118 - extract_api_error(&resp.body).unwrap_or_else(|| "Unauthorized".to_owned()); 119 119 - return Err(anyhow!( 120 120 - "{msg}\n\n\ 121 121 - Most local Ollama instances do not require authentication.\n\ 122 122 - If your deployment uses a bearer token, set it in \ 123 123 - ~/.ein/config.json under \ 124 124 - plugin_configs.ein_ollama.params.api_key" 125 125 - )); 126 126 - } 127 127 - 402 => { 128 128 - let msg = 129 129 - extract_api_error(&resp.body).unwrap_or_else(|| "Payment required".to_owned()); 130 130 - return Err(anyhow!("{msg}")); 131 131 - } 132 132 - 404 => { 133 133 - let msg = 134 134 - extract_api_error(&resp.body).unwrap_or_else(|| "Model not found".to_owned()); 135 135 - return Err(anyhow!( 136 136 - "{msg}\n\n\ 137 137 - The model may not be downloaded yet. Run:\n\ 138 138 - ollama pull {}\n\ 139 139 - To list available models: ollama list", 140 140 - req.model 141 141 - )); 142 142 - } 143 143 - s if !(200..300).contains(&s) => { 144 144 - let msg = extract_api_error(&resp.body).unwrap_or_else(|| format!("HTTP {s}")); 145 145 - return Err(anyhow!("API error: {msg}")); 146 146 - } 147 147 - _ => {} 156 156 + if let Some(e) = map_http_error(resp.status, &resp.body, &req.model) { 157 157 + return Err(e); 148 158 } 149 159 150 160 // Validate the body parses as CompletionResponse before returning. ··· 162 172 163 173 #[cfg(target_arch = "wasm32")] 164 174 ein_plugin::export_model_client!(OllamaPlugin); 175 175 + 176 176 + #[cfg(test)] 177 177 + mod tests { 178 178 + use super::*; 179 179 + use ein_plugin::model_client::CompletionResponse; 180 180 + use serde_json::json; 181 181 + 182 182 + // --------------------------------------------------------------------------- 183 183 + // extract_api_error 184 184 + // --------------------------------------------------------------------------- 185 185 + 186 186 + #[test] 187 187 + fn extract_api_error_present() { 188 188 + let body = r#"{"error": {"message": "model not loaded", "type": "not_found"}}"#; 189 189 + assert_eq!( 190 190 + extract_api_error(body).as_deref(), 191 191 + Some("model not loaded") 192 192 + ); 193 193 + } 194 194 + 195 195 + #[test] 196 196 + fn extract_api_error_missing_error_key() { 197 197 + assert!(extract_api_error(r#"{"choices": []}"#).is_none()); 198 198 + } 199 199 + 200 200 + #[test] 201 201 + fn extract_api_error_malformed_json() { 202 202 + assert!(extract_api_error("not json").is_none()); 203 203 + } 204 204 + 205 205 + // --------------------------------------------------------------------------- 206 206 + // OllamaConfig deserialization 207 207 + // --------------------------------------------------------------------------- 208 208 + 209 209 + #[test] 210 210 + fn config_default_base_url() { 211 211 + let cfg: OllamaConfig = serde_json::from_value(json!({})).unwrap(); 212 212 + assert_eq!(cfg.base_url, "http://localhost:11434/v1"); 213 213 + } 214 214 + 215 215 + #[test] 216 216 + fn config_absent_api_key_is_none() { 217 217 + let cfg: OllamaConfig = serde_json::from_value(json!({})).unwrap(); 218 218 + assert!(cfg.api_key.is_none()); 219 219 + } 220 220 + 221 221 + #[test] 222 222 + fn config_empty_api_key_treated_as_none() { 223 223 + let cfg: OllamaConfig = serde_json::from_value(json!({"api_key": ""})).unwrap(); 224 224 + assert!(cfg.api_key.is_none()); 225 225 + } 226 226 + 227 227 + #[test] 228 228 + fn config_valid_api_key() { 229 229 + let cfg: OllamaConfig = serde_json::from_value(json!({"api_key": "tok"})).unwrap(); 230 230 + assert_eq!(cfg.api_key.as_deref(), Some("tok")); 231 231 + } 232 232 + 233 233 + #[test] 234 234 + fn config_num_ctx_absent_is_none() { 235 235 + let cfg: OllamaConfig = serde_json::from_value(json!({})).unwrap(); 236 236 + assert!(cfg.num_ctx.is_none()); 237 237 + } 238 238 + 239 239 + #[test] 240 240 + fn config_num_ctx_set() { 241 241 + let cfg: OllamaConfig = serde_json::from_value(json!({"num_ctx": 16384})).unwrap(); 242 242 + assert_eq!(cfg.num_ctx, Some(16384)); 243 243 + } 244 244 + 245 245 + // --------------------------------------------------------------------------- 246 246 + // inject_num_ctx 247 247 + // --------------------------------------------------------------------------- 248 248 + 249 249 + #[test] 250 250 + fn num_ctx_injected_into_body() { 251 251 + let mut body = json!({"model": "llama3", "messages": []}); 252 252 + inject_num_ctx(&mut body, Some(8192)); 253 253 + assert_eq!(body["options"]["num_ctx"], 8192); 254 254 + } 255 255 + 256 256 + #[test] 257 257 + fn num_ctx_not_injected_when_absent() { 258 258 + let mut body = json!({"model": "llama3", "messages": []}); 259 259 + inject_num_ctx(&mut body, None); 260 260 + assert!(body.get("options").is_none()); 261 261 + } 262 262 + 263 263 + // --------------------------------------------------------------------------- 264 264 + // map_http_error 265 265 + // --------------------------------------------------------------------------- 266 266 + 267 267 + #[test] 268 268 + fn map_http_error_401_contains_api_key_hint() { 269 269 + let err = map_http_error(401, "{}", "llama3").unwrap(); 270 270 + let msg = err.to_string(); 271 271 + assert!(msg.contains("api_key"), "expected api_key hint in: {msg}"); 272 272 + } 273 273 + 274 274 + #[test] 275 275 + fn map_http_error_401_includes_api_message() { 276 276 + let body = r#"{"error": {"message": "Invalid token"}}"#; 277 277 + let err = map_http_error(401, body, "llama3").unwrap(); 278 278 + assert!(err.to_string().contains("Invalid token")); 279 279 + } 280 280 + 281 281 + #[test] 282 282 + fn map_http_error_404_suggests_ollama_pull() { 283 283 + let err = map_http_error(404, "{}", "mistral").unwrap(); 284 284 + let msg = err.to_string(); 285 285 + assert!(msg.contains("ollama pull"), "expected 'ollama pull' in: {msg}"); 286 286 + assert!(msg.contains("mistral"), "expected model name in: {msg}"); 287 287 + } 288 288 + 289 289 + #[test] 290 290 + fn map_http_error_404_passes_through_api_message() { 291 291 + let body = r#"{"error": {"message": "model 'qwen' not found"}}"#; 292 292 + let err = map_http_error(404, body, "qwen").unwrap(); 293 293 + assert!(err.to_string().contains("model 'qwen' not found")); 294 294 + } 295 295 + 296 296 + #[test] 297 297 + fn map_http_error_other_non_2xx() { 298 298 + let err = map_http_error(503, "{}", "llama3").unwrap(); 299 299 + let msg = err.to_string(); 300 300 + assert!(msg.contains("503"), "expected status code in: {msg}"); 301 301 + } 302 302 + 303 303 + #[test] 304 304 + fn map_http_error_2xx_returns_none() { 305 305 + assert!(map_http_error(200, "{}", "llama3").is_none()); 306 306 + assert!(map_http_error(201, "{}", "llama3").is_none()); 307 307 + } 308 308 + 309 309 + // --------------------------------------------------------------------------- 310 310 + // Response body validation 311 311 + // --------------------------------------------------------------------------- 312 312 + 313 313 + #[test] 314 314 + fn valid_completion_response_parses() { 315 315 + let body = r#"{ 316 316 + "id": "ollama-gen-1", 317 317 + "object": "chat.completion", 318 318 + "model": "llama3", 319 319 + "choices": [{ 320 320 + "index": 0, 321 321 + "finish_reason": "stop", 322 322 + "message": {"role": "assistant", "content": "Hello!"} 323 323 + }], 324 324 + "usage": {"prompt_tokens": 8, "completion_tokens": 3, "total_tokens": 11} 325 325 + }"#; 326 326 + let resp: Result<CompletionResponse, _> = serde_json::from_str(body); 327 327 + assert!(resp.is_ok(), "expected valid response to parse: {:?}", resp); 328 328 + } 329 329 + 330 330 + #[test] 331 331 + fn invalid_response_body_returns_error() { 332 332 + let resp: Result<CompletionResponse, _> = serde_json::from_str("not valid json"); 333 333 + assert!(resp.is_err()); 334 334 + } 335 335 + }

+168 -29

packages/ein_openrouter/src/lib.rs

reviewed

··· 26 26 .and_then(|v| v.get("error")?.get("message")?.as_str().map(str::to_owned)) 27 27 } 28 28 29 29 + fn map_http_error(status: u16, body: &str) -> Option<anyhow::Error> { 30 30 + match status { 31 31 + 401 => { 32 32 + let msg = 33 33 + extract_api_error(body).unwrap_or_else(|| "Invalid or missing API key".to_owned()); 34 34 + Some(anyhow!( 35 35 + "{msg}\n\n\ 36 36 + Set your api_key in ~/.ein/config.json under \ 37 37 + plugin_configs.ein_openrouter.params.api_key" 38 38 + )) 39 39 + } 40 40 + 402 => { 41 41 + let msg = 42 42 + extract_api_error(body).unwrap_or_else(|| "Insufficient credits".to_owned()); 43 43 + Some(anyhow!( 44 44 + "{msg}\n\nCheck your account balance at openrouter.ai." 45 45 + )) 46 46 + } 47 47 + 404 => { 48 48 + let msg = 49 49 + extract_api_error(body).unwrap_or_else(|| "Resource not found".to_owned()); 50 50 + Some(anyhow!("{msg}")) 51 51 + } 52 52 + s if !(200..300).contains(&s) => { 53 53 + let msg = extract_api_error(body).unwrap_or_default(); 54 54 + Some(anyhow!("Status HTTP {s}. API error: {msg}")) 55 55 + } 56 56 + _ => None, 57 57 + } 58 58 + } 59 59 + 29 60 #[derive(Deserialize)] 30 61 struct OpenRouterConfig { 31 62 api_key: String, ··· 65 96 .send() 66 97 .map_err(|e| anyhow!("Could not connect to {}: {e}", self.config.base_url))?; 67 98 68 68 - match resp.status { 69 69 - 401 => { 70 70 - let msg = extract_api_error(&resp.body) 71 71 - .unwrap_or_else(|| "Invalid or missing API key".to_owned()); 72 72 - return Err(anyhow!( 73 73 - "{msg}\n\n\ 74 74 - Set your api_key in ~/.ein/config.json under \ 75 75 - plugin_configs.ein_openrouter.params.api_key" 76 76 - )); 77 77 - } 78 78 - 402 => { 79 79 - let msg = extract_api_error(&resp.body) 80 80 - .unwrap_or_else(|| "Insufficient credits".to_owned()); 81 81 - return Err(anyhow!( 82 82 - "{msg}\n\nCheck your account balance at openrouter.ai." 83 83 - )); 84 84 - } 85 85 - 404 => { 86 86 - let msg = extract_api_error(&resp.body) 87 87 - .unwrap_or_else(|| "Resource not found".to_owned()); 88 88 - return Err(anyhow!("{msg}")); 89 89 - } 90 90 - s if !(200..300).contains(&s) => { 91 91 - let status = format!("HTTP {s}"); 92 92 - let msg = extract_api_error(&resp.body).unwrap_or_default(); 93 93 - 94 94 - return Err(anyhow!("Status {status}. API error: {msg}")); 95 95 - } 96 96 - _ => {} 99 99 + if let Some(e) = map_http_error(resp.status, &resp.body) { 100 100 + return Err(e); 97 101 } 98 102 99 103 // Validate the body parses as CompletionResponse before returning. ··· 111 115 112 116 #[cfg(target_arch = "wasm32")] 113 117 ein_plugin::export_model_client!(OpenRouterPlugin); 118 118 + 119 119 + #[cfg(test)] 120 120 + mod tests { 121 121 + use super::*; 122 122 + use ein_plugin::model_client::CompletionResponse; 123 123 + use serde_json::json; 124 124 + 125 125 + // --------------------------------------------------------------------------- 126 126 + // extract_api_error 127 127 + // --------------------------------------------------------------------------- 128 128 + 129 129 + #[test] 130 130 + fn extract_api_error_present() { 131 131 + let body = r#"{"error": {"message": "You exceeded your quota", "type": "quota_exceeded"}}"#; 132 132 + assert_eq!( 133 133 + extract_api_error(body).as_deref(), 134 134 + Some("You exceeded your quota") 135 135 + ); 136 136 + } 137 137 + 138 138 + #[test] 139 139 + fn extract_api_error_missing_error_key() { 140 140 + assert!(extract_api_error(r#"{"choices": []}"#).is_none()); 141 141 + } 142 142 + 143 143 + #[test] 144 144 + fn extract_api_error_missing_message_key() { 145 145 + assert!(extract_api_error(r#"{"error": {"type": "server_error"}}"#).is_none()); 146 146 + } 147 147 + 148 148 + #[test] 149 149 + fn extract_api_error_malformed_json() { 150 150 + assert!(extract_api_error("not json at all").is_none()); 151 151 + } 152 152 + 153 153 + // --------------------------------------------------------------------------- 154 154 + // OpenRouterConfig deserialization 155 155 + // --------------------------------------------------------------------------- 156 156 + 157 157 + #[test] 158 158 + fn config_default_base_url() { 159 159 + let cfg: OpenRouterConfig = 160 160 + serde_json::from_value(json!({"api_key": "sk-or-test"})).unwrap(); 161 161 + assert_eq!(cfg.api_key, "sk-or-test"); 162 162 + assert_eq!(cfg.base_url, "https://openrouter.ai/api/v1"); 163 163 + } 164 164 + 165 165 + #[test] 166 166 + fn config_custom_base_url() { 167 167 + let cfg: OpenRouterConfig = serde_json::from_value(json!({ 168 168 + "api_key": "sk-or-test", 169 169 + "base_url": "https://my-proxy.example.com/v1" 170 170 + })) 171 171 + .unwrap(); 172 172 + assert_eq!(cfg.base_url, "https://my-proxy.example.com/v1"); 173 173 + } 174 174 + 175 175 + // --------------------------------------------------------------------------- 176 176 + // map_http_error 177 177 + // --------------------------------------------------------------------------- 178 178 + 179 179 + #[test] 180 180 + fn map_http_error_401_contains_api_key_hint() { 181 181 + let err = map_http_error(401, "{}").unwrap(); 182 182 + let msg = err.to_string(); 183 183 + assert!(msg.contains("api_key"), "expected api_key hint in: {msg}"); 184 184 + } 185 185 + 186 186 + #[test] 187 187 + fn map_http_error_401_includes_api_message() { 188 188 + let body = r#"{"error": {"message": "Incorrect API key provided"}}"#; 189 189 + let err = map_http_error(401, body).unwrap(); 190 190 + assert!(err.to_string().contains("Incorrect API key provided")); 191 191 + } 192 192 + 193 193 + #[test] 194 194 + fn map_http_error_402_mentions_credits_and_balance() { 195 195 + let err = map_http_error(402, "{}").unwrap(); 196 196 + let msg = err.to_string(); 197 197 + assert!(msg.contains("openrouter.ai"), "expected openrouter.ai link in: {msg}"); 198 198 + } 199 199 + 200 200 + #[test] 201 201 + fn map_http_error_404_passes_through_api_message() { 202 202 + let body = r#"{"error": {"message": "No endpoints found for model"}}"#; 203 203 + let err = map_http_error(404, body).unwrap(); 204 204 + assert!(err.to_string().contains("No endpoints found for model")); 205 205 + } 206 206 + 207 207 + #[test] 208 208 + fn map_http_error_404_fallback_when_no_api_message() { 209 209 + let err = map_http_error(404, "{}").unwrap(); 210 210 + assert!(err.to_string().contains("Resource not found")); 211 211 + } 212 212 + 213 213 + #[test] 214 214 + fn map_http_error_other_non_2xx() { 215 215 + let err = map_http_error(503, "{}").unwrap(); 216 216 + let msg = err.to_string(); 217 217 + assert!(msg.contains("503"), "expected status code in: {msg}"); 218 218 + } 219 219 + 220 220 + #[test] 221 221 + fn map_http_error_2xx_returns_none() { 222 222 + assert!(map_http_error(200, "{}").is_none()); 223 223 + assert!(map_http_error(201, "{}").is_none()); 224 224 + } 225 225 + 226 226 + // --------------------------------------------------------------------------- 227 227 + // Response body validation 228 228 + // --------------------------------------------------------------------------- 229 229 + 230 230 + #[test] 231 231 + fn valid_completion_response_parses() { 232 232 + let body = r#"{ 233 233 + "id": "gen-abc", 234 234 + "object": "chat.completion", 235 235 + "model": "anthropic/claude-haiku-4-5", 236 236 + "choices": [{ 237 237 + "index": 0, 238 238 + "finish_reason": "stop", 239 239 + "message": {"role": "assistant", "content": "Hello!"} 240 240 + }], 241 241 + "usage": {"prompt_tokens": 10, "completion_tokens": 5, "total_tokens": 15} 242 242 + }"#; 243 243 + let resp: Result<CompletionResponse, _> = serde_json::from_str(body); 244 244 + assert!(resp.is_ok(), "expected valid response to parse: {:?}", resp); 245 245 + } 246 246 + 247 247 + #[test] 248 248 + fn invalid_response_body_returns_error() { 249 249 + let resp: Result<CompletionResponse, _> = serde_json::from_str("not valid json"); 250 250 + assert!(resp.is_err()); 251 251 + } 252 252 + }

+3

packages/ein_read/Cargo.toml

reviewed

··· 17 17 serde = { workspace = true } 18 18 serde_json = { workspace = true } 19 19 wit-bindgen = { workspace = true} 20 20 + 21 21 + [dev-dependencies] 22 22 + tempfile = "3"

+125

packages/ein_read/src/lib.rs

reviewed

··· 62 62 } 63 63 64 64 fn call(&self, id: &str, args: &str) -> anyhow::Result<ToolResult> { 65 65 + #[cfg(target_arch = "wasm32")] 65 66 ein_plugin::tool::syscalls::log(&format!("Reading file with args: {args}")); 66 67 67 68 let args: ReadArgs = serde_json::from_str(args)?; ··· 94 95 95 96 #[cfg(target_arch = "wasm32")] 96 97 ein_plugin::export_tool!(ReadTool); 98 98 + 99 99 + #[cfg(test)] 100 100 + mod tests { 101 101 + use super::*; 102 102 + use std::io::Write; 103 103 + use tempfile::NamedTempFile; 104 104 + 105 105 + fn tool() -> ReadTool { 106 106 + ReadTool::new() 107 107 + } 108 108 + 109 109 + fn call(path: &str, offset: Option<usize>, limit: Option<usize>) -> anyhow::Result<String> { 110 110 + let mut args = serde_json::json!({ "file_path": path }); 111 111 + if let Some(o) = offset { 112 112 + args["offset"] = serde_json::json!(o); 113 113 + } 114 114 + if let Some(l) = limit { 115 115 + args["limit"] = serde_json::json!(l); 116 116 + } 117 117 + tool().call("id", &args.to_string()).map(|r| r.content) 118 118 + } 119 119 + 120 120 + fn write_temp(content: &str) -> NamedTempFile { 121 121 + let mut f = NamedTempFile::new().unwrap(); 122 122 + f.write_all(content.as_bytes()).unwrap(); 123 123 + f 124 124 + } 125 125 + 126 126 + // --------------------------------------------------------------------------- 127 127 + // Basic reading 128 128 + // --------------------------------------------------------------------------- 129 129 + 130 130 + #[test] 131 131 + fn read_returns_all_lines_by_default() { 132 132 + let f = write_temp("a\nb\nc\nd\ne\n"); 133 133 + let out = call(f.path().to_str().unwrap(), None, None).unwrap(); 134 134 + assert_eq!(out, "a\nb\nc\nd\ne"); 135 135 + } 136 136 + 137 137 + #[test] 138 138 + fn read_empty_file_returns_empty_string() { 139 139 + let f = write_temp(""); 140 140 + let out = call(f.path().to_str().unwrap(), None, None).unwrap(); 141 141 + assert_eq!(out, ""); 142 142 + } 143 143 + 144 144 + // --------------------------------------------------------------------------- 145 145 + // Offset / limit windowing 146 146 + // --------------------------------------------------------------------------- 147 147 + 148 148 + #[test] 149 149 + fn read_with_offset_skips_lines() { 150 150 + let f = write_temp("line1\nline2\nline3\nline4\n"); 151 151 + let out = call(f.path().to_str().unwrap(), Some(2), None).unwrap(); 152 152 + assert_eq!(out, "line3\nline4"); 153 153 + } 154 154 + 155 155 + #[test] 156 156 + fn read_with_limit_caps_output() { 157 157 + let f = write_temp("a\nb\nc\nd\ne\n"); 158 158 + let out = call(f.path().to_str().unwrap(), None, Some(3)).unwrap(); 159 159 + // truncated — must start with the header 160 160 + assert!(out.starts_with("Lines 1-3 of 5"), "got: {out}"); 161 161 + assert!(out.contains("a\nb\nc")); 162 162 + } 163 163 + 164 164 + #[test] 165 165 + fn read_offset_and_limit_combined() { 166 166 + let f = write_temp("a\nb\nc\nd\ne\n"); 167 167 + let out = call(f.path().to_str().unwrap(), Some(1), Some(2)).unwrap(); 168 168 + // offset=1, limit=2 → lines b, c; 2 more remain → truncation header 169 169 + assert!(out.contains("b\nc"), "got: {out}"); 170 170 + } 171 171 + 172 172 + #[test] 173 173 + fn read_offset_beyond_file_end_returns_empty() { 174 174 + let f = write_temp("only one line\n"); 175 175 + let out = call(f.path().to_str().unwrap(), Some(99), None).unwrap(); 176 176 + assert_eq!(out, ""); 177 177 + } 178 178 + 179 179 + #[test] 180 180 + fn read_limit_equal_to_line_count_produces_no_header() { 181 181 + let f = write_temp("x\ny\nz\n"); 182 182 + let out = call(f.path().to_str().unwrap(), None, Some(3)).unwrap(); 183 183 + // exactly fits — no truncation header 184 184 + assert!(!out.contains("Lines"), "got: {out}"); 185 185 + assert_eq!(out, "x\ny\nz"); 186 186 + } 187 187 + 188 188 + // --------------------------------------------------------------------------- 189 189 + // Truncation header format 190 190 + // --------------------------------------------------------------------------- 191 191 + 192 192 + #[test] 193 193 + fn read_truncation_header_shows_range_and_total() { 194 194 + // 10 lines, read only first 4 195 195 + let content = (1..=10).map(|i| format!("line{i}")).collect::<Vec<_>>().join("\n"); 196 196 + let f = write_temp(&content); 197 197 + let out = call(f.path().to_str().unwrap(), None, Some(4)).unwrap(); 198 198 + assert!(out.starts_with("Lines 1-4 of 10"), "got: {out}"); 199 199 + assert!(out.contains("use offset=4 to read more"), "got: {out}"); 200 200 + } 201 201 + 202 202 + #[test] 203 203 + fn read_truncation_header_reflects_offset() { 204 204 + let content = (1..=10).map(|i| format!("line{i}")).collect::<Vec<_>>().join("\n"); 205 205 + let f = write_temp(&content); 206 206 + let out = call(f.path().to_str().unwrap(), Some(3), Some(3)).unwrap(); 207 207 + // offset=3, limit=3 → lines 4-6 (1-based), 4 remain → header 208 208 + assert!(out.starts_with("Lines 4-6 of 10"), "got: {out}"); 209 209 + assert!(out.contains("use offset=6 to read more"), "got: {out}"); 210 210 + } 211 211 + 212 212 + // --------------------------------------------------------------------------- 213 213 + // Error cases 214 214 + // --------------------------------------------------------------------------- 215 215 + 216 216 + #[test] 217 217 + fn read_returns_error_for_missing_file() { 218 218 + let err = call("/nonexistent/path/file.txt", None, None).unwrap_err(); 219 219 + assert!(err.to_string().contains("No such file") || err.to_string().contains("os error")); 220 220 + } 221 221 + }

+3

packages/ein_write/Cargo.toml

reviewed

··· 17 17 serde = { workspace = true } 18 18 serde_json = { workspace = true } 19 19 wit-bindgen = { workspace = true} 20 20 + 21 21 + [dev-dependencies] 22 22 + tempfile = "3"

+57

packages/ein_write/src/lib.rs

reviewed

··· 81 81 82 82 #[cfg(target_arch = "wasm32")] 83 83 ein_plugin::export_tool!(WriteTool); 84 84 + 85 85 + #[cfg(test)] 86 86 + mod tests { 87 87 + use super::*; 88 88 + use tempfile::TempDir; 89 89 + 90 90 + fn tool() -> WriteTool { 91 91 + WriteTool::new() 92 92 + } 93 93 + 94 94 + fn call(path: &str, content: &str) -> anyhow::Result<ToolResult> { 95 95 + let args = serde_json::json!({ "file_path": path, "content": content }).to_string(); 96 96 + tool().call("id", &args) 97 97 + } 98 98 + 99 99 + #[test] 100 100 + fn write_creates_file_with_content() { 101 101 + let dir = TempDir::new().unwrap(); 102 102 + let path = dir.path().join("out.txt"); 103 103 + call(path.to_str().unwrap(), "hello world").unwrap(); 104 104 + assert_eq!(fs::read_to_string(&path).unwrap(), "hello world"); 105 105 + } 106 106 + 107 107 + #[test] 108 108 + fn write_overwrites_existing_file() { 109 109 + let dir = TempDir::new().unwrap(); 110 110 + let path = dir.path().join("out.txt"); 111 111 + call(path.to_str().unwrap(), "first").unwrap(); 112 112 + call(path.to_str().unwrap(), "second").unwrap(); 113 113 + assert_eq!(fs::read_to_string(&path).unwrap(), "second"); 114 114 + } 115 115 + 116 116 + #[test] 117 117 + fn write_creates_parent_directories() { 118 118 + let dir = TempDir::new().unwrap(); 119 119 + let path = dir.path().join("a").join("b").join("c").join("file.txt"); 120 120 + call(path.to_str().unwrap(), "nested").unwrap(); 121 121 + assert_eq!(fs::read_to_string(&path).unwrap(), "nested"); 122 122 + } 123 123 + 124 124 + #[test] 125 125 + fn write_empty_content_creates_empty_file() { 126 126 + let dir = TempDir::new().unwrap(); 127 127 + let path = dir.path().join("empty.txt"); 128 128 + call(path.to_str().unwrap(), "").unwrap(); 129 129 + assert_eq!(fs::read_to_string(&path).unwrap(), ""); 130 130 + } 131 131 + 132 132 + #[test] 133 133 + fn write_returns_success_message_with_byte_count_and_path() { 134 134 + let dir = TempDir::new().unwrap(); 135 135 + let path = dir.path().join("f.txt"); 136 136 + let result = call(path.to_str().unwrap(), "abc").unwrap(); 137 137 + assert!(result.content.contains('3'), "expected byte count in: {}", result.content); 138 138 + assert!(result.content.contains(path.to_str().unwrap()), "expected path in: {}", result.content); 139 139 + } 140 140 + }