How to use test_should_not_allow_getting_the_path method in Playwright Python

The download.path() in playwright is just a random GUID (globally unique identifier). It's designed to validate the download works - not to keep the file.

Playwright is a testing tool and imagine running tests across every major browser on every code change - any downloads would quickly take up a lot of space and it would hack people off if you need to manually clear them out.

Good news is you are very close - If you want to keep the file you just need to give the file a name in the save_as.

instead of this:

   download.save_as(path)

use this:

   download.save_as(download.suggested_filename)

That saves the file in the same location as the script.

You can use one of those options :

const element = await page.$$("text='element'");
if (element) {
    // ...
}

or

const element = await page.$$("text='element'");
if (element.length) {
    // ...
}

or

await expect(page.locator(".MyClass")).toHaveCount(0)

Just use some condition instead of print method, for example you could check if response contains some key in its json:

def run(playwright):
    chromium = playwright.chromium
    browser = chromium.launch()
    page = browser.new_page()
    # Subscribe to "request" and "response" events.
    page.on("request", lambda request: print(">>", request.method, request.url))
    page.on("response", lambda response: print("<<", response.status, response.url))
    page.goto("https://example.com")
    browser.close()

For Example:

page.on("response", lambda response: response if key in response.body())

There should be waitForResponse for python too, and you could use that.

for i in range(0, 5):

            html = response.text
            # print(html)
            soup = BeautifulSoup(html, "html.parser")
            search_date = soup.find_all("input")[-6]["value"]
            await page.click(
                "#yDmH0d > c-wiz.zQTmif.SSPGKf > div > div:nth-child(2) > c-wiz > div > c-wiz > div.PSZ8D.EA71Tc > div.Ep1EJd > div > div.rIZzse > div.bgJkKe.K0Tsu > div > div > div.dvO2xc.k0gFV > div > div > div:nth-child(1) > div > div.oSuIZ.YICvqf.kStSsc.ieVaIb > div > div.WViz0c.CKPWLe.U9gnhd.Xbfhhd > button"
            )

            yield {
                "search_date": search_date,
            }

This logic to extract all the dates in the range is incorrect. Understand the flow of

1. you make request to the flight page.
2. you get the response.
3. In parse method you are trying to extract the search date.

search_date = soup.find_all("input")[-6]["value"]

This line is only returning one date and not a list. Moreover, I don't understand the logic behind the for loop here. Because this piece of code is not making any further requests as you are trying to achieve with the extracted dates[mentioned in the question]

Important thing to note here is, you have to got the entire html response in one go. You can now use css selectors or soup to extract all the selected dates. Running the for loop for 5 times, doesn't solve any purpose, as you are executing the same information 5 times.

Use response.css('<<Path to the dates in the select>>').getall() to get all the dates you are looking for. Process the information further.

Improvisation on the logic: You can improvise on the logic, I am not sure why you are extracting range of dates, when you can just extract the departure and return dates for the page. And make a request using them. Or Just extract the departure date and increment it and make another request using that date for further information.

Try this:

def main():
    with sync_playwright() as p:
        browser = p.chromium.launch(headless=False)
        context = browser.new_context()
        page = context.new_page()
        page.goto("https://www.aliexpress.com/wholesale?catId=0&initiative_id=AS_20220518080059&SearchText=makeup")
        countrySwitcher = page.query_selector("#switcher-info")
        countrySwitcher.click()
        # time.sleep(6000)
        page.locator("#nav-global > div.ng-item-wrap.ng-item.ng-switcher.active > div > div > div > div.switcher-shipto.item.util-clearfix > div").click()
        page.locator("[placeholder=\"Search\"]").first.click()
        page.locator("[placeholder=\"Search\"]").first.fill("Spain")
        page.locator("li:has-text(\"Spain\")").click()
        page.locator("span:has-text(\"Español\")").click()
        page.locator("text=English").nth(1).click()
        page.locator("span:has-text(\"EUR ( Euro )\")").click()
        page.locator(
            "text=EUR ( Euro ) CHF ( Swiss Franc ) MXN ( Mexican Peso ) EUR ( Euro ) CLP ( Chilean >> [placeholder=\"Search\"]").click()
        page.locator(
            "text=EUR ( Euro ) CHF ( Swiss Franc ) MXN ( Mexican Peso ) EUR ( Euro ) CLP ( Chilean >> [placeholder=\"Search\"]").fill(
            "MAD")
        page.locator("text=MAD ( Moroccan Dirham )").click()
        with page.expect_navigation():
            page.locator("button", has_text="Save").click()


if __name__ == '__main__':
    main()

The problem was that you were searching specifically for the text "Morocco" to be present. It would not have been there if you were from another country since alibaba uses country detection. Your last code line, i.e. page.locator("text=Save").click() was also faulty. The text "Save" resided inside a descendant element which you need to account for.

In general, it is always a good idea to make your locaters as general and flexible as possible to account for minor website changes done by the admin. Therefore, instead of using text to find the elements, maybe you should try using CSS selectors instead?

Further reading

Absent seeing the actual site, a traditional selection and get_attribute should be sufficient:

from playwright.sync_api import sync_playwright

with sync_playwright() as p:
    browser = p.chromium.launch(headless=True)
    page = browser.new_page()
    page.set_content("""
    <iframe title="IFRAME_NAME" src="https://www.data_I_want_TO_get.com"></iframe>
    """)
    src = page.get_attribute('iframe[title="IFRAME_NAME"]', "src")
    print(src)  # => https://www.data_I_want_TO_get.com
    browser.close()

If the frame isn't immediately visible you can wait for it by replacing the src = line with

src = (
    page.wait_for_selector('iframe[title="IFRAME_NAME"]')
        .get_attribute("src")
)

After investigating and trying several things, looks like the problem is the user_agent of the browser when is in headless mode, for some reason the default user agent does not like to that page, try with:

def extract_html(self):
    with sync_playwright() as p:
        browser = p.chromium.launch(headless=True)
        page = browser.new_page(user_agent='Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/107.0.0.0 Safari/537.36')
        page.goto('http://book.flygofirst.com/Flight/Select?inl=0&CHD=0&s=True&o1=BOM&d1=BLR&ADT=1&dd1=2022-12-10&gl=0&glo=0&cc=INR&mon=true')
        html = page.inner_html('#sectionBody')
        return html

as mentioned in https://github.com/microsoft/playwright-python/issues/480

Jupyter notebook uses asyncio event loop, so you should use async api.

from playwright.async_api import async_playwright

playwright = await async_playwright().start()
browser = await playwright.chromium.launch(headless = False)
page = await browser.new_page()

await page.goto("http://whatsmyuseragent.org/")

# await page.screenshot(path="example.png")
# await browser.close()
# await playwright.stop()

If you use sync API, it will throw an Error like this:

from playwright.sync_api import sync_playwright
playwright = sync_playwright().start()

'''
Error: It looks like you are using Playwright Sync API inside the asyncio loop.
Please use the Async API instead.
'''

Playwright will work with proprietary Chromium-based browsers (including Opera, Edge, Chrome etc.), you can install the browser independently from Playwright and then pass path to its executable via execuable_path launch option:

browser = playwrights.chromium.launch(executable_path='/opt/path_to_opera_bin')

For automating WebKit and Firefox Playwright currently requires remote debugging protocol which is only available in the custom builds.