commit d945d6daa1118903816316dc8b4a3c8d950a64e1
parent fb8a4c87c8d439b564a287a7a76f54f4e6346f1e
Author: triesap <tyson@radroots.org>
Date: Sun, 12 Jul 2026 02:36:02 +0000
crate-surface: harden final-name coverage gates
Diffstat:
5 files changed, 292 insertions(+), 0 deletions(-)
diff --git a/crates/event_codec/src/order/decode.rs b/crates/event_codec/src/order/decode.rs
@@ -1459,6 +1459,12 @@ mod tests {
RadrootsOrderEnvelopeParseError::InvalidTag("p")
);
assert_eq!(
+ map_tag_parse_error_for_order_envelope(crate::error::EventParseError::DuplicateTag(
+ "p",
+ )),
+ RadrootsOrderEnvelopeParseError::InvalidTag("p")
+ );
+ assert_eq!(
map_tag_parse_error_for_order_envelope(crate::error::EventParseError::InvalidKind {
expected: "1",
got: 2,
diff --git a/crates/event_codec/tests/coverage_edges.rs b/crates/event_codec/tests/coverage_edges.rs
@@ -30,6 +30,14 @@ fn parsed_args() -> (String, String, u32, u32, String, Vec<Vec<String>>, String)
}
#[test]
+fn event_parse_error_duplicate_tag_code_and_display_are_stable() {
+ let error = EventParseError::DuplicateTag("d");
+
+ assert_eq!(error.code(), "duplicate_tag");
+ assert_eq!(error.to_string(), "duplicate tag: d");
+}
+
+#[test]
fn parsed_wrappers_propagate_invalid_kind_errors() {
let (id, author, created_at, kind, content, tags, sig) = parsed_args();
assert_invalid_kind(
diff --git a/crates/mesh_agent_client/tests/client.rs b/crates/mesh_agent_client/tests/client.rs
@@ -54,6 +54,14 @@ fn mock_client_status_reports_reticulum_preview_unavailable() {
}
#[test]
+fn default_mock_client_uses_preview_unavailable_policy() {
+ let client = RadrootsMockMeshAgentClient::default();
+
+ assert_eq!(client.scope().as_str(), RADROOTS_RETICULUM_PREVIEW_SCOPE_ID);
+ assert_eq!(client.policy().policy_id(), RADROOTS_MESH_PREVIEW_POLICY_ID);
+}
+
+#[test]
fn mock_client_status_can_omit_transport_rows_without_enabling_delivery() {
let client = RadrootsMockMeshAgentClient::preview_unavailable();
let response = client.status(MeshAgentStatusRequest {
@@ -99,6 +107,8 @@ fn mock_client_publish_never_reports_success_outcomes() {
#[test]
fn dto_schema_names_match_capnp_surface() {
assert_eq!(MeshAgentTransportKind::Reticulum.schema_name(), "reticulum");
+ assert_eq!(MeshAgentImplementation::Real.schema_name(), "real");
+ assert_eq!(MeshAgentImplementation::Mock.schema_name(), "mock");
assert_eq!(
MeshAgentImplementation::PreviewUnavailable.schema_name(),
"previewUnavailable"
@@ -107,6 +117,18 @@ fn dto_schema_names_match_capnp_surface() {
assert_eq!(MeshAgentResponseStatus::Deferred.schema_name(), "deferred");
assert_eq!(MeshAgentResponseStatus::Rejected.schema_name(), "rejected");
assert_eq!(
+ MeshAgentTransportOutcome::Accepted.schema_name(),
+ "accepted"
+ );
+ assert_eq!(
+ MeshAgentTransportOutcome::Delivered.schema_name(),
+ "delivered"
+ );
+ assert_eq!(
+ MeshAgentTransportOutcome::Forwarded.schema_name(),
+ "forwarded"
+ );
+ assert_eq!(
MeshAgentTransportOutcome::TransportUnavailable.schema_name(),
"transportUnavailable"
);
@@ -114,6 +136,19 @@ fn dto_schema_names_match_capnp_surface() {
MeshAgentTransportOutcome::StoredByGateway.schema_name(),
"storedByGateway"
);
+ assert_eq!(
+ MeshAgentTransportOutcome::DeferredUntilImplemented.schema_name(),
+ "deferredUntilImplemented"
+ );
+ assert_eq!(
+ MeshAgentTransportOutcome::Rejected.schema_name(),
+ "rejected"
+ );
+ assert_eq!(
+ MeshAgentTransportOutcome::RouteUnavailable.schema_name(),
+ "routeUnavailable"
+ );
+ assert_eq!(MeshAgentTransportOutcome::Timeout.schema_name(), "timeout");
}
#[test]
diff --git a/crates/replica_schema/tests/query_bind_values.rs b/crates/replica_schema/tests/query_bind_values.rs
@@ -12,6 +12,9 @@ use radroots_replica_schema::nostr_relay::NostrRelayQueryBindValues;
use radroots_replica_schema::plot::PlotQueryBindValues;
use radroots_replica_schema::plot_gcs_location::PlotGcsLocationQueryBindValues;
use radroots_replica_schema::plot_tag::PlotTagQueryBindValues;
+use radroots_replica_schema::result::{
+ ReplicaSchemaError, ReplicaSchemaResult, ReplicaSchemaResultList, ReplicaSchemaResultPass,
+};
use radroots_replica_schema::trade_product::TradeProductQueryBindValues;
use serde_json::Value;
@@ -352,3 +355,34 @@ assert_query_bind_values!(
"trade-product-id",
[]
);
+
+#[test]
+fn schema_result_wrappers_cover_constructors_and_status_labels() {
+ assert_eq!(
+ ReplicaSchemaError::from("err-a".to_string()),
+ ReplicaSchemaError {
+ err: "err-a".to_string()
+ }
+ );
+ assert_eq!(
+ ReplicaSchemaError::new("err-b".to_string()),
+ ReplicaSchemaError {
+ err: "err-b".to_string()
+ }
+ );
+ assert_eq!(
+ ReplicaSchemaResult::new("result-a".to_string()),
+ ReplicaSchemaResult {
+ result: "result-a".to_string()
+ }
+ );
+
+ let empty = ReplicaSchemaResultList::<String>::new(Vec::new());
+ assert!(empty.is_empty());
+ let filled = ReplicaSchemaResultList::new(vec!["row-a".to_string()]);
+ assert!(!filled.is_empty());
+ assert_eq!(filled.results, vec!["row-a".to_string()]);
+
+ assert_eq!(ReplicaSchemaResultPass::new(true).status_label(), "pass");
+ assert_eq!(ReplicaSchemaResultPass::new(false).status_label(), "fail");
+}
diff --git a/crates/runtime_store/src/models.rs b/crates/runtime_store/src/models.rs
@@ -606,6 +606,204 @@ mod tests {
}
#[test]
+ fn relay_delivery_evidence_models_cover_states_validation_and_json() {
+ for (variant, value) in [
+ (RelayDeliveryState::Pending, "pending"),
+ (RelayDeliveryState::Acknowledged, "acknowledged"),
+ (RelayDeliveryState::Observed, "observed"),
+ (RelayDeliveryState::Failed, "failed"),
+ ] {
+ assert_eq!(variant.as_str(), value);
+ }
+
+ let failure =
+ RelayDeliveryFailure::new(" wss://relay-a.example ", " timeout ").expect("failure");
+ assert_eq!(failure.relay_url, " wss://relay-a.example ");
+ assert_eq!(failure.error, " timeout ");
+ assert_model_error_contains(RelayDeliveryFailure::new(" ", "timeout"), "relay_url");
+ assert_model_error_contains(
+ RelayDeliveryFailure::new("wss://relay-a.example", " "),
+ "relay_delivery_error",
+ );
+
+ let pending =
+ RelayDeliveryEvidence::pending([" wss://relay-a.example ", "wss://relay-a.example"])
+ .expect("pending evidence");
+ assert_eq!(pending.state, RelayDeliveryState::Pending);
+ assert_eq!(pending.target_relays, vec!["wss://relay-a.example"]);
+ assert!(pending.relay_set_fingerprint().is_some());
+ pending.to_json_value().expect("pending evidence json");
+ assert_model_error_contains(
+ RelayDeliveryEvidence::pending(Vec::<String>::new()),
+ "target_relays",
+ );
+
+ let acknowledged = RelayDeliveryEvidence::acknowledged(
+ ["wss://relay-a.example"],
+ ["wss://relay-a.example"],
+ ["wss://relay-a.example"],
+ Vec::new(),
+ )
+ .expect("acknowledged evidence");
+ assert_eq!(acknowledged.state, RelayDeliveryState::Acknowledged);
+ assert_model_error_contains(
+ RelayDeliveryEvidence::acknowledged(
+ Vec::<String>::new(),
+ Vec::<String>::new(),
+ ["wss://relay-a.example"],
+ Vec::new(),
+ ),
+ "target_relays",
+ );
+ assert_model_error_contains(
+ RelayDeliveryEvidence::acknowledged(
+ ["wss://relay-a.example"],
+ Vec::<String>::new(),
+ Vec::<String>::new(),
+ Vec::new(),
+ ),
+ "acknowledged_relays",
+ );
+
+ let observed = RelayDeliveryEvidence::observed(
+ ["wss://relay-a.example"],
+ ["wss://relay-a.example"],
+ ["wss://relay-b.example"],
+ vec![failure.clone()],
+ )
+ .expect("observed evidence");
+ assert_eq!(observed.state, RelayDeliveryState::Observed);
+ assert_eq!(
+ observed.relay_set_fingerprint(),
+ Some("wss://relay-a.example\nwss://relay-b.example".to_owned())
+ );
+ observed.to_json_value().expect("observed evidence json");
+ assert_model_error_contains(
+ RelayDeliveryEvidence::observed(
+ Vec::<String>::new(),
+ Vec::<String>::new(),
+ ["wss://relay-b.example"],
+ Vec::new(),
+ ),
+ "target_relays",
+ );
+ assert_model_error_contains(
+ RelayDeliveryEvidence::observed(
+ ["wss://relay-a.example"],
+ Vec::<String>::new(),
+ Vec::<String>::new(),
+ Vec::new(),
+ ),
+ "observed_relays",
+ );
+
+ let failed = RelayDeliveryEvidence {
+ state: RelayDeliveryState::Failed,
+ target_relays: vec!["wss://relay-a.example".to_owned()],
+ connected_relays: Vec::new(),
+ acknowledged_relays: Vec::new(),
+ observed_relays: Vec::new(),
+ failed_relays: vec![failure],
+ };
+ let failed_json = failed.to_json_value().expect("failed evidence json");
+ assert_eq!(
+ RelayDeliveryEvidence::from_json_value(&failed_json).expect("failed evidence"),
+ failed
+ );
+
+ assert_model_error_contains(
+ RelayDeliveryEvidence {
+ state: RelayDeliveryState::Pending,
+ target_relays: Vec::new(),
+ connected_relays: Vec::new(),
+ acknowledged_relays: Vec::new(),
+ observed_relays: Vec::new(),
+ failed_relays: Vec::new(),
+ }
+ .to_json_value(),
+ "target_relays",
+ );
+ assert_model_error_contains(
+ RelayDeliveryEvidence {
+ state: RelayDeliveryState::Acknowledged,
+ target_relays: vec!["wss://relay-a.example".to_owned()],
+ connected_relays: Vec::new(),
+ acknowledged_relays: Vec::new(),
+ observed_relays: Vec::new(),
+ failed_relays: Vec::new(),
+ }
+ .to_json_value(),
+ "acknowledged_relays",
+ );
+ assert_model_error_contains(
+ RelayDeliveryEvidence {
+ state: RelayDeliveryState::Observed,
+ target_relays: vec!["wss://relay-a.example".to_owned()],
+ connected_relays: Vec::new(),
+ acknowledged_relays: Vec::new(),
+ observed_relays: Vec::new(),
+ failed_relays: Vec::new(),
+ }
+ .to_json_value(),
+ "observed_relays",
+ );
+ assert_model_error_contains(
+ RelayDeliveryEvidence {
+ state: RelayDeliveryState::Failed,
+ target_relays: vec!["wss://relay-a.example".to_owned()],
+ connected_relays: Vec::new(),
+ acknowledged_relays: Vec::new(),
+ observed_relays: Vec::new(),
+ failed_relays: Vec::new(),
+ }
+ .to_json_value(),
+ "failed_relays",
+ );
+ assert_model_error_contains(
+ RelayDeliveryEvidence {
+ state: RelayDeliveryState::Failed,
+ target_relays: vec!["wss://relay-a.example".to_owned()],
+ connected_relays: Vec::new(),
+ acknowledged_relays: Vec::new(),
+ observed_relays: Vec::new(),
+ failed_relays: vec![RelayDeliveryFailure {
+ relay_url: " ".to_owned(),
+ error: "timeout".to_owned(),
+ }],
+ }
+ .to_json_value(),
+ "failed_relay_url",
+ );
+ assert_model_error_contains(
+ RelayDeliveryEvidence {
+ state: RelayDeliveryState::Failed,
+ target_relays: vec!["wss://relay-a.example".to_owned()],
+ connected_relays: Vec::new(),
+ acknowledged_relays: Vec::new(),
+ observed_relays: Vec::new(),
+ failed_relays: vec![RelayDeliveryFailure {
+ relay_url: "wss://relay-a.example".to_owned(),
+ error: " ".to_owned(),
+ }],
+ }
+ .to_json_value(),
+ "failed_relay_error",
+ );
+ assert_eq!(
+ RelayDeliveryEvidence {
+ state: RelayDeliveryState::Pending,
+ target_relays: Vec::new(),
+ connected_relays: Vec::new(),
+ acknowledged_relays: Vec::new(),
+ observed_relays: Vec::new(),
+ failed_relays: Vec::new(),
+ }
+ .relay_set_fingerprint(),
+ None
+ );
+ }
+
+ #[test]
fn local_record_input_validation_covers_success_and_error_paths() {
let mut local_work = local_work_input();
local_work.validate().expect("valid local work");
@@ -754,4 +952,15 @@ mod tests {
"expected error to contain {expected}, got {err}"
);
}
+
+ fn assert_model_error_contains<T>(result: Result<T, RuntimeStoreError>, expected: &str) {
+ let err = match result {
+ Ok(_) => panic!("expected validation error"),
+ Err(err) => err,
+ };
+ assert!(
+ err.to_string().contains(expected),
+ "expected error to contain {expected}, got {err}"
+ );
+ }
}
