Add OpenAPI spec generation via utoipa with /openapi.json endpoint
Integrate utoipa 5 to auto-generate an OpenAPI 3.1 spec from the existing
Axum handlers and serde types. All 16 endpoints are annotated with path
metadata, request/response schemas, security requirements, and tags. A
public /openapi.json endpoint serves the spec without requiring auth.
Includes 59 tests covering path completeness, HTTP methods, schema fields,
enum variants, security scheme, path/query parameters, request bodies,
response references, and endpoint integration.
https://claude.ai/code/session_01NfoPVx21rZUQned1f7WpXY
2026-04-11 13:11:14 +00:00
|
|
|
use std::collections::HashSet;
|
|
|
|
|
use std::env;
|
|
|
|
|
use std::fs;
|
|
|
|
|
use std::path::{Path, PathBuf};
|
|
|
|
|
|
|
|
|
|
use axum::Router;
|
|
|
|
|
use axum::body::{Body, to_bytes};
|
|
|
|
|
use axum::http::{Method, Request, StatusCode};
|
|
|
|
|
use omnigraph::db::Omnigraph;
|
|
|
|
|
use omnigraph::loader::{LoadMode, load_jsonl};
|
|
|
|
|
use omnigraph_server::{ApiDoc, AppState, build_app};
|
|
|
|
|
use serde_json::Value;
|
|
|
|
|
use tower::ServiceExt;
|
|
|
|
|
use utoipa::OpenApi;
|
|
|
|
|
|
|
|
|
|
fn fixture(name: &str) -> PathBuf {
|
|
|
|
|
PathBuf::from(env!("CARGO_MANIFEST_DIR"))
|
|
|
|
|
.join("../omnigraph/tests/fixtures")
|
|
|
|
|
.join(name)
|
|
|
|
|
}
|
|
|
|
|
|
2026-05-24 16:46:00 +01:00
|
|
|
fn graph_path(root: &Path) -> PathBuf {
|
Add OpenAPI spec generation via utoipa with /openapi.json endpoint
Integrate utoipa 5 to auto-generate an OpenAPI 3.1 spec from the existing
Axum handlers and serde types. All 16 endpoints are annotated with path
metadata, request/response schemas, security requirements, and tags. A
public /openapi.json endpoint serves the spec without requiring auth.
Includes 59 tests covering path completeness, HTTP methods, schema fields,
enum variants, security scheme, path/query parameters, request bodies,
response references, and endpoint integration.
https://claude.ai/code/session_01NfoPVx21rZUQned1f7WpXY
2026-04-11 13:11:14 +00:00
|
|
|
root.join("openapi_test.omni")
|
|
|
|
|
}
|
|
|
|
|
|
2026-05-24 16:46:00 +01:00
|
|
|
async fn init_loaded_graph() -> tempfile::TempDir {
|
Add OpenAPI spec generation via utoipa with /openapi.json endpoint
Integrate utoipa 5 to auto-generate an OpenAPI 3.1 spec from the existing
Axum handlers and serde types. All 16 endpoints are annotated with path
metadata, request/response schemas, security requirements, and tags. A
public /openapi.json endpoint serves the spec without requiring auth.
Includes 59 tests covering path completeness, HTTP methods, schema fields,
enum variants, security scheme, path/query parameters, request bodies,
response references, and endpoint integration.
https://claude.ai/code/session_01NfoPVx21rZUQned1f7WpXY
2026-04-11 13:11:14 +00:00
|
|
|
let temp = tempfile::tempdir().unwrap();
|
2026-05-24 16:46:00 +01:00
|
|
|
let graph = graph_path(temp.path());
|
|
|
|
|
fs::create_dir_all(&graph).unwrap();
|
Add OpenAPI spec generation via utoipa with /openapi.json endpoint
Integrate utoipa 5 to auto-generate an OpenAPI 3.1 spec from the existing
Axum handlers and serde types. All 16 endpoints are annotated with path
metadata, request/response schemas, security requirements, and tags. A
public /openapi.json endpoint serves the spec without requiring auth.
Includes 59 tests covering path completeness, HTTP methods, schema fields,
enum variants, security scheme, path/query parameters, request bodies,
response references, and endpoint integration.
https://claude.ai/code/session_01NfoPVx21rZUQned1f7WpXY
2026-04-11 13:11:14 +00:00
|
|
|
let schema = fs::read_to_string(fixture("test.pg")).unwrap();
|
|
|
|
|
let data = fs::read_to_string(fixture("test.jsonl")).unwrap();
|
2026-05-24 16:46:00 +01:00
|
|
|
Omnigraph::init(graph.to_str().unwrap(), &schema)
|
Add OpenAPI spec generation via utoipa with /openapi.json endpoint
Integrate utoipa 5 to auto-generate an OpenAPI 3.1 spec from the existing
Axum handlers and serde types. All 16 endpoints are annotated with path
metadata, request/response schemas, security requirements, and tags. A
public /openapi.json endpoint serves the spec without requiring auth.
Includes 59 tests covering path completeness, HTTP methods, schema fields,
enum variants, security scheme, path/query parameters, request bodies,
response references, and endpoint integration.
https://claude.ai/code/session_01NfoPVx21rZUQned1f7WpXY
2026-04-11 13:11:14 +00:00
|
|
|
.await
|
|
|
|
|
.unwrap();
|
2026-05-24 16:46:00 +01:00
|
|
|
let mut db = Omnigraph::open(graph.to_str().unwrap()).await.unwrap();
|
Add OpenAPI spec generation via utoipa with /openapi.json endpoint
Integrate utoipa 5 to auto-generate an OpenAPI 3.1 spec from the existing
Axum handlers and serde types. All 16 endpoints are annotated with path
metadata, request/response schemas, security requirements, and tags. A
public /openapi.json endpoint serves the spec without requiring auth.
Includes 59 tests covering path completeness, HTTP methods, schema fields,
enum variants, security scheme, path/query parameters, request bodies,
response references, and endpoint integration.
https://claude.ai/code/session_01NfoPVx21rZUQned1f7WpXY
2026-04-11 13:11:14 +00:00
|
|
|
load_jsonl(&mut db, &data, LoadMode::Overwrite)
|
|
|
|
|
.await
|
|
|
|
|
.unwrap();
|
|
|
|
|
temp
|
|
|
|
|
}
|
|
|
|
|
|
2026-05-24 16:46:00 +01:00
|
|
|
async fn app_for_loaded_graph() -> (tempfile::TempDir, Router) {
|
|
|
|
|
let temp = init_loaded_graph().await;
|
|
|
|
|
let graph = graph_path(temp.path());
|
|
|
|
|
let state = AppState::open(graph.to_string_lossy().to_string())
|
Add OpenAPI spec generation via utoipa with /openapi.json endpoint
Integrate utoipa 5 to auto-generate an OpenAPI 3.1 spec from the existing
Axum handlers and serde types. All 16 endpoints are annotated with path
metadata, request/response schemas, security requirements, and tags. A
public /openapi.json endpoint serves the spec without requiring auth.
Includes 59 tests covering path completeness, HTTP methods, schema fields,
enum variants, security scheme, path/query parameters, request bodies,
response references, and endpoint integration.
https://claude.ai/code/session_01NfoPVx21rZUQned1f7WpXY
2026-04-11 13:11:14 +00:00
|
|
|
.await
|
|
|
|
|
.unwrap();
|
|
|
|
|
let app = build_app(state);
|
|
|
|
|
(temp, app)
|
|
|
|
|
}
|
|
|
|
|
|
2026-05-24 16:46:00 +01:00
|
|
|
async fn app_for_loaded_graph_with_auth(token: &str) -> (tempfile::TempDir, Router) {
|
|
|
|
|
let temp = init_loaded_graph().await;
|
|
|
|
|
let graph = graph_path(temp.path());
|
|
|
|
|
let db = Omnigraph::open(graph.to_str().unwrap()).await.unwrap();
|
2026-04-11 16:31:48 +00:00
|
|
|
let state = AppState::new_with_bearer_token(
|
2026-05-24 16:46:00 +01:00
|
|
|
graph.to_string_lossy().to_string(),
|
2026-04-11 16:31:48 +00:00
|
|
|
db,
|
|
|
|
|
Some(token.to_string()),
|
|
|
|
|
);
|
|
|
|
|
let app = build_app(state);
|
|
|
|
|
(temp, app)
|
|
|
|
|
}
|
|
|
|
|
|
Add OpenAPI spec generation via utoipa with /openapi.json endpoint
Integrate utoipa 5 to auto-generate an OpenAPI 3.1 spec from the existing
Axum handlers and serde types. All 16 endpoints are annotated with path
metadata, request/response schemas, security requirements, and tags. A
public /openapi.json endpoint serves the spec without requiring auth.
Includes 59 tests covering path completeness, HTTP methods, schema fields,
enum variants, security scheme, path/query parameters, request bodies,
response references, and endpoint integration.
https://claude.ai/code/session_01NfoPVx21rZUQned1f7WpXY
2026-04-11 13:11:14 +00:00
|
|
|
async fn json_response(app: &Router, request: Request<Body>) -> (StatusCode, Value) {
|
|
|
|
|
let response = app.clone().oneshot(request).await.unwrap();
|
|
|
|
|
let status = response.status();
|
|
|
|
|
let body = to_bytes(response.into_body(), usize::MAX).await.unwrap();
|
|
|
|
|
let json: Value = serde_json::from_slice(&body).unwrap();
|
|
|
|
|
(status, json)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fn openapi_doc() -> utoipa::openapi::OpenApi {
|
|
|
|
|
ApiDoc::openapi()
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fn openapi_json() -> Value {
|
|
|
|
|
serde_json::to_value(openapi_doc()).unwrap()
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
|
// Endpoint integration tests
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
|
|
|
|
|
|
#[tokio::test]
|
|
|
|
|
async fn openapi_endpoint_returns_200_with_valid_json() {
|
2026-05-24 16:46:00 +01:00
|
|
|
let (_temp, app) = app_for_loaded_graph().await;
|
Add OpenAPI spec generation via utoipa with /openapi.json endpoint
Integrate utoipa 5 to auto-generate an OpenAPI 3.1 spec from the existing
Axum handlers and serde types. All 16 endpoints are annotated with path
metadata, request/response schemas, security requirements, and tags. A
public /openapi.json endpoint serves the spec without requiring auth.
Includes 59 tests covering path completeness, HTTP methods, schema fields,
enum variants, security scheme, path/query parameters, request bodies,
response references, and endpoint integration.
https://claude.ai/code/session_01NfoPVx21rZUQned1f7WpXY
2026-04-11 13:11:14 +00:00
|
|
|
let request = Request::builder()
|
|
|
|
|
.method(Method::GET)
|
|
|
|
|
.uri("/openapi.json")
|
|
|
|
|
.body(Body::empty())
|
|
|
|
|
.unwrap();
|
|
|
|
|
let (status, json) = json_response(&app, request).await;
|
|
|
|
|
assert_eq!(status, StatusCode::OK);
|
|
|
|
|
assert!(json.is_object(), "response must be a JSON object");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[tokio::test]
|
|
|
|
|
async fn openapi_endpoint_returns_openapi_31_version() {
|
2026-05-24 16:46:00 +01:00
|
|
|
let (_temp, app) = app_for_loaded_graph().await;
|
Add OpenAPI spec generation via utoipa with /openapi.json endpoint
Integrate utoipa 5 to auto-generate an OpenAPI 3.1 spec from the existing
Axum handlers and serde types. All 16 endpoints are annotated with path
metadata, request/response schemas, security requirements, and tags. A
public /openapi.json endpoint serves the spec without requiring auth.
Includes 59 tests covering path completeness, HTTP methods, schema fields,
enum variants, security scheme, path/query parameters, request bodies,
response references, and endpoint integration.
https://claude.ai/code/session_01NfoPVx21rZUQned1f7WpXY
2026-04-11 13:11:14 +00:00
|
|
|
let request = Request::builder()
|
|
|
|
|
.method(Method::GET)
|
|
|
|
|
.uri("/openapi.json")
|
|
|
|
|
.body(Body::empty())
|
|
|
|
|
.unwrap();
|
|
|
|
|
let (_, json) = json_response(&app, request).await;
|
|
|
|
|
let version = json["openapi"].as_str().unwrap();
|
|
|
|
|
assert!(
|
|
|
|
|
version.starts_with("3.1"),
|
|
|
|
|
"expected OpenAPI 3.1.x, got {version}"
|
|
|
|
|
);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[tokio::test]
|
|
|
|
|
async fn openapi_endpoint_does_not_require_auth() {
|
2026-05-24 16:46:00 +01:00
|
|
|
let temp = init_loaded_graph().await;
|
|
|
|
|
let graph = graph_path(temp.path());
|
|
|
|
|
let db = Omnigraph::open(graph.to_str().unwrap()).await.unwrap();
|
Add OpenAPI spec generation via utoipa with /openapi.json endpoint
Integrate utoipa 5 to auto-generate an OpenAPI 3.1 spec from the existing
Axum handlers and serde types. All 16 endpoints are annotated with path
metadata, request/response schemas, security requirements, and tags. A
public /openapi.json endpoint serves the spec without requiring auth.
Includes 59 tests covering path completeness, HTTP methods, schema fields,
enum variants, security scheme, path/query parameters, request bodies,
response references, and endpoint integration.
https://claude.ai/code/session_01NfoPVx21rZUQned1f7WpXY
2026-04-11 13:11:14 +00:00
|
|
|
let state = AppState::new_with_bearer_token(
|
2026-05-24 16:46:00 +01:00
|
|
|
graph.to_string_lossy().to_string(),
|
Add OpenAPI spec generation via utoipa with /openapi.json endpoint
Integrate utoipa 5 to auto-generate an OpenAPI 3.1 spec from the existing
Axum handlers and serde types. All 16 endpoints are annotated with path
metadata, request/response schemas, security requirements, and tags. A
public /openapi.json endpoint serves the spec without requiring auth.
Includes 59 tests covering path completeness, HTTP methods, schema fields,
enum variants, security scheme, path/query parameters, request bodies,
response references, and endpoint integration.
https://claude.ai/code/session_01NfoPVx21rZUQned1f7WpXY
2026-04-11 13:11:14 +00:00
|
|
|
db,
|
|
|
|
|
Some("secret-token".to_string()),
|
|
|
|
|
);
|
|
|
|
|
let app = build_app(state);
|
|
|
|
|
|
|
|
|
|
let request = Request::builder()
|
|
|
|
|
.method(Method::GET)
|
|
|
|
|
.uri("/openapi.json")
|
|
|
|
|
.body(Body::empty())
|
|
|
|
|
.unwrap();
|
|
|
|
|
let (status, _) = json_response(&app, request).await;
|
2026-05-24 16:46:00 +01:00
|
|
|
assert_eq!(
|
|
|
|
|
status,
|
|
|
|
|
StatusCode::OK,
|
|
|
|
|
"/openapi.json should not require auth"
|
|
|
|
|
);
|
Add OpenAPI spec generation via utoipa with /openapi.json endpoint
Integrate utoipa 5 to auto-generate an OpenAPI 3.1 spec from the existing
Axum handlers and serde types. All 16 endpoints are annotated with path
metadata, request/response schemas, security requirements, and tags. A
public /openapi.json endpoint serves the spec without requiring auth.
Includes 59 tests covering path completeness, HTTP methods, schema fields,
enum variants, security scheme, path/query parameters, request bodies,
response references, and endpoint integration.
https://claude.ai/code/session_01NfoPVx21rZUQned1f7WpXY
2026-04-11 13:11:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
|
// Info and metadata tests
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
|
fn openapi_info_contains_title_and_description() {
|
|
|
|
|
let doc = openapi_json();
|
|
|
|
|
let info = &doc["info"];
|
|
|
|
|
assert_eq!(info["title"].as_str().unwrap(), "Omnigraph API");
|
|
|
|
|
assert!(info["description"].as_str().unwrap().contains("Omnigraph"));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
|
fn openapi_info_contains_version() {
|
|
|
|
|
let doc = openapi_json();
|
|
|
|
|
let version = doc["info"]["version"].as_str().unwrap();
|
|
|
|
|
assert!(!version.is_empty(), "version must not be empty");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
|
// Path coverage tests
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
|
|
|
|
|
|
const EXPECTED_PATHS: &[&str] = &[
|
|
|
|
|
"/healthz",
|
mr-668: GET /graphs endpoint + per-graph policy wire-up (PR 6b/10)
PR 6b of the MR-668 multi-graph server work. First management endpoint —
`GET /graphs` lists every graph registered with the server, gated by the
server-level Cedar policy from PR 6a.
New API shapes (in `omnigraph-server::api`):
- `GraphInfo { graph_id, uri }` — one entry per registered graph.
- `GraphListResponse { graphs: Vec<GraphInfo> }` — sorted alphabetically
by `graph_id` for deterministic output.
Handler `server_graphs_list`:
- Mounted at `GET /graphs` in both modes.
- Single mode: returns 405 (resource exists in the API surface, just
not operational without a `graphs:` map). 405 chosen over 404 so
clients see "resource exists, wrong context" rather than "no such
resource".
- Multi mode: requires bearer auth (when configured); Cedar-gated by
`PolicyAction::GraphList` against `Omnigraph::Server::"root"`
(PR 6a's chassis). Returns the sorted registry list.
Cedar gate composition:
- When no `server.policy.file` is configured, the MR-723 default-deny
falls through: `GraphList` is not `Read`, so an authenticated actor
without a server policy gets 403. This is the right default — don't
expose the registry until the operator explicitly authorizes it.
- When a server policy is configured, Cedar evaluates the rule. The
test `get_graphs_with_server_policy_authorizes_per_cedar` pins the
admin-allow / viewer-deny split.
Routing:
- New `management` sub-router holding `/graphs` (auth-required, no
`resolve_graph_handle` middleware — operates on the registry, not
a single graph).
- Single mode merges flat protected routes + management.
- Multi mode merges nested `/graphs/{graph_id}/...` + management.
OpenAPI:
- `server_graphs_list` registered in `ApiDoc::paths(...)`.
- `EXPECTED_PATHS` in `tests/openapi.rs` gains `/graphs`.
- `openapi.json` regenerated (auto-tracked by
`openapi_spec_is_up_to_date` in CI).
Tests: 4 new in `tests/server.rs::multi_graph_startup`:
- `get_graphs_lists_registered_graphs_in_multi_mode`
- `get_graphs_returns_405_in_single_mode`
- `get_graphs_requires_bearer_auth_when_configured`
- `get_graphs_with_server_policy_authorizes_per_cedar`
What's NOT in this PR (deferred):
- Per-graph policy enforcement is wired through `handle.policy`
(PR 4a already did this); PR 6b doesn't add new per-graph
behavior beyond making sure the server policy lookup composes
cleanly alongside it.
- `POST /graphs` (PR 7) and `DELETE /graphs/{id}` (out of scope
for v0.7.0).
- CLI `omnigraph graphs list` (PR 8 will add).
Result: 215 server tests green (74 lib + 66 openapi + 75 integration),
11 policy tests green. MR-731 spoof regression preserved across all
this work.
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
2026-05-25 20:24:52 +02:00
|
|
|
"/graphs",
|
Add OpenAPI spec generation via utoipa with /openapi.json endpoint
Integrate utoipa 5 to auto-generate an OpenAPI 3.1 spec from the existing
Axum handlers and serde types. All 16 endpoints are annotated with path
metadata, request/response schemas, security requirements, and tags. A
public /openapi.json endpoint serves the spec without requiring auth.
Includes 59 tests covering path completeness, HTTP methods, schema fields,
enum variants, security scheme, path/query parameters, request bodies,
response references, and endpoint integration.
https://claude.ai/code/session_01NfoPVx21rZUQned1f7WpXY
2026-04-11 13:11:14 +00:00
|
|
|
"/snapshot",
|
|
|
|
|
"/read",
|
|
|
|
|
"/export",
|
|
|
|
|
"/change",
|
2026-04-16 21:15:17 +00:00
|
|
|
"/schema",
|
Add OpenAPI spec generation via utoipa with /openapi.json endpoint
Integrate utoipa 5 to auto-generate an OpenAPI 3.1 spec from the existing
Axum handlers and serde types. All 16 endpoints are annotated with path
metadata, request/response schemas, security requirements, and tags. A
public /openapi.json endpoint serves the spec without requiring auth.
Includes 59 tests covering path completeness, HTTP methods, schema fields,
enum variants, security scheme, path/query parameters, request bodies,
response references, and endpoint integration.
https://claude.ai/code/session_01NfoPVx21rZUQned1f7WpXY
2026-04-11 13:11:14 +00:00
|
|
|
"/schema/apply",
|
|
|
|
|
"/ingest",
|
|
|
|
|
"/branches",
|
|
|
|
|
"/branches/{branch}",
|
|
|
|
|
"/branches/merge",
|
|
|
|
|
"/commits",
|
|
|
|
|
"/commits/{commit_id}",
|
|
|
|
|
];
|
|
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
|
fn openapi_contains_all_expected_paths() {
|
|
|
|
|
let doc = openapi_json();
|
|
|
|
|
let paths = doc["paths"].as_object().expect("paths must be an object");
|
|
|
|
|
let path_keys: HashSet<&str> = paths.keys().map(|k| k.as_str()).collect();
|
|
|
|
|
|
|
|
|
|
for expected in EXPECTED_PATHS {
|
|
|
|
|
assert!(
|
|
|
|
|
path_keys.contains(expected),
|
|
|
|
|
"missing path: {expected}. Found: {path_keys:?}"
|
|
|
|
|
);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
|
fn openapi_has_no_unexpected_paths() {
|
|
|
|
|
let doc = openapi_json();
|
|
|
|
|
let paths = doc["paths"].as_object().expect("paths must be an object");
|
|
|
|
|
let expected: HashSet<&str> = EXPECTED_PATHS.iter().copied().collect();
|
|
|
|
|
|
|
|
|
|
for path in paths.keys() {
|
|
|
|
|
assert!(
|
|
|
|
|
expected.contains(path.as_str()),
|
|
|
|
|
"unexpected path in OpenAPI spec: {path}"
|
|
|
|
|
);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
|
// HTTP method tests
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
|
fn openapi_healthz_is_get() {
|
|
|
|
|
let doc = openapi_json();
|
|
|
|
|
assert!(doc["paths"]["/healthz"]["get"].is_object());
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
|
fn openapi_read_is_post() {
|
|
|
|
|
let doc = openapi_json();
|
|
|
|
|
assert!(doc["paths"]["/read"]["post"].is_object());
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
|
fn openapi_export_is_post() {
|
|
|
|
|
let doc = openapi_json();
|
|
|
|
|
assert!(doc["paths"]["/export"]["post"].is_object());
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
|
fn openapi_change_is_post() {
|
|
|
|
|
let doc = openapi_json();
|
|
|
|
|
assert!(doc["paths"]["/change"]["post"].is_object());
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
|
fn openapi_ingest_is_post() {
|
|
|
|
|
let doc = openapi_json();
|
|
|
|
|
assert!(doc["paths"]["/ingest"]["post"].is_object());
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
|
fn openapi_branches_supports_get_and_post() {
|
|
|
|
|
let doc = openapi_json();
|
|
|
|
|
assert!(doc["paths"]["/branches"]["get"].is_object());
|
|
|
|
|
assert!(doc["paths"]["/branches"]["post"].is_object());
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
|
fn openapi_branch_delete_is_delete() {
|
|
|
|
|
let doc = openapi_json();
|
|
|
|
|
assert!(doc["paths"]["/branches/{branch}"]["delete"].is_object());
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
|
fn openapi_branch_merge_is_post() {
|
|
|
|
|
let doc = openapi_json();
|
|
|
|
|
assert!(doc["paths"]["/branches/merge"]["post"].is_object());
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
|
fn openapi_commits_is_get() {
|
|
|
|
|
let doc = openapi_json();
|
|
|
|
|
assert!(doc["paths"]["/commits"]["get"].is_object());
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
|
fn openapi_commit_show_is_get() {
|
|
|
|
|
let doc = openapi_json();
|
|
|
|
|
assert!(doc["paths"]["/commits/{commit_id}"]["get"].is_object());
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
|
// Schema coverage tests
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
|
|
|
|
|
|
const EXPECTED_SCHEMAS: &[&str] = &[
|
|
|
|
|
"BranchCreateOutput",
|
|
|
|
|
"BranchCreateRequest",
|
|
|
|
|
"BranchDeleteOutput",
|
|
|
|
|
"BranchListOutput",
|
|
|
|
|
"BranchMergeOutcome",
|
|
|
|
|
"BranchMergeOutput",
|
|
|
|
|
"BranchMergeRequest",
|
|
|
|
|
"ChangeOutput",
|
|
|
|
|
"ChangeRequest",
|
|
|
|
|
"CommitListOutput",
|
|
|
|
|
"CommitOutput",
|
|
|
|
|
"ErrorCode",
|
|
|
|
|
"ErrorOutput",
|
|
|
|
|
"ExportRequest",
|
|
|
|
|
"HealthOutput",
|
|
|
|
|
"IngestOutput",
|
|
|
|
|
"IngestRequest",
|
|
|
|
|
"IngestTableOutput",
|
|
|
|
|
"LoadMode",
|
|
|
|
|
"MergeConflictKindOutput",
|
|
|
|
|
"MergeConflictOutput",
|
|
|
|
|
"ReadOutput",
|
|
|
|
|
"ReadRequest",
|
|
|
|
|
"ReadTargetOutput",
|
2026-04-30 08:52:50 +02:00
|
|
|
"ManifestConflictOutput",
|
Add OpenAPI spec generation via utoipa with /openapi.json endpoint
Integrate utoipa 5 to auto-generate an OpenAPI 3.1 spec from the existing
Axum handlers and serde types. All 16 endpoints are annotated with path
metadata, request/response schemas, security requirements, and tags. A
public /openapi.json endpoint serves the spec without requiring auth.
Includes 59 tests covering path completeness, HTTP methods, schema fields,
enum variants, security scheme, path/query parameters, request bodies,
response references, and endpoint integration.
https://claude.ai/code/session_01NfoPVx21rZUQned1f7WpXY
2026-04-11 13:11:14 +00:00
|
|
|
"SchemaApplyOutput",
|
|
|
|
|
"SchemaApplyRequest",
|
|
|
|
|
"SnapshotOutput",
|
|
|
|
|
"SnapshotTableOutput",
|
|
|
|
|
];
|
|
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
|
fn openapi_contains_all_expected_schemas() {
|
|
|
|
|
let doc = openapi_json();
|
|
|
|
|
let schemas = doc["components"]["schemas"]
|
|
|
|
|
.as_object()
|
|
|
|
|
.expect("schemas must be an object");
|
|
|
|
|
let schema_keys: HashSet<&str> = schemas.keys().map(|k| k.as_str()).collect();
|
|
|
|
|
|
|
|
|
|
for expected in EXPECTED_SCHEMAS {
|
|
|
|
|
assert!(
|
|
|
|
|
schema_keys.contains(expected),
|
|
|
|
|
"missing schema: {expected}. Found: {schema_keys:?}"
|
|
|
|
|
);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
|
// Schema field validation tests
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
|
fn health_output_schema_has_expected_fields() {
|
|
|
|
|
let doc = openapi_json();
|
|
|
|
|
let schema = &doc["components"]["schemas"]["HealthOutput"];
|
|
|
|
|
let props = schema["properties"].as_object().unwrap();
|
|
|
|
|
assert!(props.contains_key("status"));
|
|
|
|
|
assert!(props.contains_key("version"));
|
|
|
|
|
assert!(props.contains_key("source_version"));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
|
fn read_request_schema_has_expected_fields() {
|
|
|
|
|
let doc = openapi_json();
|
|
|
|
|
let schema = &doc["components"]["schemas"]["ReadRequest"];
|
|
|
|
|
let props = schema["properties"].as_object().unwrap();
|
|
|
|
|
assert!(props.contains_key("query_source"));
|
|
|
|
|
assert!(props.contains_key("query_name"));
|
|
|
|
|
assert!(props.contains_key("params"));
|
|
|
|
|
assert!(props.contains_key("branch"));
|
|
|
|
|
assert!(props.contains_key("snapshot"));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
|
fn read_request_query_source_is_required() {
|
|
|
|
|
let doc = openapi_json();
|
|
|
|
|
let schema = &doc["components"]["schemas"]["ReadRequest"];
|
|
|
|
|
let required: Vec<&str> = schema["required"]
|
|
|
|
|
.as_array()
|
|
|
|
|
.unwrap()
|
|
|
|
|
.iter()
|
|
|
|
|
.map(|v| v.as_str().unwrap())
|
|
|
|
|
.collect();
|
|
|
|
|
assert!(required.contains(&"query_source"));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
|
fn read_output_schema_has_expected_fields() {
|
|
|
|
|
let doc = openapi_json();
|
|
|
|
|
let schema = &doc["components"]["schemas"]["ReadOutput"];
|
|
|
|
|
let props = schema["properties"].as_object().unwrap();
|
|
|
|
|
assert!(props.contains_key("query_name"));
|
|
|
|
|
assert!(props.contains_key("target"));
|
|
|
|
|
assert!(props.contains_key("row_count"));
|
|
|
|
|
assert!(props.contains_key("rows"));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
|
fn change_request_schema_has_expected_fields() {
|
|
|
|
|
let doc = openapi_json();
|
|
|
|
|
let schema = &doc["components"]["schemas"]["ChangeRequest"];
|
|
|
|
|
let props = schema["properties"].as_object().unwrap();
|
|
|
|
|
assert!(props.contains_key("query_source"));
|
|
|
|
|
assert!(props.contains_key("query_name"));
|
|
|
|
|
assert!(props.contains_key("params"));
|
|
|
|
|
assert!(props.contains_key("branch"));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
|
fn change_output_schema_has_expected_fields() {
|
|
|
|
|
let doc = openapi_json();
|
|
|
|
|
let schema = &doc["components"]["schemas"]["ChangeOutput"];
|
|
|
|
|
let props = schema["properties"].as_object().unwrap();
|
|
|
|
|
assert!(props.contains_key("branch"));
|
|
|
|
|
assert!(props.contains_key("query_name"));
|
|
|
|
|
assert!(props.contains_key("affected_nodes"));
|
|
|
|
|
assert!(props.contains_key("affected_edges"));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
|
fn ingest_request_schema_has_expected_fields() {
|
|
|
|
|
let doc = openapi_json();
|
|
|
|
|
let schema = &doc["components"]["schemas"]["IngestRequest"];
|
|
|
|
|
let props = schema["properties"].as_object().unwrap();
|
|
|
|
|
assert!(props.contains_key("branch"));
|
|
|
|
|
assert!(props.contains_key("from"));
|
|
|
|
|
assert!(props.contains_key("mode"));
|
|
|
|
|
assert!(props.contains_key("data"));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
|
fn ingest_output_schema_has_expected_fields() {
|
|
|
|
|
let doc = openapi_json();
|
|
|
|
|
let schema = &doc["components"]["schemas"]["IngestOutput"];
|
|
|
|
|
let props = schema["properties"].as_object().unwrap();
|
|
|
|
|
assert!(props.contains_key("uri"));
|
|
|
|
|
assert!(props.contains_key("branch"));
|
|
|
|
|
assert!(props.contains_key("base_branch"));
|
|
|
|
|
assert!(props.contains_key("branch_created"));
|
|
|
|
|
assert!(props.contains_key("mode"));
|
|
|
|
|
assert!(props.contains_key("tables"));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
|
fn export_request_schema_has_expected_fields() {
|
|
|
|
|
let doc = openapi_json();
|
|
|
|
|
let schema = &doc["components"]["schemas"]["ExportRequest"];
|
|
|
|
|
let props = schema["properties"].as_object().unwrap();
|
|
|
|
|
assert!(props.contains_key("branch"));
|
|
|
|
|
assert!(props.contains_key("type_names"));
|
|
|
|
|
assert!(props.contains_key("table_keys"));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
|
fn branch_create_request_schema_has_expected_fields() {
|
|
|
|
|
let doc = openapi_json();
|
|
|
|
|
let schema = &doc["components"]["schemas"]["BranchCreateRequest"];
|
|
|
|
|
let props = schema["properties"].as_object().unwrap();
|
|
|
|
|
assert!(props.contains_key("from"));
|
|
|
|
|
assert!(props.contains_key("name"));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
|
fn branch_create_request_name_is_required() {
|
|
|
|
|
let doc = openapi_json();
|
|
|
|
|
let schema = &doc["components"]["schemas"]["BranchCreateRequest"];
|
|
|
|
|
let required: Vec<&str> = schema["required"]
|
|
|
|
|
.as_array()
|
|
|
|
|
.unwrap()
|
|
|
|
|
.iter()
|
|
|
|
|
.map(|v| v.as_str().unwrap())
|
|
|
|
|
.collect();
|
|
|
|
|
assert!(required.contains(&"name"));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
|
fn branch_merge_request_schema_has_expected_fields() {
|
|
|
|
|
let doc = openapi_json();
|
|
|
|
|
let schema = &doc["components"]["schemas"]["BranchMergeRequest"];
|
|
|
|
|
let props = schema["properties"].as_object().unwrap();
|
|
|
|
|
assert!(props.contains_key("source"));
|
|
|
|
|
assert!(props.contains_key("target"));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
|
fn error_output_schema_has_expected_fields() {
|
|
|
|
|
let doc = openapi_json();
|
|
|
|
|
let schema = &doc["components"]["schemas"]["ErrorOutput"];
|
|
|
|
|
let props = schema["properties"].as_object().unwrap();
|
|
|
|
|
assert!(props.contains_key("error"));
|
|
|
|
|
assert!(props.contains_key("code"));
|
|
|
|
|
assert!(props.contains_key("merge_conflicts"));
|
2026-04-30 08:52:50 +02:00
|
|
|
assert!(props.contains_key("manifest_conflict"));
|
Add OpenAPI spec generation via utoipa with /openapi.json endpoint
Integrate utoipa 5 to auto-generate an OpenAPI 3.1 spec from the existing
Axum handlers and serde types. All 16 endpoints are annotated with path
metadata, request/response schemas, security requirements, and tags. A
public /openapi.json endpoint serves the spec without requiring auth.
Includes 59 tests covering path completeness, HTTP methods, schema fields,
enum variants, security scheme, path/query parameters, request bodies,
response references, and endpoint integration.
https://claude.ai/code/session_01NfoPVx21rZUQned1f7WpXY
2026-04-11 13:11:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[test]
|
2026-04-30 08:52:50 +02:00
|
|
|
fn manifest_conflict_output_schema_has_expected_fields() {
|
Add OpenAPI spec generation via utoipa with /openapi.json endpoint
Integrate utoipa 5 to auto-generate an OpenAPI 3.1 spec from the existing
Axum handlers and serde types. All 16 endpoints are annotated with path
metadata, request/response schemas, security requirements, and tags. A
public /openapi.json endpoint serves the spec without requiring auth.
Includes 59 tests covering path completeness, HTTP methods, schema fields,
enum variants, security scheme, path/query parameters, request bodies,
response references, and endpoint integration.
https://claude.ai/code/session_01NfoPVx21rZUQned1f7WpXY
2026-04-11 13:11:14 +00:00
|
|
|
let doc = openapi_json();
|
2026-04-30 08:52:50 +02:00
|
|
|
let schema = &doc["components"]["schemas"]["ManifestConflictOutput"];
|
Add OpenAPI spec generation via utoipa with /openapi.json endpoint
Integrate utoipa 5 to auto-generate an OpenAPI 3.1 spec from the existing
Axum handlers and serde types. All 16 endpoints are annotated with path
metadata, request/response schemas, security requirements, and tags. A
public /openapi.json endpoint serves the spec without requiring auth.
Includes 59 tests covering path completeness, HTTP methods, schema fields,
enum variants, security scheme, path/query parameters, request bodies,
response references, and endpoint integration.
https://claude.ai/code/session_01NfoPVx21rZUQned1f7WpXY
2026-04-11 13:11:14 +00:00
|
|
|
let props = schema["properties"].as_object().unwrap();
|
2026-04-30 08:52:50 +02:00
|
|
|
assert!(props.contains_key("table_key"));
|
|
|
|
|
assert!(props.contains_key("expected"));
|
|
|
|
|
assert!(props.contains_key("actual"));
|
Add OpenAPI spec generation via utoipa with /openapi.json endpoint
Integrate utoipa 5 to auto-generate an OpenAPI 3.1 spec from the existing
Axum handlers and serde types. All 16 endpoints are annotated with path
metadata, request/response schemas, security requirements, and tags. A
public /openapi.json endpoint serves the spec without requiring auth.
Includes 59 tests covering path completeness, HTTP methods, schema fields,
enum variants, security scheme, path/query parameters, request bodies,
response references, and endpoint integration.
https://claude.ai/code/session_01NfoPVx21rZUQned1f7WpXY
2026-04-11 13:11:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
|
fn commit_output_schema_has_expected_fields() {
|
|
|
|
|
let doc = openapi_json();
|
|
|
|
|
let schema = &doc["components"]["schemas"]["CommitOutput"];
|
|
|
|
|
let props = schema["properties"].as_object().unwrap();
|
|
|
|
|
assert!(props.contains_key("graph_commit_id"));
|
|
|
|
|
assert!(props.contains_key("manifest_version"));
|
|
|
|
|
assert!(props.contains_key("parent_commit_id"));
|
|
|
|
|
assert!(props.contains_key("actor_id"));
|
|
|
|
|
assert!(props.contains_key("created_at"));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
|
fn snapshot_output_schema_has_expected_fields() {
|
|
|
|
|
let doc = openapi_json();
|
|
|
|
|
let schema = &doc["components"]["schemas"]["SnapshotOutput"];
|
|
|
|
|
let props = schema["properties"].as_object().unwrap();
|
|
|
|
|
assert!(props.contains_key("branch"));
|
|
|
|
|
assert!(props.contains_key("manifest_version"));
|
|
|
|
|
assert!(props.contains_key("tables"));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
|
fn snapshot_table_output_schema_has_expected_fields() {
|
|
|
|
|
let doc = openapi_json();
|
|
|
|
|
let schema = &doc["components"]["schemas"]["SnapshotTableOutput"];
|
|
|
|
|
let props = schema["properties"].as_object().unwrap();
|
|
|
|
|
assert!(props.contains_key("table_key"));
|
|
|
|
|
assert!(props.contains_key("table_path"));
|
|
|
|
|
assert!(props.contains_key("table_version"));
|
|
|
|
|
assert!(props.contains_key("row_count"));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
|
// Enum schema tests
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
|
fn load_mode_schema_has_three_variants() {
|
|
|
|
|
let doc = openapi_json();
|
|
|
|
|
let schema = &doc["components"]["schemas"]["LoadMode"];
|
|
|
|
|
let variants = schema["enum"].as_array().unwrap();
|
|
|
|
|
assert_eq!(variants.len(), 3);
|
|
|
|
|
let values: HashSet<&str> = variants.iter().map(|v| v.as_str().unwrap()).collect();
|
|
|
|
|
assert!(values.contains("overwrite"));
|
|
|
|
|
assert!(values.contains("append"));
|
|
|
|
|
assert!(values.contains("merge"));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
|
fn branch_merge_outcome_schema_has_three_variants() {
|
|
|
|
|
let doc = openapi_json();
|
|
|
|
|
let schema = &doc["components"]["schemas"]["BranchMergeOutcome"];
|
|
|
|
|
let variants = schema["enum"].as_array().unwrap();
|
|
|
|
|
assert_eq!(variants.len(), 3);
|
|
|
|
|
let values: HashSet<&str> = variants.iter().map(|v| v.as_str().unwrap()).collect();
|
|
|
|
|
assert!(values.contains("already_up_to_date"));
|
|
|
|
|
assert!(values.contains("fast_forward"));
|
|
|
|
|
assert!(values.contains("merged"));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
|
fn error_code_schema_has_expected_variants() {
|
|
|
|
|
let doc = openapi_json();
|
|
|
|
|
let schema = &doc["components"]["schemas"]["ErrorCode"];
|
|
|
|
|
let variants = schema["enum"].as_array().unwrap();
|
|
|
|
|
let values: HashSet<&str> = variants.iter().map(|v| v.as_str().unwrap()).collect();
|
|
|
|
|
assert!(values.contains("unauthorized"));
|
|
|
|
|
assert!(values.contains("forbidden"));
|
|
|
|
|
assert!(values.contains("bad_request"));
|
|
|
|
|
assert!(values.contains("not_found"));
|
|
|
|
|
assert!(values.contains("conflict"));
|
|
|
|
|
assert!(values.contains("internal"));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
|
fn merge_conflict_kind_output_schema_has_expected_variants() {
|
|
|
|
|
let doc = openapi_json();
|
|
|
|
|
let schema = &doc["components"]["schemas"]["MergeConflictKindOutput"];
|
|
|
|
|
let variants = schema["enum"].as_array().unwrap();
|
|
|
|
|
let values: HashSet<&str> = variants.iter().map(|v| v.as_str().unwrap()).collect();
|
|
|
|
|
assert!(values.contains("divergent_insert"));
|
|
|
|
|
assert!(values.contains("divergent_update"));
|
|
|
|
|
assert!(values.contains("delete_vs_update"));
|
|
|
|
|
assert!(values.contains("orphan_edge"));
|
|
|
|
|
assert!(values.contains("unique_violation"));
|
|
|
|
|
assert!(values.contains("cardinality_violation"));
|
|
|
|
|
assert!(values.contains("value_constraint_violation"));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
|
// Security scheme tests
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
|
fn openapi_defines_bearer_token_security_scheme() {
|
|
|
|
|
let doc = openapi_json();
|
|
|
|
|
let scheme = &doc["components"]["securitySchemes"]["bearer_token"];
|
|
|
|
|
assert_eq!(scheme["type"].as_str().unwrap(), "http");
|
|
|
|
|
assert_eq!(scheme["scheme"].as_str().unwrap(), "bearer");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
|
fn protected_endpoints_reference_bearer_token_security() {
|
|
|
|
|
let doc = openapi_json();
|
|
|
|
|
let protected_paths = [
|
|
|
|
|
("/read", "post"),
|
|
|
|
|
("/change", "post"),
|
|
|
|
|
("/schema/apply", "post"),
|
|
|
|
|
("/ingest", "post"),
|
|
|
|
|
("/export", "post"),
|
|
|
|
|
("/snapshot", "get"),
|
|
|
|
|
("/branches", "get"),
|
|
|
|
|
("/branches", "post"),
|
|
|
|
|
("/branches/{branch}", "delete"),
|
|
|
|
|
("/branches/merge", "post"),
|
|
|
|
|
("/commits", "get"),
|
|
|
|
|
("/commits/{commit_id}", "get"),
|
|
|
|
|
];
|
|
|
|
|
|
|
|
|
|
for (path, method) in protected_paths {
|
|
|
|
|
let operation = &doc["paths"][path][method];
|
|
|
|
|
let security = operation["security"]
|
|
|
|
|
.as_array()
|
|
|
|
|
.unwrap_or_else(|| panic!("no security on {method} {path}"));
|
|
|
|
|
let has_bearer = security
|
|
|
|
|
.iter()
|
|
|
|
|
.any(|s| s.as_object().unwrap().contains_key("bearer_token"));
|
|
|
|
|
assert!(has_bearer, "{method} {path} missing bearer_token security");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
|
fn healthz_does_not_require_security() {
|
|
|
|
|
let doc = openapi_json();
|
|
|
|
|
let healthz = &doc["paths"]["/healthz"]["get"];
|
|
|
|
|
assert!(
|
|
|
|
|
healthz.get("security").is_none() || healthz["security"].is_null(),
|
|
|
|
|
"/healthz should not have security requirements"
|
|
|
|
|
);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
|
// Path parameter tests
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
|
fn branch_delete_has_branch_path_parameter() {
|
|
|
|
|
let doc = openapi_json();
|
|
|
|
|
let params = doc["paths"]["/branches/{branch}"]["delete"]["parameters"]
|
|
|
|
|
.as_array()
|
|
|
|
|
.unwrap();
|
2026-05-24 16:46:00 +01:00
|
|
|
let has_branch = params
|
|
|
|
|
.iter()
|
|
|
|
|
.any(|p| p["name"].as_str() == Some("branch") && p["in"].as_str() == Some("path"));
|
|
|
|
|
assert!(
|
|
|
|
|
has_branch,
|
|
|
|
|
"DELETE /branches/{{branch}} must have 'branch' path parameter"
|
|
|
|
|
);
|
Add OpenAPI spec generation via utoipa with /openapi.json endpoint
Integrate utoipa 5 to auto-generate an OpenAPI 3.1 spec from the existing
Axum handlers and serde types. All 16 endpoints are annotated with path
metadata, request/response schemas, security requirements, and tags. A
public /openapi.json endpoint serves the spec without requiring auth.
Includes 59 tests covering path completeness, HTTP methods, schema fields,
enum variants, security scheme, path/query parameters, request bodies,
response references, and endpoint integration.
https://claude.ai/code/session_01NfoPVx21rZUQned1f7WpXY
2026-04-11 13:11:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
|
fn commit_show_has_commit_id_path_parameter() {
|
|
|
|
|
let doc = openapi_json();
|
|
|
|
|
let params = doc["paths"]["/commits/{commit_id}"]["get"]["parameters"]
|
|
|
|
|
.as_array()
|
|
|
|
|
.unwrap();
|
2026-05-24 16:46:00 +01:00
|
|
|
let has_commit_id = params
|
|
|
|
|
.iter()
|
|
|
|
|
.any(|p| p["name"].as_str() == Some("commit_id") && p["in"].as_str() == Some("path"));
|
|
|
|
|
assert!(
|
|
|
|
|
has_commit_id,
|
|
|
|
|
"GET /commits/{{commit_id}} must have 'commit_id' path parameter"
|
|
|
|
|
);
|
Add OpenAPI spec generation via utoipa with /openapi.json endpoint
Integrate utoipa 5 to auto-generate an OpenAPI 3.1 spec from the existing
Axum handlers and serde types. All 16 endpoints are annotated with path
metadata, request/response schemas, security requirements, and tags. A
public /openapi.json endpoint serves the spec without requiring auth.
Includes 59 tests covering path completeness, HTTP methods, schema fields,
enum variants, security scheme, path/query parameters, request bodies,
response references, and endpoint integration.
https://claude.ai/code/session_01NfoPVx21rZUQned1f7WpXY
2026-04-11 13:11:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
|
fn snapshot_has_branch_query_parameter() {
|
|
|
|
|
let doc = openapi_json();
|
|
|
|
|
let params = doc["paths"]["/snapshot"]["get"]["parameters"]
|
|
|
|
|
.as_array()
|
|
|
|
|
.unwrap();
|
2026-05-24 16:46:00 +01:00
|
|
|
let has_branch = params
|
|
|
|
|
.iter()
|
|
|
|
|
.any(|p| p["name"].as_str() == Some("branch") && p["in"].as_str() == Some("query"));
|
|
|
|
|
assert!(
|
|
|
|
|
has_branch,
|
|
|
|
|
"GET /snapshot must have 'branch' query parameter"
|
|
|
|
|
);
|
Add OpenAPI spec generation via utoipa with /openapi.json endpoint
Integrate utoipa 5 to auto-generate an OpenAPI 3.1 spec from the existing
Axum handlers and serde types. All 16 endpoints are annotated with path
metadata, request/response schemas, security requirements, and tags. A
public /openapi.json endpoint serves the spec without requiring auth.
Includes 59 tests covering path completeness, HTTP methods, schema fields,
enum variants, security scheme, path/query parameters, request bodies,
response references, and endpoint integration.
https://claude.ai/code/session_01NfoPVx21rZUQned1f7WpXY
2026-04-11 13:11:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
|
fn commits_has_branch_query_parameter() {
|
|
|
|
|
let doc = openapi_json();
|
|
|
|
|
let params = doc["paths"]["/commits"]["get"]["parameters"]
|
|
|
|
|
.as_array()
|
|
|
|
|
.unwrap();
|
2026-05-24 16:46:00 +01:00
|
|
|
let has_branch = params
|
|
|
|
|
.iter()
|
|
|
|
|
.any(|p| p["name"].as_str() == Some("branch") && p["in"].as_str() == Some("query"));
|
|
|
|
|
assert!(
|
|
|
|
|
has_branch,
|
|
|
|
|
"GET /commits must have 'branch' query parameter"
|
|
|
|
|
);
|
Add OpenAPI spec generation via utoipa with /openapi.json endpoint
Integrate utoipa 5 to auto-generate an OpenAPI 3.1 spec from the existing
Axum handlers and serde types. All 16 endpoints are annotated with path
metadata, request/response schemas, security requirements, and tags. A
public /openapi.json endpoint serves the spec without requiring auth.
Includes 59 tests covering path completeness, HTTP methods, schema fields,
enum variants, security scheme, path/query parameters, request bodies,
response references, and endpoint integration.
https://claude.ai/code/session_01NfoPVx21rZUQned1f7WpXY
2026-04-11 13:11:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
|
// Tag tests
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
|
fn openapi_operations_have_tags() {
|
|
|
|
|
let doc = openapi_json();
|
|
|
|
|
let paths = doc["paths"].as_object().unwrap();
|
|
|
|
|
|
|
|
|
|
for (path, methods) in paths {
|
|
|
|
|
let methods = methods.as_object().unwrap();
|
|
|
|
|
for (method, operation) in methods {
|
|
|
|
|
let tags = operation["tags"].as_array();
|
|
|
|
|
assert!(
|
|
|
|
|
tags.is_some_and(|t| !t.is_empty()),
|
|
|
|
|
"{method} {path} should have at least one tag"
|
|
|
|
|
);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
|
// Response schema reference tests
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
|
fn read_endpoint_200_references_read_output_schema() {
|
|
|
|
|
let doc = openapi_json();
|
|
|
|
|
let content = &doc["paths"]["/read"]["post"]["responses"]["200"]["content"];
|
|
|
|
|
let schema = &content["application/json"]["schema"];
|
|
|
|
|
let ref_path = schema["$ref"].as_str().unwrap();
|
|
|
|
|
assert!(
|
|
|
|
|
ref_path.contains("ReadOutput"),
|
|
|
|
|
"POST /read 200 should reference ReadOutput, got {ref_path}"
|
|
|
|
|
);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
|
fn change_endpoint_200_references_change_output_schema() {
|
|
|
|
|
let doc = openapi_json();
|
|
|
|
|
let content = &doc["paths"]["/change"]["post"]["responses"]["200"]["content"];
|
|
|
|
|
let schema = &content["application/json"]["schema"];
|
|
|
|
|
let ref_path = schema["$ref"].as_str().unwrap();
|
|
|
|
|
assert!(
|
|
|
|
|
ref_path.contains("ChangeOutput"),
|
|
|
|
|
"POST /change 200 should reference ChangeOutput, got {ref_path}"
|
|
|
|
|
);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
|
fn healthz_200_references_health_output_schema() {
|
|
|
|
|
let doc = openapi_json();
|
|
|
|
|
let content = &doc["paths"]["/healthz"]["get"]["responses"]["200"]["content"];
|
|
|
|
|
let schema = &content["application/json"]["schema"];
|
|
|
|
|
let ref_path = schema["$ref"].as_str().unwrap();
|
|
|
|
|
assert!(
|
|
|
|
|
ref_path.contains("HealthOutput"),
|
|
|
|
|
"GET /healthz 200 should reference HealthOutput, got {ref_path}"
|
|
|
|
|
);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
|
fn error_responses_reference_error_output_schema() {
|
|
|
|
|
let doc = openapi_json();
|
|
|
|
|
let paths_with_errors = [
|
|
|
|
|
("/read", "post", "400"),
|
|
|
|
|
("/read", "post", "401"),
|
|
|
|
|
("/change", "post", "400"),
|
|
|
|
|
("/change", "post", "409"),
|
|
|
|
|
("/branches", "post", "409"),
|
|
|
|
|
];
|
|
|
|
|
|
|
|
|
|
for (path, method, status) in paths_with_errors {
|
2026-05-24 16:46:00 +01:00
|
|
|
let content = &doc["paths"][path][method]["responses"][status]["content"];
|
Add OpenAPI spec generation via utoipa with /openapi.json endpoint
Integrate utoipa 5 to auto-generate an OpenAPI 3.1 spec from the existing
Axum handlers and serde types. All 16 endpoints are annotated with path
metadata, request/response schemas, security requirements, and tags. A
public /openapi.json endpoint serves the spec without requiring auth.
Includes 59 tests covering path completeness, HTTP methods, schema fields,
enum variants, security scheme, path/query parameters, request bodies,
response references, and endpoint integration.
https://claude.ai/code/session_01NfoPVx21rZUQned1f7WpXY
2026-04-11 13:11:14 +00:00
|
|
|
let schema = &content["application/json"]["schema"];
|
|
|
|
|
let ref_path = schema["$ref"].as_str().unwrap();
|
|
|
|
|
assert!(
|
|
|
|
|
ref_path.contains("ErrorOutput"),
|
|
|
|
|
"{method} {path} {status} should reference ErrorOutput, got {ref_path}"
|
|
|
|
|
);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
|
// Request body reference tests
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
|
fn post_endpoints_have_request_body() {
|
|
|
|
|
let doc = openapi_json();
|
|
|
|
|
let post_paths = [
|
|
|
|
|
("/read", "ReadRequest"),
|
|
|
|
|
("/change", "ChangeRequest"),
|
|
|
|
|
("/schema/apply", "SchemaApplyRequest"),
|
|
|
|
|
("/ingest", "IngestRequest"),
|
|
|
|
|
("/export", "ExportRequest"),
|
|
|
|
|
("/branches", "BranchCreateRequest"),
|
|
|
|
|
("/branches/merge", "BranchMergeRequest"),
|
|
|
|
|
];
|
|
|
|
|
|
|
|
|
|
for (path, expected_schema) in post_paths {
|
|
|
|
|
let request_body = &doc["paths"][path]["post"]["requestBody"];
|
|
|
|
|
assert!(
|
|
|
|
|
request_body.is_object(),
|
|
|
|
|
"POST {path} should have a requestBody"
|
|
|
|
|
);
|
|
|
|
|
let schema = &request_body["content"]["application/json"]["schema"];
|
|
|
|
|
let ref_path = schema["$ref"].as_str().unwrap();
|
|
|
|
|
assert!(
|
|
|
|
|
ref_path.contains(expected_schema),
|
|
|
|
|
"POST {path} requestBody should reference {expected_schema}, got {ref_path}"
|
|
|
|
|
);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
|
// Serialization round-trip test
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
|
fn openapi_spec_round_trips_through_json() {
|
|
|
|
|
let doc = openapi_doc();
|
|
|
|
|
let json_string = serde_json::to_string_pretty(&doc).unwrap();
|
|
|
|
|
let parsed: Value = serde_json::from_str(&json_string).unwrap();
|
|
|
|
|
assert!(parsed["openapi"].is_string());
|
|
|
|
|
assert!(parsed["paths"].is_object());
|
|
|
|
|
assert!(parsed["components"]["schemas"].is_object());
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
2026-04-11 16:31:48 +00:00
|
|
|
// Open-mode vs auth-mode: served spec reflects runtime config
|
Add OpenAPI spec generation via utoipa with /openapi.json endpoint
Integrate utoipa 5 to auto-generate an OpenAPI 3.1 spec from the existing
Axum handlers and serde types. All 16 endpoints are annotated with path
metadata, request/response schemas, security requirements, and tags. A
public /openapi.json endpoint serves the spec without requiring auth.
Includes 59 tests covering path completeness, HTTP methods, schema fields,
enum variants, security scheme, path/query parameters, request bodies,
response references, and endpoint integration.
https://claude.ai/code/session_01NfoPVx21rZUQned1f7WpXY
2026-04-11 13:11:14 +00:00
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
|
|
|
|
|
|
#[tokio::test]
|
2026-04-11 16:31:48 +00:00
|
|
|
async fn open_mode_spec_has_no_security_schemes() {
|
2026-05-24 16:46:00 +01:00
|
|
|
let (_temp, app) = app_for_loaded_graph().await;
|
2026-04-11 16:31:48 +00:00
|
|
|
let request = Request::builder()
|
|
|
|
|
.method(Method::GET)
|
|
|
|
|
.uri("/openapi.json")
|
|
|
|
|
.body(Body::empty())
|
|
|
|
|
.unwrap();
|
|
|
|
|
let (_, json) = json_response(&app, request).await;
|
|
|
|
|
let schemes = &json["components"]["securitySchemes"];
|
|
|
|
|
assert!(
|
|
|
|
|
schemes.is_null() || schemes.as_object().is_some_and(|m| m.is_empty()),
|
|
|
|
|
"open-mode spec should have no security schemes"
|
|
|
|
|
);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[tokio::test]
|
|
|
|
|
async fn open_mode_spec_has_no_operation_security() {
|
2026-05-24 16:46:00 +01:00
|
|
|
let (_temp, app) = app_for_loaded_graph().await;
|
2026-04-11 16:31:48 +00:00
|
|
|
let request = Request::builder()
|
|
|
|
|
.method(Method::GET)
|
|
|
|
|
.uri("/openapi.json")
|
|
|
|
|
.body(Body::empty())
|
|
|
|
|
.unwrap();
|
|
|
|
|
let (_, json) = json_response(&app, request).await;
|
|
|
|
|
let paths = json["paths"].as_object().unwrap();
|
|
|
|
|
for (path, methods) in paths {
|
|
|
|
|
for (method, operation) in methods.as_object().unwrap() {
|
|
|
|
|
let security = &operation["security"];
|
|
|
|
|
assert!(
|
|
|
|
|
security.is_null(),
|
|
|
|
|
"open-mode: {method} {path} should have no security requirement"
|
|
|
|
|
);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[tokio::test]
|
|
|
|
|
async fn auth_mode_spec_includes_bearer_token_security_scheme() {
|
2026-05-24 16:46:00 +01:00
|
|
|
let (_temp, app) = app_for_loaded_graph_with_auth("secret").await;
|
2026-04-11 16:31:48 +00:00
|
|
|
let request = Request::builder()
|
|
|
|
|
.method(Method::GET)
|
|
|
|
|
.uri("/openapi.json")
|
|
|
|
|
.body(Body::empty())
|
|
|
|
|
.unwrap();
|
|
|
|
|
let (_, json) = json_response(&app, request).await;
|
|
|
|
|
let scheme = &json["components"]["securitySchemes"]["bearer_token"];
|
|
|
|
|
assert_eq!(scheme["type"].as_str().unwrap(), "http");
|
|
|
|
|
assert_eq!(scheme["scheme"].as_str().unwrap(), "bearer");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[tokio::test]
|
|
|
|
|
async fn auth_mode_spec_has_security_on_protected_operations() {
|
2026-05-24 16:46:00 +01:00
|
|
|
let (_temp, app) = app_for_loaded_graph_with_auth("secret").await;
|
2026-04-11 16:31:48 +00:00
|
|
|
let request = Request::builder()
|
|
|
|
|
.method(Method::GET)
|
|
|
|
|
.uri("/openapi.json")
|
|
|
|
|
.body(Body::empty())
|
|
|
|
|
.unwrap();
|
|
|
|
|
let (_, json) = json_response(&app, request).await;
|
|
|
|
|
let protected_paths = [
|
|
|
|
|
("/read", "post"),
|
|
|
|
|
("/change", "post"),
|
|
|
|
|
("/snapshot", "get"),
|
|
|
|
|
("/branches", "get"),
|
|
|
|
|
("/commits", "get"),
|
|
|
|
|
];
|
|
|
|
|
for (path, method) in protected_paths {
|
|
|
|
|
let security = &json["paths"][path][method]["security"];
|
|
|
|
|
let arr = security
|
|
|
|
|
.as_array()
|
|
|
|
|
.unwrap_or_else(|| panic!("auth-mode: {method} {path} missing security"));
|
|
|
|
|
let has_bearer = arr
|
|
|
|
|
.iter()
|
|
|
|
|
.any(|s| s.as_object().unwrap().contains_key("bearer_token"));
|
|
|
|
|
assert!(
|
|
|
|
|
has_bearer,
|
|
|
|
|
"auth-mode: {method} {path} should require bearer_token"
|
|
|
|
|
);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[tokio::test]
|
|
|
|
|
async fn auth_mode_spec_matches_static_generation() {
|
2026-05-24 16:46:00 +01:00
|
|
|
let (_temp, app) = app_for_loaded_graph_with_auth("secret").await;
|
Add OpenAPI spec generation via utoipa with /openapi.json endpoint
Integrate utoipa 5 to auto-generate an OpenAPI 3.1 spec from the existing
Axum handlers and serde types. All 16 endpoints are annotated with path
metadata, request/response schemas, security requirements, and tags. A
public /openapi.json endpoint serves the spec without requiring auth.
Includes 59 tests covering path completeness, HTTP methods, schema fields,
enum variants, security scheme, path/query parameters, request bodies,
response references, and endpoint integration.
https://claude.ai/code/session_01NfoPVx21rZUQned1f7WpXY
2026-04-11 13:11:14 +00:00
|
|
|
let request = Request::builder()
|
|
|
|
|
.method(Method::GET)
|
|
|
|
|
.uri("/openapi.json")
|
|
|
|
|
.body(Body::empty())
|
|
|
|
|
.unwrap();
|
|
|
|
|
let (_, served) = json_response(&app, request).await;
|
|
|
|
|
let static_doc = openapi_json();
|
2026-04-11 16:31:48 +00:00
|
|
|
assert_eq!(
|
|
|
|
|
served, static_doc,
|
|
|
|
|
"auth-mode served spec must match static generation"
|
|
|
|
|
);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[tokio::test]
|
|
|
|
|
async fn auth_mode_healthz_still_has_no_security() {
|
2026-05-24 16:46:00 +01:00
|
|
|
let (_temp, app) = app_for_loaded_graph_with_auth("secret").await;
|
2026-04-11 16:31:48 +00:00
|
|
|
let request = Request::builder()
|
|
|
|
|
.method(Method::GET)
|
|
|
|
|
.uri("/openapi.json")
|
|
|
|
|
.body(Body::empty())
|
|
|
|
|
.unwrap();
|
|
|
|
|
let (_, json) = json_response(&app, request).await;
|
|
|
|
|
let healthz = &json["paths"]["/healthz"]["get"];
|
|
|
|
|
assert!(
|
|
|
|
|
healthz.get("security").is_none() || healthz["security"].is_null(),
|
|
|
|
|
"auth-mode: /healthz should still have no security"
|
|
|
|
|
);
|
Add OpenAPI spec generation via utoipa with /openapi.json endpoint
Integrate utoipa 5 to auto-generate an OpenAPI 3.1 spec from the existing
Axum handlers and serde types. All 16 endpoints are annotated with path
metadata, request/response schemas, security requirements, and tags. A
public /openapi.json endpoint serves the spec without requiring auth.
Includes 59 tests covering path completeness, HTTP methods, schema fields,
enum variants, security scheme, path/query parameters, request bodies,
response references, and endpoint integration.
https://claude.ai/code/session_01NfoPVx21rZUQned1f7WpXY
2026-04-11 13:11:14 +00:00
|
|
|
}
|
2026-04-17 14:26:31 +02:00
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
|
fn openapi_spec_is_up_to_date() {
|
2026-05-24 16:46:00 +01:00
|
|
|
let spec_path = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../../openapi.json");
|
2026-04-17 14:26:31 +02:00
|
|
|
|
|
|
|
|
let generated = serde_json::to_string_pretty(&openapi_doc()).unwrap() + "\n";
|
|
|
|
|
|
2026-04-18 21:00:46 +02:00
|
|
|
if !env::var("OMNIGRAPH_UPDATE_OPENAPI")
|
|
|
|
|
.unwrap_or_default()
|
|
|
|
|
.is_empty()
|
|
|
|
|
{
|
2026-04-17 14:26:31 +02:00
|
|
|
fs::write(&spec_path, &generated).unwrap();
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
let committed = fs::read_to_string(&spec_path).unwrap_or_else(|_| {
|
|
|
|
|
panic!(
|
|
|
|
|
"openapi.json not found at {}. Run: OMNIGRAPH_UPDATE_OPENAPI=1 cargo test -p omnigraph-server --test openapi openapi_spec_is_up_to_date",
|
|
|
|
|
spec_path.display()
|
|
|
|
|
)
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
assert_eq!(
|
|
|
|
|
committed, generated,
|
|
|
|
|
"openapi.json is out of date. Run: OMNIGRAPH_UPDATE_OPENAPI=1 cargo test -p omnigraph-server --test openapi openapi_spec_is_up_to_date"
|
|
|
|
|
);
|
|
|
|
|
}
|
mr-668: OpenAPI multi-mode cluster filter (PR 4b/10)
PR 4b of the MR-668 multi-graph server work. In multi mode, the served
`/openapi.json` reports cluster routes (`/graphs/{graph_id}/...`) instead
of the legacy flat protected paths — matching what `build_app` actually
mounts (PR 4a's `Router::nest`). Single mode is unchanged.
Implementation:
- New `server_openapi` branch: when `state.mode()` is `Multi`, call
`nest_paths_under_cluster_prefix(&mut doc)` after `ApiDoc::openapi()`.
- The rewrite consumes `doc.paths.paths`, then for every path-item:
- If the path is in `ALWAYS_FLAT_PATHS` (`/healthz` for now), keep
it flat.
- Otherwise, prefix every operation_id with `cluster_` and reinsert
the item at `/graphs/{graph_id}<original_path>`.
- Single mode hits no extra work — the path map is untouched.
- The static `ApiDoc::openapi()` still emits the flat surface, so
in-process callers (the existing `openapi_json()` helper in tests)
see the unmodified spec.
Why cluster_ prefix on operation IDs: OpenAPI specs require unique
operation_ids across the document. With both flat (single-mode) and
cluster (multi-mode) surfaces ever co-existing in a generated SDK,
the prefix prevents collision. The current served doc only carries
one surface, so the prefix is forward-compat with potential future
dual-surface generation.
Tests: 6 new in `tests/openapi.rs`, all via the `/openapi.json` route
(not the static `ApiDoc::openapi()` helper):
- `multi_mode_openapi_lists_cluster_paths` — every protected path
appears as a cluster variant.
- `multi_mode_openapi_drops_flat_protected_paths` — flat protected
paths are absent.
- `multi_mode_openapi_keeps_healthz_flat` — `/healthz` survives.
- `multi_mode_openapi_prefixes_operation_ids_with_cluster` — every
cluster operation_id starts with `cluster_`.
- `multi_mode_operation_ids_are_unique` — no operation_id collisions.
- `single_mode_openapi_unchanged_by_cluster_filter` — single mode
still emits the legacy flat surface (regression).
New test helper `app_for_multi_mode(graph_ids)` exercises the new
`AppState::new_multi` constructor from PR 4a — first user of multi-mode
construction outside of unit tests.
Result: 66 openapi tests + 57 server integration tests + 74 lib tests
= 197 green. No regression in the existing OpenAPI drift check
(`openapi_spec_is_up_to_date` still validates the static flat surface
matches the committed openapi.json).
LOC: +67 in lib.rs (rewrite logic), +219 in tests/openapi.rs (test
suite + helper).
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
2026-05-25 19:59:02 +02:00
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
2026-05-27 11:57:04 +02:00
|
|
|
// MR-668 — multi-mode OpenAPI cluster filter
|
mr-668: OpenAPI multi-mode cluster filter (PR 4b/10)
PR 4b of the MR-668 multi-graph server work. In multi mode, the served
`/openapi.json` reports cluster routes (`/graphs/{graph_id}/...`) instead
of the legacy flat protected paths — matching what `build_app` actually
mounts (PR 4a's `Router::nest`). Single mode is unchanged.
Implementation:
- New `server_openapi` branch: when `state.mode()` is `Multi`, call
`nest_paths_under_cluster_prefix(&mut doc)` after `ApiDoc::openapi()`.
- The rewrite consumes `doc.paths.paths`, then for every path-item:
- If the path is in `ALWAYS_FLAT_PATHS` (`/healthz` for now), keep
it flat.
- Otherwise, prefix every operation_id with `cluster_` and reinsert
the item at `/graphs/{graph_id}<original_path>`.
- Single mode hits no extra work — the path map is untouched.
- The static `ApiDoc::openapi()` still emits the flat surface, so
in-process callers (the existing `openapi_json()` helper in tests)
see the unmodified spec.
Why cluster_ prefix on operation IDs: OpenAPI specs require unique
operation_ids across the document. With both flat (single-mode) and
cluster (multi-mode) surfaces ever co-existing in a generated SDK,
the prefix prevents collision. The current served doc only carries
one surface, so the prefix is forward-compat with potential future
dual-surface generation.
Tests: 6 new in `tests/openapi.rs`, all via the `/openapi.json` route
(not the static `ApiDoc::openapi()` helper):
- `multi_mode_openapi_lists_cluster_paths` — every protected path
appears as a cluster variant.
- `multi_mode_openapi_drops_flat_protected_paths` — flat protected
paths are absent.
- `multi_mode_openapi_keeps_healthz_flat` — `/healthz` survives.
- `multi_mode_openapi_prefixes_operation_ids_with_cluster` — every
cluster operation_id starts with `cluster_`.
- `multi_mode_operation_ids_are_unique` — no operation_id collisions.
- `single_mode_openapi_unchanged_by_cluster_filter` — single mode
still emits the legacy flat surface (regression).
New test helper `app_for_multi_mode(graph_ids)` exercises the new
`AppState::new_multi` constructor from PR 4a — first user of multi-mode
construction outside of unit tests.
Result: 66 openapi tests + 57 server integration tests + 74 lib tests
= 197 green. No regression in the existing OpenAPI drift check
(`openapi_spec_is_up_to_date` still validates the static flat surface
matches the committed openapi.json).
LOC: +67 in lib.rs (rewrite logic), +219 in tests/openapi.rs (test
suite + helper).
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
2026-05-25 19:59:02 +02:00
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
|
//
|
|
|
|
|
// In multi-graph mode, `/openapi.json` reports cluster routes
|
|
|
|
|
// (`/graphs/{graph_id}/...`) instead of the legacy flat routes. The
|
|
|
|
|
// only flat path that survives is `/healthz`. Operation IDs gain a
|
|
|
|
|
// `cluster_` prefix so SDK generators have stable, unique ids.
|
|
|
|
|
//
|
|
|
|
|
// These tests exercise the request-time `server_openapi` handler via
|
|
|
|
|
// `oneshot`, not the static `ApiDoc::openapi()` — the rewrite happens
|
|
|
|
|
// only on the served document.
|
|
|
|
|
|
|
|
|
|
const EXPECTED_CLUSTER_PATHS: &[&str] = &[
|
|
|
|
|
"/graphs/{graph_id}/snapshot",
|
|
|
|
|
"/graphs/{graph_id}/read",
|
|
|
|
|
"/graphs/{graph_id}/export",
|
|
|
|
|
"/graphs/{graph_id}/change",
|
|
|
|
|
"/graphs/{graph_id}/schema",
|
|
|
|
|
"/graphs/{graph_id}/schema/apply",
|
|
|
|
|
"/graphs/{graph_id}/ingest",
|
|
|
|
|
"/graphs/{graph_id}/branches",
|
|
|
|
|
"/graphs/{graph_id}/branches/{branch}",
|
|
|
|
|
"/graphs/{graph_id}/branches/merge",
|
|
|
|
|
"/graphs/{graph_id}/commits",
|
|
|
|
|
"/graphs/{graph_id}/commits/{commit_id}",
|
|
|
|
|
];
|
|
|
|
|
|
|
|
|
|
async fn app_for_multi_mode(graph_ids: &[&str]) -> (Vec<tempfile::TempDir>, Router) {
|
|
|
|
|
use std::sync::Arc;
|
|
|
|
|
|
|
|
|
|
use omnigraph_server::{GraphHandle, GraphId, GraphKey};
|
|
|
|
|
|
|
|
|
|
let mut dirs = Vec::with_capacity(graph_ids.len());
|
|
|
|
|
let mut handles = Vec::with_capacity(graph_ids.len());
|
|
|
|
|
for id in graph_ids {
|
|
|
|
|
let dir = tempfile::tempdir().unwrap();
|
|
|
|
|
let graph_uri = dir.path().join(id).to_str().unwrap().to_string();
|
|
|
|
|
let schema = fs::read_to_string(fixture("test.pg")).unwrap();
|
|
|
|
|
let engine = Omnigraph::init(&graph_uri, &schema).await.unwrap();
|
|
|
|
|
handles.push(Arc::new(GraphHandle {
|
|
|
|
|
key: GraphKey::cluster(GraphId::try_from(*id).unwrap()),
|
|
|
|
|
uri: graph_uri,
|
|
|
|
|
engine: Arc::new(engine),
|
|
|
|
|
policy: None,
|
|
|
|
|
}));
|
|
|
|
|
dirs.push(dir);
|
|
|
|
|
}
|
|
|
|
|
let workload = omnigraph_server::workload::WorkloadController::from_env();
|
mr-668: remove POST /graphs and CLI graphs create (defer runtime graph mgmt)
The POST /graphs runtime-create endpoint shipped in PR 7/10 has three
unresolved high-severity bugs:
- flock-on-renamed-inode race: the YAML flock is taken on
omnigraph.yaml itself, then a temp file is renamed over it.
Cross-process writers end up locking different inodes — both
believing they hold exclusive access.
- duplicate-check outside the file lock: precheck runs against
the in-memory registry only; the locked closure does
config.graphs.insert(...) unconditionally. Concurrent same-id
POSTs can persist the loser in YAML while the in-memory registry
keeps the winner — they disagree after restart.
- best_effort_cleanup_init_artifacts deletes _schema.pg /
_schema.ir.json / __schema_state.json on any init failure. An
accidental re-init against an existing graph's URI destroys its
schema; subsequent open() fails at read_text(_schema.pg).
The correct fix is a Lance-style cluster catalog (reserve → init →
publish with recovery sidecars), parallel to the engine's existing
__manifest discipline. That work is out of scope for v0.7.0.
For now, disable runtime add/remove from the network and CLI surface.
Operators add graphs by editing omnigraph.yaml and restarting. The
GET /graphs read-only enumeration stays.
Removed:
- POST /graphs handler + router fragment + utoipa registration
- 13 post_graphs_* server tests + 3 composite POST tests +
multi_mode_app_with_real_config / post_graph helpers
- CLI omnigraph graphs create subcommand + its handler + cli.rs tests
- system_remote.rs combined list+create test trimmed to list-only
- YAML rewrite infra: rewrite_atomic[_with_modify], RewriteAtomicError,
staging_path, hash_config_file, AppState::config_hash field +
threading through new_multi and open_multi_graph_state
- fs2 dependency (verified absent from cargo tree)
- sha2/fs2 imports in config.rs (only the rewrite path used them)
- Cedar PolicyAction::GraphCreate variant + "graph_create" match arms
+ action def in Cedar schema + graph_create_action_authorizes_against_server_resource test
- GraphCreateRequest / GraphCreateResponse / GraphSchemaSpec /
GraphPolicySpec API types (only the POST handler / CLI imported them)
Kept:
- GET /graphs (read-only enumeration) and graph_list Cedar action
- omnigraph graphs list CLI subcommand
- All multi-graph startup, mode inference, cluster routes,
per-graph + server-level Cedar policies
- server_settings_drive_multi_graph_startup_end_to_end (the test
that covers operator-authored YAML + restart — the path that
survives)
- best_effort_cleanup_init_artifacts and the three init failpoints
(still reachable from CLI `omnigraph init`; preflight fix deferred
as a follow-up)
- GraphRegistry::insert and its concurrency tests — production
callers gone, but the method is the natural seam for the future
cluster-catalog work
Also fixed (transcript issue 4):
- ALWAYS_FLAT_PATHS now includes /graphs so multi-mode OpenAPI
advertises the management route correctly (was previously rewritten
to /graphs/{graph_id}/graphs)
- multi_mode_openapi_keeps_healthz_flat → renamed to
multi_mode_openapi_keeps_management_paths_flat, asserts both
/healthz and /graphs stay flat
- multi_mode_openapi_prefixes_operation_ids_with_cluster skips
/graphs in addition to /healthz
Doc fixes:
- docs/user/cli.md: graphs list example was --target http://...,
but --target is a config-graph-name lookup; corrected to --uri.
Removed the graphs create example.
- docs/user/server.md: dropped POST /graphs row, "omnigraph.yaml
ownership", and "POST /graphs body shape" sections. Added a
paragraph stating runtime add/remove is not exposed in v0.7.0.
- docs/user/policy.md: dropped graph_create action; reworded the
"Configuration" line to clarify that server-scoped rules (graph_list)
take neither branch_scope nor target_branch_scope.
- docs/releases/v0.7.0.md: rewrote release narrative — multi-graph
mode ships; runtime add/remove deferred.
- AGENTS.md: HTTP server bullet and capability matrix row updated to
reflect read-only GET /graphs and the operator-edit workflow.
- openapi.json regenerated; /graphs has only .get, no .post.
Diff: 17 files, +123 −1525 LOC.
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
2026-05-26 17:49:38 +02:00
|
|
|
let state = AppState::new_multi(handles, Vec::new(), None, workload, None).unwrap();
|
mr-668: OpenAPI multi-mode cluster filter (PR 4b/10)
PR 4b of the MR-668 multi-graph server work. In multi mode, the served
`/openapi.json` reports cluster routes (`/graphs/{graph_id}/...`) instead
of the legacy flat protected paths — matching what `build_app` actually
mounts (PR 4a's `Router::nest`). Single mode is unchanged.
Implementation:
- New `server_openapi` branch: when `state.mode()` is `Multi`, call
`nest_paths_under_cluster_prefix(&mut doc)` after `ApiDoc::openapi()`.
- The rewrite consumes `doc.paths.paths`, then for every path-item:
- If the path is in `ALWAYS_FLAT_PATHS` (`/healthz` for now), keep
it flat.
- Otherwise, prefix every operation_id with `cluster_` and reinsert
the item at `/graphs/{graph_id}<original_path>`.
- Single mode hits no extra work — the path map is untouched.
- The static `ApiDoc::openapi()` still emits the flat surface, so
in-process callers (the existing `openapi_json()` helper in tests)
see the unmodified spec.
Why cluster_ prefix on operation IDs: OpenAPI specs require unique
operation_ids across the document. With both flat (single-mode) and
cluster (multi-mode) surfaces ever co-existing in a generated SDK,
the prefix prevents collision. The current served doc only carries
one surface, so the prefix is forward-compat with potential future
dual-surface generation.
Tests: 6 new in `tests/openapi.rs`, all via the `/openapi.json` route
(not the static `ApiDoc::openapi()` helper):
- `multi_mode_openapi_lists_cluster_paths` — every protected path
appears as a cluster variant.
- `multi_mode_openapi_drops_flat_protected_paths` — flat protected
paths are absent.
- `multi_mode_openapi_keeps_healthz_flat` — `/healthz` survives.
- `multi_mode_openapi_prefixes_operation_ids_with_cluster` — every
cluster operation_id starts with `cluster_`.
- `multi_mode_operation_ids_are_unique` — no operation_id collisions.
- `single_mode_openapi_unchanged_by_cluster_filter` — single mode
still emits the legacy flat surface (regression).
New test helper `app_for_multi_mode(graph_ids)` exercises the new
`AppState::new_multi` constructor from PR 4a — first user of multi-mode
construction outside of unit tests.
Result: 66 openapi tests + 57 server integration tests + 74 lib tests
= 197 green. No regression in the existing OpenAPI drift check
(`openapi_spec_is_up_to_date` still validates the static flat surface
matches the committed openapi.json).
LOC: +67 in lib.rs (rewrite logic), +219 in tests/openapi.rs (test
suite + helper).
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
2026-05-25 19:59:02 +02:00
|
|
|
let app = build_app(state);
|
|
|
|
|
(dirs, app)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[tokio::test]
|
|
|
|
|
async fn multi_mode_openapi_lists_cluster_paths() {
|
|
|
|
|
let (_dirs, app) = app_for_multi_mode(&["alpha"]).await;
|
|
|
|
|
let request = Request::builder()
|
|
|
|
|
.method(Method::GET)
|
|
|
|
|
.uri("/openapi.json")
|
|
|
|
|
.body(Body::empty())
|
|
|
|
|
.unwrap();
|
|
|
|
|
let (status, json) = json_response(&app, request).await;
|
|
|
|
|
assert_eq!(status, StatusCode::OK);
|
|
|
|
|
let paths = json["paths"].as_object().expect("paths must be an object");
|
|
|
|
|
let path_keys: HashSet<&str> = paths.keys().map(|k| k.as_str()).collect();
|
|
|
|
|
for expected in EXPECTED_CLUSTER_PATHS {
|
|
|
|
|
assert!(
|
|
|
|
|
path_keys.contains(expected),
|
|
|
|
|
"missing cluster path in multi-mode spec: {expected}. \
|
|
|
|
|
Found: {path_keys:?}"
|
|
|
|
|
);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[tokio::test]
|
|
|
|
|
async fn multi_mode_openapi_drops_flat_protected_paths() {
|
|
|
|
|
let (_dirs, app) = app_for_multi_mode(&["alpha"]).await;
|
|
|
|
|
let request = Request::builder()
|
|
|
|
|
.method(Method::GET)
|
|
|
|
|
.uri("/openapi.json")
|
|
|
|
|
.body(Body::empty())
|
|
|
|
|
.unwrap();
|
|
|
|
|
let (_, json) = json_response(&app, request).await;
|
|
|
|
|
let paths = json["paths"].as_object().unwrap();
|
|
|
|
|
// None of the legacy flat protected paths should appear in multi mode.
|
|
|
|
|
let flat_protected = [
|
|
|
|
|
"/snapshot",
|
|
|
|
|
"/read",
|
|
|
|
|
"/export",
|
|
|
|
|
"/change",
|
|
|
|
|
"/schema",
|
|
|
|
|
"/schema/apply",
|
|
|
|
|
"/ingest",
|
|
|
|
|
"/branches",
|
|
|
|
|
"/branches/{branch}",
|
|
|
|
|
"/branches/merge",
|
|
|
|
|
"/commits",
|
|
|
|
|
"/commits/{commit_id}",
|
|
|
|
|
];
|
|
|
|
|
for flat in flat_protected {
|
|
|
|
|
assert!(
|
|
|
|
|
!paths.contains_key(flat),
|
|
|
|
|
"flat path {flat} must not appear in multi-mode spec; \
|
|
|
|
|
cluster routes are the only protected surface"
|
|
|
|
|
);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[tokio::test]
|
mr-668: remove POST /graphs and CLI graphs create (defer runtime graph mgmt)
The POST /graphs runtime-create endpoint shipped in PR 7/10 has three
unresolved high-severity bugs:
- flock-on-renamed-inode race: the YAML flock is taken on
omnigraph.yaml itself, then a temp file is renamed over it.
Cross-process writers end up locking different inodes — both
believing they hold exclusive access.
- duplicate-check outside the file lock: precheck runs against
the in-memory registry only; the locked closure does
config.graphs.insert(...) unconditionally. Concurrent same-id
POSTs can persist the loser in YAML while the in-memory registry
keeps the winner — they disagree after restart.
- best_effort_cleanup_init_artifacts deletes _schema.pg /
_schema.ir.json / __schema_state.json on any init failure. An
accidental re-init against an existing graph's URI destroys its
schema; subsequent open() fails at read_text(_schema.pg).
The correct fix is a Lance-style cluster catalog (reserve → init →
publish with recovery sidecars), parallel to the engine's existing
__manifest discipline. That work is out of scope for v0.7.0.
For now, disable runtime add/remove from the network and CLI surface.
Operators add graphs by editing omnigraph.yaml and restarting. The
GET /graphs read-only enumeration stays.
Removed:
- POST /graphs handler + router fragment + utoipa registration
- 13 post_graphs_* server tests + 3 composite POST tests +
multi_mode_app_with_real_config / post_graph helpers
- CLI omnigraph graphs create subcommand + its handler + cli.rs tests
- system_remote.rs combined list+create test trimmed to list-only
- YAML rewrite infra: rewrite_atomic[_with_modify], RewriteAtomicError,
staging_path, hash_config_file, AppState::config_hash field +
threading through new_multi and open_multi_graph_state
- fs2 dependency (verified absent from cargo tree)
- sha2/fs2 imports in config.rs (only the rewrite path used them)
- Cedar PolicyAction::GraphCreate variant + "graph_create" match arms
+ action def in Cedar schema + graph_create_action_authorizes_against_server_resource test
- GraphCreateRequest / GraphCreateResponse / GraphSchemaSpec /
GraphPolicySpec API types (only the POST handler / CLI imported them)
Kept:
- GET /graphs (read-only enumeration) and graph_list Cedar action
- omnigraph graphs list CLI subcommand
- All multi-graph startup, mode inference, cluster routes,
per-graph + server-level Cedar policies
- server_settings_drive_multi_graph_startup_end_to_end (the test
that covers operator-authored YAML + restart — the path that
survives)
- best_effort_cleanup_init_artifacts and the three init failpoints
(still reachable from CLI `omnigraph init`; preflight fix deferred
as a follow-up)
- GraphRegistry::insert and its concurrency tests — production
callers gone, but the method is the natural seam for the future
cluster-catalog work
Also fixed (transcript issue 4):
- ALWAYS_FLAT_PATHS now includes /graphs so multi-mode OpenAPI
advertises the management route correctly (was previously rewritten
to /graphs/{graph_id}/graphs)
- multi_mode_openapi_keeps_healthz_flat → renamed to
multi_mode_openapi_keeps_management_paths_flat, asserts both
/healthz and /graphs stay flat
- multi_mode_openapi_prefixes_operation_ids_with_cluster skips
/graphs in addition to /healthz
Doc fixes:
- docs/user/cli.md: graphs list example was --target http://...,
but --target is a config-graph-name lookup; corrected to --uri.
Removed the graphs create example.
- docs/user/server.md: dropped POST /graphs row, "omnigraph.yaml
ownership", and "POST /graphs body shape" sections. Added a
paragraph stating runtime add/remove is not exposed in v0.7.0.
- docs/user/policy.md: dropped graph_create action; reworded the
"Configuration" line to clarify that server-scoped rules (graph_list)
take neither branch_scope nor target_branch_scope.
- docs/releases/v0.7.0.md: rewrote release narrative — multi-graph
mode ships; runtime add/remove deferred.
- AGENTS.md: HTTP server bullet and capability matrix row updated to
reflect read-only GET /graphs and the operator-edit workflow.
- openapi.json regenerated; /graphs has only .get, no .post.
Diff: 17 files, +123 −1525 LOC.
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
2026-05-26 17:49:38 +02:00
|
|
|
async fn multi_mode_openapi_keeps_management_paths_flat() {
|
mr-668: OpenAPI multi-mode cluster filter (PR 4b/10)
PR 4b of the MR-668 multi-graph server work. In multi mode, the served
`/openapi.json` reports cluster routes (`/graphs/{graph_id}/...`) instead
of the legacy flat protected paths — matching what `build_app` actually
mounts (PR 4a's `Router::nest`). Single mode is unchanged.
Implementation:
- New `server_openapi` branch: when `state.mode()` is `Multi`, call
`nest_paths_under_cluster_prefix(&mut doc)` after `ApiDoc::openapi()`.
- The rewrite consumes `doc.paths.paths`, then for every path-item:
- If the path is in `ALWAYS_FLAT_PATHS` (`/healthz` for now), keep
it flat.
- Otherwise, prefix every operation_id with `cluster_` and reinsert
the item at `/graphs/{graph_id}<original_path>`.
- Single mode hits no extra work — the path map is untouched.
- The static `ApiDoc::openapi()` still emits the flat surface, so
in-process callers (the existing `openapi_json()` helper in tests)
see the unmodified spec.
Why cluster_ prefix on operation IDs: OpenAPI specs require unique
operation_ids across the document. With both flat (single-mode) and
cluster (multi-mode) surfaces ever co-existing in a generated SDK,
the prefix prevents collision. The current served doc only carries
one surface, so the prefix is forward-compat with potential future
dual-surface generation.
Tests: 6 new in `tests/openapi.rs`, all via the `/openapi.json` route
(not the static `ApiDoc::openapi()` helper):
- `multi_mode_openapi_lists_cluster_paths` — every protected path
appears as a cluster variant.
- `multi_mode_openapi_drops_flat_protected_paths` — flat protected
paths are absent.
- `multi_mode_openapi_keeps_healthz_flat` — `/healthz` survives.
- `multi_mode_openapi_prefixes_operation_ids_with_cluster` — every
cluster operation_id starts with `cluster_`.
- `multi_mode_operation_ids_are_unique` — no operation_id collisions.
- `single_mode_openapi_unchanged_by_cluster_filter` — single mode
still emits the legacy flat surface (regression).
New test helper `app_for_multi_mode(graph_ids)` exercises the new
`AppState::new_multi` constructor from PR 4a — first user of multi-mode
construction outside of unit tests.
Result: 66 openapi tests + 57 server integration tests + 74 lib tests
= 197 green. No regression in the existing OpenAPI drift check
(`openapi_spec_is_up_to_date` still validates the static flat surface
matches the committed openapi.json).
LOC: +67 in lib.rs (rewrite logic), +219 in tests/openapi.rs (test
suite + helper).
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
2026-05-25 19:59:02 +02:00
|
|
|
let (_dirs, app) = app_for_multi_mode(&["alpha"]).await;
|
|
|
|
|
let request = Request::builder()
|
|
|
|
|
.method(Method::GET)
|
|
|
|
|
.uri("/openapi.json")
|
|
|
|
|
.body(Body::empty())
|
|
|
|
|
.unwrap();
|
|
|
|
|
let (_, json) = json_response(&app, request).await;
|
|
|
|
|
let paths = json["paths"].as_object().unwrap();
|
mr-668: remove POST /graphs and CLI graphs create (defer runtime graph mgmt)
The POST /graphs runtime-create endpoint shipped in PR 7/10 has three
unresolved high-severity bugs:
- flock-on-renamed-inode race: the YAML flock is taken on
omnigraph.yaml itself, then a temp file is renamed over it.
Cross-process writers end up locking different inodes — both
believing they hold exclusive access.
- duplicate-check outside the file lock: precheck runs against
the in-memory registry only; the locked closure does
config.graphs.insert(...) unconditionally. Concurrent same-id
POSTs can persist the loser in YAML while the in-memory registry
keeps the winner — they disagree after restart.
- best_effort_cleanup_init_artifacts deletes _schema.pg /
_schema.ir.json / __schema_state.json on any init failure. An
accidental re-init against an existing graph's URI destroys its
schema; subsequent open() fails at read_text(_schema.pg).
The correct fix is a Lance-style cluster catalog (reserve → init →
publish with recovery sidecars), parallel to the engine's existing
__manifest discipline. That work is out of scope for v0.7.0.
For now, disable runtime add/remove from the network and CLI surface.
Operators add graphs by editing omnigraph.yaml and restarting. The
GET /graphs read-only enumeration stays.
Removed:
- POST /graphs handler + router fragment + utoipa registration
- 13 post_graphs_* server tests + 3 composite POST tests +
multi_mode_app_with_real_config / post_graph helpers
- CLI omnigraph graphs create subcommand + its handler + cli.rs tests
- system_remote.rs combined list+create test trimmed to list-only
- YAML rewrite infra: rewrite_atomic[_with_modify], RewriteAtomicError,
staging_path, hash_config_file, AppState::config_hash field +
threading through new_multi and open_multi_graph_state
- fs2 dependency (verified absent from cargo tree)
- sha2/fs2 imports in config.rs (only the rewrite path used them)
- Cedar PolicyAction::GraphCreate variant + "graph_create" match arms
+ action def in Cedar schema + graph_create_action_authorizes_against_server_resource test
- GraphCreateRequest / GraphCreateResponse / GraphSchemaSpec /
GraphPolicySpec API types (only the POST handler / CLI imported them)
Kept:
- GET /graphs (read-only enumeration) and graph_list Cedar action
- omnigraph graphs list CLI subcommand
- All multi-graph startup, mode inference, cluster routes,
per-graph + server-level Cedar policies
- server_settings_drive_multi_graph_startup_end_to_end (the test
that covers operator-authored YAML + restart — the path that
survives)
- best_effort_cleanup_init_artifacts and the three init failpoints
(still reachable from CLI `omnigraph init`; preflight fix deferred
as a follow-up)
- GraphRegistry::insert and its concurrency tests — production
callers gone, but the method is the natural seam for the future
cluster-catalog work
Also fixed (transcript issue 4):
- ALWAYS_FLAT_PATHS now includes /graphs so multi-mode OpenAPI
advertises the management route correctly (was previously rewritten
to /graphs/{graph_id}/graphs)
- multi_mode_openapi_keeps_healthz_flat → renamed to
multi_mode_openapi_keeps_management_paths_flat, asserts both
/healthz and /graphs stay flat
- multi_mode_openapi_prefixes_operation_ids_with_cluster skips
/graphs in addition to /healthz
Doc fixes:
- docs/user/cli.md: graphs list example was --target http://...,
but --target is a config-graph-name lookup; corrected to --uri.
Removed the graphs create example.
- docs/user/server.md: dropped POST /graphs row, "omnigraph.yaml
ownership", and "POST /graphs body shape" sections. Added a
paragraph stating runtime add/remove is not exposed in v0.7.0.
- docs/user/policy.md: dropped graph_create action; reworded the
"Configuration" line to clarify that server-scoped rules (graph_list)
take neither branch_scope nor target_branch_scope.
- docs/releases/v0.7.0.md: rewrote release narrative — multi-graph
mode ships; runtime add/remove deferred.
- AGENTS.md: HTTP server bullet and capability matrix row updated to
reflect read-only GET /graphs and the operator-edit workflow.
- openapi.json regenerated; /graphs has only .get, no .post.
Diff: 17 files, +123 −1525 LOC.
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
2026-05-26 17:49:38 +02:00
|
|
|
for flat in ["/healthz", "/graphs"] {
|
|
|
|
|
assert!(
|
|
|
|
|
paths.contains_key(flat),
|
|
|
|
|
"{flat} must remain flat in multi mode"
|
|
|
|
|
);
|
|
|
|
|
let nested = format!("/graphs/{{graph_id}}{flat}");
|
|
|
|
|
assert!(
|
|
|
|
|
!paths.contains_key(&nested),
|
|
|
|
|
"{flat} must NOT be cluster-prefixed to {nested}"
|
|
|
|
|
);
|
|
|
|
|
}
|
mr-668: OpenAPI multi-mode cluster filter (PR 4b/10)
PR 4b of the MR-668 multi-graph server work. In multi mode, the served
`/openapi.json` reports cluster routes (`/graphs/{graph_id}/...`) instead
of the legacy flat protected paths — matching what `build_app` actually
mounts (PR 4a's `Router::nest`). Single mode is unchanged.
Implementation:
- New `server_openapi` branch: when `state.mode()` is `Multi`, call
`nest_paths_under_cluster_prefix(&mut doc)` after `ApiDoc::openapi()`.
- The rewrite consumes `doc.paths.paths`, then for every path-item:
- If the path is in `ALWAYS_FLAT_PATHS` (`/healthz` for now), keep
it flat.
- Otherwise, prefix every operation_id with `cluster_` and reinsert
the item at `/graphs/{graph_id}<original_path>`.
- Single mode hits no extra work — the path map is untouched.
- The static `ApiDoc::openapi()` still emits the flat surface, so
in-process callers (the existing `openapi_json()` helper in tests)
see the unmodified spec.
Why cluster_ prefix on operation IDs: OpenAPI specs require unique
operation_ids across the document. With both flat (single-mode) and
cluster (multi-mode) surfaces ever co-existing in a generated SDK,
the prefix prevents collision. The current served doc only carries
one surface, so the prefix is forward-compat with potential future
dual-surface generation.
Tests: 6 new in `tests/openapi.rs`, all via the `/openapi.json` route
(not the static `ApiDoc::openapi()` helper):
- `multi_mode_openapi_lists_cluster_paths` — every protected path
appears as a cluster variant.
- `multi_mode_openapi_drops_flat_protected_paths` — flat protected
paths are absent.
- `multi_mode_openapi_keeps_healthz_flat` — `/healthz` survives.
- `multi_mode_openapi_prefixes_operation_ids_with_cluster` — every
cluster operation_id starts with `cluster_`.
- `multi_mode_operation_ids_are_unique` — no operation_id collisions.
- `single_mode_openapi_unchanged_by_cluster_filter` — single mode
still emits the legacy flat surface (regression).
New test helper `app_for_multi_mode(graph_ids)` exercises the new
`AppState::new_multi` constructor from PR 4a — first user of multi-mode
construction outside of unit tests.
Result: 66 openapi tests + 57 server integration tests + 74 lib tests
= 197 green. No regression in the existing OpenAPI drift check
(`openapi_spec_is_up_to_date` still validates the static flat surface
matches the committed openapi.json).
LOC: +67 in lib.rs (rewrite logic), +219 in tests/openapi.rs (test
suite + helper).
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
2026-05-25 19:59:02 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[tokio::test]
|
|
|
|
|
async fn multi_mode_openapi_prefixes_operation_ids_with_cluster() {
|
|
|
|
|
let (_dirs, app) = app_for_multi_mode(&["alpha"]).await;
|
|
|
|
|
let request = Request::builder()
|
|
|
|
|
.method(Method::GET)
|
|
|
|
|
.uri("/openapi.json")
|
|
|
|
|
.body(Body::empty())
|
|
|
|
|
.unwrap();
|
|
|
|
|
let (_, json) = json_response(&app, request).await;
|
|
|
|
|
// Every cluster path operation must have a `cluster_` operation_id.
|
mr-668: remove POST /graphs and CLI graphs create (defer runtime graph mgmt)
The POST /graphs runtime-create endpoint shipped in PR 7/10 has three
unresolved high-severity bugs:
- flock-on-renamed-inode race: the YAML flock is taken on
omnigraph.yaml itself, then a temp file is renamed over it.
Cross-process writers end up locking different inodes — both
believing they hold exclusive access.
- duplicate-check outside the file lock: precheck runs against
the in-memory registry only; the locked closure does
config.graphs.insert(...) unconditionally. Concurrent same-id
POSTs can persist the loser in YAML while the in-memory registry
keeps the winner — they disagree after restart.
- best_effort_cleanup_init_artifacts deletes _schema.pg /
_schema.ir.json / __schema_state.json on any init failure. An
accidental re-init against an existing graph's URI destroys its
schema; subsequent open() fails at read_text(_schema.pg).
The correct fix is a Lance-style cluster catalog (reserve → init →
publish with recovery sidecars), parallel to the engine's existing
__manifest discipline. That work is out of scope for v0.7.0.
For now, disable runtime add/remove from the network and CLI surface.
Operators add graphs by editing omnigraph.yaml and restarting. The
GET /graphs read-only enumeration stays.
Removed:
- POST /graphs handler + router fragment + utoipa registration
- 13 post_graphs_* server tests + 3 composite POST tests +
multi_mode_app_with_real_config / post_graph helpers
- CLI omnigraph graphs create subcommand + its handler + cli.rs tests
- system_remote.rs combined list+create test trimmed to list-only
- YAML rewrite infra: rewrite_atomic[_with_modify], RewriteAtomicError,
staging_path, hash_config_file, AppState::config_hash field +
threading through new_multi and open_multi_graph_state
- fs2 dependency (verified absent from cargo tree)
- sha2/fs2 imports in config.rs (only the rewrite path used them)
- Cedar PolicyAction::GraphCreate variant + "graph_create" match arms
+ action def in Cedar schema + graph_create_action_authorizes_against_server_resource test
- GraphCreateRequest / GraphCreateResponse / GraphSchemaSpec /
GraphPolicySpec API types (only the POST handler / CLI imported them)
Kept:
- GET /graphs (read-only enumeration) and graph_list Cedar action
- omnigraph graphs list CLI subcommand
- All multi-graph startup, mode inference, cluster routes,
per-graph + server-level Cedar policies
- server_settings_drive_multi_graph_startup_end_to_end (the test
that covers operator-authored YAML + restart — the path that
survives)
- best_effort_cleanup_init_artifacts and the three init failpoints
(still reachable from CLI `omnigraph init`; preflight fix deferred
as a follow-up)
- GraphRegistry::insert and its concurrency tests — production
callers gone, but the method is the natural seam for the future
cluster-catalog work
Also fixed (transcript issue 4):
- ALWAYS_FLAT_PATHS now includes /graphs so multi-mode OpenAPI
advertises the management route correctly (was previously rewritten
to /graphs/{graph_id}/graphs)
- multi_mode_openapi_keeps_healthz_flat → renamed to
multi_mode_openapi_keeps_management_paths_flat, asserts both
/healthz and /graphs stay flat
- multi_mode_openapi_prefixes_operation_ids_with_cluster skips
/graphs in addition to /healthz
Doc fixes:
- docs/user/cli.md: graphs list example was --target http://...,
but --target is a config-graph-name lookup; corrected to --uri.
Removed the graphs create example.
- docs/user/server.md: dropped POST /graphs row, "omnigraph.yaml
ownership", and "POST /graphs body shape" sections. Added a
paragraph stating runtime add/remove is not exposed in v0.7.0.
- docs/user/policy.md: dropped graph_create action; reworded the
"Configuration" line to clarify that server-scoped rules (graph_list)
take neither branch_scope nor target_branch_scope.
- docs/releases/v0.7.0.md: rewrote release narrative — multi-graph
mode ships; runtime add/remove deferred.
- AGENTS.md: HTTP server bullet and capability matrix row updated to
reflect read-only GET /graphs and the operator-edit workflow.
- openapi.json regenerated; /graphs has only .get, no .post.
Diff: 17 files, +123 −1525 LOC.
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
2026-05-26 17:49:38 +02:00
|
|
|
// Flat-mounted paths (healthz, management /graphs) keep their
|
|
|
|
|
// original operation_ids — they're not per-graph.
|
mr-668: OpenAPI multi-mode cluster filter (PR 4b/10)
PR 4b of the MR-668 multi-graph server work. In multi mode, the served
`/openapi.json` reports cluster routes (`/graphs/{graph_id}/...`) instead
of the legacy flat protected paths — matching what `build_app` actually
mounts (PR 4a's `Router::nest`). Single mode is unchanged.
Implementation:
- New `server_openapi` branch: when `state.mode()` is `Multi`, call
`nest_paths_under_cluster_prefix(&mut doc)` after `ApiDoc::openapi()`.
- The rewrite consumes `doc.paths.paths`, then for every path-item:
- If the path is in `ALWAYS_FLAT_PATHS` (`/healthz` for now), keep
it flat.
- Otherwise, prefix every operation_id with `cluster_` and reinsert
the item at `/graphs/{graph_id}<original_path>`.
- Single mode hits no extra work — the path map is untouched.
- The static `ApiDoc::openapi()` still emits the flat surface, so
in-process callers (the existing `openapi_json()` helper in tests)
see the unmodified spec.
Why cluster_ prefix on operation IDs: OpenAPI specs require unique
operation_ids across the document. With both flat (single-mode) and
cluster (multi-mode) surfaces ever co-existing in a generated SDK,
the prefix prevents collision. The current served doc only carries
one surface, so the prefix is forward-compat with potential future
dual-surface generation.
Tests: 6 new in `tests/openapi.rs`, all via the `/openapi.json` route
(not the static `ApiDoc::openapi()` helper):
- `multi_mode_openapi_lists_cluster_paths` — every protected path
appears as a cluster variant.
- `multi_mode_openapi_drops_flat_protected_paths` — flat protected
paths are absent.
- `multi_mode_openapi_keeps_healthz_flat` — `/healthz` survives.
- `multi_mode_openapi_prefixes_operation_ids_with_cluster` — every
cluster operation_id starts with `cluster_`.
- `multi_mode_operation_ids_are_unique` — no operation_id collisions.
- `single_mode_openapi_unchanged_by_cluster_filter` — single mode
still emits the legacy flat surface (regression).
New test helper `app_for_multi_mode(graph_ids)` exercises the new
`AppState::new_multi` constructor from PR 4a — first user of multi-mode
construction outside of unit tests.
Result: 66 openapi tests + 57 server integration tests + 74 lib tests
= 197 green. No regression in the existing OpenAPI drift check
(`openapi_spec_is_up_to_date` still validates the static flat surface
matches the committed openapi.json).
LOC: +67 in lib.rs (rewrite logic), +219 in tests/openapi.rs (test
suite + helper).
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
2026-05-25 19:59:02 +02:00
|
|
|
let paths = json["paths"].as_object().unwrap();
|
|
|
|
|
let mut checked = 0;
|
|
|
|
|
for (path, item) in paths {
|
mr-668: remove POST /graphs and CLI graphs create (defer runtime graph mgmt)
The POST /graphs runtime-create endpoint shipped in PR 7/10 has three
unresolved high-severity bugs:
- flock-on-renamed-inode race: the YAML flock is taken on
omnigraph.yaml itself, then a temp file is renamed over it.
Cross-process writers end up locking different inodes — both
believing they hold exclusive access.
- duplicate-check outside the file lock: precheck runs against
the in-memory registry only; the locked closure does
config.graphs.insert(...) unconditionally. Concurrent same-id
POSTs can persist the loser in YAML while the in-memory registry
keeps the winner — they disagree after restart.
- best_effort_cleanup_init_artifacts deletes _schema.pg /
_schema.ir.json / __schema_state.json on any init failure. An
accidental re-init against an existing graph's URI destroys its
schema; subsequent open() fails at read_text(_schema.pg).
The correct fix is a Lance-style cluster catalog (reserve → init →
publish with recovery sidecars), parallel to the engine's existing
__manifest discipline. That work is out of scope for v0.7.0.
For now, disable runtime add/remove from the network and CLI surface.
Operators add graphs by editing omnigraph.yaml and restarting. The
GET /graphs read-only enumeration stays.
Removed:
- POST /graphs handler + router fragment + utoipa registration
- 13 post_graphs_* server tests + 3 composite POST tests +
multi_mode_app_with_real_config / post_graph helpers
- CLI omnigraph graphs create subcommand + its handler + cli.rs tests
- system_remote.rs combined list+create test trimmed to list-only
- YAML rewrite infra: rewrite_atomic[_with_modify], RewriteAtomicError,
staging_path, hash_config_file, AppState::config_hash field +
threading through new_multi and open_multi_graph_state
- fs2 dependency (verified absent from cargo tree)
- sha2/fs2 imports in config.rs (only the rewrite path used them)
- Cedar PolicyAction::GraphCreate variant + "graph_create" match arms
+ action def in Cedar schema + graph_create_action_authorizes_against_server_resource test
- GraphCreateRequest / GraphCreateResponse / GraphSchemaSpec /
GraphPolicySpec API types (only the POST handler / CLI imported them)
Kept:
- GET /graphs (read-only enumeration) and graph_list Cedar action
- omnigraph graphs list CLI subcommand
- All multi-graph startup, mode inference, cluster routes,
per-graph + server-level Cedar policies
- server_settings_drive_multi_graph_startup_end_to_end (the test
that covers operator-authored YAML + restart — the path that
survives)
- best_effort_cleanup_init_artifacts and the three init failpoints
(still reachable from CLI `omnigraph init`; preflight fix deferred
as a follow-up)
- GraphRegistry::insert and its concurrency tests — production
callers gone, but the method is the natural seam for the future
cluster-catalog work
Also fixed (transcript issue 4):
- ALWAYS_FLAT_PATHS now includes /graphs so multi-mode OpenAPI
advertises the management route correctly (was previously rewritten
to /graphs/{graph_id}/graphs)
- multi_mode_openapi_keeps_healthz_flat → renamed to
multi_mode_openapi_keeps_management_paths_flat, asserts both
/healthz and /graphs stay flat
- multi_mode_openapi_prefixes_operation_ids_with_cluster skips
/graphs in addition to /healthz
Doc fixes:
- docs/user/cli.md: graphs list example was --target http://...,
but --target is a config-graph-name lookup; corrected to --uri.
Removed the graphs create example.
- docs/user/server.md: dropped POST /graphs row, "omnigraph.yaml
ownership", and "POST /graphs body shape" sections. Added a
paragraph stating runtime add/remove is not exposed in v0.7.0.
- docs/user/policy.md: dropped graph_create action; reworded the
"Configuration" line to clarify that server-scoped rules (graph_list)
take neither branch_scope nor target_branch_scope.
- docs/releases/v0.7.0.md: rewrote release narrative — multi-graph
mode ships; runtime add/remove deferred.
- AGENTS.md: HTTP server bullet and capability matrix row updated to
reflect read-only GET /graphs and the operator-edit workflow.
- openapi.json regenerated; /graphs has only .get, no .post.
Diff: 17 files, +123 −1525 LOC.
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
2026-05-26 17:49:38 +02:00
|
|
|
if path == "/healthz" || path == "/graphs" {
|
mr-668: OpenAPI multi-mode cluster filter (PR 4b/10)
PR 4b of the MR-668 multi-graph server work. In multi mode, the served
`/openapi.json` reports cluster routes (`/graphs/{graph_id}/...`) instead
of the legacy flat protected paths — matching what `build_app` actually
mounts (PR 4a's `Router::nest`). Single mode is unchanged.
Implementation:
- New `server_openapi` branch: when `state.mode()` is `Multi`, call
`nest_paths_under_cluster_prefix(&mut doc)` after `ApiDoc::openapi()`.
- The rewrite consumes `doc.paths.paths`, then for every path-item:
- If the path is in `ALWAYS_FLAT_PATHS` (`/healthz` for now), keep
it flat.
- Otherwise, prefix every operation_id with `cluster_` and reinsert
the item at `/graphs/{graph_id}<original_path>`.
- Single mode hits no extra work — the path map is untouched.
- The static `ApiDoc::openapi()` still emits the flat surface, so
in-process callers (the existing `openapi_json()` helper in tests)
see the unmodified spec.
Why cluster_ prefix on operation IDs: OpenAPI specs require unique
operation_ids across the document. With both flat (single-mode) and
cluster (multi-mode) surfaces ever co-existing in a generated SDK,
the prefix prevents collision. The current served doc only carries
one surface, so the prefix is forward-compat with potential future
dual-surface generation.
Tests: 6 new in `tests/openapi.rs`, all via the `/openapi.json` route
(not the static `ApiDoc::openapi()` helper):
- `multi_mode_openapi_lists_cluster_paths` — every protected path
appears as a cluster variant.
- `multi_mode_openapi_drops_flat_protected_paths` — flat protected
paths are absent.
- `multi_mode_openapi_keeps_healthz_flat` — `/healthz` survives.
- `multi_mode_openapi_prefixes_operation_ids_with_cluster` — every
cluster operation_id starts with `cluster_`.
- `multi_mode_operation_ids_are_unique` — no operation_id collisions.
- `single_mode_openapi_unchanged_by_cluster_filter` — single mode
still emits the legacy flat surface (regression).
New test helper `app_for_multi_mode(graph_ids)` exercises the new
`AppState::new_multi` constructor from PR 4a — first user of multi-mode
construction outside of unit tests.
Result: 66 openapi tests + 57 server integration tests + 74 lib tests
= 197 green. No regression in the existing OpenAPI drift check
(`openapi_spec_is_up_to_date` still validates the static flat surface
matches the committed openapi.json).
LOC: +67 in lib.rs (rewrite logic), +219 in tests/openapi.rs (test
suite + helper).
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
2026-05-25 19:59:02 +02:00
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
for method in ["get", "post", "put", "delete", "patch"] {
|
|
|
|
|
if let Some(op) = item.get(method).filter(|v| v.is_object()) {
|
|
|
|
|
if let Some(id) = op["operationId"].as_str() {
|
|
|
|
|
assert!(
|
|
|
|
|
id.starts_with("cluster_"),
|
|
|
|
|
"operation_id at {path}.{method} must start with `cluster_`, got `{id}`"
|
|
|
|
|
);
|
|
|
|
|
checked += 1;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
assert!(
|
|
|
|
|
checked >= EXPECTED_CLUSTER_PATHS.len(),
|
|
|
|
|
"expected at least {} cluster operation_ids; checked {checked}",
|
|
|
|
|
EXPECTED_CLUSTER_PATHS.len()
|
|
|
|
|
);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[tokio::test]
|
|
|
|
|
async fn multi_mode_operation_ids_are_unique() {
|
|
|
|
|
// Sanity check: the cluster_ prefix prevents collision with flat ids
|
|
|
|
|
// (which don't appear in multi mode, but the contract is "unique
|
|
|
|
|
// across the spec"). Verify every operation_id in the multi-mode
|
|
|
|
|
// spec is unique.
|
|
|
|
|
let (_dirs, app) = app_for_multi_mode(&["alpha"]).await;
|
|
|
|
|
let request = Request::builder()
|
|
|
|
|
.method(Method::GET)
|
|
|
|
|
.uri("/openapi.json")
|
|
|
|
|
.body(Body::empty())
|
|
|
|
|
.unwrap();
|
|
|
|
|
let (_, json) = json_response(&app, request).await;
|
|
|
|
|
let paths = json["paths"].as_object().unwrap();
|
|
|
|
|
let mut seen_ids: HashSet<String> = HashSet::new();
|
|
|
|
|
for (_, item) in paths {
|
|
|
|
|
for method in ["get", "post", "put", "delete", "patch"] {
|
|
|
|
|
if let Some(op) = item.get(method).filter(|v| v.is_object()) {
|
|
|
|
|
if let Some(id) = op["operationId"].as_str() {
|
|
|
|
|
assert!(
|
|
|
|
|
seen_ids.insert(id.to_string()),
|
|
|
|
|
"duplicate operation_id `{id}` in multi-mode spec"
|
|
|
|
|
);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[tokio::test]
|
|
|
|
|
async fn single_mode_openapi_unchanged_by_cluster_filter() {
|
|
|
|
|
// Regression: single mode still emits the legacy flat surface.
|
|
|
|
|
let (_temp, app) = app_for_loaded_graph().await;
|
|
|
|
|
let request = Request::builder()
|
|
|
|
|
.method(Method::GET)
|
|
|
|
|
.uri("/openapi.json")
|
|
|
|
|
.body(Body::empty())
|
|
|
|
|
.unwrap();
|
|
|
|
|
let (_, json) = json_response(&app, request).await;
|
|
|
|
|
let paths = json["paths"].as_object().unwrap();
|
|
|
|
|
let path_keys: HashSet<&str> = paths.keys().map(|k| k.as_str()).collect();
|
|
|
|
|
for expected in EXPECTED_PATHS {
|
|
|
|
|
assert!(
|
|
|
|
|
path_keys.contains(expected),
|
|
|
|
|
"single mode must still emit flat path: {expected}"
|
|
|
|
|
);
|
|
|
|
|
}
|
|
|
|
|
for cluster in EXPECTED_CLUSTER_PATHS {
|
|
|
|
|
assert!(
|
|
|
|
|
!path_keys.contains(cluster),
|
|
|
|
|
"single mode must NOT emit cluster path: {cluster}"
|
|
|
|
|
);
|
|
|
|
|
}
|
|
|
|
|
}
|