playwright-ruby-client 1.39.0 → 1.40.0

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,
+          match_substring: true,
+          normalize_white_space: true,
+          ignore_case: 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],
+          match_substring: true,
+          normalize_white_space: true,
+          ignore_case: 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, ignoreCase: nil, timeout: nil)
+      expected_text = to_expected_text_values([value], ignore_case: ignoreCase)
+      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,
+          match_substring: true,
+          normalize_white_space: true,
+          ignore_case: 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],
+          match_substring: true,
+          normalize_white_space: true,
+          ignore_case: 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

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
@@ -488,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.send(:define_method, root_method_name) do |*args, **kwargs|
+          Matchers::PlaywrightMatcher.new(method_name, *args, **kwargs)
+        end
+      end
+  end
+end

data/lib/playwright/utils.rb

@@ -70,17 +70,10 @@ module Playwright
     end
 
     module Errors
-      module SafeCloseError
+      module TargetClosedErrorMethods
         # @param err [Exception]
-        private def safe_close_error?(err)
-          return true if err.is_a?(Transport::AlreadyDisconnectedError)
-
-          [
-            'Browser has been closed',
-            'Target page, context or browser has been closed',
-          ].any? do |closed_message|
-            err.message.end_with?(closed_message)
-          end
+        private def target_closed_error?(err)
+          err.is_a?(TargetClosedError)
         end
       end
     end

data/lib/playwright/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module Playwright
-  VERSION = '1.39.0'
-  COMPATIBLE_PLAYWRIGHT_VERSION = '1.39.0'
+  VERSION = '1.40.0'
+  COMPATIBLE_PLAYWRIGHT_VERSION = '1.40.1'
 end

data/lib/playwright/waiter.rb

@@ -0,0 +1,146 @@
+require 'securerandom'
+
+module Playwright
+  # ref: https://github.com/microsoft/playwright-python/blob/v1.40.0/playwright/_impl/_waiter.py
+  # ref: https://github.com/microsoft/playwright/blob/v1.40.0/packages/playwright-core/src/client/waiter.ts
+  class Waiter
+    def initialize(channel_owner, wait_name:)
+      @result = Concurrent::Promises.resolvable_future
+      @wait_id = SecureRandom.hex(16)
+      @event = wait_name
+      @channel = channel_owner.channel
+      @registered_listeners = Set.new
+      @logs = []
+      wait_for_event_info_before
+    end
+
+    private def wait_for_event_info_before
+      @channel.async_send_message_to_server(
+        "waitForEventInfo",
+        {
+          "info": {
+            "waitId": @wait_id,
+            "phase": "before",
+            "event": @event,
+          }
+        },
+      )
+    end
+
+    private def wait_for_event_info_after(error: nil)
+      @channel.async_send_message_to_server(
+        "waitForEventInfo",
+        {
+          "info": {
+            "waitId": @wait_id,
+            "phase": "after",
+            "error": error,
+          }.compact,
+        },
+      )
+    end
+
+    def reject_on_event(emitter, event, error_or_proc, predicate: nil)
+      listener = -> (*args) {
+        if !predicate || predicate.call(*args)
+          if error_or_proc.respond_to?(:call)
+            reject(error_or_proc.call)
+          else
+            reject(error_or_proc)
+          end
+        end
+      }
+      emitter.on(event, listener)
+      @registered_listeners << [emitter, event, listener]
+
+      self
+    end
+
+    def reject_on_timeout(timeout_ms, message)
+      return if timeout_ms <= 0
+
+      Concurrent::Promises.schedule(timeout_ms / 1000.0) do
+        reject(TimeoutError.new(message: message))
+      end.rescue do |err|
+        puts err, err.backtrace
+      end
+
+      self
+    end
+
+    private def cleanup
+      @registered_listeners.each do |emitter, event, listener|
+        emitter.off(event, listener)
+      end
+      @registered_listeners.clear
+    end
+
+    private def fulfill(result)
+      cleanup
+      unless @result.resolved?
+        @result.fulfill(result)
+      end
+      wait_for_event_info_after
+    end
+
+    private def reject(error)
+      cleanup
+      klass = error.is_a?(TimeoutError) ? TimeoutError : Error
+      ex = klass.new(message: "#{error.message}#{format_log_recording(@logs)}")
+      unless @result.resolved?
+        @result.reject(ex)
+      end
+      wait_for_event_info_after(error: ex)
+    end
+
+    # @param [Playwright::EventEmitter]
+    # @param
+    def wait_for_event(emitter, event, predicate: nil)
+      listener = -> (*args) {
+        begin
+          if !predicate || predicate.call(*args)
+            fulfill(args.first)
+          end
+        rescue => err
+          reject(err)
+        end
+      }
+      emitter.on(event, listener)
+      @registered_listeners << [emitter, event, listener]
+
+      self
+    end
+
+    attr_reader :result
+
+    def log(message)
+      @logs << message
+      begin
+        @channel.async_send_message_to_server(
+          "waitForEventInfo",
+          {
+            "info": {
+              "waitId": @wait_id,
+              "phase": "log",
+              "message": message,
+            },
+          },
+        )
+      rescue => err
+        # ignore
+      end
+    end
+
+    # @param logs [Array<String>]
+    private def format_log_recording(logs)
+      return "" if logs.empty?
+
+      header = " logs "
+      header_length = 60
+      left_length = ((header_length - header.length) / 2.0).to_i
+      right_length = header_length - header.length - left_length
+      new_line = "\n"
+      "#{new_line}#{'=' * left_length}#{header}#{'=' * right_length}#{new_line}#{logs.join(new_line)}#{new_line}#{'=' * header_length}"
+    end
+  end
+end

data/lib/playwright.rb

@@ -29,7 +29,7 @@ require 'playwright/transport'
 require 'playwright/url_matcher'
 require 'playwright/version'
 require 'playwright/video'
-require 'playwright/wait_helper'
+require 'playwright/waiter'
 
 require 'playwright/playwright_api'
 # load generated files