Open source Loom alternative. Beautiful, shareable screen recordings.
Rust appcapcossloommacnextjsnextjs15open-sourceossreactrecordrustscreen-capturescreen-recorderscreenshotsolidjstauritauri-apptypescriptvite
use super::*;
use std::collections::{HashMap, VecDeque};
use std::sync::Mutex;
struct MockHost {
caps: Vec<Capability>,
actions_run: Mutex<Vec<String>>,
upload_results: Mutex<VecDeque<Result<(), String>>>,
upload_verification: Result<bool, String>,
}
impl MockHost {
fn new(caps: Vec<Capability>) -> Self {
Self {
caps,
actions_run: Mutex::new(Vec::new()),
upload_results: Mutex::new(VecDeque::new()),
upload_verification: Ok(false),
}
}
fn actions_run(&self) -> Vec<String> {
self.actions_run.lock().unwrap().clone()
}
fn record(&self, name: &str) {
self.actions_run.lock().unwrap().push(name.to_string());
}
}
impl AutomationHost for MockHost {
fn capabilities(&self) -> &[Capability] {
&self.caps
}
async fn copy_to_clipboard(
&self,
_ctx: &TriggerContext,
source: &ClipboardSource,
) -> Result<(), String> {
self.record(&format!("copy_to_clipboard:{source:?}"));
Ok(())
}
async fn save_to_location(
&self,
_ctx: &TriggerContext,
dir: &str,
tmpl: Option<&str>,
) -> Result<(), String> {
self.record(&format!("save_to_location:{dir}:{tmpl:?}"));
Ok(())
}
async fn export(
&self,
_ctx: &TriggerContext,
_profile: &ExportProfile,
_dest: &ExportDestination,
) -> Result<(), String> {
self.record("export");
Ok(())
}
async fn upload(
&self,
_ctx: &TriggerContext,
_org: Option<&str>,
_copy: bool,
_open: bool,
) -> Result<(), String> {
self.record("upload");
self.upload_results
.lock()
.unwrap()
.pop_front()
.unwrap_or(Ok(()))
}
async fn upload_is_verified(&self, _ctx: &TriggerContext) -> Result<bool, String> {
self.record("verify_upload");
self.upload_verification.clone()
}
async fn reveal_in_file_manager(&self, _ctx: &TriggerContext) -> Result<(), String> {
self.record("reveal");
Ok(())
}
async fn open_file(&self, _ctx: &TriggerContext) -> Result<(), String> {
self.record("open_file");
Ok(())
}
async fn run_command(
&self,
_ctx: &TriggerContext,
prog: &str,
_args: &[String],
_cwd: Option<&str>,
_env: &HashMap<String, String>,
_shell: bool,
) -> Result<(), String> {
self.record(&format!("run_command:{prog}"));
Ok(())
}
async fn webhook(
&self,
_ctx: &TriggerContext,
url: &str,
_method: &str,
_headers: &HashMap<String, String>,
_body: Option<&str>,
) -> Result<(), String> {
self.record(&format!("webhook:{url}"));
Ok(())
}
async fn recognize_text_to_clipboard(&self, _ctx: &TriggerContext) -> Result<(), String> {
self.record("ocr");
Ok(())
}
async fn notify(&self, _ctx: &TriggerContext, title: &str, body: &str) -> Result<(), String> {
self.record(&format!("notify:{title}:{body}"));
Ok(())
}
async fn open_editor(&self, _ctx: &TriggerContext) -> Result<(), String> {
self.record("open_editor");
Ok(())
}
async fn apply_preset(&self, _ctx: &TriggerContext, name: &str) -> Result<(), String> {
self.record(&format!("apply_preset:{name}"));
Ok(())
}
async fn delete_local_files(&self, _ctx: &TriggerContext) -> Result<(), String> {
self.record("delete_local_files");
Ok(())
}
}
fn screenshot_copy_rule() -> AutomationRule {
AutomationRule {
id: "rule-1".to_string(),
name: "Auto-copy screenshot".to_string(),
enabled: true,
trigger: Trigger::ScreenshotTaken,
match_mode: MatchMode::All,
conditions: vec![],
actions: vec![
Action::CopyToClipboard {
source: ClipboardSource::Raw,
},
Action::Notify {
title_template: "Screenshot".to_string(),
body_template: "Copied to clipboard".to_string(),
},
],
}
}
fn studio_export_rule() -> AutomationRule {
AutomationRule {
id: "rule-2".to_string(),
name: "Auto-export studio".to_string(),
enabled: true,
trigger: Trigger::StudioRecordingFinished,
match_mode: MatchMode::All,
conditions: vec![Condition::DurationAtLeast { secs: 5.0 }],
actions: vec![Action::Export {
profile: ExportProfile {
format: ExportFormat::Mp4,
fps: 60,
resolution_base: cap_project::XY { x: 1920, y: 1080 },
compression: Some(AutomationExportCompression::Web),
preset_name: None,
},
destination: ExportDestination::ProjectFolder,
}],
}
}
#[test]
fn evaluate_matches_trigger_and_returns_actions() {
let store = AutomationsStore {
version: 1,
rules: vec![screenshot_copy_rule(), studio_export_rule()],
};
let matched = evaluate(&store, &Trigger::ScreenshotTaken, &TriggerContext::new());
assert_eq!(matched.len(), 1);
assert_eq!(matched[0].0, "rule-1");
assert_eq!(matched[0].1.len(), 2);
}
#[test]
fn evaluate_skips_disabled_rules() {
let mut rule = screenshot_copy_rule();
rule.enabled = false;
let store = AutomationsStore {
version: 1,
rules: vec![rule],
};
let matched = evaluate(&store, &Trigger::ScreenshotTaken, &TriggerContext::new());
assert!(matched.is_empty());
}
#[test]
fn evaluate_skips_wrong_trigger() {
let store = AutomationsStore {
version: 1,
rules: vec![screenshot_copy_rule()],
};
let matched = evaluate(
&store,
&Trigger::StudioRecordingFinished,
&TriggerContext::new(),
);
assert!(matched.is_empty());
}
#[test]
fn condition_duration_at_least() {
let store = AutomationsStore {
version: 1,
rules: vec![studio_export_rule()],
};
let short_ctx = TriggerContext::new().with_duration(3.0);
let long_ctx = TriggerContext::new().with_duration(10.0);
let matched_short = evaluate(&store, &Trigger::StudioRecordingFinished, &short_ctx);
assert!(matched_short.is_empty());
let matched_long = evaluate(&store, &Trigger::StudioRecordingFinished, &long_ctx);
assert_eq!(matched_long.len(), 1);
}
#[test]
fn condition_capture_target() {
let rule = AutomationRule {
id: "rule-target".to_string(),
name: "Window only".to_string(),
enabled: true,
trigger: Trigger::ScreenshotTaken,
match_mode: MatchMode::All,
conditions: vec![Condition::CaptureTargetIs {
target: CaptureTargetKind::Window,
}],
actions: vec![Action::CopyToClipboard {
source: ClipboardSource::Raw,
}],
};
let store = AutomationsStore {
version: 1,
rules: vec![rule],
};
let display_ctx = TriggerContext::new().with_capture_target(CaptureTargetKind::Display);
let window_ctx = TriggerContext::new().with_capture_target(CaptureTargetKind::Window);
assert!(evaluate(&store, &Trigger::ScreenshotTaken, &display_ctx).is_empty());
assert_eq!(
evaluate(&store, &Trigger::ScreenshotTaken, &window_ctx).len(),
1
);
}
#[test]
fn condition_window_title_contains() {
let rule = AutomationRule {
id: "rule-title".to_string(),
name: "Slack screenshots".to_string(),
enabled: true,
trigger: Trigger::ScreenshotTaken,
match_mode: MatchMode::All,
conditions: vec![Condition::WindowTitleContains {
pattern: "slack".to_string(),
}],
actions: vec![Action::CopyToClipboard {
source: ClipboardSource::Raw,
}],
};
let store = AutomationsStore {
version: 1,
rules: vec![rule],
};
let no_title = TriggerContext::new();
let slack_ctx = TriggerContext::new().with_window_title("Slack - #general".to_string());
let vscode_ctx = TriggerContext::new().with_window_title("VS Code".to_string());
assert!(evaluate(&store, &Trigger::ScreenshotTaken, &no_title).is_empty());
assert_eq!(
evaluate(&store, &Trigger::ScreenshotTaken, &slack_ctx).len(),
1
);
assert!(evaluate(&store, &Trigger::ScreenshotTaken, &vscode_ctx).is_empty());
}
#[test]
fn match_mode_any_matches_on_first_true() {
let rule = AutomationRule {
id: "rule-any".to_string(),
name: "Display or window".to_string(),
enabled: true,
trigger: Trigger::ScreenshotTaken,
match_mode: MatchMode::Any,
conditions: vec![
Condition::CaptureTargetIs {
target: CaptureTargetKind::Display,
},
Condition::CaptureTargetIs {
target: CaptureTargetKind::Window,
},
],
actions: vec![Action::CopyToClipboard {
source: ClipboardSource::Raw,
}],
};
let store = AutomationsStore {
version: 1,
rules: vec![rule],
};
let area_ctx = TriggerContext::new().with_capture_target(CaptureTargetKind::Area);
let display_ctx = TriggerContext::new().with_capture_target(CaptureTargetKind::Display);
assert!(evaluate(&store, &Trigger::ScreenshotTaken, &area_ctx).is_empty());
assert_eq!(
evaluate(&store, &Trigger::ScreenshotTaken, &display_ctx).len(),
1
);
}
#[test]
fn has_skip_editor_detects_skip_action() {
let rule = AutomationRule {
id: "headless".to_string(),
name: "Headless screenshot".to_string(),
enabled: true,
trigger: Trigger::ScreenshotTaken,
match_mode: MatchMode::All,
conditions: vec![],
actions: vec![
Action::CopyToClipboard {
source: ClipboardSource::Raw,
},
Action::SkipEditor,
],
};
let store = AutomationsStore {
version: 1,
rules: vec![rule],
};
assert!(has_skip_editor(
&store,
&Trigger::ScreenshotTaken,
&TriggerContext::new()
));
assert!(!has_skip_editor(
&store,
&Trigger::StudioRecordingFinished,
&TriggerContext::new()
));
}
#[tokio::test]
async fn run_executes_actions_in_order() {
let host = MockHost::new(vec![Capability::CopyToClipboard, Capability::Notify]);
let store = AutomationsStore {
version: 1,
rules: vec![screenshot_copy_rule()],
};
let results = run(
&host,
&store,
&Trigger::ScreenshotTaken,
&TriggerContext::new(),
)
.await;
assert_eq!(results.len(), 1);
assert_eq!(results[0].action_results.len(), 2);
assert!(results[0].action_results.iter().all(|r| r.success));
let actions = host.actions_run();
assert_eq!(actions[0], "copy_to_clipboard:Raw");
assert_eq!(actions[1], "notify:Screenshot:Copied to clipboard");
}
#[tokio::test]
async fn run_skips_unsupported_capabilities() {
let host = MockHost::new(vec![Capability::CopyToClipboard]);
let store = AutomationsStore {
version: 1,
rules: vec![screenshot_copy_rule()],
};
let results = run(
&host,
&store,
&Trigger::ScreenshotTaken,
&TriggerContext::new(),
)
.await;
assert_eq!(results[0].action_results.len(), 2);
assert!(results[0].action_results[0].success);
assert!(!results[0].action_results[1].success);
let actions = host.actions_run();
assert_eq!(actions.len(), 1);
assert_eq!(actions[0], "copy_to_clipboard:Raw");
}
#[tokio::test]
async fn skip_editor_action_is_noop_and_never_opens_editor() {
let rule = AutomationRule {
id: "headless".to_string(),
name: "Headless screenshot".to_string(),
enabled: true,
trigger: Trigger::ScreenshotTaken,
match_mode: MatchMode::All,
conditions: vec![],
actions: vec![
Action::CopyToClipboard {
source: ClipboardSource::Raw,
},
Action::SkipEditor,
],
};
let store = AutomationsStore {
version: 1,
rules: vec![rule],
};
let host = MockHost::new(vec![Capability::CopyToClipboard, Capability::OpenEditor]);
let results = run(
&host,
&store,
&Trigger::ScreenshotTaken,
&TriggerContext::new(),
)
.await;
assert!(results[0].action_results.iter().all(|r| r.success));
let actions = host.actions_run();
assert_eq!(actions, vec!["copy_to_clipboard:Raw".to_string()]);
assert!(!actions.iter().any(|a| a == "open_editor"));
}
#[test]
fn serialize_roundtrip() {
let store = AutomationsStore {
version: 1,
rules: vec![screenshot_copy_rule(), studio_export_rule()],
};
let json = serde_json::to_string_pretty(&store).unwrap();
let parsed: AutomationsStore = serde_json::from_str(&json).unwrap();
assert_eq!(parsed.rules.len(), 2);
assert_eq!(parsed.version, 1);
}
#[test]
fn serialize_all_condition_and_action_shapes_roundtrip() {
use std::collections::HashMap;
let rule = AutomationRule {
id: "everything".to_string(),
name: "All shapes".to_string(),
enabled: true,
trigger: Trigger::StudioRecordingFinished,
match_mode: MatchMode::Any,
conditions: vec![
Condition::CaptureTargetIs {
target: CaptureTargetKind::Window,
},
Condition::RecordingModeIs {
mode: AutomationRecordingMode::Studio,
},
Condition::DurationAtLeast { secs: 5.0 },
Condition::DurationAtMost { secs: 600.0 },
Condition::WindowTitleContains {
pattern: "slack".to_string(),
},
Condition::OrganizationIs {
id: "org_1".to_string(),
},
],
actions: vec![
Action::CopyToClipboard {
source: ClipboardSource::Rendered,
},
Action::SaveToLocation {
dir: "/tmp/cap".to_string(),
filename_template: Some("{date}-{window}".to_string()),
},
Action::Export {
profile: ExportProfile {
format: ExportFormat::Mp4,
fps: 60,
resolution_base: cap_project::XY { x: 1920, y: 1080 },
compression: Some(AutomationExportCompression::Web),
preset_name: Some("My Preset".to_string()),
},
destination: ExportDestination::CustomPath {
dir: "/tmp/out".to_string(),
},
},
Action::Upload {
organization_id: Some("org_1".to_string()),
copy_link: true,
open_in_browser: false,
},
Action::RevealInFileManager,
Action::OpenFile,
Action::RunCommand {
program: "echo".to_string(),
args: vec!["hi".to_string()],
cwd: None,
env: HashMap::new(),
use_shell: false,
},
Action::Webhook {
url: "https://example.com/hook".to_string(),
method: "POST".to_string(),
headers: HashMap::new(),
body_template: Some("{share_link}".to_string()),
},
Action::RecognizeTextToClipboard,
Action::Notify {
title_template: "Done".to_string(),
body_template: "Recording finished".to_string(),
},
Action::OpenEditor,
Action::SkipEditor,
Action::ApplyPreset {
name: "My Preset".to_string(),
},
Action::DeleteLocalFiles,
],
};
let store = AutomationsStore {
version: 1,
rules: vec![rule],
};
let json = serde_json::to_value(&store).unwrap();
let conditions = &json["rules"][0]["conditions"];
assert_eq!(conditions[0]["type"], "captureTargetIs");
assert_eq!(conditions[0]["target"], "window");
assert_eq!(conditions[1]["type"], "recordingModeIs");
assert_eq!(conditions[1]["mode"], "studio");
let actions = &json["rules"][0]["actions"];
assert_eq!(actions[0]["type"], "copyToClipboard");
assert_eq!(actions[0]["source"], "rendered");
assert_eq!(actions[4]["type"], "revealInFileManager");
// Struct-variant fields must serialize camelCase to match the desktop+CLI frontends; serde's
// enum-level rename_all does not cover variant fields, so each multi-word variant carries its own.
assert_eq!(actions[1]["type"], "saveToLocation");
assert!(actions[1].get("filenameTemplate").is_some());
assert!(actions[1].get("filename_template").is_none());
assert!(actions[3].get("organizationId").is_some());
assert!(actions[3].get("copyLink").is_some());
assert!(actions[3].get("openInBrowser").is_some());
assert!(actions[6].get("useShell").is_some());
assert!(actions[7].get("bodyTemplate").is_some());
assert!(actions[9].get("titleTemplate").is_some());
let parsed: AutomationsStore = serde_json::from_value(json).unwrap();
assert_eq!(parsed.rules.len(), 1);
assert_eq!(parsed.rules[0].conditions.len(), 6);
assert_eq!(parsed.rules[0].actions.len(), 14);
}
#[test]
fn load_store_from_json_extracts_automations_key() {
let store = AutomationsStore {
version: 1,
rules: vec![screenshot_copy_rule()],
};
let wrapper = serde_json::json!({
"general_settings": {},
"automations": store,
});
let loaded = load_store_from_json(&wrapper).unwrap();
assert_eq!(loaded.rules.len(), 1);
assert_eq!(loaded.rules[0].id, "rule-1");
}
#[test]
fn load_store_from_json_returns_none_on_missing_key() {
let wrapper = serde_json::json!({
"general_settings": {},
});
assert!(load_store_from_json(&wrapper).is_none());
}
fn desktop_capabilities() -> Vec<Capability> {
vec![
Capability::CopyToClipboard,
Capability::SaveToLocation,
Capability::Export,
Capability::Upload,
Capability::RevealInFileManager,
Capability::OpenFile,
Capability::RunCommand,
Capability::Webhook,
Capability::RecognizeText,
Capability::Notify,
Capability::OpenEditor,
Capability::ApplyPreset,
Capability::DeleteLocalFiles,
]
}
fn cli_capabilities() -> Vec<Capability> {
vec![
Capability::SaveToLocation,
Capability::Export,
Capability::Upload,
Capability::RevealInFileManager,
Capability::OpenFile,
Capability::RunCommand,
Capability::Webhook,
Capability::ApplyPreset,
Capability::DeleteLocalFiles,
]
}
fn upload_action() -> Action {
Action::Upload {
organization_id: None,
copy_link: false,
open_in_browser: false,
}
}
fn upload_cleanup_store(trigger: Trigger, actions: Vec<Action>) -> AutomationsStore {
AutomationsStore {
version: 1,
rules: vec![AutomationRule {
id: "upload-cleanup".to_string(),
name: "Upload cleanup".to_string(),
enabled: true,
trigger,
match_mode: MatchMode::All,
conditions: vec![],
actions,
}],
}
}
#[tokio::test]
async fn failed_or_unverified_upload_retains_files_and_continues_notifications() {
for upload_result in [Ok(()), Err("storage offline".to_string())] {
let submitted = upload_result.is_ok();
let host = MockHost::new(desktop_capabilities());
host.upload_results.lock().unwrap().push_back(upload_result);
let store = upload_cleanup_store(
Trigger::StudioRecordingFinished,
vec![
upload_action(),
Action::DeleteLocalFiles,
Action::Notify {
title_template: "Recording".to_string(),
body_template: "Saved".to_string(),
},
],
);
let results = run(
&host,
&store,
&Trigger::StudioRecordingFinished,
&TriggerContext::new(),
)
.await;
let actions = &results[0].action_results;
assert_eq!(actions[0].success, submitted);
assert!(!actions[1].success);
assert!(actions[1].error.as_deref().unwrap().contains("retained"));
assert!(actions[2].success);
let expected = if submitted {
vec!["upload", "verify_upload", "notify:Recording:Saved"]
} else {
vec!["upload", "notify:Recording:Saved"]
};
assert_eq!(host.actions_run(), expected);
if submitted {
assert_eq!(
actions[1].error.as_deref(),
Some(
"Upload submitted, but remote verification is unavailable; local recording retained"
)
);
}
}
}
#[tokio::test]
async fn deletion_waits_for_every_upload_and_does_not_forget_a_failure() {
for first_upload in [Ok(()), Err("first upload failed".to_string())] {
let first_succeeded = first_upload.is_ok();
let mut host = MockHost::new(desktop_capabilities());
host.upload_verification = Ok(true);
host.upload_results.lock().unwrap().push_back(first_upload);
let store = upload_cleanup_store(
Trigger::InstantRecordingFinished,
vec![
upload_action(),
Action::DeleteLocalFiles,
upload_action(),
Action::DeleteLocalFiles,
],
);
let results = run(
&host,
&store,
&Trigger::InstantRecordingFinished,
&TriggerContext::new(),
)
.await;
assert!(!results[0].action_results[1].success);
assert_eq!(results[0].action_results[3].success, first_succeeded);
assert_eq!(
host.actions_run(),
if first_succeeded {
vec!["upload", "upload", "verify_upload", "delete_local_files"]
} else {
vec!["upload", "upload"]
}
);
}
}
#[tokio::test]
async fn upload_completed_trigger_requires_proof_even_with_a_share_link() {
for verification in [
Ok(false),
Err("receipt refers to changed media".to_string()),
Ok(true),
] {
let verified = verification == Ok(true);
let mut host = MockHost::new(desktop_capabilities());
host.upload_verification = verification;
let store = upload_cleanup_store(Trigger::UploadCompleted, vec![Action::DeleteLocalFiles]);
let ctx = TriggerContext::new()
.with_share_link("https://cap.test/s/owned".to_string())
.with_share_id("owned".to_string());
let results = run(&host, &store, &Trigger::UploadCompleted, &ctx).await;
assert_eq!(results[0].action_results[0].success, verified);
assert_eq!(
host.actions_run(),
if verified {
vec!["verify_upload", "delete_local_files"]
} else {
vec!["verify_upload"]
}
);
}
}
#[tokio::test]
async fn standalone_deletion_is_preserved_but_unsupported_upload_cannot_authorize_it() {
let host = MockHost::new(vec![Capability::DeleteLocalFiles]);
let store = upload_cleanup_store(
Trigger::StudioRecordingFinished,
vec![Action::DeleteLocalFiles],
);
let result = run(
&host,
&store,
&Trigger::StudioRecordingFinished,
&TriggerContext::new(),
)
.await;
assert!(result[0].action_results[0].success);
assert_eq!(host.actions_run(), vec!["delete_local_files"]);
let host = MockHost::new(vec![Capability::DeleteLocalFiles]);
let store = upload_cleanup_store(
Trigger::StudioRecordingFinished,
vec![upload_action(), Action::DeleteLocalFiles],
);
let result = run(
&host,
&store,
&Trigger::StudioRecordingFinished,
&TriggerContext::new(),
)
.await;
assert!(!result[0].action_results[0].success);
assert!(!result[0].action_results[1].success);
assert!(host.actions_run().is_empty());
}
#[tokio::test]
async fn deletion_in_another_rule_waits_for_all_uploads() {
for delete_first in [false, true] {
for upload_result in [Err("storage offline".to_string()), Ok(())] {
let upload_succeeded = upload_result.is_ok();
let mut host = MockHost::new(desktop_capabilities());
host.upload_verification = Ok(true);
host.upload_results.lock().unwrap().push_back(upload_result);
let mut store =
upload_cleanup_store(Trigger::StudioRecordingFinished, vec![upload_action()]);
store.rules[0].id = "upload".to_string();
let mut delete_rule = store.rules[0].clone();
delete_rule.id = "delete".to_string();
delete_rule.actions = vec![Action::DeleteLocalFiles];
if delete_first {
store.rules.insert(0, delete_rule);
} else {
store.rules.push(delete_rule);
}
let results = run(
&host,
&store,
&Trigger::StudioRecordingFinished,
&TriggerContext::new(),
)
.await;
let deletion = results
.iter()
.find(|result| result.rule_id == "delete")
.unwrap();
let should_delete = !delete_first && upload_succeeded;
assert_eq!(deletion.action_results[0].success, should_delete);
if should_delete {
assert_eq!(
host.actions_run(),
vec!["upload", "verify_upload", "delete_local_files"]
);
} else {
assert!(
deletion.action_results[0]
.error
.as_deref()
.unwrap()
.contains("retained")
);
assert_eq!(host.actions_run(), vec!["upload"]);
}
}
}
}
// Both surfaces share the same engine + store, so they must match the same rules and run the same
// actions in the same order — the only difference being that surface-specific actions (clipboard on the
// CLI) are skipped, never silently reordered or dropped.
#[tokio::test]
async fn desktop_and_cli_parity_on_screenshot_rule() {
let rule = AutomationRule {
id: "parity".to_string(),
name: "Auto-handle screenshot".to_string(),
enabled: true,
trigger: Trigger::ScreenshotTaken,
match_mode: MatchMode::All,
conditions: vec![Condition::CaptureTargetIs {
target: CaptureTargetKind::Window,
}],
actions: vec![
Action::SaveToLocation {
dir: "/tmp/shots".to_string(),
filename_template: None,
},
Action::CopyToClipboard {
source: ClipboardSource::Raw,
},
Action::RunCommand {
program: "true".to_string(),
args: vec![],
cwd: None,
env: HashMap::new(),
use_shell: false,
},
],
};
let store = AutomationsStore {
version: 1,
rules: vec![rule],
};
let ctx = TriggerContext::new().with_capture_target(CaptureTargetKind::Window);
// Both surfaces evaluate to the same matched rule + ordered actions (engine is host-independent).
let matched = evaluate(&store, &Trigger::ScreenshotTaken, &ctx);
assert_eq!(matched.len(), 1);
assert_eq!(matched[0].1.len(), 3);
let desktop = MockHost::new(desktop_capabilities());
let desktop_results = run(&desktop, &store, &Trigger::ScreenshotTaken, &ctx).await;
assert!(desktop_results[0].action_results.iter().all(|r| r.success));
assert_eq!(
desktop.actions_run(),
vec![
"save_to_location:/tmp/shots:None".to_string(),
"copy_to_clipboard:Raw".to_string(),
"run_command:true".to_string(),
]
);
let cli = MockHost::new(cli_capabilities());
let cli_results = run(&cli, &store, &Trigger::ScreenshotTaken, &ctx).await;
// Same three action slots reported, in order; the clipboard one is marked unsupported, not dropped.
assert_eq!(cli_results[0].action_results.len(), 3);
assert!(cli_results[0].action_results[0].success);
assert!(!cli_results[0].action_results[1].success);
assert!(cli_results[0].action_results[2].success);
assert_eq!(
cli.actions_run(),
vec![
"save_to_location:/tmp/shots:None".to_string(),
"run_command:true".to_string(),
]
);
}
#[tokio::test]
async fn skip_editor_runs_without_open_editor_capability() {
let rule = AutomationRule {
id: "cli-skip".to_string(),
name: "Headless".to_string(),
enabled: true,
trigger: Trigger::ScreenshotTaken,
match_mode: MatchMode::All,
conditions: vec![],
actions: vec![Action::SkipEditor],
};
let store = AutomationsStore {
version: 1,
rules: vec![rule],
};
// Host without `OpenEditor` capability, mirroring the CLI. `SkipEditor` must still succeed as a
// no-op rather than being reported unsupported.
let host = MockHost::new(vec![Capability::SaveToLocation]);
let results = run(
&host,
&store,
&Trigger::ScreenshotTaken,
&TriggerContext::new(),
)
.await;
assert_eq!(results[0].action_results.len(), 1);
assert!(results[0].action_results[0].success);
assert!(results[0].action_results[0].error.is_none());
assert!(host.actions_run().is_empty());
}
#[test]
fn shell_command_line_quotes_args_with_spaces() {
let line = shell_command_line("echo", &["hello world".to_string(), "plain".to_string()]);
#[cfg(not(target_os = "windows"))]
assert_eq!(line, "echo 'hello world' plain");
#[cfg(target_os = "windows")]
assert_eq!(line, "echo \"hello world\" plain");
}
#[test]
fn shell_command_line_escapes_embedded_quotes() {
#[cfg(not(target_os = "windows"))]
{
let line = shell_command_line("printf", &["it's".to_string()]);
assert_eq!(line, "printf 'it'\\''s'");
assert_eq!(shell_command_line("x", &[String::new()]), "x ''");
}
#[cfg(target_os = "windows")]
{
let line = shell_command_line("echo", &["a\"b".to_string()]);
assert_eq!(line, "echo \"a\"\"b\"");
}
}
#[test]
fn sanitize_filename_component_neutralizes_traversal_and_reserved_chars() {
assert_eq!(
sanitize_filename_component("../../etc/passwd"),
".._.._etc_passwd"
);
assert_eq!(sanitize_filename_component("C:\\Users\\me"), "C__Users_me");
assert_eq!(
sanitize_filename_component("Slack | #general"),
"Slack _ #general"
);
assert_eq!(sanitize_filename_component("plain title"), "plain title");
assert_eq!(sanitize_filename_component("{image_path}"), "_image_path_");
assert_eq!(sanitize_filename_component("report. "), "report");
assert_eq!(
sanitize_filename_component("trailing dots..."),
"trailing dots"
);
assert_eq!(
sanitize_filename_component(&"a".repeat(200))
.chars()
.count(),
128
);
assert_eq!(sanitize_filename_component("..."), "_");
assert_eq!(sanitize_filename_component(" "), "_");
assert_eq!(sanitize_filename_component(""), "_");
}
#[test]
fn multiple_rules_same_trigger() {
let rule1 = AutomationRule {
id: "a".to_string(),
name: "Rule A".to_string(),
enabled: true,
trigger: Trigger::ScreenshotTaken,
match_mode: MatchMode::All,
conditions: vec![],
actions: vec![Action::CopyToClipboard {
source: ClipboardSource::Raw,
}],
};
let rule2 = AutomationRule {
id: "b".to_string(),
name: "Rule B".to_string(),
enabled: true,
trigger: Trigger::ScreenshotTaken,
match_mode: MatchMode::All,
conditions: vec![],
actions: vec![Action::RevealInFileManager],
};
let store = AutomationsStore {
version: 1,
rules: vec![rule1, rule2],
};
let matched = evaluate(&store, &Trigger::ScreenshotTaken, &TriggerContext::new());
assert_eq!(matched.len(), 2);
}