Skip to content

The fastest, cheapest, most efficient open-source agent harness. Run more than 500 agents on a $10 VPS.

test(inbound): cover external source offer, results and ack

Steven Enamakel50bc8a60c5fd
diff --git a/crates/openhuman-core/src/inbound/ops_tests.rs b/crates/openhuman-core/src/inbound/ops_tests.rs
index badc66bc74..eb41018c4c 100644
--- a/crates/openhuman-core/src/inbound/ops_tests.rs
+++ b/crates/openhuman-core/src/inbound/ops_tests.rs
@@ -43,3 +43,212 @@ async fn the_operations_reach_the_module() {
.unwrap_err()
.starts_with("inbound.redrive:"));
}
+
+// ── External sources: offer, results, ack ──────────────────────────────────
+
+use std::sync::{Arc, Mutex as StdMutex};
+use std::time::Duration;
+
+use async_trait::async_trait;
+use serde_json::json;
+use tinybus::EventHandler;
+
+use crate::core::bus::BUS;
+use crate::core::events::DomainEvent;
+use crate::inbound::fixture::{memory_results, mentions_inbound, Reply, ScriptedAgent};
+use crate::inbound::pinned::{Pinned, PinnedAgent};
+use crate::inbound::results::{ResultStatus, Results};
+
+fn mentions_config(debounce_ms: u64, max_batch: u32) -> crate::config::Config {
+ let mut config = active_config();
+ config.inbound = mentions_inbound(debounce_ms, max_batch);
+ config
+}
+
+fn mention(id: &str) -> OfferParams {
+ serde_json::from_value(json!({
+ "source": "x:mentions",
+ "key": "mentions",
+ "event_id": id,
+ "text": format!("hey @bot {id} {}", id.repeat(7)),
+ "payload": { "author": format!("@user{id}") },
+ }))
+ .unwrap()
+}
+
+/// Collects the `inbound` domain events of one source.
+#[derive(Clone)]
+struct Completed(Arc<StdMutex<Vec<DomainEvent>>>, &'static str);
+
+#[async_trait]
+impl EventHandler<DomainEvent> for Completed {
+ fn name(&self) -> &str {
+ "test::inbound_completed"
+ }
+
+ fn domains(&self) -> Option<&[&str]> {
+ Some(&["inbound"])
+ }
+
+ async fn handle(&self, event: &DomainEvent) {
+ if let DomainEvent::InboundTurnCompleted { turn_id, .. } = event {
+ if turn_id.starts_with(self.1) || self.1.is_empty() {
+ self.0.lock().unwrap().push(event.clone());
+ }
+ }
+ }
+}
+
+async fn until_results(config: &crate::config::Config, results: &Results, n: usize) -> Vec<crate::inbound::results::InboundResult> {
+ let deadline = tokio::time::Instant::now() + Duration::from_secs(20);
+ loop {
+ let listed = super::results(
+ config,
+ results,
+ ResultsParams {
+ status: Some(ResultStatus::Completed),
+ ..ResultsParams::default()
+ },
+ )
+ .unwrap()
+ .value
+ .results;
+ if listed.len() >= n || tokio::time::Instant::now() >= deadline {
+ return listed;
+ }
+ tokio::time::sleep(Duration::from_millis(20)).await;
+ }
+}
+
+#[tokio::test]
+async fn an_offer_names_an_unconfigured_or_unusable_source() {
+ let config = mentions_config(10, 25);
+ let client = crate::modules::ops::client(config.clone());
+ let mut params = mention("1");
+ params.source = "x:dms".into();
+ let refused = offer(&config, &client, params).await.unwrap_err();
+ assert!(refused.contains("not configured"), "{refused}");
+ let mut params = mention("1");
+ params.source = "composio:gmail".into();
+ assert!(offer(&config, &client, params).await.unwrap_err().contains("reserved"));
+ let mut params = mention("1");
+ params.event_id = " ".into();
+ assert!(offer(&config, &client, params).await.unwrap_err().contains("event_id"));
+ let mut off = config.clone();
+ off.components.eventqueues = false;
+ assert!(offer(&off, &client, mention("1"))
+ .await
+ .unwrap_err()
+ .contains("COMPONENT_DISABLED:eventqueues"));
+ let results = memory_results();
+ assert!(super::results(&off, &results, ResultsParams::default()).is_err());
+ assert!(result_ack(&off, &results, "t").is_err());
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
+async fn three_offers_within_the_window_run_one_turn_with_one_result_and_one_event() {
+ crate::core::bus::init().await.expect("bus init");
+ let seen = Completed(Arc::new(StdMutex::new(Vec::new())), "");
+ let _handle = BUS.subscribe(Arc::new(seen.clone()));
+ let config = mentions_config(300, 25);
+ let agent = ScriptedAgent::new([Reply::Text("three drafts")]);
+ let results = memory_results();
+ let rig = Rig::pinned(
+ config.inbound.clone(),
+ Pinned::new(agent.clone() as Arc<dyn PinnedAgent>, results.clone()),
+ )
+ .await;
+
+ for id in ["101", "102", "103"] {
+ let offered = offer(&config, &rig.client, mention(id)).await.unwrap();
+ assert_eq!(offered.value.disposition, "accepted");
+ }
+ // A redelivery of a mention is a success, not an error.
+ let again = offer(&config, &rig.client, mention("102")).await.unwrap();
+ assert_eq!(again.value.disposition, "duplicate");
+
+ let listed = until_results(&config, &results, 1).await;
+ assert_eq!(listed.len(), 1, "{listed:?}");
+ let result = &listed[0];
+ assert_eq!(result.source, "x:mentions");
+ assert_eq!(result.key, "mentions");
+ assert_eq!(result.agent_id, "teeny-mentions");
+ assert_eq!(result.text.as_deref(), Some("three drafts"));
+ assert_eq!(result.event_ids, ["101", "102", "103"]);
+ tokio::time::sleep(Duration::from_millis(400)).await;
+ assert_eq!(agent.runs().len(), 1, "the batch ran more than once");
+ let completed: Vec<_> = seen
+ .0
+ .lock()
+ .unwrap()
+ .iter()
+ .filter(|event| {
+ matches!(event, DomainEvent::InboundTurnCompleted { turn_id, .. } if *turn_id == result.turn_id)
+ })
+ .cloned()
+ .collect();
+ assert_eq!(completed.len(), 1);
+
+ let acked = result_ack(&config, &results, &result.turn_id).unwrap();
+ assert!(acked.value.acked);
+ assert!(super::results(&config, &results, ResultsParams::default())
+ .unwrap()
+ .value
+ .results
+ .is_empty());
+ assert!(result_ack(&config, &results, "unknown").is_err());
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
+async fn a_burst_over_max_batch_runs_in_turns_of_at_most_max_batch() {
+ let config = mentions_config(300, 2);
+ let agent = ScriptedAgent::new([]);
+ let results = memory_results();
+ let rig = Rig::pinned(
+ config.inbound.clone(),
+ Pinned::new(agent.clone() as Arc<dyn PinnedAgent>, results.clone()),
+ )
+ .await;
+ for id in ["201", "202", "203", "204", "205"] {
+ offer(&config, &rig.client, mention(id)).await.unwrap();
+ }
+ let listed = until_results(&config, &results, 3).await;
+ let mut batches: Vec<Vec<String>> = listed.into_iter().map(|r| r.event_ids).collect();
+ batches.sort();
+ assert!(batches.iter().all(|batch| batch.len() <= 2), "{batches:?}");
+ assert_eq!(batches.concat().len(), 5, "{batches:?}");
+}
+
+#[test]
+fn results_are_limited_and_pruned_past_their_ttl() {
+ let mut config = mentions_config(10, 25);
+ config
+ .inbound
+ .sources
+ .get_mut("x:mentions")
+ .unwrap()
+ .result_ttl_days = 1;
+ let results = memory_results();
+ let now = super::now_ms();
+ let day = 24 * 60 * 60 * 1_000;
+ for (turn, at) in [("old", now - 2 * day), ("t1", now - 10), ("t2", now - 5)] {
+ results
+ .start(&crate::inbound::results::Stored::running(
+ turn,
+ "x:mentions",
+ "mentions",
+ "teeny-mentions",
+ vec![],
+ "m",
+ at,
+ ))
+ .unwrap();
+ }
+ let params: ResultsParams = serde_json::from_value(json!({ "limit": 1 })).unwrap();
+ let listed = super::results(&config, &results, params).unwrap().value.results;
+ assert_eq!(listed.len(), 1);
+ assert_eq!(listed[0].turn_id, "t1");
+ assert!(results.get("old").unwrap().is_none(), "not pruned");
+ let capped: ResultsParams = serde_json::from_value(json!({ "limit": 100_000 })).unwrap();
+ assert_eq!(super::results(&config, &results, capped).unwrap().value.results.len(), 2);
+}
diff --git a/crates/openhuman-core/src/inbound/schemas_tests.rs b/crates/openhuman-core/src/inbound/schemas_tests.rs
index cf900b3644..97ccb53c7e 100644
--- a/crates/openhuman-core/src/inbound/schemas_tests.rs
+++ b/crates/openhuman-core/src/inbound/schemas_tests.rs
@@ -6,10 +6,13 @@ use super::*;
fn every_function_has_a_schema_and_a_controller() {
let all = all_controller_schemas();
let names: Vec<&str> = all.iter().map(|schema| schema.function).collect();
- assert_eq!(names, vec!["stats", "dead", "redrive"]);
+ assert_eq!(
+ names,
+ vec!["stats", "dead", "redrive", "offer", "results", "result_ack"]
+ );
assert!(all.iter().all(|schema| schema.namespace == "inbound"));
let controllers = all_registered_controllers();
- assert_eq!(controllers.len(), 3);
+ assert_eq!(controllers.len(), 6);
assert_eq!(schemas("unknown").function, "unknown");
assert!(schemas("redrive")
.inputs
@@ -26,3 +29,34 @@ async fn malformed_params_are_refused_before_the_module_is_reached() {
let refused = handle_redrive(DispatchCtx::host_default(), Map::new()).await;
assert!(refused.unwrap_err().contains("invalid params"));
}
+
+#[test]
+fn the_external_source_functions_have_schemas() {
+ let names: Vec<&str> = all_controller_schemas().iter().map(|s| s.function).collect();
+ for name in ["offer", "results", "result_ack"] {
+ assert!(names.contains(&name), "{name}");
+ }
+ assert_eq!(all_registered_controllers().len(), names.len());
+ for required in ["source", "key", "event_id", "text"] {
+ assert!(schemas("offer")
+ .inputs
+ .iter()
+ .any(|input| input.name == required && input.required));
+ }
+ assert!(schemas("result_ack")
+ .inputs
+ .iter()
+ .any(|input| input.name == "turn_id" && input.required));
+}
+
+#[tokio::test]
+async fn malformed_external_params_are_refused_before_anything_runs() {
+ let refused = handle_offer(DispatchCtx::host_default(), Map::new()).await;
+ assert!(refused.unwrap_err().contains("invalid params"));
+ let mut params = Map::new();
+ params.insert("status".into(), Value::String("pending".into()));
+ let refused = handle_results(DispatchCtx::host_default(), params).await;
+ assert!(refused.unwrap_err().contains("invalid params"));
+ let refused = handle_result_ack(DispatchCtx::host_default(), Map::new()).await;
+ assert!(refused.unwrap_err().contains("invalid params"));
+}