How to use test_should_close_browser_with_beforeunload_page method in Playwright Python

Instead of:

page.once("dialog", lambda dialog: asyncio.create_task(dialog.accept()))

It should apparently be just:

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

This was basically a lucky guess, so take it with a grain of salt. I can't find a good source to back it up.

At the time of writing, the documentation for the Python version of Playwright doesn't seem to mention page.once() at all.

In the original JavaScript version of Playwright, page.once() is documented as part of the standard Node.js EventEmitter class, from which Page is derived. Nothing like EventEmitter exists in the Python standard library, though.

In your special case, each page has their own link. It is your base link and the page number with an hyphen (-) in between.

You can see this behaviour when clicking on the second page, compare your base-link with the link you have now: https://forum.donanimhaber.com/turkcell-25-000-dk-12-000-sms-70-gb-internet-12-ay-320-tl-ana-konu--151777938-2

(notice the -2 at the end)

One way to do it, would be to change your url in a for-loop, iterating up to 24 and scrape all of those pages individually.

Based on @ggorlen's suggestion, I spotted that the select_option triggered a request, which I was able to trigger on, and validate, thus:

        with page.expect_response(lambda response: response.url) as response_info:
            assert loc[0] in response_info.value.url, f"wrong location {response_info.value.url}, expecting {loc}"

From this page: https://playwright.dev/python/docs/network#variations

But note that there seemed to be a bug on that page as token in in the lambda function isn't relevant. The code checks that the query relates to the address of interest.

You can use the not_be_visible expect assertion for this.

expect('element CSS here').not_to_be_visible()

By default expect assertions have a 5 second timeout, in case you want to increase the timeout, you can do like this:

expect('element CSS here').not_to_be_visible(timeout=7000)

As mentioned in the comments, your tests should be independent and indeed this can be achieved with database fixtures. One way to achieve this and worked really well for me is by using testcontainers: https://github.com/testcontainers/testcontainers-python.

A fixture might look like this in pytest with, in my case, a Postgress database:

@pytest.fixture(scope="module", name="session_for_db_in_testcontainer")
def db_engine():
    """
    Creates testcontainer with Postgres db
    """
    pg_container = PostgresContainer('postgres:latest')
    pg_container.start()

    # Fireup the SQLModel engine with the uri of the container
    db_engine = create_engine(pg_container.get_connection_url())
    sqlmodel_metadata.create_all(db_engine)

    with Session(db_engine) as session_for_db_in_testcontainer:
        # add some rows to start, for test get requests and posting existing data
        add_data_to_test_db(database_input_path, session_for_db_in_testcontainer)
        yield session_for_db_in_testcontainer

    # Will be executed after the last test
    session_for_db_in_testcontainer.close()
    pg_container.stop()

Like this during the test run a (Postgres) DB is created it only runs during a session, module or function depending on the scope of the fixture. If you want, you can add test data to the db as well like in the example.

Heroku's filesystem is both ephemeral and dyno-local. Any changes made to it are lost when the dyno restarts. More importantly at the moment, when you run something like heroku run bash you don't connect to a running dyno. Instead, you get a separate one-off dyno.

Installing Chromium (or making any other filesystem changes) in such an environment will never affect what is available in your other dynos.

It looks like Playwright really wants to manage its own browser binaries. Your best bet might be to run playwright install near the beginning of your script, e.g. something like this:

import subprocess
from playwright.sync_api import sync_playwright

subprocess.run(["playwright", "install"])

with sync_playwright() as playwright:
    # ...

This should make sure that the required binaries are always available at runtime.

I believe you need to call your go_to_url function using the same recipe:

asyncio.get_event_loop().run_until_complete(go_to_url())

This here worked for me:

with page.expect_download() as download_info:    
    page.goto("Link")
    page.click('xpath=button')
download = download_info.value
path = download.path()
download.save_as("filename.csv")
print(path)

#---------------------
context.close()
browser.close()

I hope it helps you!

You cannot use page.click for elements which are on a different page (in an iframe). You need to get a handle on the frame and interact with that.

Something like:

frame = page.frame(name="frame-name")
frame.click("the selector of the element you want to click inside the frame")

Something which might give you some inspiration for the correct selectors and so on is the codegen feature of Playwright. From the docs though, it looks like it generates JavaScript so really only for inspiration.

(P.S. No experience with Python here)