playwright-ruby-client 1.25.0 → 1.27.0

data/documentation/docs/api/page.md

@@ -276,6 +276,20 @@ def drag_and_drop(
       trial: nil)
 ```
 
+This method drags the source element to the target element. It will first move to the source element, perform a
+`mousedown`, then move to the target element and perform a `mouseup`.
+
+```ruby
+page.drag_and_drop("#source", "#target")
+# or specify exact positions relative to the top-left corners of the elements:
+page.drag_and_drop(
+  "#source",
+  "#target",
+  sourcePosition: { x: 34, y: 7 },
+  targetPosition: { x: 10, y: 20 },
+)
+```
+
 
 
 ## emulate_media
@@ -592,7 +606,7 @@ that iframe. Following snippet locates element with text "Submit" in the iframe
 id="my-frame">`:
 
 ```ruby
-locator = page.frame_locator("#my-iframe").locator("text=Submit")
+locator = page.frame_locator("#my-iframe").get_by_text("Submit")
 locator.click
 ```
 
@@ -614,6 +628,103 @@ def get_attribute(selector, name, strict: nil, timeout: nil)
 
 Returns element attribute value.
 
+## get_by_alt_text
+
+```
+def get_by_alt_text(text, exact: nil)
+```
+
+Allows locating elements by their alt text. For example, this method will find the image by alt text "Castle":
+
+```html
+<img alt='Castle'>
+```
+
+
+## get_by_label
+
+```
+def get_by_label(text, exact: nil)
+```
+
+Allows locating input elements by the text of the associated label. For example, this method will find the input by
+label text Password in the following DOM:
+
+```html
+<label for="password-input">Password:</label>
+<input id="password-input">
+```
+
+
+## get_by_placeholder
+
+```
+def get_by_placeholder(text, exact: nil)
+```
+
+Allows locating input elements by the placeholder text. For example, this method will find the input by placeholder
+"Country":
+
+```html
+<input placeholder="Country">
+```
+
+
+## get_by_role
+
+```
+def get_by_role(
+      role,
+      checked: nil,
+      disabled: nil,
+      expanded: nil,
+      includeHidden: nil,
+      level: nil,
+      name: nil,
+      pressed: nil,
+      selected: nil)
+```
+
+Allows locating elements by their [ARIA role](https://www.w3.org/TR/wai-aria-1.2/#roles),
+[ARIA attributes](https://www.w3.org/TR/wai-aria-1.2/#aria-attributes) and
+[accessible name](https://w3c.github.io/accname/#dfn-accessible-name). Note that role selector **does not replace**
+accessibility audits and conformance tests, but rather gives early feedback about the ARIA guidelines.
+
+Note that many html elements have an implicitly
+[defined role](https://w3c.github.io/html-aam/#html-element-role-mappings) that is recognized by the role selector. You
+can find all the [supported roles here](https://www.w3.org/TR/wai-aria-1.2/#role_definitions). ARIA guidelines **do not
+recommend** duplicating implicit roles and attributes by setting `role` and/or `aria-*` attributes to default values.
+
+## get_by_test_id
+
+```
+def get_by_test_id(testId)
+```
+
+Locate element by the test id. By default, the `data-testid` attribute is used as a test id. Use
+[Selectors#set_test_id_attribute](./selectors#set_test_id_attribute) to configure a different test id attribute if necessary.
+
+## get_by_text
+
+```
+def get_by_text(text, exact: nil)
+```
+
+Allows locating elements that contain given text.
+
+## get_by_title
+
+```
+def get_by_title(text, exact: nil)
+```
+
+Allows locating elements by their title. For example, this method will find the button by its title "Submit":
+
+```html
+<button title='Place the order'>Order Now</button>
+```
+
+
 ## go_back
 
 ```
@@ -780,14 +891,12 @@ considered not visible.
 def locator(selector, has: nil, hasText: nil)
 ```
 
-The method returns an element locator that can be used to perform actions on the page. Locator is resolved to the
-element immediately before performing an action, so a series of actions on the same locator can in fact be performed on
-different DOM elements. That would happen if the DOM structure between those actions has changed.
+The method returns an element locator that can be used to perform actions on this page / frame. Locator is resolved to
+the element immediately before performing an action, so a series of actions on the same locator can in fact be performed
+on different DOM elements. That would happen if the DOM structure between those actions has changed.
 
 [Learn more about locators](https://playwright.dev/python/docs/locators).
 
-Shortcut for main frame's [Frame#locator](./frame#locator).
-
 ## main_frame
 
 ```
@@ -1364,7 +1473,7 @@ value. Will throw an error if the page is closed before the event is fired. Retu
 
 ```ruby
 frame = page.expect_event("framenavigated") do
-  page.click("button")
+  page.get_by_role("button")
 end
 ```
 
@@ -1415,13 +1524,13 @@ This resolves when the page reaches a required load state, `load` by default. Th
 when this method is called. If current document has already reached the required state, resolves immediately.
 
 ```ruby
-page.click("button") # click triggers navigation.
+page.get_by_role("button").click # click triggers navigation.
 page.wait_for_load_state # the promise resolves after "load" event.
 ```
 
 ```ruby
 popup = page.expect_popup do
-  page.click("button") # click triggers a popup.
+  page.get_by_role("button").click # click triggers a popup.
 end
 
 # Following resolves after "domcontentloaded" event.
@@ -1541,7 +1650,7 @@ Returns when element specified by selector satisfies `state` option. Returns `nu
 `detached`.
 
 > NOTE: Playwright automatically waits for element to be ready before performing an action. Using [Locator](./locator) objects and
-web-first assertions make the code wait-for-selector-free.
+web-first assertions makes the code wait-for-selector-free.
 
 Wait for the `selector` to satisfy `state` option (either appear/disappear from dom, or become visible/hidden). If at
 the moment of calling the method `selector` already satisfies the condition, the method will return immediately. If the

data/documentation/docs/api/tracing.md

@@ -58,7 +58,7 @@ page = context.new_page
 page.goto("https://playwright.dev")
 
 context.tracing.start_chunk
-page.locator("text=Get Started").click
+page.get_by_text("Get Started").click
 # Everything between start_chunk and stop_chunk will be recorded in the trace.
 context.tracing.stop_chunk(path: "trace1.zip")
 

data/documentation/docs/article/guides/rails_integration_with_null_driver.md

@@ -84,3 +84,62 @@ describe 'example', driver: :null do
   end
 end
 ```
+
+## Minitest Usage
+
+We can do something similar with the default Rails setup using Minitest. Here's the same example written with Minitest:
+
+```rb
+# test/application_system_test_case.rb
+
+require 'playwright'
+
+class CapybaraNullDriver < Capybara::Driver::Base
+  def needs_server?
+    true
+  end
+end
+
+Capybara.register_driver(:null) { CapybaraNullDriver.new }
+
+class ApplicationSystemTestCase < ActionDispatch::SystemTestCase
+  driven_by :null
+
+  def self.playwright
+    @playwright ||= Playwright.create(playwright_cli_executable_path: Rails.root.join("node_modules/.bin/playwright"))
+  end
+  
+  def before_setup
+    super    
+    base_url = Capybara.current_session.server.base_url
+    @playwright_browser = self.class.playwright.playwright.chromium.launch(headless: false)
+    @playwright_page = @playwright_browser.new_page(baseURL: base_url)
+  end
+
+  def after_teardown
+    super
+    @browser.close
+  end
+end
+```
+
+And here is the same test:
+
+```rb
+require "application_system_test_case"
+
+class ExampleTest < ApplicationSystemTestCase
+  def setup
+    @user = User.create!
+    @page = @playwright_page
+  end
+
+  test 'can browse' do
+    @page.goto("/tests/#{user.id}")
+    @page.wait_for_selector('input').type('hoge')
+    @page.keyboard.press('Enter')
+    
+    assert @page.text_content('#content').include?('hoge')
+  end
+end
+```

data/documentation/docs/include/api_coverage.md

@@ -159,6 +159,13 @@
 * frame_element
 * frame_locator
 * get_attribute
+* get_by_alt_text
+* get_by_label
+* get_by_placeholder
+* get_by_role
+* get_by_test_id
+* get_by_text
+* get_by_title
 * goto
 * hover
 * inner_html
@@ -204,6 +211,7 @@
 ## Selectors
 
 * register
+* ~~set_test_id_attribute~~
 
 ## ConsoleMessage
 
@@ -258,6 +266,13 @@
 * frame_locator
 * frames
 * get_attribute
+* get_by_alt_text
+* get_by_label
+* get_by_placeholder
+* get_by_role
+* get_by_test_id
+* get_by_text
+* get_by_title
 * go_back
 * go_forward
 * goto
@@ -423,6 +438,13 @@
 * focus
 * frame_locator
 * get_attribute
+* get_by_alt_text
+* get_by_label
+* get_by_placeholder
+* get_by_role
+* get_by_test_id
+* get_by_text
+* get_by_title
 * highlight
 * hover
 * inner_html
@@ -455,6 +477,13 @@
 
 * first
 * frame_locator
+* get_by_alt_text
+* get_by_label
+* get_by_placeholder
+* get_by_role
+* get_by_test_id
+* get_by_text
+* get_by_title
 * last
 * locator
 * nth

data/documentation/src/components/HomepageFeatures.js

@@ -13,7 +13,7 @@ const FeatureList = [
     ),
   },
   {
-    title: 'Make more relyable tests',
+    title: 'Make more reliable tests',
     Svg: require('../../static/img/undraw_dropdown_menu.svg').default,
     description: (
       <>

data/lib/playwright/channel_owners/api_request_context.rb

@@ -10,136 +10,34 @@ module Playwright
       @channel.send_message_to_server('dispose')
     end
 
-    def delete(
-          url,
-          data: nil,
-          failOnStatusCode: nil,
-          form: nil,
-          headers: nil,
-          ignoreHTTPSErrors: nil,
-          multipart: nil,
-          params: nil,
-          timeout: nil)
-      fetch(
-        url,
-        method: 'DELETE',
-        data: data,
-        failOnStatusCode: failOnStatusCode,
-        form: form,
-        headers: headers,
-        ignoreHTTPSErrors: ignoreHTTPSErrors,
-        multipart: multipart,
-        params: params,
-        timeout: timeout,
-      )
+    def delete(url, **options)
+      fetch_options = options.merge(method: 'DELETE')
+      fetch(url, **fetch_options)
     end
 
-    def head(
-          url,
-          failOnStatusCode: nil,
-          headers: nil,
-          ignoreHTTPSErrors: nil,
-          params: nil,
-          timeout: nil)
-      fetch(
-        url,
-        method: 'HEAD',
-        failOnStatusCode: failOnStatusCode,
-        headers: headers,
-        ignoreHTTPSErrors: ignoreHTTPSErrors,
-        params: params,
-        timeout: timeout,
-      )
+    def head(url, **options)
+      fetch_options = options.merge(method: 'HEAD')
+      fetch(url, **fetch_options)
     end
 
-    def get(
-          url,
-          failOnStatusCode: nil,
-          headers: nil,
-          ignoreHTTPSErrors: nil,
-          params: nil,
-          timeout: nil)
-      fetch(
-        url,
-        method: 'GET',
-        failOnStatusCode: failOnStatusCode,
-        headers: headers,
-        ignoreHTTPSErrors: ignoreHTTPSErrors,
-        params: params,
-        timeout: timeout,
-      )
+    def get(url, **options)
+      fetch_options = options.merge(method: 'GET')
+      fetch(url, **fetch_options)
     end
 
-    def patch(
-          url,
-          data: nil,
-          failOnStatusCode: nil,
-          form: nil,
-          headers: nil,
-          ignoreHTTPSErrors: nil,
-          multipart: nil,
-          params: nil,
-          timeout: nil)
-      fetch(
-        url,
-        method: 'PATCH',
-        data: data,
-        failOnStatusCode: failOnStatusCode,
-        form: form,
-        headers: headers,
-        ignoreHTTPSErrors: ignoreHTTPSErrors,
-        multipart: multipart,
-        params: params,
-        timeout: timeout,
-      )
+    def patch(url, **options)
+      fetch_options = options.merge(method: 'PATCH')
+      fetch(url, **fetch_options)
     end
 
-    def put(
-          url,
-          data: nil,
-          failOnStatusCode: nil,
-          form: nil,
-          headers: nil,
-          ignoreHTTPSErrors: nil,
-          multipart: nil,
-          params: nil,
-          timeout: nil)
-      fetch(
-        url,
-        method: 'PUT',
-        data: data,
-        failOnStatusCode: failOnStatusCode,
-        form: form,
-        headers: headers,
-        ignoreHTTPSErrors: ignoreHTTPSErrors,
-        multipart: multipart,
-        params: params,
-        timeout: timeout,
-      )
+    def put(url, **options)
+      fetch_options = options.merge(method: 'PUT')
+      fetch(url, **fetch_options)
     end
 
-    def post(
-          url,
-          data: nil,
-          failOnStatusCode: nil,
-          form: nil,
-          headers: nil,
-          ignoreHTTPSErrors: nil,
-          multipart: nil,
-          params: nil,
-          timeout: nil)
-      fetch(
-        url,
-        method: 'POST',
-        data: data,
-        failOnStatusCode: failOnStatusCode,
-        form: form,
-        headers: headers,
-        ignoreHTTPSErrors: ignoreHTTPSErrors,
-        multipart: multipart,
-        params: params,
-        timeout: timeout,
-      )
+    def post(url, **options)
+      fetch_options = options.merge(method: 'POST')
+      fetch(url, **fetch_options)
     end
 
     def fetch(
@@ -149,6 +47,7 @@ module Playwright
           form: nil,
           headers: nil,
           ignoreHTTPSErrors: nil,
+          maxRedirects: nil,
           method: nil,
           multipart: nil,
           params: nil,
@@ -160,6 +59,9 @@ module Playwright
       if [data, form, multipart].compact.count > 1
         raise ArgumentError.new("Only one of 'data', 'form' or 'multipart' can be specified")
       end
+      if maxRedirects && maxRedirects < 0
+        raise ArgumentError.new("'maxRedirects' should be greater than or equal to '0'")
+      end
 
       request = urlOrRequest.is_a?(ChannelOwners::Request) ? urlOrRequest : nil
       headers_obj = headers || request&.headers
@@ -212,6 +114,7 @@ module Playwright
       fetch_params[:timeout] = timeout
       fetch_params[:failOnStatusCode] = failOnStatusCode
       fetch_params[:ignoreHTTPSErrors] = ignoreHTTPSErrors
+      fetch_params[:maxRedirects] = maxRedirects
       fetch_params.compact!
       response = @channel.send_message_to_server('fetch', fetch_params)
 

data/lib/playwright/channel_owners/browser_context.rb

@@ -26,7 +26,7 @@ module Playwright
       @channel.on('page', ->(params) { on_page(ChannelOwners::Page.from(params['page']) )})
       @channel.on('route', ->(params) {
         Concurrent::Promises.future {
-          on_route(ChannelOwners::Route.from(params['route']), ChannelOwners::Request.from(params['request']))
+          on_route(ChannelOwners::Route.from(params['route']))
         }.rescue do |err|
           puts err, err.backtrace
         end
@@ -83,22 +83,21 @@ module Playwright
       emit(Events::BrowserContext::BackgroundPage, page)
     end
 
-    private def on_route(route, request)
+    private def on_route(route)
       # It is not desired to use PlaywrightApi.wrap directly.
       # However it is a little difficult to define wrapper for `handler` parameter in generate_api.
       # Just a workaround...
       wrapped_route = PlaywrightApi.wrap(route)
-      wrapped_request = PlaywrightApi.wrap(request)
 
       handled = @routes.any? do |handler_entry|
-        next false unless handler_entry.match?(request.url)
+        next false unless handler_entry.match?(route.request.url)
 
         promise = Concurrent::Promises.resolvable_future
         route.send(:set_handling_future, promise)
 
         promise_handled = Concurrent::Promises.zip(
           promise,
-          handler_entry.async_handle(wrapped_route, wrapped_request)
+          handler_entry.async_handle(wrapped_route)
         ).value!.first
 
         promise_handled

data/lib/playwright/channel_owners/dialog.rb

@@ -13,7 +13,7 @@ module Playwright
     end
 
     def accept(promptText: nil)
-      accept_async(prompt_text: promptText).value!
+      accept_async(promptText: promptText).value!
     end
 
     def accept_async(promptText: nil)

data/lib/playwright/channel_owners/frame.rb

@@ -1,6 +1,10 @@
+require_relative '../locator_utils'
+
 module Playwright
   # @ref https://github.com/microsoft/playwright-python/blob/master/playwright/_impl/_frame.py
   define_channel_owner :Frame do
+    include LocatorUtils
+
     private def after_initialize
       if @initializer['parentFrame']
         @parent_frame = ChannelOwners::Frame.from(@initializer['parentFrame'])

data/lib/playwright/channel_owners/page.rb

@@ -1,9 +1,11 @@
 require 'base64'
+require_relative '../locator_utils'
 
 module Playwright
   # @ref https://github.com/microsoft/playwright-python/blob/master/playwright/_impl/_page.py
   define_channel_owner :Page do
     include Utils::Errors::SafeCloseError
+    include LocatorUtils
     attr_writer :owned_context
 
     private def after_initialize
@@ -58,7 +60,7 @@ module Playwright
       })
       @channel.on('route', ->(params) {
         Concurrent::Promises.future {
-          on_route(ChannelOwners::Route.from(params['route']), ChannelOwners::Request.from(params['request']))
+          on_route(ChannelOwners::Route.from(params['route']))
         }.rescue do |err|
           puts err, err.backtrace
         end
@@ -93,22 +95,21 @@ module Playwright
       emit(Events::Page::FrameDetached, frame)
     end
 
-    private def on_route(route, request)
+    private def on_route(route)
       # It is not desired to use PlaywrightApi.wrap directly.
       # However it is a little difficult to define wrapper for `handler` parameter in generate_api.
       # Just a workaround...
       wrapped_route = PlaywrightApi.wrap(route)
-      wrapped_request = PlaywrightApi.wrap(request)
 
       handled = @routes.any? do |handler_entry|
-        next false unless handler_entry.match?(request.url)
+        next false unless handler_entry.match?(route.request.url)
 
         promise = Concurrent::Promises.resolvable_future
         route.send(:set_handling_future, promise)
 
         promise_handled = Concurrent::Promises.zip(
           promise,
-          handler_entry.async_handle(wrapped_route, wrapped_request)
+          handler_entry.async_handle(wrapped_route)
         ).value!.first
 
         promise_handled
@@ -120,7 +121,7 @@ module Playwright
       end
 
       unless handled
-        @browser_context.send(:on_route, route, request)
+        @browser_context.send(:on_route, route)
       end
     end
 

data/lib/playwright/channel_owners/selectors.rb

@@ -18,5 +18,9 @@ module Playwright
 
       nil
     end
+
+    def text_id_attribute=(attribute_name)
+      ::Playwright::LocatorUtils.instance_variable_set(:@test_id_attribute_name, attribute_name)
+    end
   end
 end

data/lib/playwright/frame_locator_impl.rb

@@ -1,5 +1,9 @@
+require_relative './locator_utils'
+
 module Playwright
   define_api_implementation :FrameLocatorImpl do
+    include LocatorUtils
+
     def initialize(frame:, timeout_settings:, frame_selector:)
       @frame = frame
       @timeout_settings = timeout_settings
@@ -10,7 +14,7 @@ module Playwright
       LocatorImpl.new(
         frame: @frame,
         timeout_settings: @timeout_settings,
-        selector: "#{@frame_selector} >> control=enter-frame >> #{selector}",
+        selector: "#{@frame_selector} >> internal:control=enter-frame >> #{selector}",
         hasText: hasText,
         has: has,
       )
@@ -20,7 +24,7 @@ module Playwright
       FrameLocatorImpl.new(
         frame: @frame,
         timeout_settings: @timeout_settings,
-        frame_selector: "#{@frame_selector} >> control=enter-frame >> #{selector}",
+        frame_selector: "#{@frame_selector} >> internal:control=enter-frame >> #{selector}",
       )
     end