use super::*;
fn dummy_manifest(service_id: &str, did: &str, cost: f64, latency: u32) -> ServiceCapabilityManifest {
ServiceCapabilityManifest {
service_id: service_id.to_string(),
version: "1.0.0".to_string(),
provider_did: did.to_string(),
description: "Dummy capability".to_string(),
input_schema: SchemaSpec {
schema_type: "object".to_string(),
properties: None,
required: None,
polynomial_order: None,
description: None,
},
output_schema: SchemaSpec {
schema_type: "object".to_string(),
properties: None,
required: None,
polynomial_order: None,
description: None,
},
sla: SlaWitness {
context_window: Some(4096),
compute_type: "cpu-generic".to_string(),
p95_latency_ms: latency,
throughput_tps: Some(50),
reliability_score: Some(0.99),
},
pricing: PricingSpec {
base_cost: cost,
cost_per_token: None,
currency: "PKC_TOKEN".to_string(),
},
endpoints: vec![ServiceEndpoint {
protocol: "noise_xx".to_string(),
address: "192.168.1.50".to_string(),
port: 9095,
noise_pubkey_hex: None,
}],
registered_at: 1000,
ttl_seconds: 60,
content_hash: String::new(),
signature: None,
}
}
#[test]
fn test_valid_service_id() {
assert!(is_valid_service_id("service.pkc.llm.inference"));
assert!(is_valid_service_id("service.pkc.tikz.compiler"));
assert!(!is_valid_service_id("service.ollama.inference"));
assert!(!is_valid_service_id("service.pkc."));
assert!(!is_valid_service_id("service.pkc.llm"));
}
#[test]
fn test_manifest_signing_and_verification() {
let identity = SovereignNodeIdentity::generate();
let mut manifest = dummy_manifest("service.pkc.proof.checker", &identity.did, 0.001, 35);
manifest = sign_capability_manifest(manifest, &identity).expect("sign manifest");
assert_eq!(manifest.content_hash.len(), 64);
assert!(manifest.signature.is_some());
assert!(verify_capability_manifest(&manifest));
let mut tampered = manifest.clone();
tampered.pricing.base_cost = 99.0;
assert!(!verify_capability_manifest(&tampered));
}
#[test]
fn test_router_candidate_ranking_and_loop_detection() {
let alice = SovereignNodeIdentity::generate();
let bob = SovereignNodeIdentity::generate();
let mut catalog = ServiceCatalog::new(&alice.did);
let mut m_local = dummy_manifest("service.pkc.llm.inference", &alice.did, 0.01, 20);
m_local = sign_capability_manifest(m_local, &alice).unwrap();
catalog.register_local_service(m_local).unwrap();
let mut m_remote = dummy_manifest("service.pkc.llm.inference", &bob.did, 0.001, 60);
m_remote.endpoints[0].address = "203.0.113.1".to_string(); m_remote = sign_capability_manifest(m_remote, &bob).unwrap();
catalog.register_remote_service(m_remote);
let router = ServiceRouter::new(&catalog);
let ranked = router.rank_candidates("service.pkc.llm.inference", None);
assert_eq!(ranked.len(), 2);
assert_eq!(ranked[0].tier, RouteTier::Local);
assert_eq!(ranked[1].tier, RouteTier::Overlay);
let mut trace = create_trace_vector(&alice.did, None);
append_trace_hop(&mut trace, &bob.did, 100);
assert!(detect_routing_loop(&trace, &bob.did));
}