playwright-ruby-client 0.0.8 → 1.58.1.alpha1

data/lib/playwright/mouse_impl.rb

@@ -0,0 +1,57 @@
+module Playwright
+  define_api_implementation :MouseImpl do
+    def initialize(channel)
+      @channel = channel
+    end
+
+    def move(x, y, steps: nil)
+      params = { x: x, y: y, steps: steps }.compact
+      @channel.send_message_to_server('mouseMove', params)
+      nil
+    end
+
+    def down(button: nil, clickCount: nil)
+      params = { button: button, clickCount: clickCount }.compact
+      @channel.send_message_to_server('mouseDown', params)
+      nil
+    end
+
+    def up(button: nil, clickCount: nil)
+      params = { button: button, clickCount: clickCount }.compact
+      @channel.send_message_to_server('mouseUp', params)
+      nil
+    end
+
+    def click(
+      x,
+      y,
+      button: nil,
+      clickCount: nil,
+      delay: nil)
+
+      params = {
+        x: x,
+        y: y,
+        button: button,
+        clickCount: clickCount,
+        delay: delay,
+      }.compact
+      @channel.send_message_to_server('mouseClick', params)
+
+      nil
+    end
+
+    def dblclick(x, y, button: nil, delay: nil)
+      click(x, y, button: button, clickCount: 2, delay: delay)
+    end
+
+    def wheel(deltaX, deltaY)
+      params = {
+        deltaX: deltaX,
+        deltaY: deltaY,
+      }
+      @channel.send_message_to_server('mouseWheel', params)
+      nil
+    end
+  end
+end

data/lib/playwright/page_assertions_impl.rb

@@ -0,0 +1,154 @@
+module Playwright
+  # ref: https://github.com/microsoft/playwright-python/blob/main/playwright/_impl/_assertions.py
+  define_api_implementation :PageAssertionsImpl 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(page, default_expect_timeout, is_not, message)
+      @page = PlaywrightApi.unwrap(page)
+      @frame = @page.main_frame
+      @default_expect_timeout = default_expect_timeout
+      @is_not = is_not
+      @custom_message = message
+    end
+
+    private def expect_impl(expression, expect_options, expected, message, title)
+      expect_options[:timeout] ||= @default_expect_timeout
+      expect_options[:isNot] = @is_not
+      message = message.gsub("expected to", "not expected to") if @is_not
+      expect_options.delete(:useInnerText) if expect_options.key?(:useInnerText) && expect_options[:useInnerText].nil?
+
+      result = @frame.expect(nil, expression, expect_options, title)
+
+      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
+
+        if result['errorMessage']
+          error_message = "\n#{result['errorMessage']}"
+        end
+        out = "#{out_message}\nActual value #{actual}#{error_message} #{log}"
+        raise AssertionError.new(out)
+      else
+        true
+      end
+    end
+
+    private def _not # "not" is reserved in Ruby
+      PageAssertionsImpl.new(
+        @page,
+        @default_expect_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_have_title(title_or_regex, timeout: nil)
+      expected_text = to_expected_text_values(
+        [title_or_regex],
+        normalize_white_space: true,
+      )
+
+      expect_impl(
+        "to.have.title",
+        {
+          expectedText: expected_text,
+          timeout: timeout,
+        },
+        title_or_regex,
+        "Page title expected to be",
+        'Expect "to_have_title"',
+      )
+    end
+    _define_negation :to_have_title
+
+    def to_have_url(url_or_regex, ignoreCase: nil, timeout: nil)
+      base_url = @page.context.send(:base_url)
+      if url_or_regex.is_a?(String) && base_url
+        expected = URI.join(base_url, url_or_regex).to_s
+      else
+        expected = url_or_regex
+      end
+      expected_text = to_expected_text_values(
+        [expected],
+        ignore_case: ignoreCase,
+      )
+
+      expect_impl(
+        "to.have.url",
+        {
+          expectedText: expected_text,
+          timeout: timeout,
+        },
+        expected,
+        "Page URL expected to be",
+        'Expect "to_have_url"',
+      )
+    end
+    _define_negation :to_have_url
+  end
+end

data/lib/playwright/playwright_api.rb

@@ -1,30 +1,48 @@
 module Playwright
   class PlaywrightApi
-    # Wrap ChannelOwner.
+    # Wrap ChannelOwner / ApiImplementation.
     # Playwright::ChannelOwners::XXXXX will be wrapped as Playwright::XXXXX
+    # Playwright::YYYYImpl will be wrapped as Playwright::YYYY
     # Playwright::XXXXX is automatically generated by development/generate_api
     #
-    # @param channel_owner [ChannelOwner]
+    # @param channel_owner [ChannelOwner|ApiImplementation]
     # @note Intended for internal use only.
-    def self.from_channel_owner(channel_owner)
-      Factory.new(channel_owner, 'ChannelOwners').create
+    def self.wrap(channel_owner_or_api_implementation)
+      case channel_owner_or_api_implementation
+      when ChannelOwner
+        ChannelOwnerWrapper.new(channel_owner_or_api_implementation).wrap
+      when ApiImplementation
+        ApiImplementationWrapper.new(channel_owner_or_api_implementation).wrap
+      else
+        channel_owner_or_api_implementation
+      end
+    end
+
+    # Unwrap ChannelOwner / ApiImplementation.
+    # @note Intended for internal use only.
+    def self.unwrap(api)
+      case api
+      when PlaywrightApi
+        api.instance_variable_get(:@impl)
+      else
+        api
+      end
     end
 
-    class Factory
-      def initialize(impl, module_name)
+    class ChannelOwnerWrapper
+      def initialize(impl)
         impl_class_name = impl.class.name
-        unless impl_class_name.include?("::#{module_name}::")
-          raise "#{impl_class_name} is not #{module_name}"
+        unless impl_class_name.include?("::ChannelOwners::")
+          raise "#{impl_class_name} is not ChannelOwners"
         end
 
         @impl = impl
-        @module_name = module_name
       end
 
-      def create
+      def wrap
         api_class = detect_class_for(@impl.class)
         if api_class
-          api_class.new(@impl)
+          @impl._api ||= api_class.new(@impl)
         else
           raise NotImplementedError.new("Playwright::#{expected_class_name_for(@impl.class)} is not implemented")
         end
@@ -33,11 +51,11 @@ module Playwright
       private
 
       def expected_class_name_for(klass)
-        klass.name.split("::#{@module_name}::").last
+        klass.name.split("::ChannelOwners::").last
       end
 
       def superclass_exist?(klass)
-        ![::Playwright::ChannelOwner, ::Playwright::InputType, Object].include?(klass.superclass)
+        ![::Playwright::ChannelOwner, Object].include?(klass.superclass)
       end
 
       def detect_class_for(klass)
@@ -52,13 +70,46 @@ module Playwright
       end
     end
 
-    # @param impl [Playwright::ChannelOwner|Playwright::InputType]
-    def initialize(impl)
-      @impl = impl
+    class ApiImplementationWrapper
+      def initialize(impl)
+        impl_class_name = impl.class.name
+        unless impl_class_name.end_with?("Impl")
+          raise "#{impl_class_name} is not Impl"
+        end
+
+        @impl = impl
+      end
+
+      def wrap
+        api_class = detect_class_for(@impl.class)
+        if api_class
+          api_class.new(@impl)
+        else
+          raise NotImplementedError.new("Playwright::#{expected_class_name_for(@impl.class)} is not implemented")
+        end
+      end
+
+      private
+
+      def expected_class_name_for(klass)
+        # KeyboardImpl -> Keyboard
+        # MouseImpl -> Mouse
+        klass.name[0...-4].split("::").last
+      end
+
+      def detect_class_for(klass)
+        class_name = expected_class_name_for(klass)
+        if ::Playwright.const_defined?(class_name)
+          ::Playwright.const_get(class_name)
+        else
+          nil
+        end
+      end
     end
 
-    def ==(other)
-      @impl.to_s == other.instance_variable_get(:'@impl').to_s
+    # @param impl [Playwright::ChannelOwner|Playwright::ApiImplementation]
+    def initialize(impl)
+      @impl = impl
     end
 
     # @param block [Proc]
@@ -71,22 +122,43 @@ module Playwright
       }
     end
 
-    private def wrap_impl(object)
-      case object
-      when ChannelOwner
-        PlaywrightApi.from_channel_owner(object)
-      when InputType
-        Factory.new(object, 'InputTypes').create
-      when Array
-        object.map { |obj| wrap_impl(obj) }
+    private def wrap_impl(object, visited: {})
+      if object.is_a?(Array)
+        unless visited[object]
+          visited[object] = []
+          object.each { |obj| visited[object] << wrap_impl(obj) }
+        end
+        visited[object]
+      elsif object.is_a?(Hash)
+        unless visited[object]
+          visited[object] = {}
+          object.each do |key, obj|
+            visited[object][key] = wrap_impl(obj, visited: visited)
+          end
+        end
+        visited[object]
       else
-        object
+        ::Playwright::PlaywrightApi.wrap(object)
       end
     end
 
-    private def unwrap_impl(object)
-      if object.is_a?(PlaywrightApi)
-        object.instance_variable_get(:@impl)
+    private def unwrap_impl(object, visited: {})
+      if object.is_a?(Array)
+        unless visited[object]
+          visited[object] = []
+          object.each { |obj| visited[object] << unwrap_impl(obj) }
+        end
+        visited[object]
+      elsif object.is_a?(Hash)
+        unless visited[object]
+          visited[object] = {}
+          object.each do |key, obj|
+            visited[object][key] = unwrap_impl(obj, visited: visited)
+          end
+        end
+        visited[object]
+      elsif object.is_a?(PlaywrightApi)
+        ::Playwright::PlaywrightApi.unwrap(object)
       else
         object
       end

data/lib/playwright/raw_headers.rb

@@ -0,0 +1,61 @@
+module Playwright
+  class RawHeaders
+    def initialize(headers_array)
+      h_array = []
+      h_map = {}
+      headers_array.each do |header|
+        name = header['name']
+        key = name.downcase
+        value = header['value']
+
+        h_array << [name, value]
+        h_map[key] ||= []
+        h_map[key] << value
+      end
+
+      @headers_array = h_array
+      @headers_map = h_map
+    end
+
+    # @return [String|nil]
+    def get(name)
+      key = name.downcase
+      values = @headers_map[key]
+      if values
+        join(key, values)
+      else
+        nil
+      end
+    end
+
+    # @return [Array<String>]
+    def get_all(name)
+      values = @headers_map[name.downcase]
+      if values
+        values.dup
+      else
+        []
+      end
+    end
+
+    def headers
+      @headers_map.map do |key, values|
+        [key, join(key, values)]
+      end.to_h
+    end
+
+    def headers_array
+      @headers_array.map do |name, value|
+        { name: name, value: value }
+      end
+    end
+
+    private def join(key, values)
+      if key == 'set-cookie'
+        values.join("\n")
+      else
+        values.join(", ")
+      end
+    end
+  end
+end

data/lib/playwright/route_handler.rb

@@ -0,0 +1,78 @@
+module Playwright
+  class RouteHandler
+    class CountDown
+      def initialize(count)
+        @count = count
+      end
+
+      def increment
+        return false if expired?
+
+        @count = @count - 1
+        true
+      end
+
+      def expired?
+        @count <= 0
+      end
+    end
+
+    class StubCounter
+      def increment
+        true
+      end
+
+      def expired?
+        false
+      end
+    end
+
+    # @param url [String]
+    # @param base_url [String|nil]
+    # @param handler [Proc]
+    # @param times [Integer|nil]
+    def initialize(url, base_url, handler, times)
+      @url_value = url
+      @url_matcher = UrlMatcher.new(url, base_url: base_url)
+      @handler = handler
+      @counter =
+        if times
+          CountDown.new(times)
+        else
+          StubCounter.new
+        end
+    end
+
+    def as_pattern
+      @url_matcher.as_pattern
+    end
+
+    def match?(url)
+      @url_matcher.match?(url)
+    end
+
+    def async_handle(route)
+      @counter.increment
+
+      Concurrent::Promises.future { @handler.call(route, route.request) }.rescue do |err|
+        puts err, err.backtrace
+      end
+    end
+
+    def expired?
+      @counter.expired?
+    end
+
+    def same_value?(url:, handler: nil)
+      if handler
+        @url_value == url && @handler == handler
+      else
+        @url_value == url
+      end
+    end
+
+    def self.prepare_interception_patterns(handlers)
+      handlers.map(&:as_pattern).compact
+    end
+  end
+end

data/lib/playwright/select_option_values.rb

@@ -1,7 +1,30 @@
 module Playwright
   class SelectOptionValues
-    def initialize(values)
-      @params = convert(values)
+    def initialize(element: nil, index: nil, value: nil, label: nil)
+      params = {}
+
+      options = []
+      if value
+        options.concat(convert(:value, value))
+      end
+
+      if index
+        options.concat(convert(:index, index))
+      end
+
+      if label
+        options.concat(convert(:label, label))
+      end
+
+      unless options.empty?
+        params[:options] = options
+      end
+
+      if element
+        params[:elements] = convert(:element, element)
+      end
+
+      @params = params
     end
 
     # @return [Hash]
@@ -9,23 +32,21 @@ module Playwright
       @params
     end
 
-    private def convert(values)
-      return {} unless values
-      return convert([values]) unless values.is_a?('Array')
-      return {} if values.empty?
+    private def convert(key, values)
+      return convert(key, [values]) unless values.is_a?(Enumerable)
+      return [] if values.empty?
       values.each_with_index do |value, index|
-        unless values
+        unless value
           raise ArgumentError.new("options[#{index}]: expected object, got null")
         end
       end
 
-      case values.first
-      when ElementHandle
-        { elements: values.map(&:channel) }
-      when String
-        { options: values.map { |value| { value: value } } }
+      if key == :element
+        values.map(&:channel)
+      elsif key == :value
+        values.map { |value| { valueOrLabel: value } }
       else
-        { options: values }
+        values.map { |value| { key => value } }
       end
     end
   end

data/lib/playwright/selectors_impl.rb

@@ -0,0 +1,45 @@
+module Playwright
+  # https://github.com/microsoft/playwright-python/blob/master/playwright/_impl/_selectors.py
+  define_api_implementation :SelectorsImpl do
+    def initialize
+      @selector_engines = []
+      @contexts_for_selectors = Set.new
+    end
+
+    def register(name, contentScript: nil, path: nil, script: nil)
+      source =
+        if path
+          File.read(path)
+        elsif script
+          script
+        else
+          raise ArgumentError.new('Either path or script parameter must be specified')
+        end
+      selector_engine = { name: name, source: source }
+      if contentScript
+        selector_engine[:contentScript] = true
+      end
+      @contexts_for_selectors.each do |context|
+        context.send(:register_selector_engine, selector_engine)
+      end
+      @selector_engines << selector_engine
+
+      nil
+    end
+
+    def set_test_id_attribute(attribute_name)
+      @test_id_attribute_name = attribute_name
+      ::Playwright::LocatorUtils.instance_variable_set(:@test_id_attribute_name, attribute_name)
+    end
+
+    private def update_with_selector_options(options)
+      options[:selectorEngines] = @selector_engines unless @selector_engines.empty?
+      options[:testIdAttributeName] = @test_id_attribute_name if @test_id_attribute_name
+      options
+    end
+
+    private def contexts_for_selectors
+      @contexts_for_selectors
+    end
+  end
+end