445 lines
13 KiB
Rust
445 lines
13 KiB
Rust
mod common;
|
|
|
|
use std::collections::BTreeSet;
|
|
use std::fs;
|
|
|
|
use common::{client, collection, config_for, poll, publish, spawn_relay, test_envelope, unicast};
|
|
use frxd::crypto::Keypair;
|
|
use frxd::index::LocalIndex;
|
|
use frxd::message::{
|
|
AggregateBody, QueryBody, ResponseItem, TYPE_AGGREGATE, TYPE_QUERY, TYPE_RESPONSE,
|
|
build_response,
|
|
};
|
|
use frxd::node::{self, Node};
|
|
use serde_json::Value;
|
|
|
|
fn assert_exact_keys(value: &Value, expected: &[&str]) {
|
|
let actual: BTreeSet<&str> = value
|
|
.as_object()
|
|
.expect("object")
|
|
.keys()
|
|
.map(String::as_str)
|
|
.collect();
|
|
let expected: BTreeSet<&str> = expected.iter().copied().collect();
|
|
assert_eq!(actual, expected, "fields drifted: {value}");
|
|
}
|
|
|
|
fn assert_absent_fields(value: &Value, banned: &[&str]) {
|
|
let raw = serde_json::to_string(value).unwrap();
|
|
for field in banned {
|
|
assert!(
|
|
!raw.contains(&format!("\"{field}\"")),
|
|
"purged field '{field}' present: {raw}"
|
|
);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn no_bounty_winner_selection_or_slashing() {
|
|
let query = serde_json::to_value(QueryBody::new("rust", 5)).unwrap();
|
|
assert_exact_keys(&query, &["qid", "text", "entities", "budget"]);
|
|
assert_exact_keys(query.get("budget").unwrap(), &["max_results"]);
|
|
let envelope = test_envelope(&Keypair::generate(), TYPE_QUERY, query.clone());
|
|
let envelope = serde_json::to_value(&envelope).unwrap();
|
|
for value in [&query, &envelope] {
|
|
assert_absent_fields(
|
|
value,
|
|
&[
|
|
"bounty",
|
|
"winner",
|
|
"winner_selection",
|
|
"slashing",
|
|
"stake",
|
|
"reward",
|
|
"payment",
|
|
],
|
|
);
|
|
}
|
|
}
|
|
|
|
#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
|
|
async fn no_in_protocol_citation_accounting_or_settlement() {
|
|
let relay_url = spawn_relay().await;
|
|
let http = client();
|
|
let key = Keypair::generate();
|
|
|
|
for msg_type in ["receipt", "settlement", "citation", "invoice"] {
|
|
let envelope = test_envelope(&key, msg_type, serde_json::json!({}));
|
|
assert_eq!(
|
|
publish(&http, &relay_url, &envelope).await.status(),
|
|
reqwest::StatusCode::BAD_REQUEST,
|
|
"relay accepted {msg_type} on the broadcast channel"
|
|
);
|
|
assert_eq!(
|
|
unicast(&http, &relay_url, &key.public_hex(), &envelope)
|
|
.await
|
|
.status(),
|
|
reqwest::StatusCode::BAD_REQUEST,
|
|
"relay accepted unicast {msg_type}"
|
|
);
|
|
}
|
|
|
|
let response = serde_json::to_value(build_response("q1", Vec::new(), Some(0), 5)).unwrap();
|
|
assert_absent_fields(
|
|
&response,
|
|
&[
|
|
"receipt",
|
|
"settlement",
|
|
"citation",
|
|
"cited",
|
|
"price",
|
|
"payment",
|
|
"paid",
|
|
],
|
|
);
|
|
let aggregate = serde_json::to_value(AggregateBody {
|
|
period: "2026-03".to_string(),
|
|
sent: 0,
|
|
passed: 0,
|
|
})
|
|
.unwrap();
|
|
assert_absent_fields(
|
|
&aggregate,
|
|
&[
|
|
"receipt",
|
|
"settlement",
|
|
"citation",
|
|
"cited",
|
|
"price",
|
|
"payment",
|
|
"paid",
|
|
],
|
|
);
|
|
|
|
for route in ["/v1/receipt", "/v1/settlement", "/v1/invoice"] {
|
|
let response = http
|
|
.get(format!("{relay_url}{route}"))
|
|
.send()
|
|
.await
|
|
.unwrap();
|
|
assert_eq!(response.status(), reqwest::StatusCode::NOT_FOUND);
|
|
}
|
|
}
|
|
|
|
#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
|
|
async fn no_protocol_query_dedup() {
|
|
let relay_url = spawn_relay().await;
|
|
let http = client();
|
|
let key = Keypair::generate();
|
|
let envelope = test_envelope(
|
|
&key,
|
|
TYPE_QUERY,
|
|
serde_json::json!({"qid": "q1", "text": "rust"}),
|
|
);
|
|
assert!(
|
|
publish(&http, &relay_url, &envelope)
|
|
.await
|
|
.status()
|
|
.is_success()
|
|
);
|
|
assert!(
|
|
publish(&http, &relay_url, &envelope)
|
|
.await
|
|
.status()
|
|
.is_success()
|
|
);
|
|
let response = poll(&http, &relay_url, &key, 300).await;
|
|
let payload: Value = response.json().await.unwrap();
|
|
assert_eq!(
|
|
payload
|
|
.get("messages")
|
|
.and_then(Value::as_array)
|
|
.map(Vec::len),
|
|
Some(2),
|
|
"relay deduplicated identical queries: {payload}"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn no_k_fetch_ingestion_attestations() {
|
|
let response = build_response("q1", Vec::new(), Some(0), 5);
|
|
let value = serde_json::to_value(&response).unwrap();
|
|
assert_exact_keys(
|
|
&value,
|
|
&["qid", "results", "truncated", "more_available", "cursor"],
|
|
);
|
|
assert_absent_fields(
|
|
&value,
|
|
&[
|
|
"attestation",
|
|
"attestations",
|
|
"k_fetch",
|
|
"fetch_proof",
|
|
"ingestion_proof",
|
|
"fetch_count",
|
|
],
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn no_result_count_etiquette() {
|
|
let query = serde_json::to_value(QueryBody::new("rust", 5)).unwrap();
|
|
assert_absent_fields(
|
|
&query,
|
|
&["min_results", "results_count", "serp", "count_floor"],
|
|
);
|
|
let response = serde_json::to_value(build_response("q1", Vec::new(), Some(0), 5)).unwrap();
|
|
assert_absent_fields(
|
|
&response,
|
|
&["min_results", "results_count", "serp", "count_floor"],
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn no_global_reputation_score() {
|
|
let item = ResponseItem {
|
|
url: "file:///x".to_string(),
|
|
title: "t".to_string(),
|
|
summary: String::new(),
|
|
published: String::new(),
|
|
exposure: "metadata".to_string(),
|
|
content: None,
|
|
};
|
|
let item_value = serde_json::to_value(&item).unwrap();
|
|
assert_exact_keys(
|
|
&item_value,
|
|
&[
|
|
"url",
|
|
"title",
|
|
"summary",
|
|
"published",
|
|
"exposure",
|
|
"content",
|
|
],
|
|
);
|
|
let response_value =
|
|
serde_json::to_value(build_response("q1", vec![item], Some(1), 5)).unwrap();
|
|
for value in [&item_value, &response_value] {
|
|
assert_absent_fields(value, &["score", "rank", "reputation", "weight", "rating"]);
|
|
}
|
|
}
|
|
|
|
#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
|
|
async fn no_aggregate_appeals() {
|
|
let relay_url = spawn_relay().await;
|
|
let http = client();
|
|
let sender = Keypair::generate();
|
|
let member = Keypair::generate();
|
|
|
|
let dispute = test_envelope(
|
|
&sender,
|
|
"dispute",
|
|
serde_json::json!({"about": "counter", "reason": "unfair"}),
|
|
);
|
|
assert_eq!(
|
|
publish(&http, &relay_url, &dispute).await.status(),
|
|
reqwest::StatusCode::BAD_REQUEST
|
|
);
|
|
assert_eq!(
|
|
unicast(&http, &relay_url, &member.public_hex(), &dispute)
|
|
.await
|
|
.status(),
|
|
reqwest::StatusCode::BAD_REQUEST
|
|
);
|
|
|
|
assert_eq!(
|
|
poll(&http, &relay_url, &member, 30).await.status(),
|
|
reqwest::StatusCode::NO_CONTENT
|
|
);
|
|
let aggregate = test_envelope(
|
|
&sender,
|
|
TYPE_AGGREGATE,
|
|
serde_json::to_value(AggregateBody {
|
|
period: "2026-03".to_string(),
|
|
sent: 1,
|
|
passed: 1,
|
|
})
|
|
.unwrap(),
|
|
);
|
|
assert_eq!(
|
|
unicast(&http, &relay_url, &member.public_hex(), &aggregate)
|
|
.await
|
|
.status(),
|
|
reqwest::StatusCode::OK
|
|
);
|
|
|
|
let body = serde_json::to_value(AggregateBody {
|
|
period: "2026-03".to_string(),
|
|
sent: 1,
|
|
passed: 1,
|
|
})
|
|
.unwrap();
|
|
assert_exact_keys(&body, &["period", "sent", "passed"]);
|
|
assert_absent_fields(&body, &["appeal", "dispute", "complaint", "sanction"]);
|
|
|
|
for route in ["/v1/appeal", "/v1/dispute"] {
|
|
let response = http
|
|
.get(format!("{relay_url}{route}"))
|
|
.send()
|
|
.await
|
|
.unwrap();
|
|
assert_eq!(response.status(), reqwest::StatusCode::NOT_FOUND);
|
|
}
|
|
}
|
|
|
|
#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
|
|
async fn no_topic_channels() {
|
|
let query = serde_json::to_value(QueryBody::new("rust", 5)).unwrap();
|
|
assert_exact_keys(&query, &["qid", "text", "entities", "budget"]);
|
|
assert_absent_fields(
|
|
&query,
|
|
&[
|
|
"topic", "channel", "taxonomy", "category", "routing", "topic_id",
|
|
],
|
|
);
|
|
|
|
let relay_url = spawn_relay().await;
|
|
let http = client();
|
|
let alice = Keypair::generate();
|
|
let bob = Keypair::generate();
|
|
assert_eq!(
|
|
poll(&http, &relay_url, &alice, 30).await.status(),
|
|
reqwest::StatusCode::NO_CONTENT
|
|
);
|
|
assert_eq!(
|
|
poll(&http, &relay_url, &bob, 30).await.status(),
|
|
reqwest::StatusCode::NO_CONTENT
|
|
);
|
|
let envelope = test_envelope(
|
|
&alice,
|
|
TYPE_QUERY,
|
|
serde_json::json!({"qid": "q1", "text": "rust"}),
|
|
);
|
|
assert!(
|
|
publish(&http, &relay_url, &envelope)
|
|
.await
|
|
.status()
|
|
.is_success()
|
|
);
|
|
for member in [&alice, &bob] {
|
|
let response = poll(&http, &relay_url, &member, 300).await;
|
|
let payload: Value = response.json().await.unwrap();
|
|
assert_eq!(
|
|
payload
|
|
.get("messages")
|
|
.and_then(Value::as_array)
|
|
.map(Vec::len),
|
|
Some(1),
|
|
"receiver-side filtering expected, got {payload}"
|
|
);
|
|
}
|
|
}
|
|
|
|
#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
|
|
async fn no_broadcast_responses() {
|
|
let relay_url = spawn_relay().await;
|
|
let http = client();
|
|
let key = Keypair::generate();
|
|
for msg_type in [TYPE_RESPONSE, "evidence", "commons", "broadcast_response"] {
|
|
let envelope = test_envelope(&key, msg_type, serde_json::json!({}));
|
|
assert_eq!(
|
|
publish(&http, &relay_url, &envelope).await.status(),
|
|
reqwest::StatusCode::BAD_REQUEST,
|
|
"relay accepted broadcast {msg_type}"
|
|
);
|
|
}
|
|
}
|
|
|
|
#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
|
|
async fn no_normative_query_canonical_form() {
|
|
let root = tempfile::tempdir().unwrap();
|
|
let docs = root.path().join("docs");
|
|
fs::create_dir_all(&docs).unwrap();
|
|
fs::write(docs.join("alpha.txt"), "rust ownership and borrowing").unwrap();
|
|
let config = config_for(&root.path().join("alice"), "alice", "http://127.0.0.1:1");
|
|
{
|
|
let index = LocalIndex::open(&config.index_dir()).unwrap();
|
|
index
|
|
.add_collection(&collection("docs", &docs, true, "full"))
|
|
.unwrap();
|
|
}
|
|
let node = Node::start(config).await.unwrap();
|
|
let text = "rust?! ownership/borrowing: \"quotes\" ünïcode {braces} #tag";
|
|
let outcome = node::control_query(
|
|
&format!("http://{}", node.addr),
|
|
text,
|
|
Some(5),
|
|
Some(100),
|
|
false,
|
|
)
|
|
.await
|
|
.unwrap();
|
|
assert_eq!(outcome.get("text").and_then(Value::as_str), Some(text));
|
|
assert_eq!(
|
|
outcome.pointer("/local/total").and_then(Value::as_u64),
|
|
Some(1),
|
|
"arbitrary phrasing should match lexically: {outcome}"
|
|
);
|
|
}
|
|
|
|
#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
|
|
async fn no_supply_announce_firehose() {
|
|
let relay_url = spawn_relay().await;
|
|
let http = client();
|
|
let key = Keypair::generate();
|
|
for msg_type in ["announce", "supply", "documents", "publish"] {
|
|
let envelope = test_envelope(&key, msg_type, serde_json::json!({}));
|
|
assert_eq!(
|
|
publish(&http, &relay_url, &envelope).await.status(),
|
|
reqwest::StatusCode::BAD_REQUEST,
|
|
"relay accepted supply announcement {msg_type}"
|
|
);
|
|
}
|
|
for route in ["/v1/announce", "/v1/supply"] {
|
|
let response = http
|
|
.get(format!("{relay_url}{route}"))
|
|
.send()
|
|
.await
|
|
.unwrap();
|
|
assert_eq!(response.status(), reqwest::StatusCode::NOT_FOUND);
|
|
}
|
|
}
|
|
|
|
#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
|
|
async fn no_durable_replayable_broadcast_stream() {
|
|
let relay_url = spawn_relay().await;
|
|
let http = client();
|
|
let key = Keypair::generate();
|
|
let envelope = test_envelope(
|
|
&key,
|
|
TYPE_QUERY,
|
|
serde_json::json!({"qid": "q1", "text": "rust"}),
|
|
);
|
|
assert!(
|
|
publish(&http, &relay_url, &envelope)
|
|
.await
|
|
.status()
|
|
.is_success()
|
|
);
|
|
|
|
let response = poll(&http, &relay_url, &key, 300).await;
|
|
let payload: Value = response.json().await.unwrap();
|
|
assert_eq!(
|
|
payload
|
|
.get("messages")
|
|
.and_then(Value::as_array)
|
|
.map(Vec::len),
|
|
Some(1)
|
|
);
|
|
|
|
assert_eq!(
|
|
poll(&http, &relay_url, &key, 50).await.status(),
|
|
reqwest::StatusCode::NO_CONTENT,
|
|
"relay replayed a drained message"
|
|
);
|
|
|
|
for route in ["/v1/history", "/v1/replay"] {
|
|
let response = http
|
|
.get(format!("{relay_url}{route}"))
|
|
.send()
|
|
.await
|
|
.unwrap();
|
|
assert_eq!(response.status(), reqwest::StatusCode::NOT_FOUND);
|
|
}
|
|
}
|