rpage 1.0.0

A Rust browser automation library inspired by DrissionPage
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
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155

//! Wait system - smart waiting for elements, URLs, network idle, and page load
//!
//! The wait system is a core differentiator of rpage: operations automatically
//! wait for their preconditions (element visible, clickable, etc.) before
//! proceeding, reducing flakiness without explicit sleeps.

use std::time::{Duration, Instant};

use tracing::{debug, trace};

use crate::error::{Error, Result};

/// Default timeout for wait operations
pub const DEFAULT_TIMEOUT: Duration = Duration::from_secs(10);

/// Default polling interval
pub const DEFAULT_POLL_INTERVAL: Duration = Duration::from_millis(200);

/// Wait condition builder
#[derive(Debug, Clone)]
pub struct WaitOptions {
    /// Maximum time to wait
    pub timeout: Duration,
    /// Interval between condition checks
    pub poll_interval: Duration,
}

impl Default for WaitOptions {
    fn default() -> Self {
        Self {
            timeout: DEFAULT_TIMEOUT,
            poll_interval: DEFAULT_POLL_INTERVAL,
        }
    }
}

impl WaitOptions {
    /// Create with custom timeout
    pub fn timeout(mut self, timeout: Duration) -> Self {
        self.timeout = timeout;
        self
    }

    /// Create with custom poll interval
    pub fn poll_interval(mut self, interval: Duration) -> Self {
        self.poll_interval = interval;
        self
    }
}

/// Generic async retry loop: poll `check_fn` until it returns `Ok(true)`,
/// `Err` is treated as "not yet" until timeout, then propagated.
pub async fn retry_until<F, Fut>(check_fn: F, opts: &WaitOptions, label: &str) -> Result<()>
where
    F: Fn() -> Fut,
    Fut: std::future::Future<Output = Result<bool>>,
{
    let start = Instant::now();
    debug!("Waiting for: {label} (timeout: {:?})", opts.timeout);

    loop {
        match check_fn().await {
            Ok(true) => {
                debug!("Condition met: {label} ({:?} elapsed)", start.elapsed());
                return Ok(());
            }
            Ok(false) | Err(_) => {
                if start.elapsed() >= opts.timeout {
                    return Err(Error::Timeout(format!(
                        "Timed out waiting for: {label} ({:?})",
                        opts.timeout
                    )));
                }
                trace!("Not yet: {label}, polling in {:?}", opts.poll_interval);
                tokio::time::sleep(opts.poll_interval).await;
            }
        }
    }
}

/// Sleep for a specified duration (convenience wrapper)
pub async fn sleep(duration: Duration) {
    tokio::time::sleep(duration).await;
}

/// Wait for a sync predicate to become true
pub async fn wait_sync<F>(predicate: F, opts: &WaitOptions, label: &str) -> Result<()>
where
    F: Fn() -> bool,
{
    let start = Instant::now();
    loop {
        if predicate() {
            return Ok(());
        }
        if start.elapsed() >= opts.timeout {
            return Err(Error::Timeout(format!("Timed out: {label}")));
        }
        tokio::time::sleep(opts.poll_interval).await;
    }
}

/// Wait for an element to appear, retrying up to `opts.timeout`
pub async fn wait_element<F, Fut>(
    find_fn: F,
    locator: &str,
    opts: &WaitOptions,
) -> Result<crate::element::Element>
where
    F: Fn(&str) -> Fut,
    Fut: std::future::Future<Output = Result<crate::element::Element>>,
{
    let start = Instant::now();
    loop {
        match find_fn(locator).await {
            Ok(el) => return Ok(el),
            Err(_) => {
                if start.elapsed() >= opts.timeout {
                    return Err(Error::Timeout(format!(
                        "Timed out waiting for element: {locator}"
                    )));
                }
                tokio::time::sleep(opts.poll_interval).await;
            }
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_wait_options_default() {
        let opts = WaitOptions::default();
        assert_eq!(opts.timeout, DEFAULT_TIMEOUT);
        assert_eq!(opts.poll_interval, DEFAULT_POLL_INTERVAL);
    }

    #[test]
    fn test_wait_options_builder() {
        let opts = WaitOptions::default()
            .timeout(Duration::from_secs(30))
            .poll_interval(Duration::from_millis(500));
        assert_eq!(opts.timeout, Duration::from_secs(30));
        assert_eq!(opts.poll_interval, Duration::from_millis(500));
    }

    #[tokio::test]
    async fn test_wait_sync_immediate() {
        let opts = WaitOptions::default();
        let result = wait_sync(|| true, &opts, "immediate").await;
        assert!(result.is_ok());
    }
}