Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.
TypeScript agentaiai-agentsall-in-onecrmcrm-systememaillinearmcpmessagingnotesnotionofficerustslackslack-alternativestartupstartup-toolstypescriptworkspace
use super::*;
use std::{collections::BTreeMap, sync::Arc, time::Duration};
use tokio::{
io::AsyncReadExt,
net::{TcpListener, TcpStream},
};
// Real-runtime tests are opt-in; CI and local validation also run --ignored.
async fn setup(limits: Limits) -> (tempfile::TempDir, ExecutionService) {
let root = tempfile::tempdir().unwrap();
let binary = Command::new("which").arg("deno").output().await.unwrap();
assert!(binary.status.success(), "Deno 2.9.6 must be on PATH");
let binary = PathBuf::from(String::from_utf8(binary.stdout).unwrap().trim());
let runner = DenoRunner::new(binary, root.path().to_owned(), 128)
.await
.unwrap();
(
root,
ExecutionService::new(Arc::new(runner), limits).unwrap(),
)
}
async fn collect(mut handle: ExecutionHandle) -> (Vec<ExecutionEvent>, Outcome) {
let mut events = Vec::new();
loop {
let event = tokio::time::timeout(Duration::from_secs(10), handle.events.recv())
.await
.unwrap()
.unwrap();
if let EventKind::Finished { outcome } = event.kind {
return (events, outcome);
}
events.push(event);
}
}
async fn run(
service: &ExecutionService,
source: &str,
timeout_ms: u64,
) -> (Vec<ExecutionEvent>, Outcome) {
collect(
service
.execute(
ExecuteRequest {
source: source.into(),
timeout_ms,
},
RunEnvironment::default(),
)
.unwrap(),
)
.await
}
async fn read_request(stream: &mut TcpStream) -> String {
let mut bytes = Vec::new();
loop {
let mut buffer = [0; 4096];
let count = stream.read(&mut buffer).await.unwrap();
assert_ne!(count, 0);
bytes.extend_from_slice(&buffer[..count]);
if let Some(end) = bytes.windows(4).position(|window| window == b"\r\n\r\n") {
let headers = String::from_utf8_lossy(&bytes[..end]);
let length = headers
.lines()
.find_map(|line| {
let (name, value) = line.split_once(':')?;
name.eq_ignore_ascii_case("content-length")
.then(|| value.trim().parse::<usize>().unwrap())
})
.unwrap_or_default();
if bytes.len() >= end + 4 + length {
break;
}
}
}
String::from_utf8(bytes).unwrap()
}
async fn respond(stream: &mut TcpStream, body: &str) {
let response = format!(
"HTTP/1.1 200 OK\r\nContent-Type: application/json\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}",
body.len()
);
stream.write_all(response.as_bytes()).await.unwrap();
}
#[tokio::test]
#[ignore = "requires pinned Deno runtime"]
async fn real_sdk_nested_calls_are_authenticated_and_concurrent() {
let (_root, service) = setup(Limits {
max_output_bytes: 1024,
max_frame_bytes: 1024,
max_result_bytes: 512,
..Limits::default()
})
.await;
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
let address = listener.local_addr().unwrap();
let server =
tokio::spawn(async move {
let (mut first, _) = listener.accept().await.unwrap();
let first_request = read_request(&mut first).await;
// Neither request can finish until both have arrived: proves actual HTTP concurrency.
let (mut second, _) = listener.accept().await.unwrap();
let second_request = read_request(&mut second).await;
for request in [&first_request, &second_request] {
assert!(request.contains(
"traceparent: 00-01234567890123456789012345678901-0123456789012345-01"
));
assert!(request.starts_with("POST /decisions "), "{request}");
assert!(
request
.to_ascii_lowercase()
.contains("x-macro-code-execution: 1\r\n"),
"{request}"
);
assert!(
request
.to_ascii_lowercase()
.contains("authorization: bearer fixture-run-token\r\n")
);
}
respond(&mut second, r#"{"probabilities":{"yes":0.2}}"#).await;
respond(&mut first, r#"{"probabilities":{"yes":0.8}}"#).await;
});
let environment = RunEnvironment {
token: "fixture-run-token".into(),
trace_headers: BTreeMap::from([(
"traceparent".into(),
"00-01234567890123456789012345678901-0123456789012345-01".into(),
)]),
session_id: Some(uuid::Uuid::from_u128(1)),
execution_id: Some(uuid::Uuid::from_u128(2)),
hosts: BTreeMap::from([("cognition".into(), format!("http://{address}"))]),
unattended: None,
};
let source = r#"
import { Macro } from '@macro-inc/sdk';
import Handlebars from 'handlebars';
export async function main({token, hosts, macro: supplied, session, execution}) {
if (!(supplied instanceof Macro) || session.id !== "00000000-0000-0000-0000-000000000001" || execution.id !== "00000000-0000-0000-0000-000000000002") throw new Error("Missing SDK handles");
const macro = new Macro({token, hosts});
console.log('x'.repeat(650));
const values = await Promise.all(['one', 'two'].map(input => macro.ai.decide({input, questions: {yes: 'Is this relevant?'}})));
const document = macro.documents.byId('fixture-document');
return { data: { text: Handlebars.compile('{{name}}: {{count}}')({name: document.id, count: values.length}), sum: values.reduce((sum, result) => sum + result.probabilities.yes, 0) }, reviews: [] };
}
"#;
let (events, outcome) = collect(
service
.execute(
ExecuteRequest {
source: source.into(),
timeout_ms: 5000,
},
environment,
)
.unwrap(),
)
.await;
assert!(
matches!(outcome, Outcome::Succeeded { ref value } if value["data"]["text"] == "fixture-document: 2" && value["data"]["sum"] == 1.0),
"{outcome:?}"
);
let progress: Vec<_> = events
.iter()
.filter_map(|event| match &event.kind {
EventKind::Progress { value } => Some(value),
_ => None,
})
.collect();
assert_eq!(progress.len(), 4);
assert_eq!(
progress
.iter()
.filter(|event| event["status"] == "started")
.count(),
2
);
assert_eq!(
progress
.iter()
.filter(|event| event["status"] == "completed")
.count(),
2
);
assert!(
progress
.iter()
.all(|event| event["service"] == "cognition" && event["operation"] == "decisions")
);
tokio::time::timeout(Duration::from_secs(5), server)
.await
.unwrap()
.unwrap();
service.shutdown().await;
}
#[tokio::test]
#[ignore = "requires pinned Deno runtime"]
async fn a_program_presents_a_view_through_its_session() {
let (_root, service) = setup(Limits::default()).await;
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
let address = listener.local_addr().unwrap();
let server = tokio::spawn(async move {
let (mut stream, _) = listener.accept().await.unwrap();
let request = read_request(&mut stream).await;
let response = "HTTP/1.1 204 No Content\r\nConnection: close\r\n\r\n";
stream.write_all(response.as_bytes()).await.unwrap();
request
});
let environment = RunEnvironment {
token: "fixture-run-token".into(),
trace_headers: BTreeMap::new(),
session_id: Some(uuid::Uuid::from_u128(1)),
execution_id: Some(uuid::Uuid::from_u128(2)),
hosts: BTreeMap::from([("agent-harness".into(), format!("http://{address}"))]),
unattended: None,
};
let source = r#"
export async function main({execution}) {
await execution.views.present({ title: 'Launch notes', widgets: [{ type: 'md', markdown: 'Shipped.' }] });
return { data: 'presented' };
}
"#;
let (_, outcome) = collect(
service
.execute(
ExecuteRequest {
source: source.into(),
timeout_ms: 5000,
},
environment,
)
.unwrap(),
)
.await;
assert!(
matches!(outcome, Outcome::Succeeded { ref value } if value["data"] == "presented"),
"{outcome:?}"
);
let request = tokio::time::timeout(Duration::from_secs(5), server)
.await
.unwrap()
.unwrap();
assert!(
request.starts_with("POST /agent-sessions/00000000-0000-0000-0000-000000000001/views "),
"{request}"
);
let body = request.split("\r\n\r\n").nth(1).unwrap();
let body: serde_json::Value = serde_json::from_str(body).unwrap();
assert_eq!(body["view"]["title"], "Launch notes");
assert_eq!(body["executionId"], "00000000-0000-0000-0000-000000000002");
service.shutdown().await;
}
#[tokio::test]
#[ignore = "requires pinned Deno runtime"]
async fn javascript_logs_result_and_cleanup() {
let (root, service) = setup(Limits::default()).await;
let (events, outcome) = run(&service, "export async function main() { console.log('working'); await Promise.resolve(); return 6 * 7; }", 5000).await;
assert!(matches!(outcome, Outcome::Succeeded { value } if value == 42));
assert!(events.iter().any(
|event| matches!(&event.kind, EventKind::Log { message, .. } if message == "working")
));
assert_eq!(std::fs::read_dir(root.path()).unwrap().count(), 0);
service.shutdown().await;
}
#[tokio::test]
#[ignore = "requires pinned Deno runtime"]
async fn requires_javascript_exported_main() {
let (_root, service) = setup(Limits::default()).await;
for source in [
"return 42;",
"export const main = 42;",
"export function main() { const n: number = 42; return n; }",
] {
let (_, outcome) = run(&service, source, 5000).await;
assert!(matches!(outcome, Outcome::Failed { error } if error.code == FailureCode::Runtime));
}
service.shutdown().await;
}
#[tokio::test]
#[ignore = "requires pinned Deno runtime"]
async fn denies_ambient_io_and_external_module_imports() {
let (_root, service) = setup(Limits::default()).await;
let outside = tempfile::tempdir().unwrap();
let module = outside.path().join("outside.mjs");
let json = outside.path().join("outside.json");
tokio::fs::write(&json, r#"{"secret":"fixture-only"}"#)
.await
.unwrap();
tokio::fs::write(&module, "export default 42;")
.await
.unwrap();
let bodies = [
"return Deno.env.get('PATH');".to_owned(),
"return Deno.readTextFile('/etc/passwd');".into(),
"await Deno.writeTextFile('/tmp/macro-code-execution-forbidden', 'bad');".into(),
"return new Deno.Command('/bin/true').output();".into(),
format!("return await import('{}');", module.display()),
format!(
"return await import('{}', {{with: {{type: 'json'}}}});",
json.display()
),
format!(
"const path = '{}'; return await import(path);",
module.display()
),
format!(
"const worker = new Worker('file://{}', {{type: 'module'}}); await new Promise((resolve, reject) => {{ worker.onmessage = resolve; worker.onerror = reject; }});",
module.display()
),
"const fs = await import('node:fs'); return fs.readFileSync('/etc/passwd', 'utf8');".into(),
"return await import('https://example.com/module.js');".into(),
"return await import('npm:lodash');".into(),
];
for body in bodies {
let source = format!("export async function main() {{ {body} }}");
let (_, outcome) = run(&service, &source, 5000).await;
assert!(
matches!(outcome, Outcome::Failed { .. }),
"allowed forbidden source: {source}"
);
}
let source = format!(
"import value from '{}'; export function main() {{ return value; }}",
module.display()
);
let (_, outcome) = run(&service, &source, 5000).await;
assert!(
matches!(outcome, Outcome::Failed { .. }),
"static import escaped scratch: {outcome:?}"
);
service.shutdown().await;
}
#[tokio::test]
#[ignore = "requires pinned Deno runtime"]
async fn rejects_sleeping_and_points_at_routines() {
let (_root, service) = setup(Limits::default()).await;
let sources = [
"export async function main() { await new Promise(resolve => setTimeout(resolve, 20000)); }",
"export function main() { setInterval(() => {}, 1000); }",
"export function main() { setImmediate(() => {}); }",
"export async function main() { await new Promise(resolve => AbortSignal.timeout(1000).addEventListener('abort', resolve)); }",
"export function main() { Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 1000); }",
"export async function main() { await Atomics.waitAsync(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 1000).value; }",
"export function main() { new Worker('data:text/javascript,setTimeout(() => postMessage(1), 1000)', {type: 'module'}); }",
"export async function main() { const { setTimeout } = await import('node:timers/promises'); await setTimeout(1000); }",
"import { setTimeout } from 'node:timers'; export async function main() { await new Promise(resolve => setTimeout(resolve, 1000)); }",
"import { Worker } from 'worker_threads'; export function main() { return Worker; }",
];
for source in sources {
let (_, outcome) = run(&service, source, 5000).await;
assert!(
matches!(&outcome, Outcome::Failed { error } if error.code == FailureCode::Runtime && error.message.contains("create a routine with macro.routines.create")),
"{source}: {outcome:?}"
);
}
service.shutdown().await;
}
#[tokio::test]
#[ignore = "requires pinned Deno runtime"]
async fn denies_unlisted_destinations_including_redirects() {
let (_root, service) = setup(Limits::default()).await;
let forbidden = TcpListener::bind("127.0.0.1:0").await.unwrap();
let forbidden_address = forbidden.local_addr().unwrap();
let (_, outcome) = run(
&service,
&format!(
"export async function main() {{ return await fetch('http://{forbidden_address}'); }}"
),
5000,
)
.await;
assert!(matches!(outcome, Outcome::Failed { .. }));
let allowed = TcpListener::bind("127.0.0.1:0").await.unwrap();
let allowed_address = allowed.local_addr().unwrap();
let server = tokio::spawn(async move {
let (mut stream, _) = allowed.accept().await.unwrap();
read_request(&mut stream).await;
stream.write_all(format!("HTTP/1.1 302 Found\r\nLocation: http://{forbidden_address}\r\nContent-Length: 0\r\nConnection: close\r\n\r\n").as_bytes()).await.unwrap();
});
let (_, outcome) = collect(service.execute(ExecuteRequest { source: format!("export async function main() {{ return await fetch('http://{allowed_address}'); }}"), timeout_ms: 5000 }, RunEnvironment { hosts: BTreeMap::from([("cognition".into(), format!("http://{allowed_address}"))]), ..RunEnvironment::default() }).unwrap()).await;
assert!(
matches!(outcome, Outcome::Failed { .. }),
"redirect escaped allowlist: {outcome:?}"
);
tokio::time::timeout(Duration::from_secs(5), server)
.await
.unwrap()
.unwrap();
assert!(
tokio::time::timeout(Duration::from_millis(50), forbidden.accept())
.await
.is_err()
);
service.shutdown().await;
}
#[tokio::test]
#[ignore = "requires pinned Deno runtime"]
async fn times_out_cancels_and_reaps_busy_processes() {
let (root, service) = setup(Limits::default()).await;
let (_, outcome) = run(&service, "export function main() { while (true) {} }", 300).await;
assert!(matches!(outcome, Outcome::TimedOut));
let mut handle = service
.execute(
ExecuteRequest {
source: "export function main() { console.log('ready'); while(true) {} }".into(),
timeout_ms: 5000,
},
RunEnvironment::default(),
)
.unwrap();
while !matches!(
handle.events.recv().await.unwrap().kind,
EventKind::Log { .. }
) {}
handle.cancellation.cancel();
let (_, outcome) = collect(handle).await;
assert!(matches!(outcome, Outcome::Cancelled));
assert_eq!(std::fs::read_dir(root.path()).unwrap().count(), 0);
service.shutdown().await;
}
#[tokio::test]
#[ignore = "requires pinned Deno runtime"]
async fn bounds_output_and_rejects_invalid_or_duplicate_frames() {
let (_root, service) = setup(Limits {
max_frame_bytes: 16 * 1024,
max_result_bytes: 8 * 1024,
..Limits::default()
})
.await;
for body in [
"console.log('x'.repeat(20000));",
"Deno.stderr.writeSync(new TextEncoder().encode('x'.repeat(20000)));",
"while (true) console.log('spam');",
"Deno.stdout.writeSync(new TextEncoder().encode('not json\\n'));",
"Deno.stdout.writeSync(new TextEncoder().encode('{\"type\":\"started\"}\\n'));",
"Deno.stdout.writeSync(new TextEncoder().encode('{\"type\":\"result\",\"value\":1}\\n')); return 2;",
] {
let (_, outcome) = run(
&service,
&format!("export function main() {{ {body} }}"),
5000,
)
.await;
assert!(
matches!(outcome, Outcome::Failed { ref error } if matches!(error.code, FailureCode::Limit | FailureCode::Protocol)),
"{body}: {outcome:?}"
);
}
service.shutdown().await;
}
#[tokio::test]
#[ignore = "requires pinned Deno runtime"]
async fn result_at_the_limit_fits_its_frame_unsummarized() {
let (_root, service) = setup(Limits {
max_frame_bytes: 1024,
max_output_bytes: 4096,
max_result_bytes: 1024 - RESULT_FRAME_OVERHEAD,
..Limits::default()
})
.await;
// JSON quotes bring the string to exactly max_result_bytes.
let (_, outcome) = run(
&service,
&format!(
"export function main() {{ return 'x'.repeat({}); }}",
1024 - RESULT_FRAME_OVERHEAD - 2
),
5000,
)
.await;
let Outcome::Succeeded { value } = outcome else {
panic!("{outcome:?}");
};
assert_eq!(
value.as_str().unwrap().len(),
1024 - RESULT_FRAME_OVERHEAD - 2
);
service.shutdown().await;
}
#[tokio::test]
#[ignore = "requires pinned Deno runtime"]
async fn oversized_result_data_is_summarized_and_reviews_kept() {
let limits = Limits::default();
let max_result_bytes = limits.max_result_bytes;
let (_root, service) = setup(limits).await;
let (_, outcome) = run(
&service,
"export function main(context) { return {data: {keys: Object.keys(context), items: Array.from({length: 2000}, (_, id) => ({id, name: 'x'.repeat(100)}))}, reviews: []}; }",
5000,
)
.await;
let Outcome::Succeeded { value } = outcome else {
panic!("{outcome:?}");
};
assert_eq!(value["reviews"], serde_json::json!([]));
let data = &value["data"];
assert_eq!(data["truncated"], true);
assert_eq!(data["limitBytes"], max_result_bytes);
assert!(data["bytes"].as_u64().unwrap() > max_result_bytes as u64);
assert_eq!(
data["outline"],
"{keys: Array(8) of string, items: Array(2000) of {id: number, name: string}}"
);
assert!(data["preview"].as_str().unwrap().starts_with(
r#"{"keys":["token","traceHeaders","sessionId","executionId","hosts","macro","session","execution"],"items":[{"id":0,"#
));
assert!(serde_json::to_vec(&value).unwrap().len() <= max_result_bytes);
service.shutdown().await;
}
#[tokio::test]
#[ignore = "requires pinned Deno runtime"]
async fn printed_result_cannot_complete_before_process_exit() {
let (root, service) = setup(Limits::default()).await;
let (_, outcome) = run(&service, "export function main() { Deno.stdout.writeSync(new TextEncoder().encode('{\"type\":\"result\",\"value\":42}\\n')); while(true) {} }", 300).await;
assert!(matches!(outcome, Outcome::TimedOut));
assert_eq!(std::fs::read_dir(root.path()).unwrap().count(), 0);
service.shutdown().await;
}
#[tokio::test]
#[ignore = "requires pinned Deno runtime"]
async fn dropping_receiver_and_shutdown_reap_processes() {
let (root, service) = setup(Limits::default()).await;
let mut handle = service
.execute(
ExecuteRequest {
source: "export function main() { console.log('ready'); while(true) {} }".into(),
timeout_ms: 5000,
},
RunEnvironment::default(),
)
.unwrap();
while !matches!(
handle.events.recv().await.unwrap().kind,
EventKind::Log { .. }
) {}
drop(handle);
service.shutdown().await;
assert_eq!(std::fs::read_dir(root.path()).unwrap().count(), 0);
}
#[tokio::test]
#[ignore = "requires pinned Deno runtime"]
async fn total_output_budget_applies_across_small_frames() {
let (_root, service) = setup(Limits {
max_frame_bytes: 1024,
max_output_bytes: 4096,
max_result_bytes: 512,
..Limits::default()
})
.await;
let (_, outcome) = run(&service, "export async function main() { for(let i = 0; i < 20; i++) { console.log('x'.repeat(500)); } return null; }", 5000).await;
assert!(
matches!(outcome, Outcome::Failed { error } if error.code == FailureCode::Limit && error.message == "process output limit exceeded")
);
service.shutdown().await;
}
#[tokio::test]
#[ignore = "requires pinned Deno runtime"]
async fn redacts_run_token_from_results_keys_console_stderr_and_errors() {
let (_root, service) = setup(Limits::default()).await;
let token = "fixture-secret-token";
for source in [
"export function main({token}) { console.log(token); Deno.stderr.writeSync(new TextEncoder().encode(token + '\\n')); return {[token]: token, embedded: 'Bearer ' + token}; }",
"export function main({token}) { throw new Error('token ' + token); }",
] {
let (events, outcome) = collect(
service
.execute(
ExecuteRequest {
source: source.into(),
timeout_ms: 5000,
},
RunEnvironment {
token: token.into(),
..RunEnvironment::default()
},
)
.unwrap(),
)
.await;
let serialized = serde_json::to_string(&(events, &outcome)).unwrap();
assert!(
!serialized.contains(token),
"run credential escaped redaction"
);
assert!(serialized.contains("[REDACTED]"));
match outcome {
Outcome::Succeeded { value } => {
assert_eq!(value["[REDACTED]"], "[REDACTED]");
assert_eq!(value["embedded"], "Bearer [REDACTED]");
}
Outcome::Failed { error } => assert_eq!(error.message, "Error: token [REDACTED]"),
unexpected => panic!("unexpected outcome: {unexpected:?}"),
}
}
service.shutdown().await;
}
fn unattended(
token: &str,
hosts: &[(&str, String)],
arguments: serde_json::Value,
dry_run: bool,
) -> RunEnvironment {
RunEnvironment {
token: token.into(),
hosts: hosts
.iter()
.map(|(name, url)| ((*name).to_owned(), url.clone()))
.collect(),
unattended: Some(Unattended {
arguments: arguments.as_object().unwrap().clone(),
dry_run,
}),
..RunEnvironment::default()
}
}
async fn run_unattended(
service: &ExecutionService,
source: &str,
environment: RunEnvironment,
) -> (Vec<serde_json::Value>, Outcome) {
let (events, outcome) = collect(
service
.execute(
ExecuteRequest {
source: source.into(),
timeout_ms: 10_000,
},
environment,
)
.unwrap(),
)
.await;
let progress = events
.into_iter()
.filter_map(|event| match event.kind {
EventKind::Progress { value } => Some(value),
_ => None,
})
.collect();
(progress, outcome)
}
#[tokio::test]
#[ignore = "requires pinned Deno runtime"]
async fn an_unattended_result_is_kept_whole_or_fails_over_the_limit() {
let (_root, service) = setup(Limits::default()).await;
let fits = "export function main() { return { items: Array.from({ length: 400 }, (_, id) => ({ id, name: 'x'.repeat(100) })) }; }";
let (_, outcome) = run_unattended(
&service,
fits,
unattended("fixture-run-token", &[], serde_json::json!({}), true),
)
.await;
let Outcome::Succeeded { value } = outcome else {
panic!("{outcome:?}");
};
assert_eq!(value["items"].as_array().unwrap().len(), 400);
let (_, outcome) = run_unattended(
&service,
"export function main() { return 'x'.repeat(70 * 1024); }",
unattended("fixture-run-token", &[], serde_json::json!({}), true),
)
.await;
let Outcome::Failed { error } = outcome else {
panic!("{outcome:?}");
};
assert_eq!(
error.message,
"The step's output is 71 KB as JSON; a step's output can be at most 64 KB. Return only what later steps need."
);
service.shutdown().await;
}
#[tokio::test]
#[ignore = "requires pinned Deno runtime"]
async fn unattended_typescript_gets_its_arguments_and_no_credential_or_raw_network() {
let (_root, service) = setup(Limits::default()).await;
let source = r#"
type Context = { macro: object; trigger: { subject: string } };
export async function main(context: Context): Promise<object> {
let net = "loaded";
try { await import("node:" + "net"); } catch { net = "unavailable"; }
return {
keys: Object.keys(context).sort(),
subject: context.trigger.subject,
connect: typeof Deno.connect,
worker: typeof Worker,
net,
};
}
"#;
let environment = unattended(
"fixture-run-token",
&[],
serde_json::json!({"trigger": {"subject": "Invoice 7"}}),
true,
);
let (_, outcome) = run_unattended(&service, source, environment).await;
let Outcome::Succeeded { value } = outcome else {
panic!("{outcome:?}");
};
assert_eq!(
value,
serde_json::json!({
"keys": ["macro", "trigger"],
"subject": "Invoice 7",
"connect": "undefined",
"worker": "undefined",
"net": "unavailable",
})
);
service.shutdown().await;
}
#[tokio::test]
#[ignore = "requires pinned Deno runtime"]
async fn a_dry_run_reads_but_sends_no_writes() {
let (_root, service) = setup(Limits::default()).await;
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
let host = format!("http://{}", listener.local_addr().unwrap());
let server = tokio::spawn(async move {
let (mut stream, _) = listener.accept().await.unwrap();
let request = read_request(&mut stream).await;
assert!(request.starts_with("POST /decisions "), "{request}");
respond(&mut stream, r#"{"probabilities":{"yes":0.9}}"#).await;
// Nothing else reaches the API: the write is skipped and the raw
// request is stopped in the process.
assert!(
tokio::time::timeout(Duration::from_millis(500), listener.accept())
.await
.is_err()
);
});
let source = r#"
export async function main({ macro, host }: { macro: any; host: string }) {
const decision = await macro.ai.decide({ input: "x", questions: { yes: "Yes?" } });
const archived = await macro._client.email.archiveThread({ path: { id: "thread-1" }, body: { archived: true } });
const token = macro._client.email.client.getConfig().auth;
let raw = "sent";
try {
await fetch(`${host}/email/labels`, { method: "POST", headers: { authorization: `Bearer ${token}` } });
} catch (error) {
raw = String(error);
}
return { yes: decision.probabilities.yes, archived: archived.data, raw };
}
"#;
let environment = unattended(
"fixture-run-token",
&[("cognition", host.clone()), ("email", host.clone())],
serde_json::json!({ "host": host }),
true,
);
let (progress, outcome) = run_unattended(&service, source, environment).await;
let Outcome::Succeeded { value } = outcome else {
panic!("{outcome:?}");
};
assert_eq!(value["yes"], 0.9);
assert_eq!(value["archived"], serde_json::json!({}));
assert!(
value["raw"]
.as_str()
.unwrap()
.contains("A dry run doesn't send changes."),
"{value}"
);
assert!(progress.iter().any(|event| event["service"] == "email"
&& event["operation"] == "archiveThread"
&& event["status"] == "skipped"));
server.await.unwrap();
service.shutdown().await;
}
#[tokio::test]
#[ignore = "requires pinned Deno runtime"]
async fn a_real_run_sends_its_writes() {
let (_root, service) = setup(Limits::default()).await;
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
let host = format!("http://{}", listener.local_addr().unwrap());
let server = tokio::spawn(async move {
let (mut stream, _) = listener.accept().await.unwrap();
let request = read_request(&mut stream).await;
assert!(request.starts_with("DELETE "), "{request}");
respond(&mut stream, "{}").await;
});
let source = r#"
export async function main({ macro }: { macro: any }) {
await macro._client.storage.deleteDocument({ path: { document_id: "document-1" } });
return { deleted: true };
}
"#;
let environment = unattended(
"fixture-run-token",
&[("storage", host.clone())],
serde_json::json!({}),
false,
);
let (progress, outcome) = run_unattended(&service, source, environment).await;
let Outcome::Succeeded { value } = outcome else {
panic!("{outcome:?}");
};
assert_eq!(value["deleted"], true);
assert!(
progress
.iter()
.any(|event| event["operation"] == "deleteDocument" && event["status"] == "completed")
);
server.await.unwrap();
service.shutdown().await;
}
#[tokio::test]
#[ignore = "requires pinned Deno runtime"]
async fn the_cpu_limit_stops_a_busy_program() {
let (_root, service) = setup(Limits {
max_cpu: Some(Duration::from_secs(1)),
background: true,
..Limits::default()
})
.await;
let (_, outcome) = run(
&service,
"export async function main() { for (;;) {} }",
10_000,
)
.await;
assert!(
matches!(&outcome, Outcome::Failed { error } if error.code == FailureCode::Limit && error.message.contains("CPU")),
"{outcome:?}"
);
service.shutdown().await;
}