Пример #1
0
async def test_locators_frame_should_work_with_locator_frame_locator(
        page: Page, server: Server) -> None:
    await route_iframe(page)
    await page.goto(server.EMPTY_PAGE)
    button = page.locator("body").frame_locator("iframe").locator("button")
    await button.wait_for()
    assert await button.inner_text() == "Hello iframe"
    await button.click()
Пример #2
0
async def test_locators_focus_should_work(page: Page, server: Server):
    await page.goto(server.PREFIX + "/input/button.html")
    button = page.locator("button")
    assert await button.evaluate("button => document.activeElement === button"
                                 ) is False
    await button.focus()
    assert await button.evaluate("button => document.activeElement === button"
                                 ) is True
Пример #3
0
async def test_locators_should_have_repr(page: Page, server: Server):
    await page.goto(server.PREFIX + "/input/button.html")
    button = page.locator("button")
    await button.click()
    assert (
        str(button)
        == f"<Locator frame=<Frame name= url='{server.PREFIX}/input/button.html'> selector='button'>"
    )
Пример #4
0
async def test_locators_return_empty_array_for_non_existing_elements(
        page: Page):
    await page.set_content(
        """<html><body><div>A</div><br/><div>B</div></body></html>""")
    html = page.locator("html")
    elements = await html.locator("abc").element_handles()
    assert len(elements) == 0
    assert elements == []
Пример #5
0
async def test_locators_wait_for(page: Page) -> None:
    await page.set_content("<div></div>")
    locator = page.locator("div")
    task = locator.wait_for()
    await page.eval_on_selector(
        "div", "div => div.innerHTML = '<span>target</span>'")
    await task
    assert await locator.text_content() == "target"
Пример #6
0
async def test_locators_is_checked_should_work(page: Page):
    await page.set_content("""
        <input type='checkbox' checked><div>Not a checkbox</div>
    """)

    element = page.locator("input")
    assert await element.is_checked() is True
    await element.evaluate("e => e.checked = false")
    assert await element.is_checked() is False
Пример #7
0
async def test_locators_is_enabled_and_is_disabled_should_work(page: Page):
    await page.set_content("""
        <button disabled>button1</button>
        <button>button2</button>
        <div>div</div>
    """)

    div = page.locator("div")
    assert await div.is_enabled() is True
    assert await div.is_disabled() is False

    button1 = page.locator(':text("button1")')
    assert await button1.is_enabled() is False
    assert await button1.is_disabled() is True

    button1 = page.locator(':text("button2")')
    assert await button1.is_enabled() is True
    assert await button1.is_disabled() is False
Пример #8
0
async def test_drag_to(page: Page, server: Server) -> None:
    await page.goto(server.PREFIX + "/drag-n-drop.html")
    await page.locator("#source").drag_to(page.locator("#target"))
    assert (
        await page.eval_on_selector(
            "#target", "target => target.contains(document.querySelector('#source'))"
        )
        is True
    )
Пример #9
0
async def test_locators_all_inner_texts(page: Page):
    await page.set_content(
        """
        <div>A</div><div>B</div><div>C</div>
    """
    )

    element = page.locator("div")
    assert await element.all_inner_texts() == ["A", "B", "C"]
Пример #10
0
async def test_assertions_should_serialize_regexp_correctly(
        page: Page, server: Server) -> None:
    await page.goto(server.EMPTY_PAGE)
    await page.set_content("<div>iGnOrEcAsE</div>")
    await expect(page.locator("div")
                 ).to_have_text(re.compile(r"ignorecase", re.IGNORECASE))
    await page.set_content("""<div>start
some
lines
between
end</div>""")
    await expect(page.locator("div")
                 ).to_have_text(re.compile(r"start.*end", re.DOTALL))
    await page.set_content("""<div>line1
line2
line3</div>""")
    await expect(page.locator("div")
                 ).to_have_text(re.compile(r"^line2$", re.MULTILINE))
Пример #11
0
async def test_assertions_locator_to_have_value(page: Page,
                                                server: Server) -> None:
    await page.goto(server.EMPTY_PAGE)
    await page.set_content("<input type=text id=foo>")
    my_input = page.locator("#foo")
    await expect(my_input).to_have_value("")
    await expect(my_input).not_to_have_value("bar", timeout=100)
    await my_input.fill("kektus")
    await expect(my_input).to_have_value("kektus")
Пример #12
0
async def test_locators_should_upload_a_file(page: Page, server: Server):
    await page.goto(server.PREFIX + "/input/fileupload.html")
    input = page.locator("input[type=file]")

    file_path = os.path.relpath(FILE_TO_UPLOAD, os.getcwd())
    await input.set_input_files(file_path)
    assert (await
            page.evaluate("e => e.files[0].name", await
                          input.element_handle()) == "file-to-upload.txt")
Пример #13
0
async def test_assertions_locator_to_be_focused(page: Page,
                                                server: Server) -> None:
    await page.goto(server.EMPTY_PAGE)
    await page.set_content("<input type=checkbox>")
    my_checkbox = page.locator("input")
    with pytest.raises(AssertionError):
        await expect(my_checkbox).to_be_focused(timeout=100)
    await my_checkbox.focus()
    await expect(my_checkbox).to_be_focused()
Пример #14
0
async def test_should_page_route_from_har_matching_the_method_and_following_redirects(
        page: Page, assetdir: Path) -> None:
    await page.route_from_har(har=assetdir / "har-fulfill.har")
    await page.goto("http://no.playwright/")
    # HAR contains a redirect for the script that should be followed automatically.
    assert await page.evaluate("window.value") == "foo"
    # HAR contains a POST for the css file that should not be used.
    await expect(page.locator("body")).to_have_css("background-color",
                                                   "rgb(255, 0, 0)")
Пример #15
0
async def test_locators_should_query_existing_elements(page: Page):
    await page.set_content(
        """<html><body><div>A</div><br/><div>B</div></body></html>""")
    html = page.locator("html")
    elements = await html.locator("div").element_handles()
    assert len(elements) == 2
    result = []
    for element in elements:
        result.append(await page.evaluate("e => e.textContent", element))
    assert result == ["A", "B"]
Пример #16
0
async def test_locator_should_return_page(page: Page, server: Server) -> None:
    await page.goto(server.PREFIX + "/frames/two-frames.html")
    outer = page.locator("#outer")
    assert outer.page == page

    inner = outer.locator("#inner")
    assert inner.page == page

    in_frame = page.frames[1].locator("div")
    assert in_frame.page == page
Пример #17
0
async def test_locators_should_screenshot(page: Page, server: Server,
                                          assert_to_be_golden):
    await page.set_viewport_size({
        "width": 500,
        "height": 500,
    })
    await page.goto(server.PREFIX + "/grid.html")
    await page.evaluate("window.scrollBy(50, 100)")
    element = page.locator(".box:nth-of-type(3)")
    assert_to_be_golden(await element.screenshot(),
                        "screenshot-element-bounding-box.png")
Пример #18
0
async def test_locator_frame_locator_should_throw_on_ambiguity(
        page: Page, server: Server) -> None:
    await route_ambiguous(page)
    await page.goto(server.EMPTY_PAGE)
    button = page.locator("body").frame_locator("iframe").locator("button")
    with pytest.raises(
            Error,
            match=
            '.*strict mode violation: "body >> iframe" resolved to 3 elements.*',
    ):
        await button.wait_for()
Пример #19
0
async def test_locators_should_query_existing_element(page: Page,
                                                      server: Server):
    await page.goto(server.PREFIX + "/playground.html")
    await page.set_content(
        """<html><body><div class="second"><div class="inner">A</div></div></body></html>"""
    )
    html = page.locator("html")
    second = html.locator(".second")
    inner = second.locator(".inner")
    assert (await page.evaluate("e => e.textContent", await
                                inner.element_handle()) == "A")
Пример #20
0
async def test_assertions_locator_to_have_js_property(
    page: Page, server: Server
) -> None:
    await page.goto(server.EMPTY_PAGE)
    await page.set_content("<div></div>")
    await page.eval_on_selector(
        "div", "e => e.foo = { a: 1, b: 'string', c: new Date(1627503992000) }"
    )
    await expect(page.locator("div")).to_have_js_property(
        "foo",
        {"a": 1, "b": "string", "c": datetime.utcfromtimestamp(1627503992000 / 1000)},
    )
Пример #21
0
async def test_locators_should_select_textarea(page: Page, server: Server,
                                               browser_name: str):
    await page.goto(server.PREFIX + "/input/textarea.html")
    textarea = page.locator("textarea")
    await textarea.evaluate("textarea => textarea.value = 'some value'")
    await textarea.select_text()
    if browser_name == "firefox":
        assert await textarea.evaluate("el => el.selectionStart") == 0
        assert await textarea.evaluate("el => el.selectionEnd") == 10
    else:
        assert await page.evaluate("window.getSelection().toString()"
                                   ) == "some value"
Пример #22
0
async def test_to_have_values_fails_when_not_a_select_element(
    page: Page, server: Server
) -> None:
    await page.set_content(
        """
        <input type="text">
    """
    )
    locator = page.locator("input")
    with pytest.raises(Error) as excinfo:
        await expect(locator).to_have_values(["R", "G"], timeout=500)
    assert "Error: Not a select element with a multiple attribute" in str(excinfo.value)
Пример #23
0
async def test_should_screenshot_with_mask(page: Page, server: Server,
                                           assert_to_be_golden):
    await page.set_viewport_size({
        "width": 500,
        "height": 500,
    })
    await page.goto(server.PREFIX + "/grid.html")
    assert_to_be_golden(
        await page.screenshot(mask=[page.locator("div").nth(5)]),
        "mask-should-work-with-page.png",
    )
    assert_to_be_golden(
        await
        page.locator("body").screenshot(mask=[page.locator("div").nth(5)]),
        "mask-should-work-with-locator.png",
    )
    assert_to_be_golden(
        await (await page.query_selector("body")).screenshot(
            mask=[page.locator("div").nth(5)]),
        "mask-should-work-with-element-handle.png",
    )
Пример #24
0
async def test_ignore_case(page: Page, server: Server, method: str) -> None:
    await page.goto(server.EMPTY_PAGE)
    await page.set_content("<div id=target>apple BANANA</div><div>orange</div>")
    await getattr(expect(page.locator("div#target")), method)("apple BANANA")
    await getattr(expect(page.locator("div#target")), method)(
        "apple banana", ignore_case=True
    )
    # defaults false
    with pytest.raises(AssertionError) as excinfo:
        await getattr(expect(page.locator("div#target")), method)(
            "apple banana", timeout=300
        )
    expected_error_msg = method.replace("_", " ")
    assert expected_error_msg in str(excinfo.value)

    # Array Variants
    await getattr(expect(page.locator("div")), method)(["apple BANANA", "orange"])
    await getattr(expect(page.locator("div")), method)(
        ["apple banana", "ORANGE"], ignore_case=True
    )
    # defaults false
    with pytest.raises(AssertionError) as excinfo:
        await getattr(expect(page.locator("div")), method)(
            ["apple banana", "ORANGE"], timeout=300
        )
    assert expected_error_msg in str(excinfo.value)

    # not variant
    await getattr(expect(page.locator("div#target")), f"not_{method}")("apple banana")
    with pytest.raises(AssertionError) as excinfo:
        await getattr(expect(page.locator("div#target")), f"not_{method}")(
            "apple banana", ignore_case=True, timeout=300
        )
    assert f"not {expected_error_msg}" in str(excinfo)
Пример #25
0
async def test_assertions_locator_to_be_hidden_visible(page: Page,
                                                       server: Server) -> None:
    await page.goto(server.EMPTY_PAGE)
    await page.set_content(
        "<div style='width: 50px; height: 50px;'>Something</div>")
    my_checkbox = page.locator("div")
    await expect(my_checkbox).to_be_visible()
    with pytest.raises(AssertionError):
        await expect(my_checkbox).to_be_hidden(timeout=100)
    await my_checkbox.evaluate("e => e.style.display = 'none'")
    await expect(my_checkbox).to_be_hidden()
    with pytest.raises(AssertionError):
        await expect(my_checkbox).to_be_visible(timeout=100)
Пример #26
0
async def test_assertions_locator_to_be_disabled_enabled(
        page: Page, server: Server) -> None:
    await page.goto(server.EMPTY_PAGE)
    await page.set_content("<input type=checkbox>")
    my_checkbox = page.locator("input")
    await expect(my_checkbox).not_to_be_disabled()
    await expect(my_checkbox).to_be_enabled()
    with pytest.raises(AssertionError):
        await expect(my_checkbox).to_be_disabled(timeout=100)
    await my_checkbox.evaluate("e => e.disabled = true")
    await expect(my_checkbox).to_be_disabled()
    with pytest.raises(AssertionError):
        await expect(my_checkbox).to_be_enabled(timeout=100)
Пример #27
0
async def test_to_have_values_works_with_regex(page: Page, server: Server) -> None:
    await page.set_content(
        """
        <select multiple>
            <option value="R">Red</option>
            <option value="G">Green</option>
            <option value="B">Blue</option>
        </select>
    """
    )
    locator = page.locator("select")
    await locator.select_option(["R", "G"])
    await expect(locator).to_have_values([re.compile("R"), re.compile("G")])
Пример #28
0
async def test_drag_to_with_position(page: Page, server: Server):
    await page.goto(server.EMPTY_PAGE)
    await page.set_content("""
      <div style="width:100px;height:100px;background:red;" id="red">
      </div>
      <div style="width:100px;height:100px;background:blue;" id="blue">
      </div>
    """)
    events_handle = await page.evaluate_handle("""
        () => {
        const events = [];
        document.getElementById('red').addEventListener('mousedown', event => {
            events.push({
            type: 'mousedown',
            x: event.offsetX,
            y: event.offsetY,
            });
        });
        document.getElementById('blue').addEventListener('mouseup', event => {
            events.push({
            type: 'mouseup',
            x: event.offsetX,
            y: event.offsetY,
            });
        });
        return events;
        }
    """)
    await page.locator("#red").drag_to(
        page.locator("#blue"),
        source_position={
            "x": 34,
            "y": 7
        },
        target_position={
            "x": 10,
            "y": 20
        },
    )
    assert await events_handle.json_value() == [
        {
            "type": "mousedown",
            "x": 34,
            "y": 7
        },
        {
            "type": "mouseup",
            "x": 10,
            "y": 20
        },
    ]
Пример #29
0
async def test_to_have_values_follows_labels(page: Page, server: Server) -> None:
    await page.set_content(
        """
        <label for="colors">Pick a Color</label>
        <select id="colors" multiple>
            <option value="R">Red</option>
            <option value="G">Green</option>
            <option value="B">Blue</option>
        </select>
    """
    )
    locator = page.locator("text=Pick a Color")
    await locator.select_option(["R", "G"])
    await expect(locator).to_have_values(["R", "G"])
Пример #30
0
async def test_locators_click_should_work_for_text_nodes(
        page: Page, server: Server):
    await page.goto(server.PREFIX + "/input/button.html")
    await page.evaluate("""() => {
        window['double'] = false;
        const button = document.querySelector('button');
        button.addEventListener('dblclick', event => {
        window['double'] = true;
        });
    }""")
    button = page.locator("button")
    await button.dblclick()
    assert await page.evaluate("double") is True
    assert await page.evaluate("result") == "Clicked"