playwright 0.0.20

Playwright port to Rust
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

use crate::imp::{core::*, prelude::*};
pub(crate) use tokio::sync::{broadcast, broadcast::error::TryRecvError};

pub trait EventEmitter {
    type Event: Clone;

    fn tx(&self) -> Option<broadcast::Sender<Self::Event>>;

    fn set_tx(&self, tx: broadcast::Sender<Self::Event>);

    fn new_tx(
        &self
    ) -> (
        broadcast::Sender<Self::Event>,
        broadcast::Receiver<Self::Event>
    ) {
        broadcast::channel(64)
    }

    fn subscribe_event(&self) -> broadcast::Receiver<Self::Event> {
        if let Some(tx) = self.tx() {
            tx.subscribe()
        } else {
            let (tx, rx) = self.new_tx();
            self.set_tx(tx);
            rx
        }
    }

    fn emit_event<E: Into<Self::Event>>(&self, e: E) { self.tx().map(|tx| tx.send(e.into()).ok()); }
}

pub(crate) trait IsEvent: Clone {
    type EventType: Clone + Copy + PartialEq;

    fn event_type(&self) -> Self::EventType;
}

#[cfg(any(feature = "rt-tokio", feature = "rt-actix"))]
pub(crate) async fn expect_event<E>(
    mut rx: broadcast::Receiver<E>,
    evt: E::EventType,
    timeout: u32
) -> Result<E, Error>
where
    E: IsEvent + Send + Sync + 'static,
    <E as event_emitter::IsEvent>::EventType: Send + Sync
{
    consume(&mut rx).await?;
    let sleep = sleep(Duration::from_millis(timeout as u64));
    let event = spawn(async move {
        loop {
            match rx.recv().await {
                Ok(x) if x.event_type() == evt => break Ok(x),
                Ok(_) => continue,
                Err(e) => break Err(e)
            }
        }
    });
    tokio::select! {
        _ = sleep => Err(Error::Timeout),
        x = event => x?.map_err(Error::Event)
    }
}

#[cfg(feature = "rt-async-std")]
pub(crate) async fn expect_event<E>(
    mut rx: broadcast::Receiver<E>,
    evt: E::EventType,
    timeout: u32
) -> Result<E, Error>
where
    E: IsEvent + Send + Sync + 'static,
    <E as event_emitter::IsEvent>::EventType: Send + Sync
{
    consume(&mut rx).await?;
    let sleep = sleep(Duration::from_millis(timeout as u64));
    let event = spawn(async move {
        loop {
            match rx.recv().await {
                Ok(x) if x.event_type() == evt => break Ok(x),
                Ok(_) => continue,
                Err(e) => break Err(e)
            }
        }
    });
    tokio::select! {
        _ = sleep => Err(Error::Timeout),
        x = event => x.map_err(Error::Event)
    }
}

async fn consume<E>(rx: &mut broadcast::Receiver<E>) -> Result<(), Error>
where
    E: IsEvent
{
    loop {
        match rx.try_recv() {
            Err(TryRecvError::Empty) | Err(TryRecvError::Closed) => break,
            _ => {}
        }
    }
    Ok(())
}

#[cfg(test)]
mod tests {
    crate::runtime_test!(select, {
        use crate::imp::prelude::*;
        let first = sleep(Duration::from_millis(200u64));
        let second = sleep(Duration::from_millis(400u64));
        tokio::select! {
            _ = first => {},
            _ = second => unreachable!()
        }
    });
}