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

use crate::imp::{
    core::*,
    prelude::*,
    request::Request,
    utils::{Header, ResponseTiming}
};

#[derive(Debug)]
pub(crate) struct Response {
    channel: ChannelOwner,
    url: String,
    status: i32,
    status_text: String,
    request: Weak<Request>
}

impl Response {
    pub(crate) fn try_new(ctx: &Context, channel: ChannelOwner) -> Result<Self, Error> {
        let Initializer {
            url,
            status,
            status_text,
            request,
            timing
        } = serde_json::from_value(channel.initializer.clone())?;
        let request = get_object!(ctx, &request.guid, Request)?;
        upgrade(&request)?.set_response_timing(timing);
        Ok(Self {
            channel,
            url,
            status,
            status_text,
            request
        })
    }

    pub(crate) fn url(&self) -> &str { &self.url }
    pub(crate) fn status(&self) -> i32 { self.status }
    pub(crate) fn status_text(&self) -> &str { &self.status_text }

    pub(crate) fn ok(&self) -> bool { self.status == 0 || (200..300).contains(&self.status) }

    pub(crate) async fn finished(&self) -> ArcResult<Option<String>> {
        let v = send_message!(self, "finished", Map::new());
        let s = maybe_only_str(&v)?;
        Ok(s.map(ToOwned::to_owned))
    }

    pub(crate) async fn body(&self) -> ArcResult<Vec<u8>> {
        let v = send_message!(self, "body", Map::new());
        let s = only_str(&v)?;
        let bytes = base64::decode(s).map_err(Error::InvalidBase64)?;
        Ok(bytes)
    }

    pub(crate) async fn text(&self) -> ArcResult<String> {
        Ok(String::from_utf8(self.body().await?).map_err(Error::InvalidUtf8)?)
    }

    pub(crate) fn request(&self) -> Weak<Request> { self.request.clone() }

    pub(crate) async fn headers(&self) -> ArcResult<Vec<Header>> {
        let v = send_message!(self, "body", Map::new());
        let first = first(&v).ok_or(Error::InvalidParams)?;
        let mut headers: Vec<Header> =
            serde_json::from_value((*first).clone()).map_err(Error::Serde)?;
        for h in headers.iter_mut() {
            h.name.make_ascii_lowercase();
        }
        Ok(headers)
    }
}

impl RemoteObject for Response {
    fn channel(&self) -> &ChannelOwner { &self.channel }
    fn channel_mut(&mut self) -> &mut ChannelOwner { &mut self.channel }
}

#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
struct Initializer {
    url: String,
    status: i32,
    status_text: String,
    request: OnlyGuid,
    timing: ResponseTiming
}