ferridriver 0.3.0

Browser automation in Rust with a Playwright-compatible API. Four pluggable backends: CDP pipe, CDP WebSocket, Playwright WebKit, Firefox BiDi.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

use super::{StepCategory, StepDef, q};

pub fn register(steps: &mut Vec<Box<dyn StepDef>>) {
  // Text variants MUST come before selector variants.
  steps.push(Box::new(WaitTextTimeout));
  steps.push(Box::new(WaitText));
  steps.push(Box::new(WaitSelectorTimeout));
  steps.push(Box::new(WaitSelector));
  steps.push(Box::new(WaitMs));
  steps.push(Box::new(WaitNavigation));
}

step!(WaitSelectorTimeout {
    category: StepCategory::Wait,
    pattern: r"^I wait for (.+?) for (\d+)\s*ms$",
    description: "Wait for selector with timeout",
    example: "When I wait for \"#loading\" for 5000ms",
    execute(page, caps, _table, _vars) {
        let sel = q(&caps[1]);
        let ms: u64 = caps[2].parse().unwrap_or(30000);
        wait_for_selector(page, &sel, ms).await?;
        Ok(None)
    }
});

step!(WaitSelector {
    category: StepCategory::Wait,
    pattern: r"^I wait for selector (.+)$",
    description: "Wait for selector to appear",
    example: "When I wait for selector \"#content\"",
    execute(page, caps, _table, _vars) {
        let sel = q(&caps[1]);
        wait_for_selector(page, &sel, 30000).await?;
        Ok(None)
    }
});

step!(WaitTextTimeout {
    category: StepCategory::Wait,
    pattern: r"^I wait for text (.+?) for (\d+)\s*ms$",
    description: "Wait for text with timeout",
    example: "When I wait for text \"Success\" for 5000ms",
    execute(page, caps, _table, _vars) {
        let text = q(&caps[1]);
        let ms: u64 = caps[2].parse().unwrap_or(30000);
        wait_for_text(page, &text, ms).await?;
        Ok(None)
    }
});

step!(WaitText {
    category: StepCategory::Wait,
    pattern: r"^I wait for text (.+)$",
    description: "Wait for text to appear",
    example: "When I wait for text \"Ready\"",
    execute(page, caps, _table, _vars) {
        let text = q(&caps[1]);
        wait_for_text(page, &text, 30000).await?;
        Ok(None)
    }
});

step!(WaitMs {
    category: StepCategory::Wait,
    pattern: r"^I wait (\d+)\s*ms$",
    description: "Wait a fixed duration",
    example: "When I wait 500ms",
    execute(_page, caps, _table, _vars) {
        let ms: u64 = caps[1].parse().unwrap_or(0);
        tokio::time::sleep(std::time::Duration::from_millis(ms)).await;
        Ok(None)
    }
});

step!(WaitNavigation {
    category: StepCategory::Wait,
    pattern: r"^I wait for navigation$",
    description: "Wait for next navigation",
    example: "And I wait for navigation",
    execute(page, _caps, _table, _vars) {
        let _ = page.inner().wait_for_navigation().await;
        Ok(None)
    }
});

// ── Helpers ──

async fn wait_for_selector(
  page: &std::sync::Arc<crate::page::Page>,
  selector: &str,
  timeout_ms: u64,
) -> crate::error::Result<()> {
  let deadline = tokio::time::Instant::now() + std::time::Duration::from_millis(timeout_ms);
  loop {
    if tokio::time::Instant::now() >= deadline {
      return Err(crate::error::FerriError::timeout(
        format!("waiting for {selector:?}"),
        timeout_ms,
      ));
    }
    if super::find(page, selector).await.is_ok() {
      return Ok(());
    }
    tokio::time::sleep(std::time::Duration::from_millis(16)).await;
  }
}

async fn wait_for_text(
  page: &std::sync::Arc<crate::page::Page>,
  text: &str,
  timeout_ms: u64,
) -> crate::error::Result<()> {
  let deadline = tokio::time::Instant::now() + std::time::Duration::from_millis(timeout_ms);
  let loc = page.locator("body", None);
  loop {
    if tokio::time::Instant::now() >= deadline {
      return Err(crate::error::FerriError::timeout(
        format!("waiting for text {text:?}"),
        timeout_ms,
      ));
    }
    if let Ok(Some(content)) = loc.text_content().await {
      if content.contains(text) {
        return Ok(());
      }
    }
    tokio::time::sleep(std::time::Duration::from_millis(16)).await;
  }
}