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::activity::{DatabaseChange, ToolOutcome};
use super::*;
use crate::cognition::api::context::test::{
ADMISSION_TEST_USER, TestAdmission, admission_errors, authorized_request, test_api_context,
};
use crate::cognition::service::structured_completion::{
ToolFreeCompletion, ToolFreeCompletionError, ToolFreeRequest,
};
use axum::{Router, routing::post};
use macro_db_migrator::MACRO_DB_MIGRATIONS;
use macro_user_id::user_id::MacroUserIdStr;
use serde_json::json;
use std::sync::Mutex;
use tower::ServiceExt;
#[derive(Default)]
struct OneShot(Mutex<Vec<(String, String, CompletionThinking)>>);
#[async_trait::async_trait]
impl ToolFreeCompletion for OneShot {
async fn complete(
&self,
owner: MacroUserIdStr<'static>,
request: ToolFreeRequest,
) -> Result<serde_json::Value, ToolFreeCompletionError> {
assert_eq!(request.model, chat::domain::models::FREE_MODEL);
assert_eq!(request.schema.name, "Answer");
assert!(request.system_prompt.ends_with("Be brief."));
self.0
.lock()
.unwrap()
.push((owner.to_string(), request.prompt, request.thinking));
Ok(json!({"answer": "hello"}))
}
}
#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn tool_free_requests_call_one_completion_without_an_agent_or_discovery(pool: sqlx::PgPool) {
let mut state = (*test_api_context(pool).await).clone();
let one_shot = Arc::new(OneShot::default());
state.tool_free_completions = one_shot.clone();
let admission = Arc::new(TestAdmission {
result: Ok(()),
calls: Default::default(),
});
state.ai_admission = admission.clone();
let router = Router::new()
.route("/", post(structured_completion))
.with_state(state);
let mut body = request_body();
body["additional_instructions"] = json!("Be brief.");
body["thinking"] = json!("low");
let response = router.oneshot(authorized_request("/", body)).await.unwrap();
assert_eq!(response.status(), StatusCode::OK);
let bytes = axum::body::to_bytes(response.into_body(), usize::MAX)
.await
.unwrap();
assert_eq!(
serde_json::from_slice::<serde_json::Value>(&bytes).unwrap(),
json!({
"outcome": {"status": "completed", "result": {"answer": "hello"}},
"toolActivity": []
})
);
assert_eq!(
*one_shot.0.lock().unwrap(),
[(
ADMISSION_TEST_USER.into(),
"hello".into(),
CompletionThinking::Low
)]
);
assert_eq!(
*admission.calls.lock().unwrap(),
[(
ADMISSION_TEST_USER.into(),
ai_usage::AiFeature::DynamicCompletionsApi
)]
);
}
#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn invalid_schema_is_a_client_error_before_admission_for_every_toolset(pool: sqlx::PgPool) {
let mut state = (*test_api_context(pool).await).clone();
let admission = TestAdmission::rejecting(ai_billing::AiAdmissionError::Unavailable);
let one_shot = Arc::new(OneShot::default());
state.ai_admission = admission.clone();
state.tool_free_completions = one_shot.clone();
let router = Router::new()
.route("/", post(structured_completion))
.with_state(state);
for selection in ["none", "all", "databases", "databases_read_only"] {
let mut body = request_body();
body["toolset"]["type"] = json!(selection);
body["output_schema"]["schema"] = json!({"type": "not-a-json-type"});
let response = router
.clone()
.oneshot(authorized_request("/", body))
.await
.unwrap();
assert_eq!(response.status(), StatusCode::BAD_REQUEST);
let bytes = axum::body::to_bytes(response.into_body(), usize::MAX)
.await
.unwrap();
let error: serde_json::Value = serde_json::from_slice(&bytes).unwrap();
assert_eq!(error["code"], "invalid_output_schema");
}
assert!(admission.calls.lock().unwrap().is_empty());
assert!(one_shot.0.lock().unwrap().is_empty());
}
#[test]
fn completion_failure_after_committed_changes_is_interrupted() {
let response = partial_completion_or_error(
vec![StructuredToolActivity {
name: "AddColumn".into(),
outcome: ToolOutcome::Succeeded {
changes: DatabaseChange::Schema,
},
}],
StructuredCompletionError {
error: "provider interrupted".into(),
status: StatusCode::BAD_GATEWAY,
code: None,
},
)
.unwrap()
.0;
assert_eq!(
serde_json::to_value(&response).unwrap(),
json!({
"outcome": {"status": "interrupted", "reason": "provider interrupted"},
"toolActivity": [
{
"name": "AddColumn",
"outcome": {"status": "succeeded", "changes": {"kind": "schema"}},
},
],
})
);
}
#[test]
fn completion_failure_without_changes_preserves_error_status() {
let error = partial_completion_or_error(
vec![StructuredToolActivity {
name: "QueryDatabase".into(),
outcome: ToolOutcome::Succeeded {
changes: DatabaseChange::None,
},
}],
StructuredCompletionError {
error: "provider interrupted".into(),
status: StatusCode::BAD_GATEWAY,
code: None,
},
)
.unwrap_err();
assert_eq!(error.status, StatusCode::BAD_GATEWAY);
assert_eq!(error.error, "provider interrupted");
}
#[test]
fn completed_answers_carry_the_caller_schema_result() {
let response = StructuredCompletionResponse {
outcome: StructuredCompletionOutcome::Completed {
result: json!({"answerable": true, "sql": "SELECT * FROM \"Guests\""}),
},
tool_activity: vec![StructuredToolActivity {
name: "QueryDatabase".into(),
outcome: ToolOutcome::Succeeded {
changes: DatabaseChange::Rows { count: 2 },
},
}],
};
assert_eq!(
serde_json::to_value(&response).unwrap(),
json!({
"outcome": {
"status": "completed",
"result": {"answerable": true, "sql": "SELECT * FROM \"Guests\""},
},
"toolActivity": [
{
"name": "QueryDatabase",
"outcome": {"status": "succeeded", "changes": {"kind": "rows", "count": 2}},
},
],
})
);
}
fn request_body() -> serde_json::Value {
serde_json::json!({
"prompt": "hello",
"model": chat::domain::models::FREE_MODEL,
"toolset": { "type": "none" },
"output_schema": {
"name": "Answer",
"schema": {
"type": "object",
"properties": { "answer": { "type": "string" } },
"required": ["answer"]
}
}
})
}
#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn admission_rejects_before_tool_discovery_and_both_provider_phases(pool: sqlx::PgPool) {
let ctx = test_api_context(pool).await;
for error in admission_errors() {
let admission = TestAdmission::rejecting(error);
let mut state = (*ctx).clone();
state.ai_admission = admission.clone();
let router = Router::new()
.route("/", post(structured_completion))
.with_state(state);
let response = router
.oneshot(authorized_request("/", request_body()))
.await
.unwrap();
assert_eq!(response.status(), admission_status(error));
let bytes = axum::body::to_bytes(response.into_body(), usize::MAX)
.await
.unwrap();
let body: serde_json::Value = serde_json::from_slice(&bytes).unwrap();
assert_eq!(
body,
serde_json::json!({"error": error.to_string(), "code": error.code()})
);
assert_eq!(
*admission.calls.lock().unwrap(),
vec![(
ADMISSION_TEST_USER.into(),
ai_usage::AiFeature::DynamicCompletionsApi
)]
);
}
}
#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn unauthorized_request_does_not_disclose_quota(pool: sqlx::PgPool) {
let mut state = (*test_api_context(pool).await).clone();
let admission = TestAdmission::rejecting(ai_billing::AiAdmissionError::Unavailable);
state.ai_admission = admission.clone();
let router = Router::new()
.route("/", post(structured_completion))
.with_state(state);
let mut request = authorized_request("/", request_body());
request
.headers_mut()
.insert("x-internal-auth-key", "invalid".parse().unwrap());
let response = router.oneshot(request).await.unwrap();
assert_eq!(response.status(), StatusCode::UNAUTHORIZED);
assert!(admission.calls.lock().unwrap().is_empty());
}
#[test]
fn openapi_documents_admission_failures_with_existing_payloads() {
use utoipa::OpenApi;
let doc = serde_json::to_value(crate::cognition::api::swagger::ApiDoc::openapi()).unwrap();
for (path, schema) in [
("/stream/chat/message", "ChatMessageError"),
("/structured-completion", "StructuredCompletionError"),
] {
for status in ["402", "503"] {
assert_eq!(
doc["paths"][path]["post"]["responses"][status]["content"]["application/json"]["schema"]
["$ref"],
format!("#/components/schemas/{schema}")
);
}
}
}