gleewright/expect

Assertions about the page. Assertions on locators and pages retry until they pass or their timeout (5 seconds by default) runs out, so there’s no need to wait for the page to settle first.

use _ <- step.try(
  page.get_by_role(page, role.Heading)
  |> expect.locator
  |> expect.to_have_text("Welcome back"),
)
use _ <- step.try(expect.page(page) |> expect.to_have_url("/dashboard"))
page.get_by_text(page, "Loading")
|> expect.locator
|> expect.not
|> expect.to_be_visible

Types

Expectation

opaque </>

Something to make assertions about: a Locator or a Page.

pub opaque type Expectation(subject)

Values

equal

</>

pub fn equal(actual: a, expected: a) -> step.Step(Nil)

Two values are equal. Useful for checking values read with the query functions in gleewright/locator, which don’t retry.

locator

</>

pub fn locator(
  locator: locator.Locator,
) -> Expectation(locator.Locator)

Make assertions about the elements matched by a locator.

not

</>

pub fn not(
  expectation: Expectation(subject),
) -> Expectation(subject)

Invert the assertion that follows.

page

</>

pub fn page(page: page.Page) -> Expectation(page.Page)

Make assertions about a page.

to_be_attached

</>

pub fn to_be_attached(
  expectation: Expectation(locator.Locator),
) -> step.Step(Nil)

The element is in the page (though possibly not visible).

to_be_checked

</>

pub fn to_be_checked(
  expectation: Expectation(locator.Locator),
) -> step.Step(Nil)

The checkbox or radio button is checked.

to_be_disabled

</>

pub fn to_be_disabled(
  expectation: Expectation(locator.Locator),
) -> step.Step(Nil)

The element is disabled.

to_be_editable

</>

pub fn to_be_editable(
  expectation: Expectation(locator.Locator),
) -> step.Step(Nil)

The element is editable.

to_be_empty

</>

pub fn to_be_empty(
  expectation: Expectation(locator.Locator),
) -> step.Step(Nil)

The element has no text, or the input has no value.

to_be_enabled

</>

pub fn to_be_enabled(
  expectation: Expectation(locator.Locator),
) -> step.Step(Nil)

The element is enabled.

to_be_focused

</>

pub fn to_be_focused(
  expectation: Expectation(locator.Locator),
) -> step.Step(Nil)

The element has focus.

to_be_hidden

</>

pub fn to_be_hidden(
  expectation: Expectation(locator.Locator),
) -> step.Step(Nil)

The element is hidden or not in the page.

to_be_visible

</>

pub fn to_be_visible(
  expectation: Expectation(locator.Locator),
) -> step.Step(Nil)

The element is visible.

to_contain_text

</>

pub fn to_contain_text(
  expectation: Expectation(locator.Locator),
  text: String,
) -> step.Step(Nil)

The element’s text contains the given text.

to_have_accessible_name

</>

pub fn to_have_accessible_name(
  expectation: Expectation(locator.Locator),
  name: String,
) -> step.Step(Nil)

The element has the given accessible name.

to_have_attribute

</>

pub fn to_have_attribute(
  expectation: Expectation(locator.Locator),
  name: String,
  value: String,
) -> step.Step(Nil)

The element has an attribute with the given value.

to_have_class

</>

pub fn to_have_class(
  expectation: Expectation(locator.Locator),
  class: String,
) -> step.Step(Nil)

The element has the given CSS class, amongst any others.

to_have_count

</>

pub fn to_have_count(
  expectation: Expectation(locator.Locator),
  count: Int,
) -> step.Step(Nil)

The locator matches exactly this many elements.

to_have_id

</>

pub fn to_have_id(
  expectation: Expectation(locator.Locator),
  id: String,
) -> step.Step(Nil)

The element has the given id.

to_have_text

</>

pub fn to_have_text(
  expectation: Expectation(locator.Locator),
  text: String,
) -> step.Step(Nil)

The element’s text is exactly the given text, ignoring surrounding whitespace.

to_have_text_matching

</>

pub fn to_have_text_matching(
  expectation: Expectation(locator.Locator),
  pattern: String,
) -> step.Step(Nil)

The element’s text matches a JavaScript regular expression.

to_have_texts

</>

pub fn to_have_texts(
  expectation: Expectation(locator.Locator),
  texts: List(String),
) -> step.Step(Nil)

The texts of all the matched elements are exactly the given texts, in order.

to_have_title

</>

pub fn to_have_title(
  expectation: Expectation(page.Page),
  title: String,
) -> step.Step(Nil)

The page’s title is exactly the given title.

to_have_title_matching

</>

pub fn to_have_title_matching(
  expectation: Expectation(page.Page),
  pattern: String,
) -> step.Step(Nil)

The page’s title matches a JavaScript regular expression.

to_have_url

</>

pub fn to_have_url(
  expectation: Expectation(page.Page),
  url: String,
) -> step.Step(Nil)

The page’s URL is the given URL. Relative URLs are resolved against the base_url of the test config.

to_have_url_matching

</>

pub fn to_have_url_matching(
  expectation: Expectation(page.Page),
  pattern: String,
) -> step.Step(Nil)

The page’s URL matches a JavaScript regular expression.

to_have_value

</>

pub fn to_have_value(
  expectation: Expectation(locator.Locator),
  value: String,
) -> step.Step(Nil)

The input’s value is the given value.

true

</>

pub fn true(condition: Bool, message: String) -> step.Step(Nil)

A condition holds, failing with the given message if it doesn’t.

within

</>

pub fn within(
  expectation: Expectation(subject),
  milliseconds: Int,
) -> Expectation(subject)

Retry the assertion for up to the given number of milliseconds instead of the default 5 seconds.