playwright/docs/src/verification.md at d14ecec61220ba4a8b3bf711f46faaee81856062

docs: merge assertions with verification doc (#12361 )

2022-02-25 22:58:41 +01:00

13 KiB

Raw Blame History

id	title
verification	Verification

:::note Playwright has Web-First Assertions which automatically retry until the expected condition is met. This helps to reduce flakiness and readability of tests. :::

Text content

const content = await page.locator('nav:first-child').textContent();
expect(content).toBe('home');

String content = page.locator("nav:first-child").textContent();
assertEquals("home", content);

content = await page.locator("nav:first-child").text_content()
assert content == "home"

content = page.locator("nav:first-child").text_content()
assert content == "home"

var content = await page.Locator("nav:first-child").TextContentAsync();
Assert.AreEqual("home", content);

API reference

[method: Page.textContent]
[method: ElementHandle.textContent]

Inner text

const text = await page.locator('.selected').innerText();
expect(text).toBe('value');

String text = page.locator(".selected").innerText();
assertEquals("value", text);

text = await page.locator(".selected").inner_text()
assert text == "value"

text = page.locator(".selected").inner_text()
assert text == "value"

var content = await page.Locator(".selected").InnerTextAsync();
Assert.AreEqual("value", content);

API reference

[method: Page.innerText]
[method: ElementHandle.innerText]

Attribute value

const alt = await page.locator('input').getAttribute('alt');
expect(alt).toBe('Text');

String alt = page.locator("input").getAttribute("alt");
assertEquals("Text", alt);

alt = await page.locator("input").get_attribute("alt")
assert alt == "Text"

alt = page.locator("input").get_attribute("alt")
assert alt == "Text"

var value = await page.Locator("input").GetAttributeAsync("alt");
Assert.AreEqual("Text", value);

Checkbox state

const checked = await page.locator('input').isChecked();
expect(checked).toBeTruthy();

boolean checked = page.locator("input").isChecked();
assertTrue(checked);

checked = await page.locator("input").is_checked()
assert checked

checked = page.locator("input").is_checked()
assert checked

var checked = await page.Locator("input").IsCheckedAsync();
Assert.True(checked);

API reference

[method: Page.isChecked]
[method: ElementHandle.isChecked]

Text content

const content = await page.locator('nav:first-child').textContent();
expect(content).toBe('home');

Object content = page.locator("nav:first-child").textContent();
assertEquals("home", content);

content = await page.locator("nav:first-child").text_content()
assert content == "home"

content = page.locator("nav:first-child").text_content()
assert content == "home"

var content = await page.locator("nav:first-child").TextContentAsync();
Assert.AreEqual("home", content);

API reference

[method: Page.evalOnSelector]
[method: JSHandle.evaluate]

Inner HTML

const html = await page.locator('div.result').innerHTML();
expect(html).toBe('<p>Result</p>');

String html = page.locator("div.result").innerHTML();
assertEquals("<p>Result</p>", html);

html = await page.locator("div.result").inner_html()
assert html == "<p>Result</p>"

html = page.locator("div.result").inner_html()
assert html == "<p>Result</p>"

var html = await page.Locator("div.result").InnerHTMLAsync();
Assert.AreEqual("<p>Result</p>", html);

API reference

[method: Page.innerHTML]
[method: ElementHandle.innerHTML]

Visibility

const visible = await page.locator('input').isVisible();
expect(visible).toBeTruthy();

boolean visible = page.locator("input").isVisible();
assertTrue(visible);

visible = await page.locator("input").is_visible()
assert visible

visible = page.locator("input").is_visible()
assert visible

var visibility = await page.Locator("input").IsVisibleAsync();
Assert.True(visibility);

API reference

[method: Page.isVisible]
[method: ElementHandle.isVisible]

Enabled state

const enabled = await page.locator('input').isEnabled();
expect(enabled).toBeTruthy();

boolean enabled = page.locator("input").isEnabled();
assertTrue(enabled);

enabled = await page.locator("input").is_enabled()
assert enabled

enabled = page.locator("input").is_enabled()
assert enabled

var enabled = await page.Locator("input").IsEnabledAsync();
Assert.True(enabled);

API reference

[method: Page.isEnabled]
[method: ElementHandle.isEnabled]

Custom assertions

With Playwright, you can also write custom JavaScript to run in the context of the browser. This is useful in situations where you want to assert for values that are not covered by the convenience APIs above.

// Assert local storage value
const userId = page.evaluate(() => window.localStorage.getItem('userId'));
expect(userId).toBeTruthy();

// Assert value for input element
const value = await page.locator('#search').inputValue();
expect(value === 'query').toBeTruthy();

// Assert computed style
const fontSize = await page.locator('div').evaluate(el => window.getComputedStyle(el).fontSize);
expect(fontSize === '16px').toBeTruthy();

// Assert list length
const length = await page.locator('li.selected').count();
expect(length === 3).toBeTruthy();

// Assert local storage value
Object userId = page.evaluate("() => window.localStorage.getItem('userId')");
assertNotNull(userId);

// Assert value for input element
Object value = page.locator("#search").inputValue();
assertEquals("query", value);

// Assert computed style
Object fontSize = page.locator("div").evaluate("el => window.getComputedStyle(el).fontSize");
assertEquals("16px", fontSize);

// Assert list length
Object length = page.locator("li.selected").count();
assertEquals(3, length);

# Assert local storage value
user_id = page.evaluate("() => window.localStorage.getItem('user_id')")
assert user_id

# Assert value for input element
value = await page.locator('#search').input_value()
assert value == 'query'

# Assert computed style
font_size = await page.locator('div').evaluate('el => window.getComputedStyle(el).fontSize')
assert font_size == '16px'

# Assert list length
length = await page.locator('li.selected').count()
assert length == 3

# Assert local storage value
user_id = page.evaluate("() => window.localStorage.getItem('user_id')")
assert user_id

# Assert value for input element
value = page.locator('#search').input_value()
assert value == 'query'

# Assert computed style
font_size = page.locator('div').evaluate('el => window.getComputedStyle(el).fontSize')
assert font_size == '16px'

# Assert list length
length = page.locator('li.selected').count()
assert length == 3

// Assert local storage value
var userId = await page.EvaluateAsync<string>("() => window.localStorage.getItem('userId')");
Assert.NotNull(userId);

// Assert value for input element
var value = await page.Locator("#search").InputValueAsync();
Assert.AreEqual("query", value);

// Assert computed style
var fontSize = await page.Locator("div").EvalOnSelectorAsync<string>("el => window.getComputedStyle(el).fontSize");
Assert.AreEqual("16px", fontSize);

// Assert list length
var length = await page.Locator("li.selected").CountAsync();
Assert.AreEqual(3, length);

Console logs

Console messages logged in the page can be brought into the Playwright context.

// Listen for all console logs
page.on('console', msg => console.log(msg.text()))

// Listen for all console events and handle errors
page.on('console', msg => {
  if (msg.type() === 'error')
    console.log(`Error text: "${msg.text()}"`);
});

// Get the next console log
const [msg] = await Promise.all([
  page.waitForEvent('console'),
  // Issue console.log inside the page
  page.evaluate(() => {
    console.log('hello', 42, { foo: 'bar' });
  }),
]);

// Deconstruct console log arguments
await msg.args[0].jsonValue() // hello
await msg.args[1].jsonValue() // 42

// Listen for all System.out.printlns
page.onConsoleMessage(msg -> System.out.println(msg.text()));

// Listen for all console events and handle errors
page.onConsoleMessage(msg -> {
  if ("error".equals(msg.type()))
    System.out.println("Error text: " + msg.text());
});

// Get the next System.out.println
ConsoleMessage msg = page.waitForConsoleMessage(() -> {
  // Issue console.log inside the page
  page.evaluate("console.log('hello', 42, { foo: 'bar' });");
});

// Deconstruct console.log arguments
msg.args().get(0).jsonValue() // hello
msg.args().get(1).jsonValue() // 42

# Listen for all console logs
page.on("console", lambda msg: print(msg.text))

# Listen for all console events and handle errors
page.on("console", lambda msg: print(f"error: {msg.text}") if msg.type == "error" else None)

# Get the next console log
async with page.expect_console_message() as msg_info:
    # Issue console.log inside the page
    await page.evaluate("console.log('hello', 42, { foo: 'bar' })")
msg = await msg_info.value

# Deconstruct print arguments
await msg.args[0].json_value() # hello
await msg.args[1].json_value() # 42

# Listen for all console logs
page.on("console", lambda msg: print(msg.text))

# Listen for all console events and handle errors
page.on("console", lambda msg: print(f"error: {msg.text}") if msg.type == "error" else None)

# Get the next console log
with page.expect_console_message() as msg_info:
    # Issue console.log inside the page
    page.evaluate("console.log('hello', 42, { foo: 'bar' })")
msg = msg_info.value

# Deconstruct print arguments
msg.args[0].json_value() # hello
msg.args[1].json_value() # 42

// Listen for all System.out.printlns
page.Console += (_, msg) => Console.WriteLine(msg.Text);

// Listen for all console events and handle errors
page.Console += (_, msg) =>
{
    if ("error".Equals(msg.Type))
        Console.WriteLine("Error text: " + msg.Text);
};

// Get the next System.out.println
var waitForMessageTask = page.WaitForConsoleMessageAsync();
await page.EvaluateAsync("console.log('hello', 42, { foo: 'bar' });");
var message = await waitForMessageTask;
// Deconstruct console.log arguments
await message.Args.ElementAt(0).JsonValueAsync<string>(); // hello
await message.Args.ElementAt(1).JsonValueAsync<int>(); // 42

API reference

[ConsoleMessage]
[Page]
[event: Page.console]

Page errors

Listen for uncaught exceptions in the page with the pagerror event.

// Log all uncaught errors to the terminal
page.on('pageerror', exception => {
  console.log(`Uncaught exception: "${exception}"`);
});

// Navigate to a page with an exception.
await page.goto('data:text/html,<script>throw new Error("Test")</script>');

// Log all uncaught errors to the terminal
page.onPageError(exception -> {
  System.out.println("Uncaught exception: " + exception);
});

// Navigate to a page with an exception.
page.navigate("data:text/html,<script>throw new Error('Test')</script>");

# Log all uncaught errors to the terminal
page.on("pageerror", lambda exc: print(f"uncaught exception: {exc}"))

# Navigate to a page with an exception.
await page.goto("data:text/html,<script>throw new Error('test')</script>")

# Log all uncaught errors to the terminal
page.on("pageerror", lambda exc: print(f"uncaught exception: {exc}"))

# Navigate to a page with an exception.
page.goto("data:text/html,<script>throw new Error('test')</script>")

// Log all uncaught errors to the terminal
page.PageError += (_, exception) =>
{
  Console.WriteLine("Uncaught exception: " + exception);
};

API reference

[Page]
[event: Page.pageError]

Page events

`"requestfailed"`

page.on('requestfailed', request => {
  console.log(request.url() + ' ' + request.failure().errorText);
});

page.onRequestFailed(request -> {
  System.out.println(request.url() + " " + request.failure());
});

page.on("requestfailed", lambda request: print(request.url + " " + request.failure.error_text))

`"dialog"` - handle alert, confirm, prompt

page.on('dialog', dialog => {
  dialog.accept();
});

page.onDialog(dialog -> {
  dialog.accept();
});

page.on("dialog", lambda dialog: dialog.accept())

page.RequestFailed += (_, request) =>
{
    Console.WriteLine(request.Url + " " + request.Failure);
};

`"popup"` - handle popup windows

const [popup] = await Promise.all([
  page.waitForEvent('popup'),
  page.click('#open')
]);

Page popup = page.waitForPopup(() -> {
  page.click("#open");
});

async with page.expect_popup() as popup_info:
    await page.click("#open")
popup = await popup_info.value

with page.expect_popup() as popup_info:
    page.click("#open")
popup = popup_info.value

var popup = await page.RunAndWaitForPopupAsync(async () =>
{
    await page.ClickAsync("#open");
});

API reference

[Page]
[event: Page.requestFailed]
[event: Page.dialog]
[event: Page.popup]

13 KiB Raw Blame History

Text content

API reference

Inner text

API reference

Attribute value

Checkbox state

API reference

Text content

API reference

Inner HTML

API reference

Visibility

API reference

Enabled state

API reference

Custom assertions

Console logs

API reference

Page errors

API reference

Page events

"requestfailed"

"dialog" - handle alert, confirm, prompt

"popup" - handle popup windows

API reference

13 KiB

Raw Blame History

`"requestfailed"`

`"dialog"` - handle alert, confirm, prompt

`"popup"` - handle popup windows