CI / Rust Checks (pull_request) Failing after 13m41s
CI / UI Checks (pull_request) Skipped
CI / Frontend E2E (pull_request) Skipped
CI / Community Image Smoke (pull_request) Skipped
CI / Deploy (pull_request) Skipped
Community Release / release (push) Failing after 13m33s
Recovery delivery of the accumulated, TL-accepted Epic 3 work that had never been
committed to Git (stories 3.6-3.17, see the crank board). Story 3.18 is not accepted
yet and is deliberately excluded: its logging surface, its capability registration,
its oracle projections and its tests are not part of this tree.
Accepted scope
- 3.6 typed static Resource Drafts; 3.7 publication and exact binding of static
Resource Versions; 3.8 MCP discovery/read and revocation of static Resources;
- 3.9 Resource import/export in API and UI plus TLS dependency maintenance;
3.10 REST-backed Resource templates; 3.11 shared REST read runtime and the MCP
revision/capability foundation;
- 3.12 parameterised Prompt Drafts with preview; 3.13 Prompt publication and exact
version binding to Agents; 3.14 MCP prompts; 3.15 Prompt import/export;
- 3.16 composite Prompts with published Resources (dependency content scan plus
dynamic read through the accepted 3.11 runtime, admin preview and MCP prompts/get);
- 3.17 bounded MCP completion suggestions from typed published schemas and the
resources/list admission fix for bound template publications.
Accepted evidence being reused (unchanged code paths)
- 3.16 candidate: core 7, admin-api 22, registry 4, mcp-server 4, UI 6; one final
`just verify` run 1651 passed / 0 failed / 2 ignored.
- 3.17 candidate: full run 1672 passed / 0 failed / 2 ignored, QA targeted reruns and
a real MCP Inspector 2.12.0 client smoke.
Delivery engineering in this commit
- CI: one event per change (feature branches are gated by their pull request, push
runs only on main), story events run the changed packages, the full workspace suite
stays the feature/release gate; no cache/sharding without a measured runner check.
- Release: the packaged archives, checksums and SBOM are now uploaded to the Gitea
release entry of the tag instead of dying with the runner workspace.
Not included on purpose: Story 3.18 work, build caches, runtime databases, local
credentials and scratch evidence.
Refs: crank kanban t_e39d7263; baseline 1b6db09bd1.
484 lines
15 KiB
Rust
484 lines
15 KiB
Rust
//! Legacy transport lifecycle and negotiation: initialized-notification gate, SSE GET/initialize,
|
|
//! expired and unknown sessions, the GET rate bucket, session-header requirement, DELETE and the
|
|
//! JSON-only response negotiation.
|
|
//!
|
|
//! Tests moved verbatim from `transport_protocol.rs` (Story 3.6, kanban t_987bf309); only the module
|
|
//! prefix changed.
|
|
|
|
use super::super::common::*;
|
|
use axum::{
|
|
Json, Router,
|
|
http::header,
|
|
response::sse::{Event, KeepAlive, Sse},
|
|
routing::{get, post},
|
|
};
|
|
use base64::{Engine as _, engine::general_purpose::URL_SAFE_NO_PAD};
|
|
use crank_community_mcp::{
|
|
auth::{CommunityMachineCredentialVerifier, SharedMachineCredentialVerifier},
|
|
build_app,
|
|
catalog::PublishedToolCatalog,
|
|
session::{InMemorySessionStore, SharedSessionStore, TransportSessionStore},
|
|
};
|
|
use crank_core::{
|
|
Agent, AgentId, AgentOperationBinding, AgentStatus, AgentVersion, ExecutionConfig, HttpMethod,
|
|
Operation, OperationId, OperationStatus, PlatformApiKey, PlatformApiKeyId, PlatformApiKeyScope,
|
|
PlatformApiKeyStatus, Protocol, RestTarget, Target, ToolAccessMode, ToolDescription, ToolGroup,
|
|
ToolSearchSettings, ToolSelectionPolicy, WorkspaceId,
|
|
};
|
|
use crank_runtime::{
|
|
InMemoryCoordinationStateStore, RequestRateLimitConfig, RequestRateLimiter, RuntimeExecutor,
|
|
SecretCrypto,
|
|
};
|
|
use futures_util::stream;
|
|
use serde_json::{Value, json};
|
|
use std::{
|
|
collections::BTreeMap,
|
|
io,
|
|
sync::{Arc, Mutex},
|
|
time::Duration,
|
|
};
|
|
use time::{OffsetDateTime, format_description::well_known::Rfc3339};
|
|
use uuid::Version;
|
|
#[tokio::test]
|
|
async fn requires_initialized_notification_before_tool_methods() {
|
|
let registry = test_registry().await;
|
|
publish_agent_with_bindings(®istry, "sales-init", vec![]).await;
|
|
let api_key = create_platform_api_key(
|
|
®istry,
|
|
"sales-init",
|
|
"mcp-init",
|
|
&[PlatformApiKeyScope::Read],
|
|
)
|
|
.await;
|
|
let base_url = spawn_mcp_server(build_test_app(
|
|
registry,
|
|
Duration::from_millis(0),
|
|
Some("https://crank.example.com".to_owned()),
|
|
))
|
|
.await;
|
|
let client = reqwest::Client::new();
|
|
let mcp_url = agent_mcp_url(&base_url, "sales-init");
|
|
let initialize_response = client
|
|
.post(&mcp_url)
|
|
.header(header::ACCEPT, "application/json, text/event-stream")
|
|
.header(header::AUTHORIZATION, format!("Bearer {api_key}"))
|
|
.json(&json!({
|
|
"jsonrpc": "2.0",
|
|
"id": 1,
|
|
"method": "initialize",
|
|
"params": {
|
|
"protocolVersion": "2025-11-25"
|
|
}
|
|
}))
|
|
.send()
|
|
.await
|
|
.unwrap();
|
|
let session_id = initialize_response
|
|
.headers()
|
|
.get("MCP-Session-Id")
|
|
.unwrap()
|
|
.to_str()
|
|
.unwrap()
|
|
.to_owned();
|
|
let tools_list = client
|
|
.post(&mcp_url)
|
|
.header(header::ACCEPT, "application/json, text/event-stream")
|
|
.header(header::AUTHORIZATION, format!("Bearer {api_key}"))
|
|
.header("MCP-Session-Id", session_id)
|
|
.header("MCP-Protocol-Version", "2025-11-25")
|
|
.json(&json!({
|
|
"jsonrpc": "2.0",
|
|
"id": 2,
|
|
"method": "tools/list",
|
|
"params": {}
|
|
}))
|
|
.send()
|
|
.await
|
|
.unwrap()
|
|
.json::<Value>()
|
|
.await
|
|
.unwrap();
|
|
|
|
assert_eq!(tools_list["error"]["code"], -32002);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn initialize_can_return_sse_response_when_client_prefers_event_stream() {
|
|
let registry = test_registry().await;
|
|
publish_agent_with_bindings(®istry, "sales-sse-init", vec![]).await;
|
|
let api_key = create_platform_api_key(
|
|
®istry,
|
|
"sales-sse-init",
|
|
"mcp-sse-init",
|
|
&[PlatformApiKeyScope::Read, PlatformApiKeyScope::Write],
|
|
)
|
|
.await;
|
|
let base_url = spawn_mcp_server(build_test_app(
|
|
registry,
|
|
Duration::from_millis(0),
|
|
Some("https://crank.example.com".to_owned()),
|
|
))
|
|
.await;
|
|
let client = reqwest::Client::new();
|
|
let response = client
|
|
.post(agent_mcp_url(&base_url, "sales-sse-init"))
|
|
.header(header::ACCEPT, "text/event-stream, application/json")
|
|
.header(header::AUTHORIZATION, format!("Bearer {api_key}"))
|
|
.json(&json!({
|
|
"jsonrpc": "2.0",
|
|
"id": 1,
|
|
"method": "initialize",
|
|
"params": {
|
|
"protocolVersion": "2025-11-25"
|
|
}
|
|
}))
|
|
.send()
|
|
.await
|
|
.unwrap();
|
|
|
|
assert_eq!(response.status(), reqwest::StatusCode::OK);
|
|
assert_eq!(
|
|
response
|
|
.headers()
|
|
.get(header::CONTENT_TYPE)
|
|
.unwrap()
|
|
.to_str()
|
|
.unwrap(),
|
|
"text/event-stream"
|
|
);
|
|
assert!(response.headers().get("MCP-Session-Id").is_some());
|
|
|
|
let body = response.text().await.unwrap();
|
|
assert!(body.contains("\"jsonrpc\":\"2.0\""));
|
|
assert!(body.contains("\"protocolVersion\":\"2025-11-25\""));
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn get_opens_sse_stream_for_initialized_session() {
|
|
let registry = test_registry().await;
|
|
publish_agent_with_bindings(®istry, "sales-get-sse", vec![]).await;
|
|
let api_key = create_platform_api_key(
|
|
®istry,
|
|
"sales-get-sse",
|
|
"mcp-get-sse",
|
|
&[PlatformApiKeyScope::Read, PlatformApiKeyScope::Write],
|
|
)
|
|
.await;
|
|
let base_url = spawn_mcp_server(build_test_app(
|
|
registry,
|
|
Duration::from_millis(0),
|
|
Some("https://crank.example.com".to_owned()),
|
|
))
|
|
.await;
|
|
let client = reqwest::Client::new();
|
|
let mcp_url = agent_mcp_url(&base_url, "sales-get-sse");
|
|
let initialized_session = initialize_session(&client, &mcp_url, &api_key).await;
|
|
|
|
let response = client
|
|
.get(&mcp_url)
|
|
.header(header::ACCEPT, "text/event-stream")
|
|
.header(header::AUTHORIZATION, format!("Bearer {api_key}"))
|
|
.header("MCP-Session-Id", &initialized_session)
|
|
.header("MCP-Protocol-Version", "2025-11-25")
|
|
.send()
|
|
.await
|
|
.unwrap();
|
|
|
|
assert_eq!(response.status(), reqwest::StatusCode::OK);
|
|
assert_eq!(
|
|
response
|
|
.headers()
|
|
.get(header::CONTENT_TYPE)
|
|
.unwrap()
|
|
.to_str()
|
|
.unwrap(),
|
|
"text/event-stream"
|
|
);
|
|
assert_eq!(
|
|
response
|
|
.headers()
|
|
.get("MCP-Session-Id")
|
|
.unwrap()
|
|
.to_str()
|
|
.unwrap(),
|
|
initialized_session
|
|
);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn get_returns_not_found_for_expired_transport_session() {
|
|
let registry = test_registry().await;
|
|
publish_agent_with_bindings(®istry, "sales-expired-session", vec![]).await;
|
|
let api_key = create_platform_api_key(
|
|
®istry,
|
|
"sales-expired-session",
|
|
"mcp-expired-session",
|
|
&[PlatformApiKeyScope::Read],
|
|
)
|
|
.await;
|
|
let session_store = Arc::new(InMemorySessionStore::default());
|
|
let session_id = session_store
|
|
.create(
|
|
"2025-11-25",
|
|
test_workspace_slug(),
|
|
"sales-expired-session",
|
|
false,
|
|
OffsetDateTime::parse("2026-05-01T10:00:00Z", &Rfc3339).unwrap(),
|
|
Some(OffsetDateTime::parse("2026-05-01T10:00:01Z", &Rfc3339).unwrap()),
|
|
)
|
|
.await
|
|
.unwrap();
|
|
session_store
|
|
.mark_initialized(
|
|
&session_id,
|
|
OffsetDateTime::parse("2026-05-01T10:00:01Z", &Rfc3339).unwrap(),
|
|
)
|
|
.await
|
|
.unwrap();
|
|
let base_url = spawn_mcp_server(build_test_app_with_store(
|
|
registry,
|
|
Duration::from_millis(0),
|
|
Some("https://crank.example.com".to_owned()),
|
|
RequestRateLimitConfig::new(10_000, 10_000).unwrap(),
|
|
session_store,
|
|
std::sync::Arc::new(CommunityMachineCredentialVerifier),
|
|
))
|
|
.await;
|
|
let client = reqwest::Client::new();
|
|
|
|
let response = client
|
|
.get(agent_mcp_url(&base_url, "sales-expired-session"))
|
|
.header(header::ACCEPT, "text/event-stream")
|
|
.header(header::AUTHORIZATION, format!("Bearer {api_key}"))
|
|
.header("MCP-Session-Id", &session_id)
|
|
.header("MCP-Protocol-Version", "2025-11-25")
|
|
.send()
|
|
.await
|
|
.unwrap();
|
|
|
|
assert_eq!(response.status(), reqwest::StatusCode::NOT_FOUND);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn rejects_rapid_transport_get_requests_with_429() {
|
|
let registry = test_registry().await;
|
|
publish_agent_with_bindings(®istry, "sales-get-rate-limit", vec![]).await;
|
|
let api_key = create_platform_api_key(
|
|
®istry,
|
|
"sales-get-rate-limit",
|
|
"mcp-get-rate-limit",
|
|
&[PlatformApiKeyScope::Read, PlatformApiKeyScope::Write],
|
|
)
|
|
.await;
|
|
let base_url = spawn_mcp_server(build_test_app_with_rate_limit(
|
|
registry,
|
|
Duration::from_millis(0),
|
|
Some("https://crank.example.com".to_owned()),
|
|
RequestRateLimitConfig::new(1, 2).unwrap(),
|
|
))
|
|
.await;
|
|
let client = reqwest::Client::new();
|
|
let mcp_url = agent_mcp_url(&base_url, "sales-get-rate-limit");
|
|
let initialized_session = initialize_session(&client, &mcp_url, &api_key).await;
|
|
|
|
let first_response = client
|
|
.get(&mcp_url)
|
|
.header(header::ACCEPT, "text/event-stream")
|
|
.header(header::AUTHORIZATION, format!("Bearer {api_key}"))
|
|
.header("MCP-Session-Id", &initialized_session)
|
|
.header("MCP-Protocol-Version", "2025-11-25")
|
|
.send()
|
|
.await
|
|
.unwrap();
|
|
assert_eq!(first_response.status(), reqwest::StatusCode::OK);
|
|
|
|
let second_response = client
|
|
.get(&mcp_url)
|
|
.header(header::ACCEPT, "text/event-stream")
|
|
.header(header::AUTHORIZATION, format!("Bearer {api_key}"))
|
|
.header("MCP-Session-Id", &initialized_session)
|
|
.header("MCP-Protocol-Version", "2025-11-25")
|
|
.send()
|
|
.await
|
|
.unwrap();
|
|
|
|
assert_eq!(
|
|
second_response.status(),
|
|
reqwest::StatusCode::TOO_MANY_REQUESTS
|
|
);
|
|
assert!(second_response.headers().get(header::RETRY_AFTER).is_some());
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn get_requires_session_header() {
|
|
let registry = test_registry().await;
|
|
publish_agent_with_bindings(®istry, "sales-get-sse-missing", vec![]).await;
|
|
let api_key = create_platform_api_key(
|
|
®istry,
|
|
"sales-get-sse-missing",
|
|
"mcp-get-sse-missing",
|
|
&[PlatformApiKeyScope::Read],
|
|
)
|
|
.await;
|
|
let base_url = spawn_mcp_server(build_test_app(
|
|
registry,
|
|
Duration::from_millis(0),
|
|
Some("https://crank.example.com".to_owned()),
|
|
))
|
|
.await;
|
|
let client = reqwest::Client::new();
|
|
|
|
let response = client
|
|
.get(agent_mcp_url(&base_url, "sales-get-sse-missing"))
|
|
.header(header::ACCEPT, "text/event-stream")
|
|
.header(header::AUTHORIZATION, format!("Bearer {api_key}"))
|
|
.header("x-request-id", "req_early_mcp_error")
|
|
.send()
|
|
.await
|
|
.unwrap();
|
|
|
|
assert_eq!(response.status(), reqwest::StatusCode::BAD_REQUEST);
|
|
assert_eq!(
|
|
response.headers()["x-request-id"].to_str().unwrap(),
|
|
"req_early_mcp_error"
|
|
);
|
|
|
|
let invalid_response = client
|
|
.get(agent_mcp_url(&base_url, "sales-get-sse-missing"))
|
|
.header(header::ACCEPT, "text/event-stream")
|
|
.header(header::AUTHORIZATION, format!("Bearer {api_key}"))
|
|
.header("x-request-id", "bad,value")
|
|
.send()
|
|
.await
|
|
.unwrap();
|
|
let generated = invalid_response.headers()["x-request-id"].to_str().unwrap();
|
|
assert_eq!(
|
|
uuid::Uuid::parse_str(generated).unwrap().get_version(),
|
|
Some(Version::SortRand)
|
|
);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn delete_terminates_transport_session() {
|
|
let registry = test_registry().await;
|
|
publish_agent_with_bindings(®istry, "sales-delete-session", vec![]).await;
|
|
let api_key = create_platform_api_key(
|
|
®istry,
|
|
"sales-delete-session",
|
|
"mcp-delete-session",
|
|
&[PlatformApiKeyScope::Read],
|
|
)
|
|
.await;
|
|
let base_url = spawn_mcp_server(build_test_app(
|
|
registry,
|
|
Duration::from_millis(0),
|
|
Some("https://crank.example.com".to_owned()),
|
|
))
|
|
.await;
|
|
let client = reqwest::Client::new();
|
|
let mcp_url = agent_mcp_url(&base_url, "sales-delete-session");
|
|
let initialized_session = initialize_session(&client, &mcp_url, &api_key).await;
|
|
|
|
let delete_response = client
|
|
.delete(&mcp_url)
|
|
.header(header::AUTHORIZATION, format!("Bearer {api_key}"))
|
|
.header("MCP-Session-Id", &initialized_session)
|
|
.header("MCP-Protocol-Version", "2025-11-25")
|
|
.send()
|
|
.await
|
|
.unwrap();
|
|
|
|
assert_eq!(delete_response.status(), reqwest::StatusCode::NO_CONTENT);
|
|
|
|
let after_delete = client
|
|
.get(&mcp_url)
|
|
.header(header::ACCEPT, "text/event-stream")
|
|
.header(header::AUTHORIZATION, format!("Bearer {api_key}"))
|
|
.header("MCP-Session-Id", &initialized_session)
|
|
.header("MCP-Protocol-Version", "2025-11-25")
|
|
.send()
|
|
.await
|
|
.unwrap();
|
|
|
|
assert_eq!(after_delete.status(), reqwest::StatusCode::NOT_FOUND);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn initialize_accepts_json_only_response_negotiation() {
|
|
let registry = test_registry().await;
|
|
publish_agent_with_bindings(®istry, "sales-json-accept", vec![]).await;
|
|
let api_key = create_platform_api_key(
|
|
®istry,
|
|
"sales-json-accept",
|
|
"mcp-json-accept",
|
|
&[PlatformApiKeyScope::Read],
|
|
)
|
|
.await;
|
|
let base_url = spawn_mcp_server(build_test_app(
|
|
registry,
|
|
Duration::from_millis(0),
|
|
Some("https://crank.example.com".to_owned()),
|
|
))
|
|
.await;
|
|
let client = reqwest::Client::new();
|
|
let response = client
|
|
.post(agent_mcp_url(&base_url, "sales-json-accept"))
|
|
.header(header::ACCEPT, "application/json")
|
|
.header(header::AUTHORIZATION, format!("Bearer {api_key}"))
|
|
.json(&json!({
|
|
"jsonrpc": "2.0",
|
|
"id": 1,
|
|
"method": "initialize",
|
|
"params": {
|
|
"protocolVersion": "2025-11-25"
|
|
}
|
|
}))
|
|
.send()
|
|
.await
|
|
.unwrap();
|
|
|
|
assert_eq!(response.status(), reqwest::StatusCode::OK);
|
|
assert_eq!(
|
|
response
|
|
.headers()
|
|
.get(header::CONTENT_TYPE)
|
|
.and_then(|value| value.to_str().ok())
|
|
.unwrap(),
|
|
"application/json"
|
|
);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn rejects_get_with_protocol_version_mismatch() {
|
|
let registry = test_registry().await;
|
|
publish_agent_with_bindings(®istry, "sales-get-bad-version", vec![]).await;
|
|
let api_key = create_platform_api_key(
|
|
®istry,
|
|
"sales-get-bad-version",
|
|
"mcp-get-bad-version",
|
|
&[PlatformApiKeyScope::Read],
|
|
)
|
|
.await;
|
|
let base_url = spawn_mcp_server(build_test_app(
|
|
registry,
|
|
Duration::from_millis(0),
|
|
Some("https://crank.example.com".to_owned()),
|
|
))
|
|
.await;
|
|
let client = reqwest::Client::new();
|
|
let mcp_url = agent_mcp_url(&base_url, "sales-get-bad-version");
|
|
let initialized_session = initialize_session(&client, &mcp_url, &api_key).await;
|
|
|
|
let response = client
|
|
.get(&mcp_url)
|
|
.header(header::ACCEPT, "text/event-stream")
|
|
.header(header::AUTHORIZATION, format!("Bearer {api_key}"))
|
|
.header("MCP-Session-Id", &initialized_session)
|
|
.header("MCP-Protocol-Version", "2025-06-18")
|
|
.send()
|
|
.await
|
|
.unwrap();
|
|
|
|
assert_eq!(response.status(), reqwest::StatusCode::BAD_REQUEST);
|
|
}
|