playwright-ruby-client 1.37.1 → 1.38.1

data/documentation/docs/api/request.md

@@ -54,6 +54,20 @@ def frame
 
 Returns the [Frame](./frame) that initiated this request.
 
+**Usage**
+
+```ruby
+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 [Request#navigation_request?](./request#navigation_request?) to check that.
+
+Here is an example that handles all the cases:
+
 ## headers
 
 ```
@@ -93,6 +107,9 @@ def navigation_request?
 
 Whether this request is driving frame's navigation.
 
+Some navigation requests are issued before the corresponding frame is created, and therefore
+do not have [Request#frame](./request#frame) available.
+
 ## method
 
 ```

data/documentation/docs/include/api_coverage.md

@@ -470,6 +470,7 @@
 * or
 * page
 * press
+* press_sequentially
 * screenshot
 * scroll_into_view_if_needed
 * select_option
@@ -526,6 +527,49 @@
 
 * ~~new_context~~
 
+## LocatorAssertions
+
+* not_to_be_attached
+* not_to_be_checked
+* not_to_be_disabled
+* not_to_be_editable
+* not_to_be_empty
+* not_to_be_enabled
+* not_to_be_focused
+* not_to_be_hidden
+* not_to_be_in_viewport
+* not_to_be_visible
+* not_to_contain_text
+* not_to_have_attribute
+* not_to_have_class
+* not_to_have_count
+* not_to_have_css
+* not_to_have_id
+* not_to_have_js_property
+* not_to_have_text
+* not_to_have_value
+* not_to_have_values
+* to_be_attached
+* to_be_checked
+* to_be_disabled
+* to_be_editable
+* to_be_empty
+* to_be_enabled
+* to_be_focused
+* to_be_hidden
+* to_be_in_viewport
+* to_be_visible
+* to_contain_text
+* to_have_attribute
+* to_have_class
+* to_have_count
+* to_have_css
+* to_have_id
+* to_have_js_property
+* to_have_text
+* to_have_value
+* to_have_values
+
 ## Android
 
 * ~~connect~~

data/lib/playwright/channel.rb

@@ -46,7 +46,7 @@ module Playwright
 
     private def with_logging(&block)
       locations = caller_locations
-      first_api_call_location_idx = locations.index { |loc| loc.absolute_path.include?('playwright_api') }
+      first_api_call_location_idx = locations.index { |loc| loc.absolute_path&.include?('playwright_api') }
       unless first_api_call_location_idx
         return block.call(nil)
       end

data/lib/playwright/channel_owners/browser_context.rb

@@ -38,6 +38,12 @@ module Playwright
       @channel.on('console', ->(params) {
         on_console_message(ChannelOwners::ConsoleMessage.from(params['message']))
       })
+      @channel.on('pageError', ->(params) {
+        on_page_error(
+          Error.parse(params['error']['error']),
+          ChannelOwners::Page.from_nullable(params['page']),
+        )
+      })
       @channel.on('dialog', ->(params) {
         on_dialog(ChannelOwners::Dialog.from(params['dialog']))
       })
@@ -97,6 +103,8 @@ module Playwright
     end
 
     private def on_route(route)
+      route.send(:update_context, self)
+
       # 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...
@@ -177,6 +185,13 @@ module Playwright
       end
     end
 
+    private def on_page_error(error, page)
+      emit(Events::BrowserContext::WebError, WebError.new(error, page))
+      if page
+        page.emit(Events::Page::PageError, error)
+      end
+    end
+
     private def on_request(request, page)
       emit(Events::BrowserContext::Request, request)
       page&.emit(Events::Page::Request, request)

data/lib/playwright/channel_owners/page.rb

@@ -96,6 +96,8 @@ module Playwright
     end
 
     private def on_route(route)
+      route.send(:update_context, self)
+
       # 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...

data/lib/playwright/channel_owners/request.rb

@@ -86,8 +86,24 @@ module Playwright
       ChannelOwners::Response.from_nullable(resp)
     end
 
+    class FramePageNotReadyError < StandardError
+      MESSAGE = [
+        'Frame for this navigation request is not available, because the request',
+        'was issued before the frame is created. You can check whether the request',
+        'is a navigation request by calling isNavigationRequest() method.',
+      ].join('\n').freeze
+
+      def initialize
+        super(MESSAGE)
+      end
+    end
+
     def frame
-      ChannelOwners::Frame.from(@initializer['frame'])
+      ChannelOwners::Frame.from(@initializer['frame']).tap do |result|
+        unless result.page
+          raise FramePageNotReadyError.new
+        end
+      end
     end
 
     def navigation_request?

data/lib/playwright/channel_owners/route.rb

@@ -111,7 +111,7 @@ module Playwright
     end
 
     def fetch(headers: nil, method: nil, postData: nil, url: nil, maxRedirects: nil, timeout: nil)
-      api_request_context = request.frame.page.context.request
+      api_request_context = @context.request
       api_request_context.send(:_inner_fetch,
         request,
         url,
@@ -172,5 +172,9 @@ module Playwright
       mime_types = MIME::Types.type_for(filepath)
       mime_types.first.to_s || 'application/octet-stream'
     end
+
+    private def update_context(context)
+      @context = context
+    end
   end
 end

data/lib/playwright/errors.rb

@@ -5,13 +5,13 @@ module Playwright
       if error_payload['name'] == 'TimeoutError'
         TimeoutError.new(
           message: error_payload['message'],
-          stack: error_payload['stack'].split("\n"),
+          stack: error_payload['stack'],
         )
       else
         new(
           name: error_payload['name'],
           message: error_payload['message'],
-          stack: error_payload['stack'].split("\n"),
+          stack: error_payload['stack'],
         )
       end
     end
@@ -25,6 +25,8 @@ module Playwright
       @message = message
       @stack = stack
     end
+
+    attr_reader :name, :message, :stack
   end
 
   class DriverCrashedError < StandardError
@@ -38,4 +40,15 @@ module Playwright
       super(name: 'TimeoutError', message: message, stack: stack)
     end
   end
+
+  class WebError
+    def initialize(error, page)
+      @error = error
+      @page = PlaywrightApi.wrap(page)
+    end
+
+    attr_reader :error, :page
+  end
+
+  class AssertionError < StandardError; end
 end

data/lib/playwright/events.rb

@@ -29,6 +29,7 @@ end
     Console: 'console',
     Dialog: 'dialog',
     Page: 'page',
+    WebError: 'weberror',
     ServiceWorker: 'serviceworker',
     Request: 'request',
     Response: 'response',

data/lib/playwright/javascript/value_parser.rb

@@ -56,6 +56,14 @@ module Playwright
           return hash['bi'].to_i
         end
 
+        if hash.key?('m')
+          return parse_hash(hash['m']).to_h
+        end
+
+        if hash.key?('se')
+          return Set.new(parse_hash(hash['se']))
+        end
+
         if hash.key?('r')
           # @see https://developer.mozilla.org/ja/docs/Web/JavaScript/Reference/Global_Objects/RegExp
           # @see https://docs.ruby-lang.org/ja/latest/class/Regexp.html

data/lib/playwright/javascript/value_serializer.rb

@@ -24,7 +24,7 @@ module Playwright
           @handles << value.channel
           { h: index }
         when nil
-          { v: 'undefined' }
+          { v: 'null' }
         when Float::NAN
           { v: 'NaN'}
         when Float::INFINITY
@@ -56,11 +56,17 @@ module Playwright
           result = []
           value.each { |v| result << serialize_value(v) }
           { a: result, id: id }
+        when Set
+          { se: serialize_value(value.to_a) }
         when Hash
-          id = @visited.log(value)
-          result = []
-          value.each { |key, v| result << { k: key, v: serialize_value(v) } }
-          { o: result, id: id }
+          if value.any? { |k, v| !k.is_a?(String) && !k.is_a?(Symbol) } # Map
+            { m: serialize_value(value.to_a) }
+          else
+            id = @visited.log(value)
+            result = []
+            value.each { |key, v| result << { k: key, v: serialize_value(v) } }
+            { o: result, id: id }
+          end
         else
           raise ArgumentError.new("Unexpected value: #{value}")
         end

data/lib/playwright/locator_assertions_impl.rb

@@ -0,0 +1,417 @@
+module Playwright
+  # ref: https://github.com/microsoft/playwright-python/blob/main/playwright/_impl/_assertions.py
+  define_api_implementation :LocatorAssertionsImpl do
+    def self._define_negation(method_name)
+      define_method("not_#{method_name}") do |*args, **kwargs|
+        if kwargs.empty? # for Ruby < 2.7
+          _not.public_send(method_name, *args)
+        else
+          _not.public_send(method_name, *args, **kwargs)
+        end
+      end
+    end
+
+    def initialize(locator, timeout, is_not, message)
+      @locator = locator
+      @timeout = timeout
+      @is_not = is_not
+      @custom_message = message
+    end
+
+    private def expect_impl(expression, expect_options, expected, message)
+      expect_options[:timeout] ||= 5000
+      expect_options[:isNot] = @is_not
+      message.gsub!("expected to", "not expected to") if @is_not
+      expect_options.delete(:useInnerText) if expect_options.key?(:useInnerText) && expect_options[:useInnerText].nil?
+
+      result = @locator.expect(expression, expect_options)
+
+      if result["matches"] == @is_not
+        actual = result["received"]
+
+        log =
+          if result.key?("log")
+            log_contents = result["log"].join("\n").strip
+
+            "\nCall log:\n #{log_contents}"
+          else
+            ""
+          end
+
+        out_message =
+          if @custom_message && expected
+            "\nExpected value: '#{expected}'"
+          elsif @custom_message
+            @custom_message
+          elsif message != "" && expected
+            "\n#{message} '#{expected}'"
+          else
+            "\n#{message}"
+          end
+
+          out = "#{out_message}\nActual value #{actual} #{log}"
+          raise AssertionError.new(out)
+      else
+        true
+      end
+    end
+
+    private def _not # "not" is reserved in Ruby
+      LocatorAssertionsImpl.new(
+        @locator,
+        @timeout,
+        !@is_not,
+        @message
+      )
+    end
+
+    private def expected_regex(pattern, match_substring, normalize_white_space, ignore_case)
+      regex = JavaScript::Regex.new(pattern)
+      expected = {
+        regexSource: regex.source,
+        regexFlags: regex.flag,
+        matchSubstring: match_substring,
+        normalizeWhiteSpace: normalize_white_space,
+        ignoreCase: ignore_case
+      }
+      expected.delete(:ignoreCase) if ignore_case.nil?
+
+      expected
+    end
+
+    private def to_expected_text_values(items, match_substring = false, normalize_white_space = false, ignore_case = false)
+      return [] unless items.respond_to?(:each)
+
+      items.each.with_object([]) do |item, out|
+        out <<
+          if item.is_a?(String) && ignore_case
+            {
+              string: item,
+              matchSubstring: match_substring,
+              normalizeWhiteSpace: normalize_white_space,
+              ignoreCase: ignore_case,
+            }
+          elsif item.is_a?(String)
+            {
+              string: item,
+              matchSubstring: match_substring,
+              normalizeWhiteSpace: normalize_white_space,
+            }
+          elsif item.is_a?(Regexp)
+            expected_regex(item, match_substring, normalize_white_space, ignore_case)
+          end
+      end
+    end
+
+    def to_contain_text(expected, ignoreCase: nil, timeout: nil, useInnerText: nil)
+      useInnerText = false if useInnerText.nil?
+
+      if expected.respond_to?(:each)
+        expected_text = to_expected_text_values(
+          expected,
+          true,
+          true,
+          ignoreCase,
+        )
+
+        expect_impl(
+          "to.contain.text.array",
+          {
+            expectedText: expected_text,
+            useInnerText: useInnerText,
+            timeout: timeout,
+          },
+          expected,
+          "Locator expected to contain text"
+        )
+      else
+        expected_text = to_expected_text_values(
+          [expected],
+          true,
+          true,
+          ignoreCase
+        )
+
+        expect_impl(
+          "to.have.text",
+          {
+            expectedText: expected_text,
+            useInnerText: useInnerText,
+            timeout: timeout,
+          },
+          expected,
+          "Locator expected to contain text"
+        )
+      end
+    end
+    _define_negation :to_contain_text
+
+    def to_have_attribute(name, value, timeout: nil)
+      expected_text = to_expected_text_values([value])
+      expect_impl(
+        "to.have.attribute.value",
+        {
+          expressionArg: name,
+          expectedText: expected_text,
+          timeout: timeout,
+        },
+        value,
+        "Locator expected to have attribute"
+      )
+    end
+    _define_negation :to_have_attribute
+
+    def to_have_class(expected, timeout: nil)
+      if expected.respond_to?(:each)
+        expected_text = to_expected_text_values(expected)
+        expect_impl(
+          "to.have.class.array",
+          {
+            expectedText: expected_text,
+            timeout: timeout,
+          },
+          expected,
+          "Locator expected to have class"
+        )
+      else
+        expected_text = to_expected_text_values([expected])
+        expect_impl(
+          "to.have.class",
+          {
+            expectedText: expected_text,
+            timeout: timeout,
+          },
+          expected,
+          "Locator expected to have class"
+        )
+      end
+    end
+    _define_negation :to_have_class
+
+    def to_have_count(count, timeout: nil)
+      expect_impl(
+        "to.have.count",
+        {
+          expectedNumber: count,
+          timeout: timeout,
+        },
+        count,
+        "Locator expected to have count"
+      )
+    end
+    _define_negation :to_have_count
+
+    def to_have_css(name, value, timeout: nil)
+      expected_text = to_expected_text_values([value])
+      expect_impl(
+        "to.have.css",
+        {
+          expressionArg: name,
+          expectedText: expected_text,
+          timeout: timeout,
+        },
+        value,
+        "Locator expected to have CSS"
+      )
+    end
+    _define_negation :to_have_css
+
+    def to_have_id(id, timeout: nil)
+      expected_text = to_expected_text_values([id])
+      expect_impl(
+        "to.have.id",
+        {
+          expectedText: expected_text,
+          timeout: timeout,
+        },
+        id,
+        "Locator expected to have ID"
+      )
+    end
+    _define_negation :to_have_id
+
+    def to_have_js_property(name, value, timeout: nil)
+      expect_impl(
+        "to.have.property",
+        {
+          expressionArg: name,
+          expectedValue: value,
+          timeout: timeout,
+        },
+        value,
+        "Locator expected to have JS Property"
+      )
+    end
+    _define_negation :to_have_js_property
+
+    def to_have_value(value, timeout: nil)
+      expected_text = to_expected_text_values([value])
+
+      expect_impl(
+        "to.have.value",
+        {
+          expectedText: expected_text,
+          timeout: timeout,
+        },
+        value,
+        "Locator expected to have Value"
+      )
+    end
+    _define_negation :to_have_value
+
+    def to_have_values(values, timeout: nil)
+      expected_text = to_expected_text_values(values)
+
+      expect_impl(
+        "to.have.values",
+        {
+          expectedText: expected_text,
+          timeout: timeout,
+        },
+        values,
+        "Locator expected to have Values"
+      )
+    end
+    _define_negation :to_have_values
+
+    def to_have_text(expected, ignoreCase: nil, timeout: nil, useInnerText: nil)
+      if expected.respond_to?(:each)
+        expected_text = to_expected_text_values(
+          expected,
+          true,
+          true,
+          ignoreCase,
+        )
+        expect_impl(
+          "to.have.text.array",
+          {
+            expectedText: expected_text,
+            useInnerText: useInnerText,
+            timeout: timeout,
+          },
+          expected,
+          "Locator expected to have text"
+        )
+      else
+        expected_text = to_expected_text_values(
+          [expected],
+          true,
+          true,
+          ignoreCase,
+        )
+        expect_impl(
+          "to.have.text",
+          {
+            expectedText: expected_text,
+            useInnerText: useInnerText,
+            timeout: timeout,
+          },
+          expected,
+          "Locator expected to have text"
+        )
+      end
+    end
+    _define_negation :to_have_text
+
+    def to_be_attached(attached: nil, timeout: nil)
+      expect_impl(
+        (attached || attached.nil?) ? "to.be.attached" : "to.be.detached",
+        { timeout: timeout },
+        nil,
+        "Locator expected to be attached"
+      )
+    end
+    _define_negation :to_be_attached
+
+    def to_be_checked(checked: nil, timeout: nil)
+      expect_impl(
+        (checked || checked.nil?) ? "to.be.checked" : "to.be.unchecked",
+        { timeout: timeout },
+        nil,
+        "Locator expected to be checked"
+      )
+    end
+    _define_negation :to_be_checked
+
+    def to_be_disabled(timeout: nil)
+      expect_impl(
+        "to.be.disabled",
+        { timeout: timeout },
+        nil,
+        "Locator expected to be disabled"
+      )
+    end
+    _define_negation :to_be_disabled
+
+    def to_be_editable(editable: nil, timeout: nil)
+      expect_impl(
+        (editable || editable.nil?) ? "to.be.editable" : "to.be.readonly",
+        { timeout: timeout },
+        nil,
+        "Locator expected to be editable"
+      )
+    end
+    _define_negation :to_be_editable
+
+    def to_be_empty(timeout: nil)
+      expect_impl(
+        "to.be.empty",
+        { timeout: timeout },
+        nil,
+        "Locator expected to be empty"
+      )
+    end
+    _define_negation :to_be_empty
+
+    def to_be_enabled(enabled: nil, timeout: nil)
+      expect_impl(
+        (enabled || enabled.nil?) ? "to.be.enabled" : "to.be.disabled",
+        { timeout: timeout },
+        nil,
+        "Locator expected to be enabled"
+      )
+    end
+    _define_negation :to_be_enabled
+
+    def to_be_hidden(timeout: nil)
+      expect_impl(
+        "to.be.hidden",
+        { timeout: timeout },
+        nil,
+        "Locator expected to be hidden"
+      )
+    end
+    _define_negation :to_be_hidden
+
+    def to_be_visible(timeout: nil, visible: nil)
+      expect_impl(
+        (visible || visible.nil?) ? "to.be.visible" : "to.be.hidden",
+        { timeout: timeout },
+        nil,
+        "Locator expected to be visible"
+      )
+    end
+    _define_negation :to_be_visible
+
+    def to_be_focused(timeout: nil)
+      expect_impl(
+        "to.be.focused",
+        { timeout: timeout },
+        nil,
+        "Locator expected to be focused"
+      )
+    end
+    _define_negation :to_be_focused
+
+    def to_be_in_viewport(ratio: nil, timeout: nil)
+      expect_impl(
+        "to.be.in.viewport",
+        { timeout: timeout, expectedNumber: ratio },
+        nil,
+        "Locator expected to be in viewport"
+      )
+    end
+    _define_negation :to_be_in_viewport
+
+  end
+end