ferridriver-expect 0.3.0

Value matchers (Jest-compatible) and asymmetric matchers for ferridriver's expect API. Shared core between the test runner and the QuickJS scripting layer.
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

//! Page web-first matchers — url + title only. Snapshot/screenshot/
//! aria matchers live in `ferridriver-test` because they need the
//! test-runner's snapshot directory + image pipeline.

use std::sync::Arc;

use ferridriver::Page;

use crate::AssertionFailure;
use crate::builder::Expect;
use crate::poll::{ExpectContext, MatchError, poll_until};
use crate::value::StringOrRegex;

fn page_ctx(method: &'static str, is_not: bool) -> ExpectContext {
  ExpectContext {
    method,
    subject: "page".into(),
    is_not,
  }
}

impl Expect<'_, Arc<Page>> {
  pub async fn to_have_title(&self, expected: impl Into<StringOrRegex>) -> Result<(), AssertionFailure> {
    let expected = expected.into();
    let page = self.subject;
    let is_not = self.is_not;
    poll_until(self.timeout, page_ctx("toHaveTitle", is_not), || {
      let expected = expected.clone();
      async move {
        let actual = page
          .title()
          .await
          .map_err(|e| MatchError::new("(title)", e.to_string()))?;
        let matches = expected.matches(&actual);
        if matches == is_not {
          Err(MatchError::new(
            format!("{}{}", if is_not { "not " } else { "" }, expected.description()),
            format!("\"{actual}\""),
          ))
        } else {
          Ok(())
        }
      }
    })
    .await
  }

  pub async fn to_contain_title(&self, expected: &str) -> Result<(), AssertionFailure> {
    let expected = expected.to_string();
    let page = self.subject;
    let is_not = self.is_not;
    poll_until(self.timeout, page_ctx("toContainTitle", is_not), || {
      let expected = expected.clone();
      async move {
        let actual = page
          .title()
          .await
          .map_err(|e| MatchError::new("(title)", e.to_string()))?;
        let contains = actual.contains(&expected);
        if contains == is_not {
          Err(MatchError::new(
            format!("{}containing \"{expected}\"", if is_not { "not " } else { "" }),
            format!("\"{actual}\""),
          ))
        } else {
          Ok(())
        }
      }
    })
    .await
  }

  pub async fn to_have_url(&self, expected: impl Into<StringOrRegex>) -> Result<(), AssertionFailure> {
    let expected = expected.into();
    let page = self.subject;
    let is_not = self.is_not;
    poll_until(self.timeout, page_ctx("toHaveURL", is_not), || {
      let expected = expected.clone();
      async move {
        let actual = page.url();
        let matches = expected.matches(&actual);
        if matches == is_not {
          Err(MatchError::new(
            format!("{}{}", if is_not { "not " } else { "" }, expected.description()),
            format!("\"{actual}\""),
          ))
        } else {
          Ok(())
        }
      }
    })
    .await
  }

  pub async fn to_contain_url(&self, expected: &str) -> Result<(), AssertionFailure> {
    let expected = expected.to_string();
    let page = self.subject;
    let is_not = self.is_not;
    poll_until(self.timeout, page_ctx("toContainURL", is_not), || {
      let expected = expected.clone();
      async move {
        let actual = page.url();
        let contains = actual.contains(&expected);
        if contains == is_not {
          Err(MatchError::new(
            format!("{}containing \"{expected}\"", if is_not { "not " } else { "" }),
            format!("\"{actual}\""),
          ))
        } else {
          Ok(())
        }
      }
    })
    .await
  }
}