chromate-rb 0.0.1.pre → 0.0.3.pre

data/lib/chromate/client.rb

@@ -2,23 +2,27 @@
 
 require 'websocket-client-simple'
 require 'chromate/helpers'
+require 'chromate/exceptions'
 
 module Chromate
   class Client
     include Helpers
 
+    # @return [Array<Proc>]
     def self.listeners
       @@listeners ||= [] # rubocop:disable Style/ClassVars
     end
 
     attr_reader :port, :ws, :browser
 
+    # @param [Chromate::Browser] browser
     def initialize(browser)
-      @browser = browser
-      options = browser.options
-      @port = options[:port] || find_available_port
+      @browser  = browser
+      options   = browser.options
+      @port     = options[:port] || find_available_port
     end
 
+    # @return [self]
     def start
       @ws_url = fetch_websocket_debug_url
       @ws = WebSocket::Client::Simple.connect(@ws_url)
@@ -29,7 +33,7 @@ module Chromate
 
       @ws.on :message do |msg|
         message = JSON.parse(msg.data)
-        client_self.handle_message(message)
+        client_self.send(:handle_message, message)
 
         Client.listeners.each do |listener|
           listener.call(message)
@@ -37,79 +41,114 @@ module Chromate
       end
 
       @ws.on :open do
-        puts "Connexion WebSocket établie avec #{@ws_url}"
+        Chromate::CLogger.log('Successfully connected to WebSocket', level: :debug)
       end
 
       @ws.on :error do |e|
-        puts "Erreur WebSocket : #{e.message}"
+        Chromate::CLogger.log("WebSocket error: #{e.message}", level: :error)
       end
 
       @ws.on :close do |_e|
-        puts 'Connexion WebSocket fermée'
+        Chromate::CLogger.log('WebSocket connection closed', level: :debug)
       end
 
-      sleep 0.2
+      sleep 0.2 # Wait for the connection to be established
       client_self.send_message('Target.setDiscoverTargets', { discover: true })
+
       client_self
     end
 
+    # @return [self]
     def stop
       @ws&.close
+
+      self
     end
 
+    # @param [String] method
+    # @param [Hash] params
+    # @return [Hash]
     def send_message(method, params = {})
       @id += 1
       message = { id: @id, method: method, params: params }
-      puts "Envoi du message : #{message}"
+      Chromate::CLogger.log("Sending WebSocket message: #{message}", level: :debug)
 
       begin
         @ws.send(message.to_json)
         @callbacks[@id] = Queue.new
         result = @callbacks[@id].pop
-        puts "Réponse reçue pour le message #{message[:id]} : #{result}"
+        Chromate::CLogger.log("Response received for message #{message[:id]}: #{result}", level: :debug)
         result
       rescue StandardError => e
-        puts "Erreur WebSocket lors de l'envoi du message : #{e.message}"
+        Chromate::CLogger.log("Error sending WebSocket message: #{e.message}", level: :error)
         reconnect
         retry
       end
     end
 
+    # @return [self]
     def reconnect
       @ws_url = fetch_websocket_debug_url
       @ws     = WebSocket::Client::Simple.connect(@ws_url)
-      puts 'Reconnexion WebSocket réussie'
+      Chromate::CLogger.log('Successfully reconnected to WebSocket')
+
+      self
     end
 
+    # Allowing different parts to subscribe to WebSocket messages
+    # @yieldparam [Hash] message
+    # @return [void]
+    def on_message(&block)
+      Client.listeners << block
+    end
+
+    private
+
+    # @param [Hash] message
+    # @return [self]
     def handle_message(message)
-      puts "Message reçu : #{message}"
+      Chromate::CLogger.log("Message received: #{message}", level: :debug)
       return unless message['id'] && @callbacks[message['id']]
 
       @callbacks[message['id']].push(message['result'])
       @callbacks.delete(message['id'])
-    end
 
-    # Allowing different parts to subscribe to WebSocket messages
-    def on_message(&block)
-      Client.listeners << block
+      self
     end
 
+    # @return [String]
     def fetch_websocket_debug_url
-      uri = URI("http://localhost:#{@port}/json/list")
-      response = Net::HTTP.get(uri)
-      targets = JSON.parse(response)
+      retries = 0
+      max_retries = 5
+      base_delay = 0.5
 
-      page_target = targets.find { |target| target['type'] == 'page' }
+      begin
+        uri = URI("http://localhost:#{@port}/json/list")
+        response = Net::HTTP.get(uri)
+        targets = JSON.parse(response)
+
+        page_target = targets.find { |target| target['type'] == 'page' }
+        websocket_url = if page_target
+                          page_target['webSocketDebuggerUrl']
+                        else
+                          create_new_page_target
+                        end
+        raise Exceptions::DebugURLError, 'Can\'t get WebSocket URL' if websocket_url.nil?
+
+        websocket_url
+      rescue StandardError => e
+        retries += 1
+        raise Exceptions::ConnectionTimeoutError, "Can't get WebSocket URL after #{max_retries} retries" if retries >= max_retries
 
-      if page_target
-        page_target['webSocketDebuggerUrl']
-      else
-        create_new_page_target
+        delay = base_delay * (2**retries) # Exponential delay: 0.5s, 1s, 2s, 4s, 8s
+        Chromate::CLogger.log("Attempting to reconnect in #{delay} seconds, #{e.message}", level: :debug)
+        sleep delay
+        retry
       end
     end
 
+    # @return [String]
     def create_new_page_target
-      # Créer une nouvelle page
       uri = URI("http://localhost:#{@port}/json/new")
       response = Net::HTTP.get(uri)
       new_target = JSON.parse(response)

data/lib/chromate/configuration.rb

@@ -9,25 +9,26 @@ module Chromate
     include Helpers
     include Exceptions
     DEFAULT_ARGS = [
-      '--no-first-run',
-      '--no-default-browser-check',
-      '--disable-blink-features=AutomationControlled',
-      '--disable-extensions',
-      '--disable-infobars',
-      '--no-sandbox',
-      '--disable-popup-blocking',
-      '--ignore-certificate-errors',
-      '--disable-gpu',
-      '--disable-dev-shm-usage',
+      '--no-first-run', # Skip the first run wizard
+      '--no-default-browser-check', # Disable the default browser check
+      '--disable-blink-features=AutomationControlled', # Disable the AutomationControlled feature
+      '--disable-extensions', # Disable extensions
+      '--disable-infobars', # Disable the infobar that asks if you want to install Chrome
+      '--no-sandbox', # Required for chrome devtools to work
+      '--test-type', # Remove the not allowed message for --no-sandbox flag
+      '--disable-dev-shm-usage', # Disable /dev/shm usage
+      '--disable-popup-blocking', # Disable popup blocking
+      '--ignore-certificate-errors', # Ignore certificate errors
       '--window-size=1920,1080', # TODO: Make this automatic
-      '--hide-crash-restore-bubble'
+      '--hide-crash-restore-bubble' # Hide the crash restore bubble
     ].freeze
     HEADLESS_ARGS = [
       '--headless=new',
       '--window-position=2400,2400'
     ].freeze
     XVFB_ARGS = [
-      '--window-position=0,0'
+      '--window-position=0,0',
+      '--start-fullscreen'
     ].freeze
     DISABLED_FEATURES = %w[
       Translate
@@ -45,14 +46,16 @@ module Chromate
       enable-automation
     ].freeze
 
-    attr_accessor :user_data_dir, :headless, :xfvb, :native_control, :args, :headless_args, :xfvb_args, :exclude_switches, :proxy,
-                  :disable_features
+    attr_accessor :user_data_dir, :headless, :xfvb, :native_control, :startup_patch,
+                  :args, :headless_args, :xfvb_args, :exclude_switches, :proxy, :disable_features,
+                  :mouse_controller, :keyboard_controller
 
     def initialize
       @user_data_dir      = File.expand_path('~/.config/google-chrome/Default')
       @headless           = true
       @xfvb               = false
       @native_control     = false
+      @startup_patch      = true
       @proxy              = nil
       @args               = [] + DEFAULT_ARGS
       @headless_args      = [] + HEADLESS_ARGS
@@ -63,18 +66,27 @@ module Chromate
       @args << '--use-angle=metal' if mac?
     end
 
+    # @return [Chromate::Configuration]
     def self.config
       @config ||= Configuration.new
     end
 
+    # @yield [Chromate::Configuration]
     def self.configure
       yield(config)
     end
 
+    # @return [Chromate::Configuration]
     def config
       self.class.config
     end
 
+    # @return [Boolean]
+    def patch?
+      @startup_patch
+    end
+
+    # @return [String]
     def chrome_path
       return ENV['CHROME_BIN'] if ENV['CHROME_BIN']
 
@@ -89,6 +101,10 @@ module Chromate
       end
     end
 
+    # @option [Boolean] headless
+    # @option [Boolean] xfvb
+    # @option [Hash] proxy
+    # @option [Array<String>] disable_features
     def generate_arguments(headless: @headless, xfvb: @xfvb, proxy: @proxy, disable_features: @disable_features, **_args)
       dynamic_args = []
 
@@ -100,6 +116,7 @@ module Chromate
       @args + dynamic_args
     end
 
+    # @return [Hash]
     def options
       {
         chrome_path: chrome_path,

data/lib/chromate/element.rb

@@ -1,7 +1,11 @@
 # frozen_string_literal: true
 
+require 'chromate/elements/tags'
+
 module Chromate
   class Element
+    include Elements::Tags
+
     class NotFoundError < StandardError
       def initialize(selector, root_id)
         super("Element not found with selector: #{selector} under root_id: #{root_id}")
@@ -13,7 +17,7 @@ module Chromate
         super("Unable to resolve element with selector: #{selector}")
       end
     end
-    attr_reader :selector, :client, :mouse
+    attr_reader :selector, :client, :root_id, :object_id, :node_id
 
     # @param [String] selector
     # @param [Chromate::Client] client
@@ -25,37 +29,51 @@ module Chromate
       @client     = client
       @object_id  = object_id
       @node_id    = node_id
-      @object_id, @node_id = find(selector, root_id) unless @object_id && @node_id
-      @root_id  = root_id || document['root']['nodeId']
-      @mouse    = Hardwares.mouse(client: client, element: self)
+      @object_id, @node_id = magick_find(selector, root_id) unless @object_id && @node_id
+      @root_id = root_id || document['root']['nodeId']
+    end
+
+    # @return [Chromate::Hardwares::MouseController]
+    def mouse
+      Chromate.configuration.mouse_controller.set_element(self)
+    end
+
+    # @return [Chromate::Hardwares::KeyboardController]
+    def keyboard
+      Chromate.configuration.keyboard_controller.set_element(self)
     end
 
+    # @return [String]
     def inspect
       value = selector.length > 20 ? "#{selector[0..20]}..." : selector
       "#<Chromate::Element:#{value}>"
     end
 
+    # @return [String]
     def text
-      return @text if @text
+      evaluate_script('function() { return this.innerText; }')
+    end
 
-      result = client.send_message('Runtime.callFunctionOn', functionDeclaration: 'function() { return this.innerText; }', objectId: @object_id)
-      @text = result['result']['value']
+    # @return [String]
+    def value
+      evaluate_script('function() { return this.value; }')
     end
 
     # @return [String]
     def html
-      return @html if @html
-
-      @html = client.send_message('DOM.getOuterHTML', objectId: @object_id)
-      @html = @html['outerHTML']
+      html = client.send_message('DOM.getOuterHTML', objectId: @object_id)
+      html['outerHTML']
     end
 
     # @return [Hash]
     def attributes
-      return @attributes if @attributes
-
       result = client.send_message('DOM.getAttributes', nodeId: @node_id)
-      @attributes = Hash[*result['attributes']]
+      Hash[*result['attributes']]
+    end
+
+    # @return [String]
+    def tag_name
+      evaluate_script('function() { return this.tagName.toLowerCase(); }')
     end
 
     # @param [String] name
@@ -94,6 +112,13 @@ module Chromate
       bounding_box['height']
     end
 
+    # @return [self]
+    def focus
+      client.send_message('DOM.focus', nodeId: @node_id)
+
+      self
+    end
+
     # @return [self]
     def click
       mouse.click
@@ -109,9 +134,24 @@ module Chromate
     end
 
     # @param [String] text
+    # @return [self]
     def type(text)
-      client.send_message('Runtime.callFunctionOn', functionDeclaration: "function(value) { this.value = value; this.dispatchEvent(new Event('input')); }",
-                                                    objectId: @object_id, arguments: [{ value: text }])
+      focus
+      keyboard.type(text)
+
+      self
+    end
+
+    # @return [self]
+    def press_enter
+      keyboard.press_key('Enter')
+      submit_parent_form
+
+      self
+    end
+
+    def drop_to(element)
+      mouse.drag_and_drop_to(element)
 
       self
     end
@@ -169,8 +209,23 @@ module Chromate
       end
     end
 
+    # @param [String] script
+    # @return [String]
+    def evaluate_script(script, options = {})
+      result = client.send_message(
+        'Runtime.callFunctionOn',
+        functionDeclaration: script,
+        objectId: @object_id,
+        returnByValue: true,
+        **options
+      )
+      result['result']['value']
+    end
+
     private
 
+    # @param [String] event
+    # @return [void]
     def dispatch_event(event)
       client.send_message('DOM.dispatchEvent', nodeId: @node_id, type: event)
     end
@@ -187,8 +242,56 @@ module Chromate
       [node_info['object']['objectId'], result['nodeId']]
     end
 
+    # @param [String] selector
+    # @option [Integer] root_id
+    # @return [Chromate::Element, nil]
+    def magick_find(selector, root_id = nil)
+      find(selector, root_id)
+    rescue NotFoundError, InvalidSelectorError
+      el = find_in_shadow_recursively(selector)
+      raise NotFoundError.new(selector, @root_id) unless el
+
+      el
+    end
+
+    # @param [String] selector
+    # @return [Chromate::Element, nil]
+    def find_in_shadow_recursively(selector)
+      shadow_children = find_shadow_children('*')
+      shadow_children.each do |child|
+        found_element = child.find_element(selector) || child.find_in_shadow_recursively(selector)
+        return found_element if found_element
+      end
+
+      nil
+    end
+
+    # @return [Hash]
     def document
       @document ||= client.send_message('DOM.getDocument')
     end
+
+    # Allows to submit the parent form of the element
+    # can be used to submit a form
+    #
+    # @return [void]
+    def submit_parent_form
+      script = <<~JAVASCRIPT
+        function() {
+          const form = this.closest('form');
+          if (form) {
+            const submitEvent = new Event('submit', {
+              bubbles: true,
+              cancelable: true
+            });
+            if (form.dispatchEvent(submitEvent)) {
+              form.submit();
+            }
+          }
+        }
+      JAVASCRIPT
+
+      evaluate_script(script)
+    end
   end
 end

data/lib/chromate/elements/checkbox.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'chromate/element'
+
+module Chromate
+  module Elements
+    class Checkbox < Element
+      def initialize(selector, client, **options)
+        super
+        raise InvalidSelectorError, selector unless checkbox?
+      end
+
+      # @return [Boolean]
+      def checked?
+        attributes['checked'] == 'true'
+      end
+
+      # @return [self]
+      def check
+        click unless checked?
+
+        self
+      end
+
+      # @return [self]
+      def uncheck
+        click if checked?
+
+        self
+      end
+
+      # @return [self]
+      def toggle
+        click
+
+        self
+      end
+    end
+  end
+end

data/lib/chromate/elements/option.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'chromate/element'
+
+module Chromate
+  module Elements
+    class Option < Element
+      attr_reader :value
+
+      # @param [String] value
+      def initialize(value, client, node_id: nil, object_id: nil, root_id: nil)
+        super("option[value='#{value}']", client, node_id: node_id, object_id: object_id, root_id: root_id)
+
+        @value = value
+      end
+
+      def bounding_box
+        script = <<~JAVASCRIPT
+          function() {
+            const select = this.closest('select');
+            const rect = select.getBoundingClientRect();
+            return {
+              x: rect.x,
+              y: rect.y,
+              width: rect.width,
+              height: rect.height
+            };
+          }
+        JAVASCRIPT
+
+        result = evaluate_script(script)
+        # TODO: fix this
+        # The offset is due to the fact that the option return the wrong coordinates
+        # can be fixed by mesuring an option and use the offset multiply by the index of the option
+        {
+          'content' => [result['x'] + 100, result['y'] + 100],
+          'width' => result['width'],
+          'height' => result['height']
+        }
+      end
+    end
+  end
+end

data/lib/chromate/elements/radio.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'chromate/element'
+
+module Chromate
+  module Elements
+    class Radio < Element
+      def initialize(selector = nil, client = nil, **options)
+        if selector
+          super
+          raise InvalidSelectorError, selector unless radio?
+        else
+          super(**options)
+        end
+      end
+
+      # @return [Boolean]
+      def checked?
+        attributes['checked'] == 'true'
+      end
+
+      # @return [self]
+      def check
+        click unless checked?
+
+        self
+      end
+
+      # @return [self]
+      def uncheck
+        click if checked?
+
+        self
+      end
+    end
+  end
+end

data/lib/chromate/elements/select.rb

@@ -1,18 +1,62 @@
 # frozen_string_literal: true
 
 require 'chromate/element'
+require 'chromate/elements/option'
 
 module Chromate
   module Elements
     class Select < Element
-      # @param [String] selector
+      # @param [String] value
+      # @return [self]
       def select_option(value)
         click
-        opt = find_elements('option').find do |option|
-          option.attributes['value'] == value
-        end
-        opt.set_attribute('selected', 'true')
-        click
+
+        evaluate_script(javascript, arguments: [{ value: value }]) unless Chromate.configuration.native_control
+
+        Option.new(value, client).click
+
+        self
+      end
+
+      # @return [String|nil]
+      def selected_value
+        evaluate_script('function() { return this.value; }')
+      end
+
+      # @return [String|nil]
+      def selected_text
+        evaluate_script('function() {
+            const option = this.options[this.selectedIndex];
+            return option ? option.textContent.trim() : null;
+          }')
+      end
+
+      private
+
+      # @return [String]
+      def javascript
+        <<~JAVASCRIPT
+          function() {
+            this.focus();
+            this.dispatchEvent(new MouseEvent('mousedown'));
+
+            const options = Array.from(this.options);
+            const option = options.find(opt =>#{" "}
+              opt.value === arguments[0] || opt.textContent.trim() === arguments[0]
+            );
+
+            if (!option) {
+              throw new Error(`Option '${arguments[0]}' not found in select`);
+            }
+
+            this.value = option.value;
+
+            this.dispatchEvent(new Event('change', { bubbles: true }));
+            this.dispatchEvent(new Event('input', { bubbles: true }));
+
+            this.blur();
+          }
+        JAVASCRIPT
       end
     end
   end