playwright-ruby-client 0.0.8 → 1.58.1.alpha1

data/lib/playwright_api/page_assertions.rb

@@ -0,0 +1,60 @@
+module Playwright
+  #
+  # The `PageAssertions` class provides assertion methods that can be used to make assertions about the `Page` state in the tests.
+  #
+  # ```python sync
+  # import re
+  # from playwright.sync_api import Page, expect
+  #
+  # def test_navigates_to_login_page(page: Page) -> None:
+  #     # ..
+  #     page.get_by_text("Sign in").click()
+  #     expect(page).to_have_url(re.compile(r".*/login"))
+  # ```
+  class PageAssertions < PlaywrightApi
+
+    #
+    # The opposite of [`method: PageAssertions.toHaveTitle`].
+    def not_to_have_title(titleOrRegExp, timeout: nil)
+      wrap_impl(@impl.not_to_have_title(unwrap_impl(titleOrRegExp), timeout: unwrap_impl(timeout)))
+    end
+
+    #
+    # The opposite of [`method: PageAssertions.toHaveURL`].
+    def not_to_have_url(urlOrRegExp, ignoreCase: nil, timeout: nil)
+      wrap_impl(@impl.not_to_have_url(unwrap_impl(urlOrRegExp), ignoreCase: unwrap_impl(ignoreCase), timeout: unwrap_impl(timeout)))
+    end
+
+    #
+    # Ensures the page has the given title.
+    #
+    # **Usage**
+    #
+    # ```python sync
+    # import re
+    # from playwright.sync_api import expect
+    #
+    # # ...
+    # expect(page).to_have_title(re.compile(r".*checkout"))
+    # ```
+    def to_have_title(titleOrRegExp, timeout: nil)
+      wrap_impl(@impl.to_have_title(unwrap_impl(titleOrRegExp), timeout: unwrap_impl(timeout)))
+    end
+
+    #
+    # Ensures the page is navigated to the given URL.
+    #
+    # **Usage**
+    #
+    # ```python sync
+    # import re
+    # from playwright.sync_api import expect
+    #
+    # # ...
+    # expect(page).to_have_url(re.compile(".*checkout"))
+    # ```
+    def to_have_url(urlOrRegExp, ignoreCase: nil, timeout: nil)
+      wrap_impl(@impl.to_have_url(unwrap_impl(urlOrRegExp), ignoreCase: unwrap_impl(ignoreCase), timeout: unwrap_impl(timeout)))
+    end
+  end
+end

data/lib/playwright_api/playwright.rb

@@ -1,102 +1,37 @@
 module Playwright
+  #
   # Playwright module provides a method to launch a browser instance. The following is a typical example of using Playwright
   # to drive automation:
-  # 
   #
-  # ```js
-  # const { chromium, firefox, webkit } = require('playwright');
-  # 
-  # (async () => {
-  #   const browser = await chromium.launch();  // Or 'firefox' or 'webkit'.
-  #   const page = await browser.newPage();
-  #   await page.goto('http://example.com');
-  #   // other actions...
-  #   await browser.close();
-  # })();
-  # ```
-  # 
-  # ```python async
-  # import asyncio
-  # from playwright.async_api import async_playwright
-  # 
-  # async def run(playwright):
-  #     chromium = playwright.chromium # or "firefox" or "webkit".
-  #     browser = await chromium.launch()
-  #     page = await browser.new_page()
-  #     await page.goto("http://example.com")
-  #     # other actions...
-  #     await browser.close()
-  # 
-  # async def main():
-  #     async with async_playwright() as playwright:
-  #         await run(playwright)
-  # asyncio.run(main())
-  # ```
-  # 
   # ```python sync
-  # from playwright.sync_api import sync_playwright
-  # 
-  # def run(playwright):
+  # from playwright.sync_api import sync_playwright, Playwright
+  #
+  # def run(playwright: Playwright):
   #     chromium = playwright.chromium # or "firefox" or "webkit".
   #     browser = chromium.launch()
   #     page = browser.new_page()
   #     page.goto("http://example.com")
   #     # other actions...
   #     browser.close()
-  # 
+  #
   # with sync_playwright() as playwright:
   #     run(playwright)
   # ```
   class Playwright < PlaywrightApi
 
-    # This object can be used to launch or connect to Chromium, returning instances of `ChromiumBrowser`.
+    #
+    # This object can be used to launch or connect to Chromium, returning instances of `Browser`.
     def chromium # property
       wrap_impl(@impl.chromium)
     end
 
+    #
     # Returns a dictionary of devices to be used with [`method: Browser.newContext`] or [`method: Browser.newPage`].
-    # 
     #
-    # ```js
-    # const { webkit, devices } = require('playwright');
-    # const iPhone = devices['iPhone 6'];
-    # 
-    # (async () => {
-    #   const browser = await webkit.launch();
-    #   const context = await browser.newContext({
-    #     ...iPhone
-    #   });
-    #   const page = await context.newPage();
-    #   await page.goto('http://example.com');
-    #   // other actions...
-    #   await browser.close();
-    # })();
-    # ```
-    # 
-    # ```python async
-    # import asyncio
-    # from playwright.async_api import async_playwright
-    # 
-    # async def run(playwright):
-    #     webkit = playwright.webkit
-    #     iphone = playwright.devices["iPhone 6"]
-    #     browser = await webkit.launch()
-    #     context = await browser.new_context(**iphone)
-    #     page = await context.new_page()
-    #     await page.goto("http://example.com")
-    #     # other actions...
-    #     await browser.close()
-    # 
-    # async def main():
-    #     async with async_playwright() as playwright:
-    #         await run(playwright)
-    # asyncio.run(main())
-    # ```
-    # 
     # ```python sync
-    # from playwright.sync_api import sync_playwright
-    # 
-    # def run(playwright):
+    # from playwright.sync_api import sync_playwright, Playwright
+    #
+    # def run(playwright: Playwright):
     #     webkit = playwright.webkit
     #     iphone = playwright.devices["iPhone 6"]
     #     browser = webkit.launch()
@@ -105,7 +40,7 @@ module Playwright
     #     page.goto("http://example.com")
     #     # other actions...
     #     browser.close()
-    # 
+    #
     # with sync_playwright() as playwright:
     #     run(playwright)
     # ```
@@ -113,58 +48,51 @@ module Playwright
       wrap_impl(@impl.devices)
     end
 
-    # Playwright methods might throw errors if they are unable to fulfill a request. For example,
-    # [`method: Page.waitForSelector`] might fail if the selector doesn't match any nodes during the given timeframe.
-    # 
-    # For certain types of errors Playwright uses specific error classes. These classes are available via
-    # [`playwright.errors`](#playwrighterrors).
-    # 
-    # An example of handling a timeout error:
-    # 
     #
-    # ```js
-    # try {
-    #   await page.waitForSelector('.foo');
-    # } catch (e) {
-    #   if (e instanceof playwright.errors.TimeoutError) {
-    #     // Do something if this is a timeout.
-    #   }
-    # }
-    # ```
-    # 
-    # ```python async
-    # try:
-    #     await page.wait_for_selector(".foo")
-    # except TimeoutError as e:
-    #     # do something if this is a timeout.
-    # ```
-    # 
-    # ```python sync
-    # try:
-    #     page.wait_for_selector(".foo")
-    # except TimeoutError as e:
-    #     # do something if this is a timeout.
-    # ```
-    def errors # property
-      raise NotImplementedError.new('errors is not implemented yet.')
-    end
-
-    # This object can be used to launch or connect to Firefox, returning instances of `FirefoxBrowser`.
+    # This object can be used to launch or connect to Firefox, returning instances of `Browser`.
     def firefox # property
       wrap_impl(@impl.firefox)
     end
 
+    #
+    # Exposes API that can be used for the Web API testing.
+    def request # property
+      raise NotImplementedError.new('request is not implemented yet.')
+    end
+
+    #
     # Selectors can be used to install custom selector engines. See
-    # [Working with selectors](./selectors.md#working-with-selectors) for more information.
+    # [extensibility](../extensibility.md) for more information.
     def selectors # property
-      raise NotImplementedError.new('selectors is not implemented yet.')
+      wrap_impl(@impl.selectors)
     end
 
-    # This object can be used to launch or connect to WebKit, returning instances of `WebKitBrowser`.
+    #
+    # This object can be used to launch or connect to WebKit, returning instances of `Browser`.
     def webkit # property
       wrap_impl(@impl.webkit)
     end
 
+    #
+    # Terminates this instance of Playwright in case it was created bypassing the Python context manager. This is useful in REPL applications.
+    #
+    # ```py
+    # from playwright.sync_api import sync_playwright
+    #
+    # playwright = sync_playwright().start()
+    #
+    # browser = playwright.chromium.launch()
+    # page = browser.new_page()
+    # page.goto("https://playwright.dev/")
+    # page.screenshot(path="example.png")
+    # browser.close()
+    #
+    # playwright.stop()
+    # ```
+    def stop
+      raise NotImplementedError.new('stop is not implemented yet.')
+    end
+
     # @nodoc
     def android
       wrap_impl(@impl.android)
@@ -177,20 +105,24 @@ module Playwright
 
     # -- inherited from EventEmitter --
     # @nodoc
-    def on(event, callback)
-      wrap_impl(@impl.on(unwrap_impl(event), unwrap_impl(callback)))
+    def once(event, callback)
+      event_emitter_proxy.once(event, callback)
     end
 
     # -- inherited from EventEmitter --
     # @nodoc
-    def off(event, callback)
-      wrap_impl(@impl.off(unwrap_impl(event), unwrap_impl(callback)))
+    def on(event, callback)
+      event_emitter_proxy.on(event, callback)
     end
 
     # -- inherited from EventEmitter --
     # @nodoc
-    def once(event, callback)
-      wrap_impl(@impl.once(unwrap_impl(event), unwrap_impl(callback)))
+    def off(event, callback)
+      event_emitter_proxy.off(event, callback)
+    end
+
+    private def event_emitter_proxy
+      @event_emitter_proxy ||= EventEmitterProxy.new(self, @impl)
     end
   end
 end

data/lib/playwright_api/request.rb

@@ -1,30 +1,33 @@
 module Playwright
+  #
   # Whenever the page sends a request for a network resource the following sequence of events are emitted by `Page`:
   # - [`event: Page.request`] emitted when the request is issued by the page.
   # - [`event: Page.response`] emitted when/if the response status and headers are received for the request.
-  # - [`event: Page.requestfinished`] emitted when the response body is downloaded and the request is complete.
-  # 
+  # - [`event: Page.requestFinished`] emitted when the response body is downloaded and the request is complete.
+  #
   # If request fails at some point, then instead of `'requestfinished'` event (and possibly instead of 'response' event),
-  # the  [`event: Page.requestfailed`] event is emitted.
-  # 
-  # > NOTE: HTTP Error responses, such as 404 or 503, are still successful responses from HTTP standpoint, so request will
-  # complete with `'requestfinished'` event.
-  # 
-  # If request gets a 'redirect' response, the request is successfully finished with the 'requestfinished' event, and a new
+  # the  [`event: Page.requestFailed`] event is emitted.
+  #
+  # **NOTE**: HTTP Error responses, such as 404 or 503, are still successful responses from HTTP standpoint, so request will complete
+  # with `'requestfinished'` event.
+  #
+  # If request gets a 'redirect' response, the request is successfully finished with the `requestfinished` event, and a new
   # request is  issued to a redirected url.
   class Request < PlaywrightApi
 
+    #
+    # An object with all the request HTTP headers associated with this request. The header names are lower-cased.
+    def all_headers
+      wrap_impl(@impl.all_headers)
+    end
+
+    #
     # The method returns `null` unless this request has failed, as reported by `requestfailed` event.
-    # 
+    #
+    # **Usage**
+    #
     # Example of logging of all the failed requests:
-    # 
     #
-    # ```js
-    # page.on('requestfailed', request => {
-    #   console.log(request.url() + ' ' + request.failure().errorText);
-    # });
-    # ```
-    # 
     # ```py
     # page.on("requestfailed", lambda request: print(request.url + " " + request.failure))
     # ```
@@ -32,81 +35,101 @@ module Playwright
       wrap_impl(@impl.failure)
     end
 
+    #
     # Returns the `Frame` that initiated this request.
+    #
+    # **Usage**
+    #
+    # ```py
+    # frame_url = request.frame.url
+    # ```
+    #
+    # **Details**
+    #
+    # Note that in some cases the frame is not available, and this method will throw.
+    # - When request originates in the Service Worker. You can use `request.serviceWorker()` to check that.
+    # - When navigation request is issued before the corresponding frame is created. You can use [`method: Request.isNavigationRequest`] to check that.
+    #
+    # Here is an example that handles all the cases:
     def frame
       wrap_impl(@impl.frame)
     end
 
-    # An object with HTTP headers associated with the request. All header names are lower-case.
+    #
+    # An object with the request HTTP headers. The header names are lower-cased.
+    # Note that this method does not return security-related headers, including cookie-related ones.
+    # You can use [`method: Request.allHeaders`] for complete list of headers that include `cookie` information.
     def headers
       wrap_impl(@impl.headers)
     end
 
+    #
+    # An array with all the request HTTP headers associated with this request. Unlike [`method: Request.allHeaders`], header names are NOT lower-cased.
+    # Headers with multiple entries, such as `Set-Cookie`, appear in the array multiple times.
+    def headers_array
+      wrap_impl(@impl.headers_array)
+    end
+
+    #
+    # Returns the value of the header matching the name. The name is case-insensitive.
+    def header_value(name)
+      wrap_impl(@impl.header_value(unwrap_impl(name)))
+    end
+
+    #
     # Whether this request is driving frame's navigation.
+    #
+    # Some navigation requests are issued before the corresponding frame is created, and therefore
+    # do not have [`method: Request.frame`] available.
     def navigation_request?
       wrap_impl(@impl.navigation_request?)
     end
 
+    #
     # Request's method (GET, POST, etc.)
     def method
       wrap_impl(@impl.method)
     end
 
+    #
     # Request's post body, if any.
     def post_data
       wrap_impl(@impl.post_data)
     end
 
+    #
     # Request's post body in a binary form, if any.
     def post_data_buffer
       wrap_impl(@impl.post_data_buffer)
     end
 
+    #
     # Returns parsed request's body for `form-urlencoded` and JSON as a fallback if any.
-    # 
+    #
     # When the response is `application/x-www-form-urlencoded` then a key/value object of the values will be returned.
     # Otherwise it will be parsed as JSON.
     def post_data_json
       wrap_impl(@impl.post_data_json)
     end
 
+    #
     # Request that was redirected by the server to this one, if any.
-    # 
+    #
     # When the server responds with a redirect, Playwright creates a new `Request` object. The two requests are connected by
     # `redirectedFrom()` and `redirectedTo()` methods. When multiple server redirects has happened, it is possible to
     # construct the whole redirect chain by repeatedly calling `redirectedFrom()`.
-    # 
+    #
+    # **Usage**
+    #
     # For example, if the website `http://example.com` redirects to `https://example.com`:
-    # 
     #
-    # ```js
-    # const response = await page.goto('http://example.com');
-    # console.log(response.request().redirectedFrom().url()); // 'http://example.com'
-    # ```
-    # 
-    # ```python async
-    # response = await page.goto("http://example.com")
-    # print(response.request.redirected_from.url) # "http://example.com"
-    # ```
-    # 
     # ```python sync
     # response = page.goto("http://example.com")
     # print(response.request.redirected_from.url) # "http://example.com"
     # ```
-    # 
+    #
     # If the website `https://google.com` has no redirects:
-    # 
     #
-    # ```js
-    # const response = await page.goto('https://google.com');
-    # console.log(response.request().redirectedFrom()); // null
-    # ```
-    # 
-    # ```python async
-    # response = await page.goto("https://google.com")
-    # print(response.request.redirected_from) # None
-    # ```
-    # 
     # ```python sync
     # response = page.goto("https://google.com")
     # print(response.request.redirected_from) # None
@@ -115,15 +138,13 @@ module Playwright
       wrap_impl(@impl.redirected_from)
     end
 
+    #
     # New request issued by the browser if the server responded with redirect.
-    # 
+    #
+    # **Usage**
+    #
     # This method is the opposite of [`method: Request.redirectedFrom`]:
-    # 
     #
-    # ```js
-    # console.log(request.redirectedFrom().redirectedTo() === request); // true
-    # ```
-    # 
     # ```py
     # assert request.redirected_from.redirected_to == request
     # ```
@@ -131,6 +152,7 @@ module Playwright
       wrap_impl(@impl.redirected_to)
     end
 
+    #
     # Contains the request's resource type as it was perceived by the rendering engine. ResourceType will be one of the
     # following: `document`, `stylesheet`, `image`, `media`, `font`, `script`, `texttrack`, `xhr`, `fetch`, `eventsource`,
     # `websocket`, `manifest`, `other`.
@@ -138,31 +160,37 @@ module Playwright
       wrap_impl(@impl.resource_type)
     end
 
+    #
     # Returns the matching `Response` object, or `null` if the response was not received due to error.
     def response
       wrap_impl(@impl.response)
     end
 
+    #
+    # The Service `Worker` that is performing the request.
+    #
+    # **Details**
+    #
+    # This method is Chromium only. It's safe to call when using other browsers, but it will always be `null`.
+    #
+    # Requests originated in a Service Worker do not have a [`method: Request.frame`] available.
+    def service_worker
+      raise NotImplementedError.new('service_worker is not implemented yet.')
+    end
+
+    #
+    # Returns resource size information for given request.
+    def sizes
+      wrap_impl(@impl.sizes)
+    end
+
+    #
     # Returns resource timing information for given request. Most of the timing values become available upon the response,
     # `responseEnd` becomes available when request finishes. Find more information at
     # [Resource Timing API](https://developer.mozilla.org/en-US/docs/Web/API/PerformanceResourceTiming).
-    # 
-    #
-    # ```js
-    # const [request] = await Promise.all([
-    #   page.waitForEvent('requestfinished'),
-    #   page.goto('http://example.com')
-    # ]);
-    # console.log(request.timing());
-    # ```
-    # 
-    # ```python async
-    # async with page.expect_event("requestfinished") as request_info:
-    #     await page.goto("http://example.com")
-    # request = await request_info.value
-    # print(request.timing)
-    # ```
-    # 
+    #
+    # **Usage**
+    #
     # ```python sync
     # with page.expect_event("requestfinished") as request_info:
     #     page.goto("http://example.com")
@@ -173,32 +201,42 @@ module Playwright
       wrap_impl(@impl.timing)
     end
 
+    #
     # URL of the request.
     def url
       wrap_impl(@impl.url)
     end
 
     # @nodoc
-    def after_initialize
-      wrap_impl(@impl.after_initialize)
+    def apply_fallback_overrides(overrides)
+      wrap_impl(@impl.apply_fallback_overrides(unwrap_impl(overrides)))
+    end
+
+    # @nodoc
+    def header_values(name)
+      wrap_impl(@impl.header_values(unwrap_impl(name)))
     end
 
     # -- inherited from EventEmitter --
     # @nodoc
-    def on(event, callback)
-      wrap_impl(@impl.on(unwrap_impl(event), unwrap_impl(callback)))
+    def once(event, callback)
+      event_emitter_proxy.once(event, callback)
     end
 
     # -- inherited from EventEmitter --
     # @nodoc
-    def off(event, callback)
-      wrap_impl(@impl.off(unwrap_impl(event), unwrap_impl(callback)))
+    def on(event, callback)
+      event_emitter_proxy.on(event, callback)
     end
 
     # -- inherited from EventEmitter --
     # @nodoc
-    def once(event, callback)
-      wrap_impl(@impl.once(unwrap_impl(event), unwrap_impl(callback)))
+    def off(event, callback)
+      event_emitter_proxy.off(event, callback)
+    end
+
+    private def event_emitter_proxy
+      @event_emitter_proxy ||= EventEmitterProxy.new(self, @impl)
     end
   end
 end