appium_lib_core 4.1.0 → 9.1.0

data/lib/appium_lib_core/common/base/bridge.rb

@@ -15,53 +15,78 @@
 module Appium
   module Core
     class Base
+      class LocatorConverter
+        def convert(how, what)
+          [how, what]
+        end
+      end # LocatorConverter
+
       class Bridge < ::Selenium::WebDriver::Remote::Bridge
+        include Device::DeviceLock
+        include Device::Keyboard
+        include Device::ImeActions
+        include Device::Setting
+        include Device::Context
+        include Device::FileManagement
+        include Device::KeyEvent
+        include Device::ImageComparison
+        include Device::AppManagement
+        include Device::AppState
+        include Device::ScreenRecord::Command
+        include Device::Device
+        include Device::ExecuteDriver
+        include Device::Orientation
+
+        Bridge.locator_converter = LocatorConverter.new
+
         # Prefix for extra capability defined by W3C
         APPIUM_PREFIX = 'appium:'
 
-        # TODO: Remove the forceMjsonwp after Appium server won't need it
-        FORCE_MJSONWP = :forceMjsonwp
+        # No 'browserName' means the session is native appium connection
+        APPIUM_NATIVE_BROWSER_NAME = 'appium'
+
+        attr_reader :available_commands
+
+        def browser
+          @browser ||= begin
+            name = @capabilities&.browser_name
+            name ? name.tr(' ', '_').downcase.to_sym : 'unknown'
+          rescue KeyError
+            APPIUM_NATIVE_BROWSER_NAME
+          end
+        end
 
-        # Almost same as self.handshake in ::Selenium::WebDriver::Remote::Bridge
+        # Appium only.
+        # Attach to an existing session.
         #
-        # Implements protocol handshake which:
+        # @param [String] The session id to attach to.
+        # @param [String] platform_name The platform name to keep in the dummy capabilities
+        # @param [String] platform_name The automation name to keep in the dummy capabilities
+        # @return [::Appium::Core::Base::Capabilities]
         #
-        #   1. Creates session with driver.
-        #   2. Sniffs response.
-        #   3. Based on the response, understands which dialect we should use.
+        # @example
         #
-        # @return [Bridge::MJSONWP, Bridge::W3C]
+        #   new_driver = ::Appium::Core::Driver.attach_to(
+        #     driver.session_id,
+        #     url: 'http://127.0.0.1:4723/wd/hub', automation_name: 'UiAutomator2', platform_name: 'Android'
+        #   )
         #
-        def self.handshake(**opts)
-          desired_capabilities = opts.delete(:desired_capabilities) { ::Selenium::WebDriver::Remote::Capabilities.new }
-
-          if desired_capabilities.is_a?(Symbol)
-            unless ::Selenium::WebDriver::Remote::Capabilities.respond_to?(desired_capabilities)
-              raise ::Selenium::WebDriver::Error::WebDriverError, "invalid desired capability: #{desired_capabilities.inspect}"
-            end
-
-            desired_capabilities = ::Selenium::WebDriver::Remote::Capabilities.__send__(desired_capabilities)
-          end
-
-          bridge = new(opts)
-          capabilities = bridge.create_session(desired_capabilities)
-
-          case bridge.dialect
-          when :oss # for MJSONWP
-            Bridge::MJSONWP.new(capabilities, bridge.session_id, **opts)
-          when :w3c
-            Bridge::W3C.new(capabilities, bridge.session_id, **opts)
-          else
-            raise CoreError, 'cannot understand dialect'
-          end
+        def attach_to(session_id, platform_name, automation_name)
+          @available_commands = ::Appium::Core::Commands::COMMANDS.dup
+          @session_id = session_id
+
+          # generate a dummy capabilities instance which only has the given platformName and automationName
+          @capabilities = ::Appium::Core::Base::Capabilities.new(
+            'platformName' => platform_name,
+            'automationName' => automation_name
+          )
         end
 
         # Override
-        # Creates session handling both OSS and W3C dialects.
-        # Copy from Selenium::WebDriver::Remote::Bridge to keep using +merged_capabilities+ for Appium
+        # Creates session handling.
         #
-        # @param [::Selenium::WebDriver::Remote::W3C::Capabilities, Hash] desired_capabilities A capability
-        # @return [::Selenium::WebDriver::Remote::Capabilities, ::Selenium::WebDriver::Remote::W3C::Capabilities]
+        # @param [::Appium::Core::Base::Capabilities, Hash] capabilities A capability
+        # @return [::Appium::Core::Base::Capabilities]
         #
         # @example
         #
@@ -79,44 +104,31 @@ module Appium
         #     }
         #   }
         #   core = ::Appium::Core.for(caps)
-        #   driver = core.start_driver #=> driver.dialect == :w3c if the Appium server support W3C.
+        #   driver = core.start_driver
         #
-        def create_session(desired_capabilities)
-          response = execute(:new_session, {}, merged_capabilities(desired_capabilities))
+        def create_session(capabilities)
+          @available_commands = ::Appium::Core::Commands::COMMANDS.dup
 
-          @session_id = response['sessionId']
-          oss_status = response['status'] # for compatibility with Appium 1.7.1-
-          value = response['value']
-
-          if value.is_a?(Hash) # include for W3C format
-            @session_id = value['sessionId'] if value.key?('sessionId')
-
-            if value.key?('capabilities')
-              value = value['capabilities']
-            elsif value.key?('value')
-              value = value['value']
-            end
-          end
+          always_match = add_appium_prefix(capabilities)
+          response = execute(:new_session, {}, { capabilities: { alwaysMatch: always_match, firstMatch: [{}] } })
 
+          @session_id = response['sessionId']
           raise ::Selenium::WebDriver::Error::WebDriverError, 'no sessionId in returned payload' unless @session_id
 
-          json_create(oss_status, value)
+          @capabilities = json_create(response['capabilities'])
         end
 
         # Append +appium:+ prefix for Appium following W3C spec
         # https://www.w3.org/TR/webdriver/#dfn-validate-capabilities
         #
-        # @param [::Selenium::WebDriver::Remote::W3C::Capabilities, Hash] capabilities A capability
-        # @return [::Selenium::WebDriver::Remote::W3C::Capabilities]
+        # @param [::Appium::Core::Base::Capabilities, Hash] capabilities A capability
+        # @return [::Appium::Core::Base::Capabilities]
         def add_appium_prefix(capabilities)
-          w3c_capabilities = ::Selenium::WebDriver::Remote::W3C::Capabilities.new
+          w3c_capabilities = ::Appium::Core::Base::Capabilities.new
 
-          capabilities = capabilities.__send__(:capabilities) unless capabilities.is_a?(Hash)
+          capabilities = capabilities.send(:capabilities) unless capabilities.is_a?(Hash)
 
           capabilities.each do |name, value|
-            next if value.nil?
-            next if value.is_a?(String) && value.empty?
-
             capability_name = name.to_s
             w3c_name = extension_prefix?(capability_name) ? name : "#{APPIUM_PREFIX}#{capability_name}"
 
@@ -128,61 +140,211 @@ module Appium
 
         private
 
-        def camel_case(str)
-          str.gsub(/_([a-z])/) { Regexp.last_match(1).upcase }
+        def camel_case(str_or_sym)
+          str_or_sym.to_s.gsub(/_([a-z])/) { Regexp.last_match(1).upcase }
         end
 
         def extension_prefix?(capability_name)
-          snake_cased_capability_names = ::Selenium::WebDriver::Remote::W3C::Capabilities::KNOWN.map(&:to_s)
+          snake_cased_capability_names = ::Appium::Core::Base::Capabilities::KNOWN.map(&:to_s)
           camel_cased_capability_names = snake_cased_capability_names.map { |v| camel_case(v) }
 
+          # Check 'EXTENSION_CAPABILITY_PATTERN'
           snake_cased_capability_names.include?(capability_name) ||
             camel_cased_capability_names.include?(capability_name) ||
-            capability_name.match(::Selenium::WebDriver::Remote::W3C::Capabilities::EXTENSION_CAPABILITY_PATTERN)
+            capability_name.match(':')
         end
 
-        def json_create(oss_status, value)
-          if oss_status
-            ::Selenium::WebDriver.logger.info 'Detected OSS dialect.'
-            @dialect = :oss
-            ::Selenium::WebDriver::Remote::Capabilities.json_create(value)
-          else
-            ::Selenium::WebDriver.logger.info 'Detected W3C dialect.'
-            @dialect = :w3c
-            ::Selenium::WebDriver::Remote::W3C::Capabilities.json_create(value)
-          end
+        def json_create(value)
+          ::Appium::Core::Base::Capabilities.json_create(value)
         end
 
-        def delete_force_mjsonwp(capabilities)
-          w3c_capabilities = ::Selenium::WebDriver::Remote::W3C::Capabilities.new
+        public
 
-          capabilities = capabilities.__send__(:capabilities) unless capabilities.is_a?(Hash)
-          capabilities.each do |name, value|
-            next if value.nil?
-            next if value.is_a?(String) && value.empty?
-            next if name == FORCE_MJSONWP
+        # command for Appium 2.0.
+
+        # Example:
+        #   driver.add_command(name: :available_contexts, method: :get, url: 'session/:session_id/contexts') do
+        #     execute(:available_contexts, {}) || []
+        #   end
+        # Then,
+        #   driver.available_contexts #=> ["NATIVE_APP"]
+
+        # def add_command(method:, url:, name:, &block)
+        #   Bridge.add_command name, method, url, &block
+        # end
+
+        def add_command(method:, url:, name:, &block)
+          ::Appium::Logger.info "Overriding the method '#{name}' for '#{url}'" if @available_commands.key? name
+
+          @available_commands[name] = [method, url]
+
+          ::Appium::Core::Device.add_endpoint_method name, &block
+        end
 
-            w3c_capabilities[name] = value
+        def commands(command)
+          @available_commands[command] || Bridge.extra_commands[command]
+        end
+
+        def status
+          execute :status
+        end
+
+        # Perform 'touch' actions for W3C module.
+        # Generate +touch+ pointer action here and users can use this via +driver.action+
+        # - https://www.selenium.dev/documentation/webdriver/actions_api/
+        # - https://www.selenium.dev/selenium/docs/api/rb/Selenium/WebDriver/ActionBuilder.html
+        # - https://www.selenium.dev/selenium/docs/api/rb/Selenium/WebDriver/PointerActions.html
+        # - https://www.selenium.dev/selenium/docs/api/rb/Selenium/WebDriver/KeyActions.html
+        #
+        # The pointer type is 'touch' by default in the Appium Ruby client.
+        #
+        # @example
+        #
+        #     element = @driver.find_element(:id, "some id")
+        #     @driver.action.click(element).perform # The 'click' is a part of 'PointerActions'
+        #
+        def action(_deprecated_async = nil, async: false, devices: nil)
+          ::Selenium::WebDriver::ActionBuilder.new(
+            self,
+            devices: devices || [::Selenium::WebDriver::Interactions.pointer(:touch, name: 'touch')],
+            async: async,
+            duration: 50 # milliseconds
+          )
+        end
+
+        # Port from MJSONWP
+        def get_timeouts
+          execute :get_timeouts
+        end
+
+        # For Appium
+        # override
+        def element_displayed?(element)
+          # For W3C
+          # https://github.com/SeleniumHQ/selenium/commit/b618499adcc3a9f667590652c5757c0caa703289
+          # execute_atom :isDisplayed, element
+          execute :is_element_displayed, id: element.id
+        end
+
+        # For Appium
+        # override
+        def element_attribute(element, name)
+          # For W3C in Selenium Client
+          # execute_atom :getAttribute, element, name.
+          # 'dom_attribute' in the WebDriver Selenium.
+          execute :get_element_attribute, id: element.id, name: name
+        end
+
+        # For Appium
+        alias switch_to_active_element active_element
+
+        # For Appium
+        # @param [Hash] id The id which can get as a response from server
+        # @return [::Appium::Core::Element]
+        def convert_to_element(id)
+          ::Appium::Core::Element.new self, element_id_from(id)
+        end
+
+        # For Appium
+        # override
+        # called in 'extend DriverExtensions::HasNetworkConnection'
+        def network_connection
+          execute :get_network_connection
+        end
+
+        # For Appium
+        # override
+        # called in 'extend DriverExtensions::HasNetworkConnection'
+        def network_connection=(type)
+          execute :set_network_connection, {}, { parameters: { type: type } }
+        end
+
+        # For Appium
+        # No implementation for W3C webdriver module
+        # called in 'extend DriverExtensions::HasLocation'
+        def location
+          obj = execute(:get_location) || {}
+          ::Appium::Location.new obj['latitude'], obj['longitude'], obj['altitude']
+        end
+
+        # For Appium
+        # No implementation for W3C webdriver module
+        def set_location(lat, lon, alt = 0.0, speed: nil, satellites: nil)
+          loc = { latitude: lat, longitude: lon, altitude: alt }
+          loc[:speed] = speed unless speed.nil?
+          loc[:satellites] = satellites unless satellites.nil?
+          execute :set_location, {}, { location: loc }
+        end
+
+        #
+        # logs
+        #
+        # For Appium
+        # No implementation for W3C webdriver module
+        def available_log_types
+          types = execute :get_available_log_types
+          Array(types).map(&:to_sym)
+        end
+
+        # For Appium
+        # No implementation for W3C webdriver module
+        def log(type)
+          data = execute :get_log, {}, { type: type.to_s }
+
+          Array(data).map do |l|
+            ::Selenium::WebDriver::LogEntry.new l.fetch('level', 'UNKNOWN'), l.fetch('timestamp'), l.fetch('message')
+          rescue KeyError
+            next
           end
+        end
 
-          w3c_capabilities
+        # For Appium
+        def log_event(vendor, event)
+          execute :post_log_event, {}, { vendor: vendor, event: event }
         end
 
-        def merged_capabilities(desired_capabilities)
-          force_mjsonwp = desired_capabilities[FORCE_MJSONWP]
-          desired_capabilities = delete_force_mjsonwp(desired_capabilities) unless force_mjsonwp.nil?
+        # For Appium
+        def log_events(type = nil)
+          args = {}
+          args['type'] = type unless type.nil?
 
-          ::Appium::Logger.warn "'forceMjsonwp' no longer works. Sending both W3C and MJSONWP capabilities" if force_mjsonwp
+          execute :get_log_events, {}, args
+        end
 
-          new_caps = add_appium_prefix(desired_capabilities)
-          w3c_capabilities = ::Selenium::WebDriver::Remote::W3C::Capabilities.from_oss(new_caps)
+        def viewport_screenshot
+          execute_script('mobile: viewportScreenshot')
+        end
 
-          {
-            desiredCapabilities: desired_capabilities,
-            capabilities: {
-              firstMatch: [w3c_capabilities]
-            }
-          }
+        def element_screenshot(element_id)
+          execute :take_element_screenshot, id: element_id
+        end
+
+        # for selenium-webdriver compatibility in chrome browser session.
+        # This may be needed in selenium-webdriver 4.8 or over? (around the version)
+        # when a session starts browserName: 'chrome' for bridge.
+        # This method is not only for Android, but also chrome desktop browser as well.
+        # So this bridge itself does not restrict the target module.
+        def send_command(command_params)
+          execute :chrome_send_command, {}, command_params
+        end
+
+        private
+
+        def unwrap_script_result(arg)
+          case arg
+          when Array
+            arg.map { |e| unwrap_script_result(e) }
+          when Hash
+            element_id = element_id_from(arg)
+            return ::Appium::Core::Element.new(self, element_id) if element_id
+
+            shadow_root_id = shadow_root_id_from(arg)
+            return ::Selenium::WebDriver::Remote::ShadowRoot.new self, shadow_root_id if shadow_root_id
+
+            arg.each { |k, v| arg[k] = unwrap_script_result(v) }
+          else
+            arg
+          end
         end
       end # class Bridge
     end # class Base

data/lib/appium_lib_core/common/base/capabilities.rb

@@ -15,14 +15,27 @@
 module Appium
   module Core
     class Base
-      module Capabilities
-        # @private
-        # @param [Hash] opts_caps Capabilities for Appium server. All capability keys are converted to lowerCamelCase when
-        #                         this client sends capabilities to Appium server as JSON format.
-        # @return [::Selenium::WebDriver::Remote::W3C::Capabilities] Return instance of Appium::Core::Base::Capabilities
-        #                         inherited ::Selenium::WebDriver::Remote::W3C::Capabilities
-        def self.create_capabilities(opts_caps = {})
-          ::Selenium::WebDriver::Remote::W3C::Capabilities.new(opts_caps)
+      class Capabilities < ::Selenium::WebDriver::Remote::Capabilities
+        # TODO: Move to 'Options' way instead of 'Capabilities'.
+        # Selenium 5 will have Options instead of 'Capabilities'.
+        # https://github.com/SeleniumHQ/selenium/blob/trunk/rb/lib/selenium/webdriver/common/options.rb
+        # Then, Ruby client also shoud move to the Options way.
+        # Appium's capabilities could change by depending on Appium versions. So it does not have
+        # standard options like chrome and firefox etc. So, the implementation should differ from
+        # other browsers. But here should inherit `Options` to follow Selenium.
+
+        # Method override
+        # FIXME: when we drop "symbolize_keys", this can be removed.
+        def convert_key(key)
+          case key
+          when String
+            key.to_s
+          when Symbol
+            # here do not convert to camel case
+            key.to_s
+          else
+            raise TypeError, "expected String or Symbol, got #{key.inspect}:#{key.class}"
+          end
         end
       end
     end

data/lib/appium_lib_core/common/{command/mjsonwp.rb → base/device_ime.rb}

@@ -14,15 +14,36 @@
 
 module Appium
   module Core
-    module Commands
-      module MJSONWP
-        COMMANDS = ::Appium::Core::Commands::COMMANDS.merge(::Appium::Core::Base::Commands::OSS).merge(
-          {
-            # W3C already has.
-            take_element_screenshot:    [:get, 'session/:session_id/element/:id/screenshot']
-          }
-        ).freeze
-      end # module MJSONWP
-    end # module Commands
-  end # module Core
-end # Appium
+    class Base
+      #
+      # @api private
+      #
+      class DeviceIME
+        # @private this class is private
+        def initialize(bridge)
+          @bridge = bridge
+        end
+
+        def activate(ime_name)
+          @bridge.ime_activate(ime_name)
+        end
+
+        def available_engines
+          @bridge.ime_available_engines
+        end
+
+        def active_engine
+          @bridge.ime_active_engine
+        end
+
+        def activated?
+          @bridge.ime_activated
+        end
+
+        def deactivate
+          @bridge.ime_deactivate
+        end
+      end
+    end
+  end
+end