1. 1//! Real command stress cases for the universal sandbox execution contract.
2. 2
3. 3#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
4. 4
5. 5use std::sync::Arc;
6. 6use vak_tools::{Tool, ToolContext, bash::BashTool, sandbox_events::SandboxEventSink};
7. 7
8. 8#[tokio::test]
9. 9async fn nested_data_artifacts_are_reported_from_the_workspace() {
10. 10 let workspace = tempfile::tempdir().unwrap();
11. 11 let (sink, mut events) = SandboxEventSink::new_with_id("stress-data".into());
12. 12 let ctx = ToolContext::new(workspace.path().to_path_buf()).with_sandbox_sink(sink);
13. 13 let output = BashTool
14. 14 .execute(
15. 15 &serde_json::json!({"command": "mkdir -p nested/deeper && printf 'a,b\\n1,2\\n' > nested/deeper/data.csv && pwd"}),
16. 16 &ctx,
17. 17 )
18. 18 .await;
19. 19 assert!(!output.is_error, "{}", output.content);
20. 20 assert!(workspace.path().join("nested/deeper/data.csv").is_file());
21. 21 let mut saw_nested = false;
22. 22 while let Ok(event) = events.try_recv() {
23. 23 if let vak_tools::SandboxEvent::ArtifactGenerated {
24. 24 execution_id, path, ..
25. 25 } = event
26. 26 {
27. 27 assert_eq!(execution_id, "stress-data");
28. 28 saw_nested |= path.contains("nested/deeper/data.csv");
29. 29 }
30. 30 }
31. 31 assert!(saw_nested, "nested artifact was not observed");
32. 32}
33. 33
34. 34#[tokio::test]
35. 35async fn timeout_keeps_partial_output_and_kills_descendant() {
36. 36 let workspace = tempfile::tempdir().unwrap();
37. 37 let ctx = ToolContext::new(workspace.path().to_path_buf());
38. 38 let start = std::time::Instant::now();
39. 39 let output = BashTool
40. 40 .execute(
41. 41 &serde_json::json!({"command": "printf before; sleep 30", "timeout_ms": 1000}),
42. 42 &ctx,
43. 43 )
44. 44 .await;
45. 45 assert!(output.is_error);
46. 46 assert!(output.content.contains("before"));
47. 47 assert!(start.elapsed() < std::time::Duration::from_secs(5));
48. 48}
49. 49
50. 50#[tokio::test]
51. 51async fn concurrent_executions_keep_event_identity_separate() {
52. 52 let a = tempfile::tempdir().unwrap();
53. 53 let b = tempfile::tempdir().unwrap();
54. 54 let (sink_a, mut events_a) = SandboxEventSink::new_with_id("stress-a".into());
55. 55 let (sink_b, mut events_b) = SandboxEventSink::new_with_id("stress-b".into());
56. 56 let ctx_a = Arc::new(ToolContext::new(a.path().to_path_buf()).with_sandbox_sink(sink_a));
57. 57 let ctx_b = Arc::new(ToolContext::new(b.path().to_path_buf()).with_sandbox_sink(sink_b));
58. 58 let args_a = serde_json::json!({"command": "echo alpha"});
59. 59 let args_b = serde_json::json!({"command": "echo beta"});
60. 60 let (out_a, out_b) = tokio::join!(
61. 61 BashTool.execute(&args_a, &ctx_a),
62. 62 BashTool.execute(&args_b, &ctx_b),
63. 63 );
64. 64 assert!(out_a.content.contains("alpha"));
65. 65 assert!(out_b.content.contains("beta"));
66. 66 while let Ok(event) = events_a.try_recv() {
67. 67 let id = match event {
68. 68 vak_tools::SandboxEvent::ExecutionStarted { execution_id, .. }
69. 69 | vak_tools::SandboxEvent::Stdout { execution_id, .. }
70. 70 | vak_tools::SandboxEvent::Stderr { execution_id, .. }
71. 71 | vak_tools::SandboxEvent::ExecutionFinished { execution_id, .. } => execution_id,
72. 72 _ => "stress-a".into(),
73. 73 };
74. 74 assert_eq!(id, "stress-a");
75. 75 }
76. 76 while let Ok(event) = events_b.try_recv() {
77. 77 let id = match event {
78. 78 vak_tools::SandboxEvent::ExecutionStarted { execution_id, .. }
79. 79 | vak_tools::SandboxEvent::Stdout { execution_id, .. }
80. 80 | vak_tools::SandboxEvent::Stderr { execution_id, .. }
81. 81 | vak_tools::SandboxEvent::ExecutionFinished { execution_id, .. } => execution_id,
82. 82 _ => "stress-b".into(),
83. 83 };
84. 84 assert_eq!(id, "stress-b");
85. 85 }
86. 86}
87. 87
88. 88#[tokio::test]
89. 89async fn control_files_are_denied_before_spawn() {
90. 90 let workspace = tempfile::tempdir().unwrap();
91. 91 std::fs::write(workspace.path().join(".env"), "SECRET=must-not-leak").unwrap();
92. 92 let (sink, _events) = SandboxEventSink::new_with_id("stress-control".into());
93. 93 let ctx = ToolContext::new(workspace.path().to_path_buf()).with_sandbox_sink(sink);
94. 94 let output = BashTool
95. 95 .execute(&serde_json::json!({"command": "cat .env"}), &ctx)
96. 96 .await;
97. 97 assert!(output.is_error);
98. 98 assert!(output.content.contains("control files"));
99. 99}
100. 100