457 lines
17 KiB
Rust
457 lines
17 KiB
Rust
//! Explicit opt-in contract against an owned, disposable fixture. No production credential path.
|
|
mod support;
|
|
use axum::{
|
|
body::Body,
|
|
extract::{Request, State},
|
|
http::StatusCode,
|
|
response::Response,
|
|
};
|
|
use hermes_grocy_mcp::{mcp::McpServer, model::AccessMode, setup};
|
|
use rmcp::{ServiceExt, model::CallToolRequestParams};
|
|
use serde_json::{Value, json};
|
|
use std::sync::{
|
|
Arc,
|
|
atomic::{AtomicUsize, Ordering},
|
|
};
|
|
use support::{MemoryStore, selection};
|
|
#[derive(Clone)]
|
|
struct Proxy {
|
|
target: String,
|
|
http: reqwest::Client,
|
|
outside: Arc<AtomicUsize>,
|
|
}
|
|
async fn forward(State(state): State<Proxy>, req: Request) -> Response {
|
|
let path = req.uri().path();
|
|
let route = if path.starts_with("/api/") {
|
|
path
|
|
} else if let Some(s) = path.strip_prefix("/household") {
|
|
if s.starts_with("/api/") { s } else { "" }
|
|
} else {
|
|
""
|
|
};
|
|
if route.is_empty() {
|
|
state.outside.fetch_add(1, Ordering::SeqCst);
|
|
return Response::builder()
|
|
.status(StatusCode::FORBIDDEN)
|
|
.body(Body::empty())
|
|
.unwrap();
|
|
}
|
|
let url = format!(
|
|
"{}{}{}",
|
|
state.target,
|
|
route,
|
|
req.uri()
|
|
.query()
|
|
.map(|q| format!("?{q}"))
|
|
.unwrap_or_default()
|
|
);
|
|
let mut r = state.http.request(req.method().clone(), url);
|
|
for name in ["GROCY-API-KEY", "content-type", "accept-encoding"] {
|
|
if let Some(v) = req.headers().get(name) {
|
|
r = r.header(name, v)
|
|
}
|
|
}
|
|
let bytes = axum::body::to_bytes(req.into_body(), 9 * 1024 * 1024)
|
|
.await
|
|
.unwrap();
|
|
let res = r.body(bytes).send().await.unwrap();
|
|
let status = res.status();
|
|
let headers = res.headers().clone();
|
|
let bytes = res.bytes().await.unwrap();
|
|
if !status.is_success() && status != StatusCode::NOT_FOUND {
|
|
eprintln!(
|
|
"Fixture API {}: {}",
|
|
status,
|
|
String::from_utf8_lossy(&bytes[..bytes.len().min(600)])
|
|
)
|
|
}
|
|
let mut response = Response::builder().status(status);
|
|
if let Some(v) = headers.get("content-type") {
|
|
response = response.header("content-type", v)
|
|
}
|
|
response.body(Body::from(bytes)).unwrap()
|
|
}
|
|
fn id(v: &Value) -> u64 {
|
|
let v = &v["write"]["receipt"]["created_object_id"];
|
|
v.as_u64()
|
|
.or_else(|| v.as_str().and_then(|s| s.parse().ok()))
|
|
.expect("created ID in receipt")
|
|
}
|
|
fn numeric(v: &Value) -> f64 {
|
|
v.as_f64()
|
|
.or_else(|| v.as_str().and_then(|s| s.parse().ok()))
|
|
.unwrap()
|
|
}
|
|
#[tokio::test]
|
|
#[ignore = "requires scripts/docker_fixture.py with a disposable synthetic instance"]
|
|
async fn docker_household_contract() {
|
|
let path = std::env::var("GROCY_CONTRACT_MANIFEST").expect("fixture manifest");
|
|
let fixture: Value = serde_json::from_slice(&std::fs::read(path).unwrap()).unwrap();
|
|
let outside = Arc::new(AtomicUsize::new(0));
|
|
let proxy = Proxy {
|
|
target: fixture["url"].as_str().unwrap().into(),
|
|
http: reqwest::Client::builder()
|
|
.no_proxy()
|
|
.redirect(reqwest::redirect::Policy::none())
|
|
.build()
|
|
.unwrap(),
|
|
outside: outside.clone(),
|
|
};
|
|
let app = axum::Router::new().fallback(forward).with_state(proxy);
|
|
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
|
|
let port = listener.local_addr().unwrap().port();
|
|
let api = tokio::spawn(async move { axum::serve(listener, app).await.unwrap() });
|
|
let store = Arc::new(MemoryStore {
|
|
url: format!("http://127.0.0.1:{port}/household"),
|
|
access: AccessMode::Full,
|
|
key: fixture["api_key"].as_str().unwrap().into(),
|
|
});
|
|
let report = setup::doctor(selection(), store.clone()).await.unwrap();
|
|
assert_eq!(report.version.as_deref(), Some("4.7.1"));
|
|
assert!(report.household_access);
|
|
let server = McpServer::new(store.clone(), selection(), AccessMode::Full);
|
|
let (a, b) = tokio::io::duplex(65536);
|
|
let serving =
|
|
tokio::spawn(async move { server.serve(a).await.unwrap().waiting().await.unwrap() });
|
|
let client = ().serve(b).await.unwrap();
|
|
assert!(client.list_all_tools().await.unwrap().len() > 50);
|
|
macro_rules! call {
|
|
($name:expr,$args:expr) => {{
|
|
let result = client
|
|
.call_tool(
|
|
CallToolRequestParams::new($name)
|
|
.with_arguments($args.as_object().unwrap().clone()),
|
|
)
|
|
.await
|
|
.unwrap();
|
|
assert_ne!(
|
|
result.is_error,
|
|
Some(true),
|
|
"{}: {:?}",
|
|
$name,
|
|
result.structured_content
|
|
);
|
|
let text: Value =
|
|
serde_json::from_str(&result.content[0].as_text().unwrap().text).unwrap();
|
|
assert_eq!(Some(text.clone()), result.structured_content);
|
|
text
|
|
}};
|
|
}
|
|
macro_rules! create {($entity:expr,$fields:expr)=>{id(&call!("records_create",json!({"entity":$entity,"fields":$fields})))}}
|
|
let fixture_http = reqwest::Client::builder()
|
|
.no_proxy()
|
|
.redirect(reqwest::redirect::Policy::none())
|
|
.build()
|
|
.unwrap();
|
|
let account:Value=fixture_http.post(format!("http://127.0.0.1:{port}/api/objects/userfields")).header("GROCY-API-KEY",&store.key).json(&json!({"entity":"users","name":format!("account{}",std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_nanos()),"caption":"Account-only definition","type":"text-single-line"})).send().await.unwrap().json().await.unwrap();
|
|
let account_id = numeric(&account["created_object_id"]) as u64;
|
|
let definitions = call!("records_list", json!({"entity":"userfields","limit":500}));
|
|
assert!(
|
|
!definitions["data"]["items"]
|
|
.as_array()
|
|
.unwrap()
|
|
.iter()
|
|
.any(|r| r["entity"] == "users")
|
|
);
|
|
for (tool, args) in [
|
|
(
|
|
"records_get",
|
|
json!({"entity":"userfields","id":account_id}),
|
|
),
|
|
(
|
|
"records_update",
|
|
json!({"entity":"userfields","id":account_id,"fields":{"caption":"Changed"}}),
|
|
),
|
|
(
|
|
"records_delete",
|
|
json!({"entity":"userfields","id":account_id}),
|
|
),
|
|
] {
|
|
let denied = client
|
|
.call_tool(
|
|
CallToolRequestParams::new(tool).with_arguments(args.as_object().unwrap().clone()),
|
|
)
|
|
.await
|
|
.unwrap();
|
|
assert_eq!(denied.is_error, Some(true));
|
|
}
|
|
let suffix = std::time::SystemTime::now()
|
|
.duration_since(std::time::UNIX_EPOCH)
|
|
.unwrap()
|
|
.as_nanos()
|
|
.to_string();
|
|
let name = |s: &str| format!("Contract {s} {suffix}");
|
|
let unit = create!("quantity_units", json!({"name":name("unit")}));
|
|
let kilo = create!("quantity_units", json!({"name":name("kilounit")}));
|
|
let loc = create!("locations", json!({"name":name("location")}));
|
|
let loc2 = create!("locations", json!({"name":name("location2")}));
|
|
let product = create!(
|
|
"products",
|
|
json!({"name":name("product"),"location_id":loc,"qu_id_purchase":unit,"qu_id_stock":unit,"qu_id_consume":unit,"qu_id_price":unit})
|
|
);
|
|
call!(
|
|
"records_update",
|
|
json!({"entity":"products","id":product,"fields":{"description":"Synthetic contract product"}})
|
|
);
|
|
let added = call!(
|
|
"stock_add",
|
|
json!({"product_id":product,"amount":"10","location_id":loc,"best_before_date":"2999-01-01"})
|
|
);
|
|
assert!(added["write"]["receipt"].is_array());
|
|
let stock = call!("stock_list", json!({}));
|
|
assert!(
|
|
stock["data"]["items"]
|
|
.as_array()
|
|
.unwrap()
|
|
.iter()
|
|
.any(|r| numeric(&r["product_id"]) == product as f64)
|
|
);
|
|
let entries = call!("stock_entries", json!({"product_id":product}));
|
|
let entry = numeric(&entries["data"]["items"][0]["id"]) as u64;
|
|
let entry_edit = call!(
|
|
"stock_entry_put",
|
|
json!({"entry_id":entry,"amount":"10","price":"1.25"})
|
|
);
|
|
let stock_note = format!("stocknote{suffix}");
|
|
create!(
|
|
"userfields",
|
|
json!({"entity":"stock","name":stock_note,"caption":"Stock note","type":"text-single-line"})
|
|
);
|
|
call!(
|
|
"userfields_update",
|
|
json!({"entity":"stock","id":entry,"stock_transaction_id":entry_edit["write"]["receipt"][0]["transaction_id"],"fields":{stock_note.clone():"Stock value"}})
|
|
);
|
|
let stock_fields = call!("userfields_get", json!({"entity":"stock","id":entry}));
|
|
assert_eq!(stock_fields["data"][&stock_note], "Stock value");
|
|
call!("stock_open", json!({"product_id":product,"amount":"1"}));
|
|
call!(
|
|
"stock_transfer",
|
|
json!({"product_id":product,"amount":"1","location_id_from":loc,"location_id_to":loc2})
|
|
);
|
|
let consumed = call!(
|
|
"stock_consume",
|
|
json!({"product_id":product,"amount":"1","location_id":loc})
|
|
);
|
|
let booking = &consumed["write"]["receipt"][0];
|
|
let transaction = booking["transaction_id"].clone();
|
|
call!("stock_transaction", json!({"transaction_id":transaction}));
|
|
call!(
|
|
"stock_undo_transaction",
|
|
json!({"transaction_id":transaction})
|
|
);
|
|
call!(
|
|
"stock_inventory",
|
|
json!({"product_id":product,"new_amount":"9","location_id":loc})
|
|
);
|
|
create!(
|
|
"quantity_unit_conversions",
|
|
json!({"from_qu_id":unit,"to_qu_id":kilo,"factor":0.001,"product_id":product})
|
|
);
|
|
call!(
|
|
"records_update",
|
|
json!({"entity":"products","id":product,"fields":{"qu_id_stock":kilo}})
|
|
);
|
|
let details = call!("stock_product", json!({"product_id":product}));
|
|
assert_eq!(
|
|
numeric(&details["data"]["product"]["qu_id_stock"]),
|
|
kilo as f64
|
|
);
|
|
call!(
|
|
"stock_add",
|
|
json!({"product_id":product,"amount":"1000","quantity_unit_id":unit,"best_before_date":"2999-01-01"})
|
|
);
|
|
call!("stock_volatile", json!({}));
|
|
let list = create!("shopping_lists", json!({"name":name("shopping")}));
|
|
call!(
|
|
"shopping_add_product",
|
|
json!({"product_id":product,"list_id":list,"product_amount":2,"qu_id":kilo})
|
|
);
|
|
let exported = call!("shopping_export", json!({"list_id":list}));
|
|
assert!(!exported["data"]["items"].as_array().unwrap().is_empty());
|
|
call!(
|
|
"shopping_remove_product",
|
|
json!({"product_id":product,"list_id":list,"product_amount":1})
|
|
);
|
|
call!("shopping_clear", json!({"list_id":list}));
|
|
let recipe = create!(
|
|
"recipes",
|
|
json!({"name":name("recipe"),"base_servings":1,"desired_servings":1})
|
|
);
|
|
create!(
|
|
"recipes_pos",
|
|
json!({"recipe_id":recipe,"product_id":product,"amount":0.001,"qu_id":kilo})
|
|
);
|
|
let nested = create!(
|
|
"recipes",
|
|
json!({"name":name("nested"),"base_servings":1,"desired_servings":1})
|
|
);
|
|
create!(
|
|
"recipes_nestings",
|
|
json!({"recipe_id":nested,"includes_recipe_id":recipe,"servings":1})
|
|
);
|
|
call!("recipe_fulfillment", json!({"recipe_id":recipe}));
|
|
call!("recipe_copy", json!({"recipe_id":recipe}));
|
|
let used = call!("recipe_consume", json!({"recipe_id":recipe}));
|
|
assert!(used["write"]["receipt"].is_null()); // Grocy returns 204 for this action.
|
|
let log = call!("records_list", json!({"entity":"stock_log","limit":500}));
|
|
let row = log["data"]["items"]
|
|
.as_array()
|
|
.unwrap()
|
|
.iter()
|
|
.rev()
|
|
.find(|r| {
|
|
r["recipe_id"]
|
|
.as_str()
|
|
.is_some_and(|s| s == recipe.to_string())
|
|
|| r["recipe_id"].as_u64() == Some(recipe)
|
|
})
|
|
.expect("recipe consume booking");
|
|
let tx = row["transaction_id"].clone();
|
|
call!("stock_undo_transaction", json!({"transaction_id":tx}));
|
|
let section = create!("meal_plan_sections", json!({"name":name("section")}));
|
|
let meal = create!(
|
|
"meal_plan",
|
|
json!({"day":"2030-01-01","type":"recipe","recipe_id":recipe,"recipe_servings":1,"section_id":section})
|
|
);
|
|
call!(
|
|
"records_update",
|
|
json!({"entity":"meal_plan","id":meal,"fields":{"note":"Synthetic meal"}})
|
|
);
|
|
let chore = create!(
|
|
"chores",
|
|
json!({"name":name("chore"),"period_type":"daily","period_interval":1})
|
|
);
|
|
let executed = call!(
|
|
"chore_execute",
|
|
json!({"chore_id":chore,"tracked_time":"2030-01-01 10:00:00"})
|
|
);
|
|
call!(
|
|
"chore_undo_execution",
|
|
json!({"execution_id":executed["write"]["receipt"]["id"]})
|
|
);
|
|
let task = create!(
|
|
"tasks",
|
|
json!({"name":name("task"),"due_date":"2030-01-01 10:00:00"})
|
|
);
|
|
call!("task_complete", json!({"task_id":task}));
|
|
call!("task_undo", json!({"task_id":task}));
|
|
call!(
|
|
"records_update",
|
|
json!({"entity":"tasks","id":task,"fields":{"due_date":"2030-01-02 10:00:00"}})
|
|
);
|
|
let battery = create!(
|
|
"batteries",
|
|
json!({"name":name("battery"),"charge_interval_days":7})
|
|
);
|
|
let charged = call!(
|
|
"battery_charge",
|
|
json!({"battery_id":battery,"tracked_time":"2030-01-01 10:00:00"})
|
|
);
|
|
call!(
|
|
"battery_undo_charge",
|
|
json!({"charge_cycle_id":charged["write"]["receipt"]["id"]})
|
|
);
|
|
let equipment = create!("equipment", json!({"name":name("equipment")}));
|
|
let note_name = format!("contractnote{suffix}");
|
|
create!(
|
|
"userfields",
|
|
json!({"entity":"equipment","name":note_name,"caption":"Contract note","type":"text-single-line"})
|
|
);
|
|
call!(
|
|
"userfields_update",
|
|
json!({"entity":"equipment","id":equipment,"fields":{note_name.clone():"Synthetic only"}})
|
|
);
|
|
let fields = call!(
|
|
"userfields_get",
|
|
json!({"entity":"equipment","id":equipment})
|
|
);
|
|
assert_eq!(fields["data"][¬e_name], "Synthetic only");
|
|
let entity = create!(
|
|
"userentities",
|
|
json!({"name":name("entity"),"caption":"Synthetic"})
|
|
);
|
|
let custom = create!("userobjects", json!({"userentity_id":entity}));
|
|
create!(
|
|
"userfields",
|
|
json!({"entity":format!("userentity-{}",name("entity")),"name":"customnote","caption":"Custom note","type":"text-single-line"})
|
|
);
|
|
call!(
|
|
"userfields_update",
|
|
json!({"entity":"userobjects","id":custom,"fields":{"customnote":"Custom value"}})
|
|
);
|
|
let custom_fields = call!(
|
|
"userfields_get",
|
|
json!({"entity":"userobjects","id":custom})
|
|
);
|
|
assert_eq!(custom_fields["data"]["customnote"], "Custom value");
|
|
call!("assignment_users", json!({}));
|
|
use base64::{Engine, engine::general_purpose::STANDARD};
|
|
let file = format!("manual-{suffix}.pdf");
|
|
let bytes = b"%PDF-1.4\nSynthetic test\n%%EOF";
|
|
call!(
|
|
"file_upload",
|
|
json!({"group":"equipmentmanuals","filename":file,"content_base64":STANDARD.encode(bytes)})
|
|
);
|
|
let downloaded = client
|
|
.call_tool(
|
|
CallToolRequestParams::new("file_get").with_arguments(
|
|
json!({"group":"equipmentmanuals","filename":file})
|
|
.as_object()
|
|
.unwrap()
|
|
.clone(),
|
|
),
|
|
)
|
|
.await
|
|
.unwrap();
|
|
assert_ne!(downloaded.is_error, Some(true));
|
|
let wire = serde_json::to_value(&downloaded.content).unwrap();
|
|
assert!(wire.to_string().contains(&STANDARD.encode(bytes)));
|
|
call!(
|
|
"file_delete",
|
|
json!({"group":"equipmentmanuals","filename":file})
|
|
);
|
|
call!("calendar_export", json!({}));
|
|
call!(
|
|
"records_delete",
|
|
json!({"entity":"equipment","id":equipment})
|
|
);
|
|
client.cancel().await.unwrap();
|
|
serving.await.unwrap();
|
|
// Root API enrollment and read-only rejection are independent of deployment prefix.
|
|
let readonly = Arc::new(MemoryStore {
|
|
url: format!("http://127.0.0.1:{port}/api"),
|
|
access: AccessMode::ReadOnly,
|
|
key: store.key.clone(),
|
|
});
|
|
setup::doctor(selection(), readonly.clone()).await.unwrap();
|
|
let server = McpServer::new(readonly, selection(), AccessMode::ReadOnly);
|
|
let (a, b) = tokio::io::duplex(65536);
|
|
let serving =
|
|
tokio::spawn(async move { server.serve(a).await.unwrap().waiting().await.unwrap() });
|
|
let client = ().serve(b).await.unwrap();
|
|
assert!(
|
|
!client
|
|
.list_all_tools()
|
|
.await
|
|
.unwrap()
|
|
.iter()
|
|
.any(|t| t.name == "stock_add")
|
|
);
|
|
let blocked = client
|
|
.call_tool(
|
|
CallToolRequestParams::new("stock_add").with_arguments(
|
|
json!({"product_id":product,"amount":1})
|
|
.as_object()
|
|
.unwrap()
|
|
.clone(),
|
|
),
|
|
)
|
|
.await
|
|
.unwrap();
|
|
assert_eq!(blocked.is_error, Some(true));
|
|
client.cancel().await.unwrap();
|
|
serving.await.unwrap();
|
|
assert_eq!(outside.load(Ordering::SeqCst), 0);
|
|
api.abort();
|
|
}
|