G16 给 ExecRuntime 加了出向 TDS 通道字段 tds: TdsClient,但集成测试 tests/exec_endpoints.rs 的构造点没同步 ⇒ cargo test 编译不过 (missing field `tds`)。按 src 内单测同口径补 TdsClient::new(None, String::new()) (契约测试不真连平台)。 验证:cargo check 通过;cargo test 全绿 307 passed / 0 failed。
315 lines
11 KiB
Rust
315 lines
11 KiB
Rust
//! 平台下发三端点的契约回归(对位 `build/fake-tdc-receiver.py` 与 ② 的 ⑦ 探测)。
|
||
//!
|
||
//! 🔴 验收锚点:`verify-contract-driven-tunnel.sh:410-413` 的裸 curl
|
||
//! `POST .../DeliveryTask/PROBE/Exec/Start` 必须从 **404 → 200**(端点存在)。
|
||
//!
|
||
//! ⚠️ 每个测试用独立临时目录构造 `ExecRuntime`(直接替换 `state.exec`),
|
||
//! **不设进程级环境变量** ⇒ 并行测试无 env 竞态。
|
||
|
||
use std::collections::BTreeMap;
|
||
use std::fs;
|
||
use std::path::{Path, PathBuf};
|
||
use std::sync::Arc;
|
||
|
||
use axum::body::Body;
|
||
use axum::http::{Request, StatusCode};
|
||
use axum::Router;
|
||
use http_body_util::BodyExt;
|
||
use pglite::PGlite;
|
||
use serde_json::{json, Value};
|
||
use tdc_connector::platform::auth::{auth_middleware, AuthState};
|
||
use tdc_connector::platform::config::Config;
|
||
use tdc_connector::platform::session::SessionStore;
|
||
use tdc_connector::platform::state::AppState;
|
||
use tdc_connector::tdc::client::mpc_control_plane::MpcControlPlaneClient;
|
||
use tdc_connector::tdc::client::tds::TdsClient;
|
||
use tdc_connector::tdc::config::TdcConfig;
|
||
use tdc_connector::tdc::controller::build_router;
|
||
use tdc_connector::tdc::engine::config::{self, ExecConfig};
|
||
use tdc_connector::tdc::engine::{ExecRuntime, ExecStore};
|
||
use tdc_connector::tdc::state::{BootstrapIdentity, TdcState};
|
||
use tdc_connector::tdc::support::public_paths;
|
||
use tokio::sync::OnceCell;
|
||
use tower::ServiceExt;
|
||
|
||
static DB: OnceCell<Arc<PGlite>> = OnceCell::const_new();
|
||
|
||
async fn shared_db() -> Arc<PGlite> {
|
||
DB.get_or_init(|| async {
|
||
let db = Arc::new(PGlite::open_temp().await.expect("打开临时 PGlite 失败"));
|
||
tdc_connector::platform::db::ensure_schema(db.as_ref())
|
||
.await
|
||
.expect("建表失败");
|
||
db
|
||
})
|
||
.await
|
||
.clone()
|
||
}
|
||
|
||
const ARTIFACT: &[u8] = b"import sys\nprint('fake algorithm for contract-driven tunnel test')\n";
|
||
|
||
/// 每个用例一个目录(含进程 id + 用例名),避免并行互踩。
|
||
fn case_dir(name: &str) -> PathBuf {
|
||
let d = std::env::temp_dir().join(format!("tdc-exec-it-{}-{}", std::process::id(), name));
|
||
let _ = fs::remove_dir_all(&d);
|
||
fs::create_dir_all(d.join("artifacts")).unwrap();
|
||
fs::write(d.join("artifacts/algorithm.py"), ARTIFACT).unwrap();
|
||
d
|
||
}
|
||
|
||
fn exec_config(dir: &Path) -> ExecConfig {
|
||
let env: BTreeMap<String, String> = [
|
||
(config::ENV_ARTIFACT_DIR, dir.join("artifacts").to_string_lossy().to_string()),
|
||
(config::ENV_STATE_DIR, dir.join("state").to_string_lossy().to_string()),
|
||
(config::ENV_LOCAL_VIP, "10.12.0.2".to_string()),
|
||
(config::ENV_SITE_ENDPOINTS, "alice=10.12.0.1:9449,carol=10.12.0.2:9449".to_string()),
|
||
(config::ENV_DRY_RUN, "1".to_string()),
|
||
]
|
||
.into_iter()
|
||
.map(|(k, v)| (k.to_string(), v))
|
||
.collect();
|
||
ExecConfig::from_raw(&env, dir)
|
||
}
|
||
|
||
async fn build(name: &str) -> (Router, String, Arc<ExecRuntime>) {
|
||
let dir = case_dir(name);
|
||
let db = shared_db().await;
|
||
let config = Config::from_env(std::env::current_dir().unwrap());
|
||
let sessions = Arc::new(SessionStore::new());
|
||
let token = config.internal_token.clone();
|
||
let mut state = TdcState::new(
|
||
AppState::new(config.clone(), db, sessions.clone()),
|
||
TdcConfig::default(),
|
||
BootstrapIdentity {
|
||
identity_id: "TEST-OP".to_string(),
|
||
identity_code: "TEST-CONNECTOR".to_string(),
|
||
issued_secret: None,
|
||
},
|
||
);
|
||
let cfg = exec_config(&dir);
|
||
let exec = Arc::new(ExecRuntime {
|
||
store: ExecStore::new(&cfg.state_dir),
|
||
config: cfg,
|
||
control_plane: MpcControlPlaneClient::new(None, String::new()),
|
||
// 出向 TDS 通道:契约测试不真连平台 ⇒ 无 base_url / 无令牌(与 src 内单测同口径)。
|
||
tds: TdsClient::new(None, String::new()),
|
||
});
|
||
state.exec = exec.clone();
|
||
let auth_state = AuthState {
|
||
internal_token: token.clone(),
|
||
sessions,
|
||
public_paths: Arc::new(public_paths::all_public_paths()),
|
||
};
|
||
let app: Router = build_router(state.clone())
|
||
.layer(axum::middleware::from_fn_with_state(
|
||
auth_state,
|
||
auth_middleware,
|
||
))
|
||
.with_state(state);
|
||
(app, token, exec)
|
||
}
|
||
|
||
fn req(method: &str, uri: &str, body: &str, token: Option<&str>) -> Request<Body> {
|
||
let mut b = Request::builder()
|
||
.method(method)
|
||
.uri(uri)
|
||
.header("Content-Type", "application/json");
|
||
if let Some(t) = token {
|
||
b = b
|
||
.header("X-Internal-Token", t)
|
||
.header("X-Protocol-Version", "3.2")
|
||
.header("X-Internal-Operator", "it");
|
||
}
|
||
b.body(Body::from(body.to_string())).unwrap()
|
||
}
|
||
|
||
async fn call(app: Router, r: Request<Body>) -> (StatusCode, Value) {
|
||
let resp = app.oneshot(r).await.unwrap();
|
||
let status = resp.status();
|
||
let bytes = resp.into_body().collect().await.unwrap().to_bytes();
|
||
let v = serde_json::from_slice(&bytes).unwrap_or(Value::Null);
|
||
(status, v)
|
||
}
|
||
|
||
/// ⑦ 验收:**裸 curl 存活探测**从 404 → 200,且零副作用。
|
||
#[tokio::test]
|
||
async fn probe_is_200_without_any_credentials_and_has_no_side_effects() {
|
||
let (app, _token, exec) = build("probe").await;
|
||
let (status, v) = call(
|
||
app,
|
||
req(
|
||
"POST",
|
||
"/api/ssw/tdc/DeliveryTask/PROBE/Exec/Start",
|
||
"",
|
||
None,
|
||
),
|
||
)
|
||
.await;
|
||
assert_eq!(status, StatusCode::OK);
|
||
assert_eq!(v["code"], 200);
|
||
assert_eq!(v["data"]["ok"], true);
|
||
assert_eq!(v["data"]["probe"], true);
|
||
// 零副作用:不落任何执行记录
|
||
assert!(exec.store.list().is_empty(), "PROBE 不得产生状态记录");
|
||
}
|
||
|
||
/// 真实 taskId **仍需内部令牌**:白名单放行 ≠ 免鉴权。
|
||
#[tokio::test]
|
||
async fn real_dispatch_without_token_is_401() {
|
||
let (app, _token, _exec) = build("unauth").await;
|
||
let (status, v) = call(
|
||
app,
|
||
req(
|
||
"POST",
|
||
"/api/ssw/tdc/DeliveryTask/T1/Exec/Start",
|
||
"{}",
|
||
None,
|
||
),
|
||
)
|
||
.await;
|
||
assert_eq!(status, StatusCode::UNAUTHORIZED);
|
||
assert_eq!(v["code"], 401);
|
||
assert_eq!(v["success"], false);
|
||
}
|
||
|
||
/// `SelfCheckStatus`:`readyStatus=READY` + 能力清单如实列出。
|
||
#[tokio::test]
|
||
async fn self_check_is_ready_and_reports_capabilities() {
|
||
let (app, token, _exec) = build("selfcheck").await;
|
||
let (status, v) = call(
|
||
app,
|
||
req(
|
||
"POST",
|
||
"/api/ssw/tdc/DeliveryTask/T1/Internal/SelfCheckStatus",
|
||
"{}",
|
||
Some(&token),
|
||
),
|
||
)
|
||
.await;
|
||
assert_eq!(status, StatusCode::OK);
|
||
assert_eq!(v["code"], 200);
|
||
assert_eq!(v["data"]["readyStatus"], "READY");
|
||
assert_eq!(v["data"]["ok"], true);
|
||
assert_eq!(v["data"]["capabilities"]["engineReady"], true);
|
||
assert_eq!(v["data"]["capabilities"]["ray"]["enabled"], false);
|
||
assert_eq!(v["data"]["capabilities"]["controlPlane"]["configured"], false);
|
||
}
|
||
|
||
/// `Dev/Artifact`:`files` 是 **List**、`algorithmHash` 与 Python `dirDigest` 实算值一致。
|
||
#[tokio::test]
|
||
async fn artifact_is_a_list_with_self_computed_hash() {
|
||
let (app, token, _exec) = build("artifact").await;
|
||
let (status, v) = call(
|
||
app,
|
||
req(
|
||
"GET",
|
||
"/api/ssw/tdc/DeliveryTask/T1/Dev/Artifact?versionNo=1",
|
||
"",
|
||
Some(&token),
|
||
),
|
||
)
|
||
.await;
|
||
assert_eq!(status, StatusCode::OK);
|
||
assert_eq!(v["code"], 200);
|
||
let files = v["data"]["files"].as_array().expect("files 必须是 List");
|
||
assert_eq!(files.len(), 1);
|
||
assert_eq!(files[0]["name"], "algorithm.py");
|
||
assert_eq!(files[0]["contentBase64"], "aW1wb3J0IHN5cwpwcmludCgnZmFrZSBhbGdvcml0aG0gZm9yIGNvbnRyYWN0LWRyaXZlbiB0dW5uZWwgdGVzdCcpCg==");
|
||
// sha256( "algorithm.py\t" + sha256(ARTIFACT) )
|
||
assert_eq!(
|
||
v["data"]["algorithmHash"].as_str().unwrap().len(),
|
||
64,
|
||
"必须是 sha256 hex"
|
||
);
|
||
assert_eq!(v["data"]["entry"], "algorithm.py");
|
||
}
|
||
|
||
/// `Exec/Start`:立即回执 + 后台状态机推进;`dry_run` 收口为 `PLANNED`(**不是 SUCCEEDED**)。
|
||
#[tokio::test]
|
||
async fn exec_start_accepts_and_background_state_machine_reaches_planned() {
|
||
let (app, token, exec) = build("dispatch").await;
|
||
let payload = json!({
|
||
"algorithmHash": "ignored-when-local-artifacts-absent",
|
||
"clusterConfig": {
|
||
"nax": {
|
||
"vnetName": "ssw-PORTAL-DEMO-SPACE",
|
||
"vnetSecret": "ssw-IT-TEST-SECRET",
|
||
"namespace": "nax-991794557079009427-v1",
|
||
"rayHead": "10.12.0.2:30417",
|
||
"rayHeadName": "nax-head-991794557079009427-v1",
|
||
"parties": ["p1", "p2"],
|
||
"consumerParty": "p1"
|
||
},
|
||
"parties": {
|
||
"p1": {"address": "sf-99179455-p1.default.svc.cluster.local:20001"},
|
||
"p2": {"address": "sf-99179455-p2.default.svc.cluster.local:20001"}
|
||
}
|
||
},
|
||
"selfParty": "p1",
|
||
"versionNo": 1
|
||
});
|
||
// 🔴 平台 payload 带 algorithmHash 时,本地产物 hash 必须一致;这里改成真实值。
|
||
let mut payload = payload;
|
||
let hash = {
|
||
let mut files = BTreeMap::new();
|
||
files.insert("algorithm.py".to_string(), ARTIFACT.to_vec());
|
||
tdc_connector::tdc::engine::digest::dir_digest(&files)
|
||
};
|
||
payload["algorithmHash"] = json!(hash);
|
||
|
||
let (status, v) = call(
|
||
app,
|
||
req(
|
||
"POST",
|
||
"/api/ssw/tdc/DeliveryTask/T1/Exec/Start",
|
||
&payload.to_string(),
|
||
Some(&token),
|
||
),
|
||
)
|
||
.await;
|
||
assert_eq!(status, StatusCode::OK);
|
||
assert_eq!(v["code"], 200);
|
||
assert_eq!(v["data"]["ok"], true);
|
||
assert_eq!(v["data"]["accepted"], true);
|
||
let exec_id = v["data"]["execId"].as_str().unwrap().to_string();
|
||
|
||
// 等后台状态机跑完(纯本地、无网络调用)。
|
||
let mut rec = None;
|
||
for _ in 0..40 {
|
||
if let Some(r) = exec.store.get(&exec_id) {
|
||
if r.phase == tdc_connector::tdc::engine::ExecPhase::Planned
|
||
|| r.phase == tdc_connector::tdc::engine::ExecPhase::Failed
|
||
{
|
||
rec = Some(r);
|
||
break;
|
||
}
|
||
}
|
||
tokio::time::sleep(std::time::Duration::from_millis(25)).await;
|
||
}
|
||
let rec = rec.expect("后台状态机未在 1s 内收口");
|
||
assert_eq!(
|
||
rec.phase,
|
||
tdc_connector::tdc::engine::ExecPhase::Planned,
|
||
"dry-run 必须是 PLANNED;实际 message={}",
|
||
rec.message
|
||
);
|
||
assert_eq!(rec.steps.len(), 6, "六个阶段各留一步轨迹");
|
||
// 计划脱敏:不得出现 vnetSecret 明文
|
||
let plan = serde_json::to_string(&rec.plan).unwrap();
|
||
assert!(!plan.contains("ssw-IT-TEST-SECRET"), "计划泄漏 vnetSecret");
|
||
assert!(plan.contains("k8sServiceDnsUnusable"));
|
||
}
|
||
|
||
/// 重复派发(同 namespace / vnet / taskId)复用同一记录,不重复起实例。
|
||
#[tokio::test]
|
||
async fn duplicate_dispatch_is_idempotent() {
|
||
let (app, token, exec) = build("dup").await;
|
||
let body = json!({"clusterConfig":{"nax":{"namespace":"ns","vnetName":"vn"}}}).to_string();
|
||
let uri = "/api/ssw/tdc/DeliveryTask/T1/Exec/Start";
|
||
let (_, a) = call(app.clone(), req("POST", uri, &body, Some(&token))).await;
|
||
let (_, b) = call(app, req("POST", uri, &body, Some(&token))).await;
|
||
assert_eq!(a["data"]["execId"], b["data"]["execId"]);
|
||
assert_eq!(b["data"]["duplicate"], true);
|
||
assert_eq!(exec.store.list().len(), 1);
|
||
}
|