271 lines
10 KiB
Rust
271 lines
10 KiB
Rust
use super::*;
|
|
use std::sync::Arc;
|
|
|
|
#[tokio::test]
|
|
#[ignore = "requires the disposable RLS database from tests/local_access_database.py"]
|
|
async fn inbox_count_cursor_history_and_customer_permissions() {
|
|
let admin = sqlx::PgPool::connect(&std::env::var("RMM_TEST_REPAIR_ADMIN_URL").unwrap())
|
|
.await
|
|
.unwrap();
|
|
let pool = sqlx::postgres::PgPoolOptions::new()
|
|
.max_connections(1)
|
|
.connect(&std::env::var("RMM_TEST_REPAIR_APP_URL").unwrap())
|
|
.await
|
|
.unwrap();
|
|
let a = Uuid::new_v4();
|
|
let b = Uuid::new_v4();
|
|
let c = Uuid::new_v4();
|
|
let user = format!("fixture:{a}");
|
|
let op = Uuid::new_v4();
|
|
let plan = Uuid::new_v4();
|
|
let agent = Uuid::new_v4();
|
|
let stamp = Utc::now() - chrono::Duration::minutes(1);
|
|
|
|
for (tenant, name) in [(a, "Kunde A"), (b, "Kunde B"), (c, "Nur Leser")] {
|
|
sqlx::query("INSERT INTO tenants(tenant_id,name) VALUES($1,$2)")
|
|
.bind(tenant)
|
|
.bind(name)
|
|
.execute(&admin)
|
|
.await
|
|
.unwrap();
|
|
let mut permissions = vec!["operations:read"];
|
|
if tenant != c {
|
|
permissions.push("plans:approve");
|
|
}
|
|
if tenant == a {
|
|
permissions.push("inventory:read");
|
|
}
|
|
sqlx::query("INSERT INTO memberships(tenant_id,principal,kind,permissions) VALUES($1,$2,'human',$3)")
|
|
.bind(tenant).bind(&user).bind(permissions).execute(&admin).await.unwrap();
|
|
|
|
// IDs can coincide across customers. A human-readable label may only
|
|
// come from the customer's own authenticated membership and inventory.
|
|
sqlx::query("INSERT INTO assets(tenant_id,asset_id) VALUES($1,$2)")
|
|
.bind(tenant)
|
|
.bind(agent)
|
|
.execute(&admin)
|
|
.await
|
|
.unwrap();
|
|
sqlx::query("INSERT INTO agent_installations(tenant_id,agent_id,asset_id,certificate_sha256) VALUES($1,$2,$2,$3)")
|
|
.bind(tenant).bind(agent).bind(rmm_domain::jobs::hash(tenant.as_bytes())).execute(&admin).await.unwrap();
|
|
let snapshot = Uuid::new_v4();
|
|
sqlx::query("INSERT INTO observations(tenant_id,agent_id,message_id,boot_id,sequence,observed_at,source_id,quality,completeness,snapshot_id,data,payload_sha256)
|
|
VALUES($1,$2,$3,$3,1,now(),'linux.base','valid','partial',$3,$4,$5)")
|
|
.bind(tenant).bind(agent).bind(snapshot).bind(json!({"hostname":name})).bind("0".repeat(64)).execute(&admin).await.unwrap();
|
|
|
|
for (i, status, expired) in [
|
|
(0, "pending_approval", false),
|
|
(1, "pending_approval", true),
|
|
(2, "rejected", false),
|
|
] {
|
|
let (op_id, plan_id) = if i == 0 {
|
|
(op, plan)
|
|
} else {
|
|
(Uuid::new_v4(), Uuid::new_v4())
|
|
};
|
|
let payload = json!({"jobs":[{"payload":{"asset_id":agent,"agent_id":agent,"action":{"action":"run_script"}}}],
|
|
"reason":"Testauftrag","script_revision":{"revision_id":op,"name":"Kernelversion","version":3}});
|
|
sqlx::query("INSERT INTO operation_plans(tenant_id,plan_id,principal,payload,plan_hash,expires_at)
|
|
VALUES($1,$2,'mcp:fixture',$3,'fixture',CASE WHEN $4 THEN now()-interval '1 hour' ELSE now()+interval '1 hour' END)")
|
|
.bind(tenant).bind(plan_id).bind(serde_json::to_vec(&payload).unwrap()).bind(expired).execute(&admin).await.unwrap();
|
|
sqlx::query("INSERT INTO approval_requests(tenant_id,operation_id,plan_id,principal,idempotency_key,request_hash,created_at,approval_state)
|
|
VALUES($1,$2,$3,'mcp:fixture',$4,'fixture',$5,$6)")
|
|
.bind(tenant).bind(op_id).bind(plan_id).bind(plan_id.to_string()).bind(stamp).bind(status).execute(&admin).await.unwrap();
|
|
if status == "rejected" {
|
|
sqlx::query("INSERT INTO audit_events VALUES($1,$2,$3,'plan_authorization',$4,$5)")
|
|
.bind(tenant).bind(Uuid::new_v4()).bind(format!("reviewer:{tenant}"))
|
|
.bind(json!({"operation_id":op_id,"plan_id":plan_id,"plan_hash":"fixture",
|
|
"decision":"reject","testsimulation":true}))
|
|
.bind(stamp + chrono::Duration::seconds(5)).execute(&admin).await.unwrap();
|
|
}
|
|
}
|
|
}
|
|
|
|
let dir = std::env::temp_dir().join(format!("approvals-{a}"));
|
|
let state = crate::State {
|
|
pool,
|
|
signer: None,
|
|
viewer_a: [0; 32],
|
|
viewer_b: [1; 32],
|
|
auth: Arc::new(crate::auth::Auth::from_env("development").await.unwrap()),
|
|
job_signer: Arc::new(
|
|
crate::job_signer::JobSigner::load_or_create(&dir.join("inbox.key")).unwrap(),
|
|
),
|
|
};
|
|
let mut p = Principal {
|
|
tenant: a,
|
|
tenants: vec![a, b, c],
|
|
name: user.clone(),
|
|
operator: true,
|
|
session_hash: Some("session".into()),
|
|
csrf: None,
|
|
scopes: None,
|
|
testsimulation: true,
|
|
identity: None,
|
|
};
|
|
|
|
let first = list(
|
|
&state,
|
|
&p,
|
|
Filters {
|
|
limit: Some(1),
|
|
..Default::default()
|
|
},
|
|
)
|
|
.await
|
|
.unwrap();
|
|
assert_eq!(first["pending_count"], 2);
|
|
assert_eq!(first["customers"].as_array().unwrap().len(), 2);
|
|
assert_eq!(first["can_review"], true);
|
|
let cursor = first["next_cursor"].as_str().unwrap().to_owned();
|
|
let second = list(
|
|
&state,
|
|
&p,
|
|
Filters {
|
|
cursor: Some(cursor.clone()),
|
|
..Default::default()
|
|
},
|
|
)
|
|
.await
|
|
.unwrap();
|
|
assert_eq!(second["pending_count"], 2);
|
|
assert!(second["next_cursor"].is_null());
|
|
let rows = [&first["items"][0], &second["items"][0]];
|
|
assert_ne!(rows[0]["tenant_id"], rows[1]["tenant_id"]);
|
|
for row in rows {
|
|
assert_eq!(row["operation_id"], json!(op));
|
|
assert_eq!(row["title"], "Kernelversion");
|
|
assert_eq!(row["script_revision"]["version"], 3);
|
|
assert_eq!(row["action"], "run_script");
|
|
assert_eq!(row["requester"], "mcp:fixture");
|
|
assert_eq!(row["targets"][0]["asset_id"], json!(agent));
|
|
if row["tenant_id"] == json!(a) {
|
|
assert_eq!(row["targets"][0]["hostname"], "Kunde A");
|
|
} else {
|
|
assert!(row["targets"][0]["hostname"].is_null());
|
|
}
|
|
}
|
|
assert_eq!(
|
|
list(
|
|
&state,
|
|
&p,
|
|
Filters {
|
|
cursor: Some(cursor.clone()),
|
|
status: Status::History,
|
|
..Default::default()
|
|
}
|
|
)
|
|
.await
|
|
.unwrap_err()
|
|
.0,
|
|
StatusCode::BAD_REQUEST
|
|
);
|
|
let history = list(
|
|
&state,
|
|
&p,
|
|
Filters {
|
|
tenant_id: Some(a),
|
|
status: Status::History,
|
|
..Default::default()
|
|
},
|
|
)
|
|
.await
|
|
.unwrap();
|
|
assert_eq!(history["pending_count"], 1);
|
|
let states: Vec<_> = history["items"]
|
|
.as_array()
|
|
.unwrap()
|
|
.iter()
|
|
.map(|item| item["approval_state"].as_str().unwrap())
|
|
.collect();
|
|
assert_eq!(states.len(), 2);
|
|
assert!(states.contains(&"expired") && states.contains(&"rejected"));
|
|
let items = history["items"].as_array().unwrap();
|
|
let rejected = items.iter().find(|item| item["approval_state"] == "rejected").unwrap();
|
|
assert_eq!(rejected["decision"]["principal"], format!("reviewer:{a}"));
|
|
assert_eq!(rejected["decision"]["testsimulation"], true);
|
|
let at: DateTime<Utc> = serde_json::from_value(rejected["decision"]["at"].clone()).unwrap();
|
|
assert_eq!(at.timestamp_micros(), (stamp + chrono::Duration::seconds(5)).timestamp_micros());
|
|
assert!(items.iter().find(|item| item["approval_state"] == "expired").unwrap()["decision"].is_null());
|
|
|
|
// Filter the authorized storage rows before applying the page limit.
|
|
for (tenant, disclose_names, matches) in [(a, true, 1), (b, false, 0)] {
|
|
let mut tx = rmm_persistence::tenant_tx(&state.pool, tenant).await.unwrap();
|
|
let rows: Vec<(Uuid, DateTime<Utc>)> = sqlx::query_as(include_str!("../order_filter.sql"))
|
|
.bind(Utc::now()).bind(None::<DateTime<Utc>>).bind(Uuid::nil())
|
|
.bind(stamp - chrono::Duration::seconds(1)).bind(stamp + chrono::Duration::seconds(1))
|
|
.bind("kernel").bind("rejected").bind("Kunde").bind(None::<Uuid>).bind(disclose_names)
|
|
.bind(1_i64).fetch_all(&mut *tx).await.unwrap();
|
|
assert_eq!(rows.len(), matches);
|
|
tx.commit().await.unwrap();
|
|
}
|
|
let count = list(
|
|
&state,
|
|
&p,
|
|
Filters {
|
|
count_only: true,
|
|
..Default::default()
|
|
},
|
|
)
|
|
.await
|
|
.unwrap();
|
|
assert_eq!(count["pending_count"], 2);
|
|
assert_eq!(count["items"], json!([]));
|
|
assert_eq!(
|
|
list(
|
|
&state,
|
|
&p,
|
|
Filters {
|
|
tenant_id: Some(c),
|
|
..Default::default()
|
|
}
|
|
)
|
|
.await
|
|
.unwrap_err()
|
|
.0,
|
|
StatusCode::FORBIDDEN
|
|
);
|
|
assert_eq!(
|
|
list(
|
|
&state,
|
|
&p,
|
|
Filters {
|
|
tenant_id: Some(Uuid::new_v4()),
|
|
..Default::default()
|
|
}
|
|
)
|
|
.await
|
|
.unwrap_err()
|
|
.0,
|
|
StatusCode::NOT_FOUND
|
|
);
|
|
sqlx::query("UPDATE memberships SET permissions=ARRAY['operations:read'] WHERE principal=$1 AND tenant_id=$2")
|
|
.bind(&user).bind(b).execute(&admin).await.unwrap();
|
|
assert_eq!(
|
|
list(
|
|
&state,
|
|
&p,
|
|
Filters {
|
|
cursor: Some(cursor),
|
|
..Default::default()
|
|
}
|
|
)
|
|
.await
|
|
.unwrap_err()
|
|
.0,
|
|
StatusCode::BAD_REQUEST
|
|
);
|
|
p.tenants = vec![c];
|
|
p.tenant = c;
|
|
let none = list(&state, &p, Filters::default()).await.unwrap();
|
|
assert_eq!(none["pending_count"], 0);
|
|
assert_eq!(none["items"], json!([]));
|
|
assert_eq!(none["can_review"], false);
|
|
p.session_hash = None;
|
|
assert_eq!(
|
|
list(&state, &p, Filters::default()).await.unwrap_err().0,
|
|
StatusCode::FORBIDDEN
|
|
);
|
|
std::fs::remove_dir_all(dir).unwrap();
|
|
}
|