Skip to content

armgit / cua

Public Imported from GitHub
0

Scale computer-use 2.0 with open-source drivers, cross-OS sandboxes, and benchmarks for training, evaluation, and data generation.

test(cua-driver): prune redundant core and contract tests (#4106)

Francesco Bonaccif5f1d8ccd1c5
diff --git a/libs/cua-driver/rust/crates/cua-driver-contract/src/bin/cua-contract-gen.rs b/libs/cua-driver/rust/crates/cua-driver-contract/src/bin/cua-contract-gen.rs
index 08a4d864f1..43405026ff 100644
--- a/libs/cua-driver/rust/crates/cua-driver-contract/src/bin/cua-contract-gen.rs
+++ b/libs/cua-driver/rust/crates/cua-driver-contract/src/bin/cua-contract-gen.rs
@@ -93,16 +93,3 @@ fn write_or_check(path: &Path, expected: &str, check: bool) -> Result<(), String
println!("generated {}", path.display());
Ok(())
}
-
-#[cfg(test)]
-mod tests {
- use super::*;
-
- #[test]
- fn manifest_output_is_pretty_and_newline_terminated() {
- let mut output = serde_json::to_string_pretty(&manifest()).expect("serialize manifest");
- output.push('\n');
- assert!(output.starts_with("{\n"));
- assert!(output.ends_with("\n"));
- }
-}
diff --git a/libs/cua-driver/rust/crates/cua-driver-contract/src/lib.rs b/libs/cua-driver/rust/crates/cua-driver-contract/src/lib.rs
index 1336622507..d0ef464eab 100644
--- a/libs/cua-driver/rust/crates/cua-driver-contract/src/lib.rs
+++ b/libs/cua-driver/rust/crates/cua-driver-contract/src/lib.rs
@@ -451,6 +451,10 @@ mod tests {
.join(" ");
assert!(description.starts_with(MULTI_CALL_SESSION_DESCRIPTION));
assert!(description.contains("never selects capture modality or authorization"));
+
+ assert!(MULTI_CALL_SESSION_DESCRIPTION.contains("prefer a short public session label"));
+ assert!(MULTI_CALL_SESSION_DESCRIPTION.contains("repeat it on every call that accepts it"));
+ assert!(MULTI_CALL_SESSION_DESCRIPTION.contains("implicit lifecycle session"));
}
#[test]
@@ -465,6 +469,22 @@ mod tests {
}
}
+ #[test]
+ fn delivery_mode_capability_matches_the_typed_input_schema() {
+ for tool in manifest().tools {
+ assert_eq!(
+ tool.input_schema
+ .pointer("/properties/delivery_mode")
+ .is_some(),
+ tool.capabilities
+ .iter()
+ .any(|capability| capability == "input.delivery_mode"),
+ "{} typed contract delivery_mode schema/capability mismatch",
+ tool.name
+ );
+ }
+ }
+
#[test]
fn desktop_contracts_are_explicit_portable_subsets() {
for name in [
diff --git a/libs/cua-driver/rust/crates/cua-driver-core/src/cursor_shape.rs b/libs/cua-driver/rust/crates/cua-driver-core/src/cursor_shape.rs
index e65ee1b9e8..e68a2ba4aa 100644
--- a/libs/cua-driver/rust/crates/cua-driver-core/src/cursor_shape.rs
+++ b/libs/cua-driver/rust/crates/cua-driver-core/src/cursor_shape.rs
@@ -107,12 +107,10 @@ pub fn current_system_cursor_shape() -> SystemCursorShape {
mod tests {
use super::*;
- /// The distinction the whole module rests on: an unsupported platform must
- /// report `Unknown`, never `Default`. Reporting `Default` would render a
- /// confident arrow on a host that has no idea what the pointer looks like.
+ /// The derived default is the ordinary arrow. Unsupported platforms never
+ /// reach it: they report `Unknown` (see the next test).
#[test]
- fn unknown_is_not_default() {
- assert_ne!(SystemCursorShape::Unknown, SystemCursorShape::Default);
+ fn default_variant_is_default_arrow() {
assert_eq!(SystemCursorShape::default(), SystemCursorShape::Default);
}
diff --git a/libs/cua-driver/rust/crates/cua-driver-core/src/element_cache.rs b/libs/cua-driver/rust/crates/cua-driver-core/src/element_cache.rs
index fec5c7c208..c42a79d86a 100644
--- a/libs/cua-driver/rust/crates/cua-driver-core/src/element_cache.rs
+++ b/libs/cua-driver/rust/crates/cua-driver-core/src/element_cache.rs
@@ -703,6 +703,37 @@ mod tests {
use crate::snapshot_test_support::Payload;
use std::sync::atomic::{AtomicUsize, Ordering};
+ fn publish(cache: &ElementCacheCore<Payload>, pid: i32, window: u64, count: usize) -> u32 {
+ cache.publish(pid, window, Payload((0..count).collect()))
+ }
+
+ fn resolve(
+ cache: &ElementCacheCore<Payload>,
+ pid: i32,
+ token: &str,
+ ) -> Result<(u64, usize), String> {
+ cache
+ .resolve_element_args(pid, None, Some(token), None, None, "click")
+ .map(|result| match result {
+ ResolvedElement::Element {
+ window_id: Some(window),
+ element_index,
+ element,
+ ..
+ } => {
+ assert_eq!(element, element_index);
+ (window, element_index)
+ }
+ _ => panic!("expected element"),
+ })
+ .map_err(|error| {
+ error.structured_content.unwrap()["refusal"]["message"]
+ .as_str()
+ .unwrap()
+ .to_owned()
+ })
+ }
+
#[test]
fn publish_then_resolve_returns_projection() {
let cache = ElementCacheCore::new();
@@ -712,18 +743,161 @@ mod tests {
.unwrap();
assert!(matches!(
result,
- ResolvedElement::Element { element: 30, .. }
+ ResolvedElement::Element {
+ window_id: Some(7),
+ element_index: 2,
+ element: 30,
+ ..
+ }
));
}
#[test]
- fn miss_returns_refusal() {
- let cache = ElementCacheCore::<Payload>::new();
+ fn resolve_with_unknown_pid_returns_stale_error() {
+ assert_eq!(
+ resolve(&ElementCacheCore::new(), 999, &token_for(0x1234, 0)),
+ Err(STALE_TOKEN_ERROR.into())
+ );
+ }
+
+ #[test]
+ fn resolve_with_bad_format_returns_invalid_error() {
+ let cache = ElementCacheCore::new();
+ publish(&cache, 10, 1, 1);
+ assert!(resolve(&cache, 10, "garbage")
+ .unwrap_err()
+ .contains("invalid format"));
+ }
+
+ #[test]
+ fn out_of_range_index_returns_actionable_error() {
+ let cache = ElementCacheCore::new();
+ let id = publish(&cache, 11, 1, 3);
+ assert!(resolve(&cache, 11, &token_for(id, 7))
+ .unwrap_err()
+ .contains("out of range"));
+ }
+
+ #[test]
+ fn snapshots_for_different_windows_share_the_bounded_lru() {
+ let cache = ElementCacheCore::new();
+ let first = publish(&cache, 12, 1, 5);
+ let second = publish(&cache, 12, 2, 5);
+ assert_eq!(resolve(&cache, 12, &token_for(first, 0)), Ok((1, 0)));
+ assert_eq!(resolve(&cache, 12, &token_for(second, 0)), Ok((2, 0)));
+ }
+
+ #[test]
+ fn tokens_in_different_pids_dont_collide() {
+ let cache = ElementCacheCore::new();
+ let first = publish(&cache, 100, 11, 3);
+ let second = publish(&cache, 200, 22, 3);
+ assert_eq!(resolve(&cache, 100, &token_for(first, 0)), Ok((11, 0)));
+ assert_eq!(resolve(&cache, 200, &token_for(second, 0)), Ok((22, 0)));
+ assert_eq!(
+ resolve(&cache, 200, &token_for(first, 0)),
+ Err(STALE_TOKEN_ERROR.into())
+ );
+ }
+
+ #[test]
+ fn clear_then_register_starts_clean() {
+ let cache = ElementCacheCore::new();
+ let first = publish(&cache, 1, 1, 1);
+ assert_eq!(cache.clear(), 1);
+ assert_eq!(cache.clear(), 0);
+ assert_eq!(
+ resolve(&cache, 1, &token_for(first, 0)),
+ Err(STALE_TOKEN_ERROR.into())
+ );
+ let second = publish(&cache, 1, 1, 1);
+ assert_eq!(resolve(&cache, 1, &token_for(second, 0)), Ok((1, 0)));
+ }
+
+ #[test]
+ fn bare_element_index_is_refused() {
+ assert!(ElementCacheCore::<Payload>::new()
+ .resolve_element_args(1, Some(7), None, None, Some(99), "click")
+ .is_err());
+ }
+
+ #[test]
+ fn element_token_alone_resolves_to_same_action() {
+ let cache = ElementCacheCore::new();
+ let id = publish(&cache, 1, 555, 4);
+ let resolved = cache
+ .resolve_element_args(1, None, Some(&token_for(id, 2)), None, None, "click")
+ .unwrap();
+ assert!(matches!(
+ resolved,
+ ResolvedElement::Element {
+ window_id: Some(555),
+ element_index: 2,
+ via_token: true,
+ element: 2
+ }
+ ));
+ }
+
+ #[test]
+ fn conflicting_token_and_index_are_refused() {
+ let cache = ElementCacheCore::new();
+ let id = publish(&cache, 1, 777, 5);
assert!(cache
- .resolve_element_args(1, None, Some(&token_for(0, 0)), None, None, "click")
+ .resolve_element_args(1, Some(99), Some(&token_for(id, 3)), None, None, "click")
.is_err());
}
+ #[test]
+ fn snapshot_id_and_index_resolve_safely() {
+ let cache = ElementCacheCore::new();
+ let id = publish(&cache, 1, 888, 5);
+ let result = cache
+ .resolve_element_args(
+ 1,
+ Some(2),
+ None,
+ Some(&format!("s{id:08x}")),
+ Some(888),
+ "click",
+ )
+ .unwrap();
+ assert!(matches!(
+ result,
+ ResolvedElement::Element {
+ window_id: Some(888),
+ element_index: 2,
+ via_token: false,
+ element: 2
+ }
+ ));
+ }
+
+ #[test]
+ fn token_only_stale_returns_error_not_silent_fallback_to_integer() {
+ let result = ElementCacheCore::<Payload>::new()
+ .resolve_element_args(
+ 1,
+ Some(0),
+ Some(&token_for(0xdead, 0)),
+ None,
+ Some(1),
+ "click",
+ )
+ .unwrap_err();
+ assert!(result.is_error.unwrap_or(false));
+ }
+
+ #[test]
+ fn neither_returns_none() {
+ assert!(matches!(
+ ElementCacheCore::<Payload>::new()
+ .resolve_element_args(1, None, None, None, None, "click")
+ .unwrap(),
+ ResolvedElement::None
+ ));
+ }
+
#[test]
fn membership_matches_payload_length() {
let cache = ElementCacheCore::new();
@@ -1443,9 +1617,4 @@ mod tests {
assert_eq!(retire_runtime_scope("snapshot-weak-discovery"), 0);
});
}
-
- #[test]
- fn default_impl_matches_new() {
- let _cache: ElementCacheCore<Payload> = ElementCacheCore::default();
- }
}
diff --git a/libs/cua-driver/rust/crates/cua-driver-core/src/element_token.rs b/libs/cua-driver/rust/crates/cua-driver-core/src/element_token.rs
index c349e73bd1..581b7a1850 100644
--- a/libs/cua-driver/rust/crates/cua-driver-core/src/element_token.rs
+++ b/libs/cua-driver/rust/crates/cua-driver-core/src/element_token.rs
@@ -11,12 +11,8 @@ pub(crate) fn mint_snapshot_id() -> u32 {
SNAPSHOT_COUNTER.fetch_add(1, Ordering::Relaxed)
}
-pub fn format_token(snapshot_id: u32, element_index: usize) -> String {
- format!("s{snapshot_id:08x}:{element_index}")
-}
-
pub fn token_for(snapshot_id: u32, element_index: usize) -> String {
- format_token(snapshot_id, element_index)
+ format!("s{snapshot_id:08x}:{element_index}")
}
pub fn parse_token(token: &str) -> Option<(u32, usize)> {
@@ -139,65 +135,17 @@ pub(crate) fn parse_element_args(
#[cfg(test)]
mod tests {
use super::*;
- use crate::element_cache::{
- current_runtime_cache, register_runtime_cache, ElementCacheCore, SnapshotPayload,
- };
- use crate::tool::with_runtime_scope;
- use std::sync::Arc;
-
- struct Payload(Vec<usize>);
- impl SnapshotPayload for Payload {
- type Element = usize;
- fn len(&self) -> usize {
- self.0.len()
- }
- fn retain(&self, index: usize) -> Option<usize> {
- self.0.get(index).copied()
- }
- }
- fn cache() -> ElementCacheCore<Payload> {
- ElementCacheCore::new()
- }
- fn publish(cache: &ElementCacheCore<Payload>, pid: i32, window: u64, count: usize) -> u32 {
- cache.publish(pid, window, Payload((0..count).collect()))
- }
- fn resolve(
- cache: &ElementCacheCore<Payload>,
- pid: i32,
- token: &str,
- ) -> Result<(u64, usize), String> {
- cache
- .resolve_element_args(pid, None, Some(token), None, None, "click")
- .map(|result| match result {
- ResolvedElement::Element {
- window_id: Some(window),
- element_index,
- element,
- ..
- } => {
- assert_eq!(element, element_index);
- (window, element_index)
- }
- _ => panic!("expected element"),
- })
- .map_err(|error| {
- error.structured_content.unwrap()["refusal"]["message"]
- .as_str()
- .unwrap()
- .to_owned()
- })
- }
#[test]
fn token_round_trips_through_format_then_parse() {
- assert_eq!(format_token(0x1234, 42), "s00001234:42");
- assert_eq!(parse_token(&format_token(0x1234, 42)), Some((0x1234, 42)));
+ assert_eq!(token_for(0x1234, 42), "s00001234:42");
+ assert_eq!(parse_token(&token_for(0x1234, 42)), Some((0x1234, 42)));
}
#[test]
fn token_format_pads_to_eight_hex_chars() {
- assert_eq!(format_token(1, 0), "s00000001:0");
- assert_eq!(format_token(0, 999), "s00000000:999");
- assert_eq!(format_token(0x0001_0001, 3), "s00010001:3");
+ assert_eq!(token_for(1, 0), "s00000001:0");
+ assert_eq!(token_for(0, 999), "s00000000:999");
+ assert_eq!(token_for(0x0001_0001, 3), "s00010001:3");
assert_eq!(parse_token("s00010001:3"), Some((0x0001_0001, 3)));
}
#[test]
@@ -214,197 +162,4 @@ mod tests {
assert!(parse_token(token).is_none(), "{token}");
}
}
- #[test]
- fn register_then_resolve_returns_window_and_index() {
- let cache = cache();
- let id = publish(&cache, 100, 42, 5);
- assert_eq!(resolve(&cache, 100, &format_token(id, 3)), Ok((42, 3)));
- }
- #[test]
- fn resolve_with_unknown_pid_returns_stale_error() {
- assert_eq!(
- resolve(&cache(), 999, &format_token(0x1234, 0)),
- Err(STALE_TOKEN_ERROR.into())
- );
- }
- #[test]
- fn resolve_with_bad_format_returns_invalid_error() {
- let cache = cache();
- publish(&cache, 10, 1, 1);
- assert!(resolve(&cache, 10, "garbage")
- .unwrap_err()
- .contains("invalid format"));
- }
- #[test]
- fn out_of_range_index_returns_actionable_error() {
- let cache = cache();
- let id = publish(&cache, 11, 1, 3);
- assert!(resolve(&cache, 11, &format_token(id, 7))
- .unwrap_err()
- .contains("out of range"));
- }
- #[test]
- fn next_snapshot_for_same_window_invalidates_old_immediately() {
- let cache = cache();
- let first = publish(&cache, 12, 1, 5);
- let second = publish(&cache, 12, 1, 5);
- assert_eq!(
- resolve(&cache, 12, &format_token(first, 0)),
- Err(STALE_TOKEN_ERROR.into())
- );
- assert_eq!(resolve(&cache, 12, &format_token(second, 0)), Ok((1, 0)));
- }
- #[test]
- fn snapshots_for_different_windows_share_the_bounded_lru() {
- let cache = cache();
- let first = publish(&cache, 12, 1, 5);
- let second = publish(&cache, 12, 2, 5);
- assert_eq!(resolve(&cache, 12, &format_token(first, 0)), Ok((1, 0)));
- assert_eq!(resolve(&cache, 12, &format_token(second, 0)), Ok((2, 0)));
- }
- #[test]
- fn lru_eviction_invalidates_oldest_snapshot() {
- let cache = cache();
- let ids: Vec<_> = (1..=LRU_CAP_PER_PID as u64 + 1)
- .map(|window| publish(&cache, 13, window, 5))
- .collect();
- assert_eq!(
- resolve(&cache, 13, &format_token(ids[0], 0)),
- Err(STALE_TOKEN_ERROR.into())
- );
- assert_eq!(
- ids.iter()
- .filter(|id| resolve(&cache, 13, &format_token(**id, 0)).is_ok())
- .count(),
- LRU_CAP_PER_PID
- );
- }
- #[test]
- fn tokens_in_different_pids_dont_collide() {
- let cache = cache();
- let first = publish(&cache, 100, 11, 3);
- let second = publish(&cache, 200, 22, 3);
- assert_eq!(resolve(&cache, 100, &format_token(first, 0)), Ok((11, 0)));
- assert_eq!(resolve(&cache, 200, &format_token(second, 0)), Ok((22, 0)));
- assert_eq!(
- resolve(&cache, 200, &format_token(first, 0)),
- Err(STALE_TOKEN_ERROR.into())
- );
- }
- #[test]
- fn runtime_cache_discovery_is_weak_and_shared_across_calls() {
- with_runtime_scope("token-discovery-test".into(), || {
- let cache = Arc::new(cache());
- register_runtime_cache(&cache);
- assert!(Arc::ptr_eq(
- &cache,
- &current_runtime_cache::<Payload>().unwrap()
- ));
- drop(cache);
- assert!(current_runtime_cache::<Payload>().is_none());
- });
- }
- #[test]
- fn stale_token_returns_explicit_error_not_silent_misclick() {
- let cache = cache();
- let first = publish(&cache, 14, 1, 5);
- for _ in 0..LRU_CAP_PER_PID {
- publish(&cache, 14, 1, 5);
- }
- assert_eq!(
- resolve(&cache, 14, &format_token(first, 2)),
- Err(STALE_TOKEN_ERROR.into())
- );
- }
- #[test]
- fn clear_then_register_starts_clean() {
- let cache = cache();
- let first = publish(&cache, 1, 1, 1);
- assert_eq!(cache.clear(), 1);
- assert_eq!(cache.clear(), 0);
- assert_eq!(
- resolve(&cache, 1, &format_token(first, 0)),
- Err(STALE_TOKEN_ERROR.into())
- );
- let second = publish(&cache, 1, 1, 1);
- assert_eq!(resolve(&cache, 1, &format_token(second, 0)), Ok((1, 0)));
- }
- #[test]
- fn bare_element_index_is_refused() {
- assert!(cache()
- .resolve_element_args(1, Some(7), None, None, Some(99), "click")
- .is_err());
- }
- #[test]
- fn element_token_alone_resolves_to_same_action() {
- let cache = cache();
- let id = publish(&cache, 1, 555, 4);
- let resolved = cache
- .resolve_element_args(1, None, Some(&format_token(id, 2)), None, None, "click")
- .unwrap();
- assert!(matches!(
- resolved,
- ResolvedElement::Element {
- window_id: Some(555),
- element_index: 2,
- via_token: true,
- element: 2
- }
- ));
- }
- #[test]
- fn conflicting_token_and_index_are_refused() {
- let cache = cache();
- let id = publish(&cache, 1, 777, 5);
- assert!(cache
- .resolve_element_args(1, Some(99), Some(&format_token(id, 3)), None, None, "click")
- .is_err());
- }
- #[test]
- fn snapshot_id_and_index_resolve_safely() {
- let cache = cache();
- let id = publish(&cache, 1, 888, 5);
- let result = cache
- .resolve_element_args(
- 1,
- Some(2),
- None,
- Some(&format!("s{id:08x}")),
- Some(888),
- "click",
- )
- .unwrap();
- assert!(matches!(
- result,
- ResolvedElement::Element {
- window_id: Some(888),
- element_index: 2,
- via_token: false,
- element: 2
- }
- ));
- }
- #[test]
- fn token_only_stale_returns_error_not_silent_fallback_to_integer() {
- let result = cache()
- .resolve_element_args(
- 1,
- Some(0),
- Some(&format_token(0xdead, 0)),
- None,
- Some(1),
- "click",
- )
- .unwrap_err();
- assert!(result.is_error.unwrap_or(false));
- }
- #[test]
- fn neither_returns_none() {
- assert!(matches!(
- cache()
- .resolve_element_args(1, None, None, None, None, "click")
- .unwrap(),
- ResolvedElement::None
- ));
- }
}
diff --git a/libs/cua-driver/rust/crates/cua-driver-core/src/health_report.rs b/libs/cua-driver/rust/crates/cua-driver-core/src/health_report.rs
index e4326c37d2..8fe4e81f43 100644
--- a/libs/cua-driver/rust/crates/cua-driver-core/src/health_report.rs
+++ b/libs/cua-driver/rust/crates/cua-driver-core/src/health_report.rs
@@ -512,13 +512,6 @@ mod tests {
]
}
- fn parse_args(v: Value) -> (BTreeSet<String>, BTreeSet<String>) {
- (
- parse_string_set(v.get("include")),
- parse_string_set(v.get("skip")),
- )
- }
-
// ── select_checks ────────────────────────────────────────────────
#[test]
@@ -747,11 +740,4 @@ mod tests {
"schema_version=1 must be documented in the tool description"
);
}
-
- // Belt-and-suspenders use of `parse_args` — keeps the helper
- // exercised in case future tests reach for it.
- #[test]
- fn parse_args_compiles() {
- let _ = parse_args(json!({ "include": ["x"], "skip": ["y"] }));
- }
}
diff --git a/libs/cua-driver/rust/crates/cua-driver-core/src/tool.rs b/libs/cua-driver/rust/crates/cua-driver-core/src/tool.rs
index 06c5878e46..5aedb222cd 100644
--- a/libs/cua-driver/rust/crates/cua-driver-core/src/tool.rs
+++ b/libs/cua-driver/rust/crates/cua-driver-core/src/tool.rs
@@ -5394,36 +5394,6 @@ mod capability_tests {
}
}
- #[test]
- fn capability_version_is_string_one() {
- // Bumping this constant in a non-breaking PR is an error —
- // the version is the contract version, not the build version.
- // Pinned to "1" until we ship a BREAKING vocabulary change.
- assert_eq!(CAPABILITY_VERSION, "1");
- }
-
- #[test]
- fn delivery_mode_capability_is_derived_from_the_runtime_schema() {
- let with_delivery_mode = serde_json::json!({
- "type": "object",
- "properties": {
- "delivery_mode": crate::tool_schema::delivery_mode_schema()
- }
- });
- let without_delivery_mode = serde_json::json!({"type": "object", "properties": {}});
-
- assert!(
- advertised_capabilities_for("press_key", &with_delivery_mode)
- .iter()
- .any(|capability| capability == "input.delivery_mode")
- );
- assert!(
- !advertised_capabilities_for("press_key", &without_delivery_mode)
- .iter()
- .any(|capability| capability == "input.delivery_mode")
- );
- }
-
#[test]
fn delivery_mode_normalization_is_schema_gated_modern_first_and_fail_closed() {
let with_delivery_mode = super::ToolDef {
@@ -5495,16 +5465,6 @@ mod capability_tests {
assert_eq!(unrelated, serde_json::json!({"dispatch": "foreground"}));
}
- #[test]
- fn unknown_tools_get_empty_capabilities() {
- // Tools without a mapping (typically internal/stub tools like
- // `unsupported_platform`) return `[]`. Consumers fall back to
- // name-matching for those, which is fine — they were never
- // load-bearing for capability routing.
- assert!(default_capabilities_for("unsupported_platform").is_empty());
- assert!(default_capabilities_for("totally_made_up_tool").is_empty());
- }
-
fn dummy_def(name: &str) -> ToolDef {
ToolDef {
name: name.into(),
@@ -5611,14 +5571,16 @@ mod capability_tests {
#[test]
fn to_list_entry_includes_empty_capabilities_array_for_unknown_tool() {
// Even when no capabilities are claimed, the field is still
- // present — consumers can rely on the key existing.
- let def = dummy_def("totally_made_up_tool");
- let entry = def.to_list_entry();
- let caps = entry
- .get("capabilities")
- .and_then(|v| v.as_array())
- .expect("capabilities must be present even if empty");
- assert!(caps.is_empty());
+ // present — consumers can rely on the key existing. Internal stub
+ // tools such as `unsupported_platform` claim nothing either.
+ for name in ["totally_made_up_tool", "unsupported_platform"] {
+ let entry = dummy_def(name).to_list_entry();
+ let caps = entry
+ .get("capabilities")
+ .and_then(|v| v.as_array())
+ .expect("capabilities must be present even if empty");
+ assert!(caps.is_empty(), "{name}");
+ }
}
#[test]
diff --git a/libs/cua-driver/rust/crates/cua-driver-core/src/tool_schema.rs b/libs/cua-driver/rust/crates/cua-driver-core/src/tool_schema.rs
index 39e9266257..70fb1fd91d 100644
--- a/libs/cua-driver/rust/crates/cua-driver-core/src/tool_schema.rs
+++ b/libs/cua-driver/rust/crates/cua-driver-core/src/tool_schema.rs
@@ -338,17 +338,6 @@ mod tests {
assert_eq!(s, json!({ "type": "string", "enum": ["a", "b"] }));
}
- #[test]
- fn session_description_prefers_named_multi_call_runs() {
- let schema = session_schema();
- let description = schema["description"]
- .as_str()
- .expect("session schema should carry agent guidance");
- assert!(description.contains("prefer a short public session label"));
- assert!(description.contains("repeat it on every call that accepts it"));
- assert!(description.contains("implicit lifecycle session"));
- }
-
#[test]
fn action_session_description_without_repeat_guidance_is_flagged() {
let tool = json!({
diff --git a/libs/cua-driver/rust/crates/cua-driver-core/tests/contract_parity.rs b/libs/cua-driver/rust/crates/cua-driver-core/tests/contract_parity.rs
index 4e1c06ffca..64697390de 100644
--- a/libs/cua-driver/rust/crates/cua-driver-core/tests/contract_parity.rs
+++ b/libs/cua-driver/rust/crates/cua-driver-core/tests/contract_parity.rs
@@ -3,7 +3,7 @@
use cua_driver_contract::{manifest, SchemaMode, CAPABILITY_VERSION, TOOLS_LIST_SCHEMA_VERSION};
use cua_driver_core::perception_client::PerceptionClient;
-use cua_driver_core::tool::{default_capabilities_for, ToolRegistry};
+use cua_driver_core::tool::ToolRegistry;
#[test]
fn canonical_core_contracts_match_live_registry() {
@@ -51,38 +51,9 @@ fn canonical_core_contracts_match_live_registry() {
entry["annotations"]["openWorldHint"], contract.annotations.open_world,
"openWorldHint"
);
- assert_eq!(
- default_capabilities_for(&contract.name),
- contract.capabilities,
- "capabilities"
- );
assert_eq!(
entry["capabilities"],
serde_json::json!(contract.capabilities)
);
}
}
-
-#[test]
-fn every_generated_contract_uses_live_capability_tokens() {
- for contract in manifest().tools {
- assert_eq!(
- default_capabilities_for(&contract.name),
- contract.capabilities,
- "{} capabilities",
- contract.name
- );
- assert_eq!(
- contract
- .input_schema
- .pointer("/properties/delivery_mode")
- .is_some(),
- contract
- .capabilities
- .iter()
- .any(|capability| capability == "input.delivery_mode"),
- "{} typed contract delivery_mode schema/capability mismatch",
- contract.name
- );
- }
-}
diff --git a/libs/cua-driver/rust/crates/cua-driver-core/tests/snapshot_invariants.rs b/libs/cua-driver/rust/crates/cua-driver-core/tests/snapshot_invariants.rs
index b5243c3f5a..83f9d01229 100644
--- a/libs/cua-driver/rust/crates/cua-driver-core/tests/snapshot_invariants.rs
+++ b/libs/cua-driver/rust/crates/cua-driver-core/tests/snapshot_invariants.rs
@@ -2,7 +2,7 @@ use cua_driver_core::element_cache::{
register_runtime_cache, retire_runtime_scope, ElementCacheCore, SnapshotPayload,
};
use cua_driver_core::element_token::{
- format_token, ResolvedElement, LRU_CAP_PER_PID, STALE_TOKEN_ERROR,
+ token_for, ResolvedElement, LRU_CAP_PER_PID, STALE_TOKEN_ERROR,
};
use cua_driver_core::tool::with_runtime_scope;
use std::sync::atomic::{AtomicUsize, Ordering};
@@ -47,7 +47,7 @@ fn resolve<T: Clone + Send + Sync + 'static>(
.resolve_element_args(
42,
None,
- Some(&format_token(snapshot, index)),
+ Some(&token_for(snapshot, index)),
None,
None,
"click",
@@ -97,14 +97,21 @@ fn replacement_invalidates_every_old_member_and_admits_new_members() {
#[test]
fn resolving_does_not_change_publication_order_eviction() {
let cache = ElementCacheCore::new();
- let first = cache.publish(42, 1, payload(vec![1]));
- for window in 2..=LRU_CAP_PER_PID as u64 {
- cache.publish(42, window, payload(vec![1]));
- }
+ let mut ids: Vec<_> = (1..=LRU_CAP_PER_PID as u64)
+ .map(|window| cache.publish(42, window, payload(vec![1])))
+ .collect();
+ let first = ids[0];
assert_eq!(resolve(&cache, first, 0), Ok((1, 0, 1)));
let latest = cache.publish(42, LRU_CAP_PER_PID as u64 + 1, payload(vec![1]));
+ ids.push(latest);
assert_eq!(resolve(&cache, first, 0), Err(STALE_TOKEN_ERROR.to_owned()));
assert!(resolve(&cache, latest, 0).is_ok());
+ assert_eq!(
+ ids.iter()
+ .filter(|id| resolve(&cache, **id, 0).is_ok())
+ .count(),
+ LRU_CAP_PER_PID
+ );
}
#[test]
diff --git a/libs/cua-driver/rust/crates/platform-windows/src/uia/cache_uaf_repro.rs b/libs/cua-driver/rust/crates/platform-windows/src/uia/cache_uaf_repro.rs
index 86683594e1..e4107a4e98 100644
--- a/libs/cua-driver/rust/crates/platform-windows/src/uia/cache_uaf_repro.rs
+++ b/libs/cua-driver/rust/crates/platform-windows/src/uia/cache_uaf_repro.rs
@@ -36,7 +36,7 @@
//! BEFORE deterministically trips and AFTER deterministically survives.
use super::{CachedSnapshot, ElementCache, RetainedElement, SnapshotKind};
-use cua_driver_core::element_token::{format_token, ResolvedElement};
+use cua_driver_core::element_token::{token_for, ResolvedElement};
use std::ffi::c_void;
use std::sync::atomic::{AtomicIsize, AtomicUsize, Ordering};
use std::sync::mpsc;
@@ -146,7 +146,7 @@ fn acquire(cache: &ElementCache, snapshot: u32, idx: usize) -> Option<RetainedEl
.resolve_element_args(
PID as i32,
None,
- Some(&format_token(snapshot, idx)),
+ Some(&token_for(snapshot, idx)),
None,
Some(HWND),
"test",
@@ -323,7 +323,7 @@ fn exact_snapshot_retains_matching_identity_and_geometry() {
.resolve_element_args(
PID as i32,
None,
- Some(&format_token(second, 0)),
+ Some(&token_for(second, 0)),
None,
Some(HWND + 1),
"test",
@@ -447,7 +447,7 @@ fn recording_metadata_uses_snapshot_without_native_geometry() {
cua_driver_core::element_cache::register_runtime_cache(&cache);
let ptr = make_fake(hits, false);
let id = cache.publish(PID as i32, HWND, snapshot_with(vec![ptr]));
- let args = serde_json::json!({"element_token": format_token(id, 0)});
+ let args = serde_json::json!({"element_token": token_for(id, 0)});
assert_eq!(
crate::recording_hooks::element_window_local_xy(PID as i64, &args, false),
Some((HWND, None))