playwright-ruby-client 1.38.0 → 1.38.1

data/documentation/docs/include/api_coverage.md

@@ -527,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/errors.rb

@@ -49,4 +49,6 @@ module Playwright
 
     attr_reader :error, :page
   end
+
+  class AssertionError < StandardError; end
 end

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

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

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

data/lib/playwright/version.rb

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

data/lib/playwright_api/locator.rb

@@ -1149,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)