playwright-ruby-client 1.37.1 → 1.38.1

data/lib/playwright/locator_impl.rb

@@ -304,11 +304,7 @@ module Playwright
     end
 
     def all
-      Enumerator.new do |out|
-        count.times do |i|
-          out << nth(i)
-        end
-      end
+      count.times.map { |i| nth(i) }
     end
 
     def count
@@ -446,6 +442,10 @@ module Playwright
       @frame.type(@selector, text, strict: true, delay: delay, noWaitAfter: noWaitAfter, timeout: timeout)
     end
 
+    def press_sequentially(text, delay: nil, noWaitAfter: nil, timeout: nil)
+      type(text, delay: delay, noWaitAfter: noWaitAfter, timeout: timeout)
+    end
+
     def uncheck(
           force: nil,
           noWaitAfter: nil,
@@ -484,5 +484,28 @@ module Playwright
     def highlight
       @frame.highlight(@selector)
     end
+
+    def expect(expression, options)
+      if options.key?(:expectedValue)
+        options[:expectedValue] = JavaScript::ValueSerializer
+          .new(options[:expectedValue])
+          .serialize
+      end
+
+      result = @frame.channel.send_message_to_server_result(
+        "expect",
+        {
+          selector: @selector,
+          expression: expression,
+          **options,
+        }
+      )
+
+      if result.key?('received')
+        result['received'] = JavaScript::ValueParser.new(result['received']).parse
+      end
+
+      result
+    end
   end
 end

data/lib/playwright/test.rb

@@ -0,0 +1,68 @@
+module Playwright
+  # this module is responsible for running playwright assertions and integrating
+  # with test frameworks.
+  module Test
+    # ref: https://github.com/microsoft/playwright-python/blob/main/playwright/sync_api/__init__.py#L90
+    class Expect
+      def initialize
+        @timeout_settings = TimeoutSettings.new
+      end
+
+      def call(actual, message = nil)
+        if actual.is_a?(Locator)
+          LocatorAssertions.new(
+            LocatorAssertionsImpl.new(
+              actual,
+              @timeout_settings.timeout,
+              false,
+              message,
+            )
+          )
+        else
+          raise NotImplementedError.new("Only locator assertions are currently implemented")
+        end
+      end
+    end
+
+    module Matchers
+      class PlaywrightMatcher
+        def initialize(expectation_method, *args, **kwargs)
+          @method = expectation_method
+          @args = args
+          @kwargs = kwargs
+        end
+
+        def matches?(actual)
+          Expect.new.call(actual).send(@method, *@args, **@kwargs)
+          true
+        rescue AssertionError => e
+          @failure_message = e.full_message
+          false
+        end
+
+        def failure_message
+          @failure_message
+        end
+
+        # we have to invert the message again here because RSpec wants to control
+        # its own negation
+        def failure_message_when_negated
+          @failure_message.gsub("expected to", "not expected to")
+        end
+      end
+    end
+
+    ALL_ASSERTIONS = LocatorAssertions.instance_methods(false)
+
+    ALL_ASSERTIONS
+      .map(&:to_s)
+      .each do |method_name|
+        # to_be_visible => be_visible
+        # not_to_be_visible => not_be_visible
+        root_method_name = method_name.gsub("to_", "")
+        Matchers.define_method(root_method_name) do |*args, **kwargs| 
+          Matchers::PlaywrightMatcher.new(method_name, *args, **kwargs)
+        end
+      end
+  end
+end

data/lib/playwright/utils.rb

@@ -61,6 +61,10 @@ module Playwright
           end
         end
 
+        if params[:acceptDownloads] || params[:acceptDownloads] == false
+          params[:acceptDownloads] = params[:acceptDownloads] ? 'accept' : 'deny'
+        end
+
         params
       end
     end

data/lib/playwright/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module Playwright
-  VERSION = '1.37.1'
-  COMPATIBLE_PLAYWRIGHT_VERSION = '1.37.0'
+  VERSION = '1.38.1'
+  COMPATIBLE_PLAYWRIGHT_VERSION = '1.38.1'
 end

data/lib/playwright_api/download.rb

@@ -5,14 +5,17 @@ module Playwright
   # All the downloaded files belonging to the browser context are deleted when the
   # browser context is closed.
   #
-  # Download event is emitted once the download starts. Download path becomes available once download completes:
+  # Download event is emitted once the download starts. Download path becomes available once download completes.
   #
   # ```python sync
+  # # Start waiting for the download
   # with page.expect_download() as download_info:
+  #     # Perform the action that initiates download
   #     page.get_by_text("Download file").click()
   # download = download_info.value
-  # # wait for download to complete
-  # path = download.path()
+  #
+  # # Wait for the download process to complete and save the downloaded file somewhere
+  # download.save_as("/path/to/save/at/" + download.suggested_filename)
   # ```
   class Download < PlaywrightApi
 
@@ -54,6 +57,12 @@ module Playwright
     #
     # Copy the download to a user-specified path. It is safe to call this method while the download
     # is still in progress. Will wait for the download to finish if necessary.
+    #
+    # **Usage**
+    #
+    # ```python sync
+    # download.save_as("/path/to/save/at/" + download.suggested_filename)
+    # ```
     def save_as(path)
       wrap_impl(@impl.save_as(unwrap_impl(path)))
     end

data/lib/playwright_api/element_handle.rb

@@ -224,7 +224,7 @@ module Playwright
     #
     # If the target element is not an `<input>`, `<textarea>` or `[contenteditable]` element, this method throws an error. However, if the element is inside the `<label>` element that has an associated [control](https://developer.mozilla.org/en-US/docs/Web/API/HTMLLabelElement/control), the control will be filled instead.
     #
-    # To send fine-grained keyboard events, use [`method: ElementHandle.type`].
+    # To send fine-grained keyboard events, use [`method: Locator.pressSequentially`].
     def fill(value, force: nil, noWaitAfter: nil, timeout: nil)
       wrap_impl(@impl.fill(unwrap_impl(value), force: unwrap_impl(force), noWaitAfter: unwrap_impl(noWaitAfter), timeout: unwrap_impl(timeout)))
     end
@@ -503,19 +503,6 @@ module Playwright
     # To press a special key, like `Control` or `ArrowDown`, use [`method: ElementHandle.press`].
     #
     # **Usage**
-    #
-    # ```python sync
-    # element_handle.type("hello") # types instantly
-    # element_handle.type("world", delay=100) # types slower, like a user
-    # ```
-    #
-    # An example of typing into a text field and then submitting the form:
-    #
-    # ```python sync
-    # element_handle = page.query_selector("input")
-    # element_handle.type("some text")
-    # element_handle.press("Enter")
-    # ```
     def type(text, delay: nil, noWaitAfter: nil, timeout: nil)
       wrap_impl(@impl.type(unwrap_impl(text), delay: unwrap_impl(delay), noWaitAfter: unwrap_impl(noWaitAfter), timeout: unwrap_impl(timeout)))
     end

data/lib/playwright_api/frame.rb

@@ -300,7 +300,7 @@ module Playwright
     #
     # If the target element is not an `<input>`, `<textarea>` or `[contenteditable]` element, this method throws an error. However, if the element is inside the `<label>` element that has an associated [control](https://developer.mozilla.org/en-US/docs/Web/API/HTMLLabelElement/control), the control will be filled instead.
     #
-    # To send fine-grained keyboard events, use [`method: Frame.type`].
+    # To send fine-grained keyboard events, use [`method: Locator.pressSequentially`].
     def fill(
           selector,
           value,
@@ -867,11 +867,6 @@ module Playwright
     # To press a special key, like `Control` or `ArrowDown`, use [`method: Keyboard.press`].
     #
     # **Usage**
-    #
-    # ```python sync
-    # frame.type("#mytextarea", "hello") # types instantly
-    # frame.type("#mytextarea", "world", delay=100) # types slower, like a user
-    # ```
     def type(
           selector,
           text,

data/lib/playwright_api/keyboard.rb

@@ -81,6 +81,8 @@ module Playwright
       wrap_impl(@impl.insert_text(unwrap_impl(text)))
     end
 
+    #
+    # **NOTE**: In most cases, you should use [`method: Locator.press`] instead.
     #
     # `key` can specify the intended
     # [keyboardEvent.key](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key) value or a single character to
@@ -119,6 +121,8 @@ module Playwright
       wrap_impl(@impl.press(unwrap_impl(key), delay: unwrap_impl(delay)))
     end
 
+    #
+    # **NOTE**: In most cases, you should use [`method: Locator.fill`] instead. You only need to press keys one by one if there is special keyboard handling on the page - in this case use [`method: Locator.pressSequentially`].
     #
     # Sends a `keydown`, `keypress`/`input`, and `keyup` event for each character in the text.
     #

data/lib/playwright_api/locator.rb

@@ -391,7 +391,7 @@ module Playwright
     #
     # If the target element is not an `<input>`, `<textarea>` or `[contenteditable]` element, this method throws an error. However, if the element is inside the `<label>` element that has an associated [control](https://developer.mozilla.org/en-US/docs/Web/API/HTMLLabelElement/control), the control will be filled instead.
     #
-    # To send fine-grained keyboard events, use [`method: Locator.type`].
+    # To send fine-grained keyboard events, use [`method: Locator.pressSequentially`].
     def fill(value, force: nil, noWaitAfter: nil, timeout: nil)
       wrap_impl(@impl.fill(unwrap_impl(value), force: unwrap_impl(force), noWaitAfter: unwrap_impl(noWaitAfter), timeout: unwrap_impl(timeout)))
     end
@@ -869,6 +869,31 @@ module Playwright
       wrap_impl(@impl.press(unwrap_impl(key), delay: unwrap_impl(delay), noWaitAfter: unwrap_impl(noWaitAfter), timeout: unwrap_impl(timeout)))
     end
 
+    #
+    # **NOTE**: In most cases, you should use [`method: Locator.fill`] instead. You only need to press keys one by one if there is special keyboard handling on the page.
+    #
+    # Focuses the element, and then sends a `keydown`, `keypress`/`input`, and `keyup` event for each character in the text.
+    #
+    # To press a special key, like `Control` or `ArrowDown`, use [`method: Locator.press`].
+    #
+    # **Usage**
+    #
+    # ```python sync
+    # locator.press_sequentially("hello") # types instantly
+    # locator.press_sequentially("world", delay=100) # types slower, like a user
+    # ```
+    #
+    # An example of typing into a text field and then submitting the form:
+    #
+    # ```python sync
+    # locator = page.get_by_label("Password")
+    # locator.press_sequentially("my password")
+    # locator.press("Enter")
+    # ```
+    def press_sequentially(text, delay: nil, noWaitAfter: nil, timeout: nil)
+      wrap_impl(@impl.press_sequentially(unwrap_impl(text), delay: unwrap_impl(delay), noWaitAfter: unwrap_impl(noWaitAfter), timeout: unwrap_impl(timeout)))
+    end
+
     #
     # Take a screenshot of the element matching the locator.
     #
@@ -1066,27 +1091,12 @@ module Playwright
       wrap_impl(@impl.text_content(timeout: unwrap_impl(timeout)))
     end
 
-    #
-    # **NOTE**: In most cases, you should use [`method: Locator.fill`] instead. You only need to type characters if there is special keyboard handling on the page.
     #
     # Focuses the element, and then sends a `keydown`, `keypress`/`input`, and `keyup` event for each character in the text.
     #
     # To press a special key, like `Control` or `ArrowDown`, use [`method: Locator.press`].
     #
     # **Usage**
-    #
-    # ```python sync
-    # element.type("hello") # types instantly
-    # element.type("world", delay=100) # types slower, like a user
-    # ```
-    #
-    # An example of typing into a text field and then submitting the form:
-    #
-    # ```python sync
-    # element = page.get_by_label("Password")
-    # element.type("my password")
-    # element.press("Enter")
-    # ```
     def type(text, delay: nil, noWaitAfter: nil, timeout: nil)
       wrap_impl(@impl.type(unwrap_impl(text), delay: unwrap_impl(delay), noWaitAfter: unwrap_impl(noWaitAfter), timeout: unwrap_impl(timeout)))
     end
@@ -1139,6 +1149,11 @@ module Playwright
       wrap_impl(@impl.wait_for(state: unwrap_impl(state), timeout: unwrap_impl(timeout)))
     end
 
+    # @nodoc
+    def expect(expression, options)
+      wrap_impl(@impl.expect(unwrap_impl(expression), unwrap_impl(options)))
+    end
+
     # @nodoc
     def to_s
       wrap_impl(@impl.to_s)