appium_lib 9.0.0 → 9.1.0

data/lib/appium_lib/android/element/text.rb

@@ -1,7 +1,7 @@
 # TextView methods
 module Appium
   module Android
-    TextView = 'android.widget.TextView'
+    TextView = 'android.widget.TextView'.freeze
 
     # Find the first TextView that contains value or by index.
     # @param value [String, Integer] the value to find.

data/lib/appium_lib/android/element/textfield.rb

@@ -1,6 +1,6 @@
 module Appium
   module Android
-    EditText = 'android.widget.EditText'
+    EditText = 'android.widget.EditText'.freeze
 
     # Find the first EditText that contains value or by index.
     # @param value [String, Integer] the text to match exactly.

data/lib/appium_lib/android/helper.rb

@@ -50,8 +50,8 @@ module Appium
 
         string_ids = nil
 
-        if id_matches && id_matches.length > 0
-          space_suffix = ' ' * '  strings.xml: '.length
+        if id_matches && !id_matches.empty?
+          space_suffix = ' ' * 15 # 15 is '  strings.xml: '.length
           string_ids   = ''
 
           # add first
@@ -130,11 +130,11 @@ module Appium
       source_header  = source[0..doctype_string.length].downcase
       source_is_html = source_header.start_with?(doctype_string, '<html')
 
-      if source_is_html # parse html from webview
-        parser = @android_html_parser ||= Nokogiri::HTML::SAX::Parser.new(Common::HTMLElements.new)
-      else
-        parser = @android_native_parser ||= Nokogiri::XML::SAX::Parser.new(AndroidElements.new)
-      end
+      parser = if source_is_html # parse html from webview
+                 @android_html_parser ||= Nokogiri::HTML::SAX::Parser.new(Common::HTMLElements.new)
+               else
+                 @android_native_parser ||= Nokogiri::XML::SAX::Parser.new(AndroidElements.new)
+               end
       parser.document.reset # ensure document is reset before parsing
       parser.document.filter = class_name
       parser.parse source
@@ -208,7 +208,7 @@ module Appium
         index = results.length
         index -= 1 if index >= 0
       else
-        fail 'Index must be >= 1' unless index >= 1
+        raise 'Index must be >= 1' unless index >= 1
         index -= 1 if index >= 1
       end
 
@@ -289,9 +289,9 @@ module Appium
       value = %("#{value}")
 
       if class_name == '*'
-        return _resource_id(value, "new UiSelector().resourceId(#{value});") +
+        return (_resource_id(value, "new UiSelector().resourceId(#{value});") +
           "new UiSelector().descriptionContains(#{value});" \
-          "new UiSelector().textContains(#{value});"
+          "new UiSelector().textContains(#{value});")
       end
 
       class_name = %("#{class_name}")
@@ -326,9 +326,9 @@ module Appium
       value = %("#{value}")
 
       if class_name == '*'
-        return _resource_id(value, "new UiSelector().resourceId(#{value});") +
+        return (_resource_id(value, "new UiSelector().resourceId(#{value});") +
           "new UiSelector().description(#{value});" \
-          "new UiSelector().text(#{value});"
+          "new UiSelector().text(#{value});")
       end
 
       class_name = %("#{class_name}")

data/lib/appium_lib/android/mobile_methods.rb

@@ -8,9 +8,7 @@ module Appium
       #    find_elements :uiautomator, 'new UiSelector().clickable(true)'
       #   ```
       def extended(_mod)
-        Selenium::WebDriver::SearchContext.class_eval do
-          Selenium::WebDriver::SearchContext::FINDERS[:uiautomator] = '-android uiautomator'
-        end
+        ::Appium::Driver::SearchContext::FINDERS[:uiautomator] = '-android uiautomator'
       end
     end # class << self
   end # module Android

data/lib/appium_lib/common/command.rb

@@ -0,0 +1,55 @@
+module Appium
+  class Driver
+    module Commands
+      COMMAND_NO_ARG = {
+        # common
+        shake:                  [:post, 'session/:session_id/appium/device/shake'.freeze],
+        launch_app:             [:post, 'session/:session_id/appium/app/launch'.freeze],
+        close_app:              [:post, 'session/:session_id/appium/app/close'.freeze],
+        reset:                  [:post, 'session/:session_id/appium/app/reset'.freeze],
+        device_locked?:         [:post, 'session/:session_id/appium/device/is_locked'.freeze],
+
+        # Android
+        open_notifications:     [:post, 'session/:session_id/appium/device/open_notifications'.freeze],
+        toggle_airplane_mode:   [:post, 'session/:session_id/appium/device/toggle_airplane_mode'.freeze],
+        current_activity:       [:get,  'session/:session_id/appium/device/current_activity'.freeze],
+        get_network_connection: [:get,  'session/:session_id/network_connection'.freeze],
+
+        # iOS
+        device_time:            [:get,  'session/:session_id/appium/device/system_time'.freeze],
+        current_context:        [:get,  'session/:session_id/context'.freeze]
+      }.freeze
+
+      COMMAND = {
+        # common
+        available_contexts:     [:get,  'session/:session_id/contexts'.freeze],
+        set_context:            [:post, 'session/:session_id/context'.freeze],
+        app_strings:            [:post, 'session/:session_id/appium/app/strings'.freeze],
+        lock:                   [:post, 'session/:session_id/appium/device/lock'.freeze],
+        install_app:            [:post, 'session/:session_id/appium/device/install_app'.freeze],
+        remove_app:             [:post, 'session/:session_id/appium/device/remove_app'.freeze],
+        app_installed?:         [:post, 'session/:session_id/appium/device/app_installed'.freeze],
+        background_app:         [:post, 'session/:session_id/appium/app/background'.freeze],
+        hide_keyboard:          [:post, 'session/:session_id/appium/device/hide_keyboard'.freeze],
+        press_keycode:          [:post, 'session/:session_id/appium/device/press_keycode'.freeze],
+        long_press_keycode:     [:post, 'session/:session_id/appium/device/long_press_keycode'.freeze],
+        set_immediate_value:    [:post, 'session/:session_id/appium/element/:id/value'.freeze],
+        push_file:              [:post, 'session/:session_id/appium/device/push_file'.freeze],
+        pull_file:              [:post, 'session/:session_id/appium/device/pull_file'.freeze],
+        pull_folder:            [:post, 'session/:session_id/appium/device/pull_folder'.freeze],
+        get_settings:           [:get,  'session/:session_id/appium/settings'.freeze],
+        update_settings:        [:post, 'session/:session_id/appium/settings'.freeze],
+        touch_actions:          [:post, 'session/:session_id/touch/perform'.freeze],
+        multi_touch:            [:post, 'session/:session_id/touch/multi/perform'.freeze],
+
+        # Android
+        start_activity:         [:post, 'session/:session_id/appium/device/start_activity'.freeze],
+        end_coverage:           [:post, 'session/:session_id/appium/app/end_test_coverage'.freeze],
+        set_network_connection: [:post, 'session/:session_id/network_connection'.freeze],
+
+        # iOS
+        touch_id:               [:post, 'session/:session_id/appium/simulator/touch_id'.freeze]
+      }.merge(COMMAND_NO_ARG).merge(::Selenium::WebDriver::Remote::Bridge::COMMANDS).freeze
+    end
+  end
+end

data/lib/appium_lib/common/helper.rb

@@ -55,11 +55,11 @@ module Appium
 
     def _print_source(source)
       opts = Nokogiri::XML::ParseOptions::NOBLANKS | Nokogiri::XML::ParseOptions::NONET
-      if source.start_with? '<html'
-        doc = Nokogiri::HTML(source) { |cfg| cfg.options = opts }
-      else
-        doc = Nokogiri::XML(source)  { |cfg| cfg.options = opts }
-      end
+      doc = if source.start_with? '<html'
+              Nokogiri::HTML(source) { |cfg| cfg.options = opts }
+            else
+              Nokogiri::XML(source)  { |cfg| cfg.options = opts }
+            end
       puts doc.to_xml indent: 2
     end
 
@@ -215,8 +215,8 @@ module Appium
     end
 
     def _no_such_element
-      fail Selenium::WebDriver::Error::NoSuchElementError,
-           'An element could not be located on the page using the given search parameters.'
+      error_message = 'An element could not be located on the page using the given search parameters.'
+      raise Selenium::WebDriver::Error::NoSuchElementError, error_message
     end
   end # module Common
 end # module Appium

data/lib/appium_lib/common/patch.rb

@@ -52,10 +52,13 @@ end # module Appium
 #
 # Requires from lib/selenium/webdriver/remote.rb
 require 'selenium/webdriver/remote/capabilities'
+require 'selenium/webdriver/remote/w3c_capabilities'
 require 'selenium/webdriver/remote/bridge'
+require 'selenium/webdriver/remote/w3c_bridge'
 require 'selenium/webdriver/remote/server_error'
 require 'selenium/webdriver/remote/response'
 require 'selenium/webdriver/remote/commands'
+require 'selenium/webdriver/remote/w3c_commands'
 require 'selenium/webdriver/remote/http/common'
 require 'selenium/webdriver/remote/http/default'
 
@@ -67,14 +70,15 @@ def patch_webdriver_bridge
   Selenium::WebDriver::Remote::Bridge.class_eval do
     # Code from lib/selenium/webdriver/remote/bridge.rb
     def raw_execute(command, opts = {}, command_hash = nil)
-      verb, path = Selenium::WebDriver::Remote::Bridge::COMMANDS[command] ||
-                   fail(ArgumentError, "unknown command: #{command.inspect}")
-      path       = path.dup
+      verb, path = commands(command) || raise(ArgumentError, "unknown command: #{command.inspect}")
+      path = path.dup
 
       path[':session_id'] = @session_id if path.include?(':session_id')
 
       begin
-        opts.each { |key, value| path[key.inspect] = escaper.escape(value.to_s) }
+        opts.each do |key, value|
+          path[key.inspect] = escaper.escape(value.to_s)
+        end
       rescue IndexError
         raise ArgumentError, "#{opts.inspect} invalid for #{command.inspect}"
       end
@@ -107,10 +111,11 @@ def patch_webdriver_bridge
         else
           Appium::Logger.ap_info print_command
         end
-      else # non-standard command hash
+      elsif command_hash
+        # non-standard command hash
         # It's important to output this for debugging problems.
         # for example invalid JSON will not be a Hash
-        Appium::Logger.ap_info command_hash if command_hash
+        Appium::Logger.ap_info command_hash
       end
       delay = $driver.global_webdriver_http_sleep
       sleep delay if !delay.nil? && delay > 0
@@ -131,7 +136,7 @@ class Selenium::WebDriver::Remote::Response
     case val
     when Hash
       msg = val['origValue'] || val['message'] or return 'unknown error'
-      msg << " (#{ val['class'] })" if val['class']
+      msg << " (#{val['class']})" if val['class']
     when String
       msg = val
     else
@@ -144,5 +149,13 @@ end
 
 class Selenium::WebDriver::Remote::Http::Common # rubocop:disable Style/ClassAndModuleChildren
   remove_const :DEFAULT_HEADERS if defined? DEFAULT_HEADERS
-  DEFAULT_HEADERS = { 'Accept' => CONTENT_TYPE, 'User-Agent' => "appium/ruby_lib/#{::Appium::VERSION}" }
+  DEFAULT_HEADERS = { 'Accept' => CONTENT_TYPE, 'User-Agent' => "appium/ruby_lib/#{::Appium::VERSION}" }.freeze
+end
+
+def patch_remote_driver_commands
+  Selenium::WebDriver::Remote::Bridge.class_eval do
+    def commands(command)
+      ::Appium::Driver::Commands::COMMAND[command]
+    end
+  end
 end

data/lib/appium_lib/common/search_context.rb

@@ -0,0 +1,10 @@
+module Appium
+  class Driver
+    module SearchContext
+      # rubocop:disable Style/MutableConstant
+      FINDERS = {
+        accessibility_id: 'accessibility id'
+      }
+    end
+  end
+end

data/lib/appium_lib/common/version.rb

@@ -1,5 +1,5 @@
 module Appium
   # Version and Date are defined on the 'Appium' module, not 'Appium::Common'
-  VERSION = '9.0.0' unless defined? ::Appium::VERSION
-  DATE    = '2016-12-09' unless defined? ::Appium::DATE
+  VERSION = '9.1.0'.freeze unless defined? ::Appium::VERSION
+  DATE    = '2016-12-18'.freeze unless defined? ::Appium::DATE
 end

data/lib/appium_lib/common/wait.rb

@@ -11,7 +11,7 @@ module Appium
       invalid_keys = []
       opts.keys.each { |key| invalid_keys << key unless valid_keys.include?(key) }
       # [:one, :two] => :one, :two
-      fail "Invalid keys #{invalid_keys.to_s[1..-2]}. Valid keys are #{valid_keys.to_s[1..-2]}" unless invalid_keys.empty?
+      raise "Invalid keys #{invalid_keys.to_s[1..-2]}. Valid keys are #{valid_keys.to_s[1..-2]}" unless invalid_keys.empty?
 
       timeout        = opts.fetch(:timeout, 30)
       interval       = opts.fetch(:interval, 0.5)
@@ -24,12 +24,10 @@ module Appium
 
       until Time.now > end_time
         begin
-          if return_if_true
-            result = block.call
-            return result if result
-          else
-            return block.call
-          end
+          return block.call unless return_if_true
+
+          result = block.call
+          return result if result
         rescue ::Errno::ECONNREFUSED => e
           raise e
         rescue *ignored => last_error # rubocop:disable Lint/HandleExceptions
@@ -39,21 +37,17 @@ module Appium
         sleep interval
       end
 
-      if message
-        msg = message.dup
-      else
-        msg = "timed out after #{timeout} seconds"
-      end
+      msg = message ? message.dup : "timed out after #{timeout} seconds"
 
       msg << " (#{last_error.message})" if last_error
 
-      fail Selenium::WebDriver::Error::TimeOutError, msg
+      raise Selenium::WebDriver::Error::TimeOutError, msg
     end
 
     # process opts before calling _generic_wait
     def _process_wait_opts(opts)
       opts = { timeout: opts } if opts.is_a?(Numeric)
-      fail 'opts must be a hash' unless opts.is_a? Hash
+      raise 'opts must be a hash' unless opts.is_a? Hash
       opts
     end
 

data/lib/appium_lib/device/device.rb

@@ -4,24 +4,6 @@ module Appium
   module Device
     extend Forwardable
 
-    NoArgMethods = {
-      post: {
-        open_notifications:   'session/:session_id/appium/device/open_notifications',
-        shake:                'session/:session_id/appium/device/shake',
-        launch_app:           'session/:session_id/appium/app/launch',
-        close_app:            'session/:session_id/appium/app/close',
-        reset:                'session/:session_id/appium/app/reset',
-        toggle_airplane_mode: 'session/:session_id/appium/device/toggle_airplane_mode',
-        device_locked?:       'session/:session_id/appium/device/is_locked'
-      },
-      get:  {
-        device_time:            'session/:session_id/appium/device/system_time',
-        current_activity:       'session/:session_id/appium/device/current_activity',
-        current_context:        'session/:session_id/context',
-        get_network_connection: 'session/:session_id/network_connection'
-      }
-    }
-
     # @!method app_strings
     #   Return the hash of all localization strings.
     #   ```ruby
@@ -117,49 +99,49 @@ module Appium
       def extended(_mod)
         extend_webdriver_with_forwardable
 
-        NoArgMethods.each_pair do |verb, pair|
-          pair.each_pair { |command, path| add_endpoint_method command, path, verb }
+        ::Appium::Driver::Commands::COMMAND_NO_ARG.each_key do |method|
+          add_endpoint_method method
         end
 
-        add_endpoint_method(:available_contexts, 'session/:session_id/contexts', :get) do
+        add_endpoint_method(:available_contexts) do
           def available_contexts
             # return empty array instead of nil on failure
             execute(:available_contexts, {}) || []
           end
         end
 
-        add_endpoint_method(:app_strings, 'session/:session_id/appium/app/strings') do
+        add_endpoint_method(:app_strings) do
           def app_strings(language = nil)
             opts = language ? { language: language } : {}
             execute :app_strings, {}, opts
           end
         end
 
-        add_endpoint_method(:lock, 'session/:session_id/appium/device/lock') do
+        add_endpoint_method(:lock) do
           def lock(duration)
             execute :lock, {}, seconds: duration
           end
         end
 
-        add_endpoint_method(:install_app, 'session/:session_id/appium/device/install_app') do
+        add_endpoint_method(:install_app) do
           def install_app(path)
             execute :install_app, {}, appPath: path
           end
         end
 
-        add_endpoint_method(:remove_app, 'session/:session_id/appium/device/remove_app') do
+        add_endpoint_method(:remove_app) do
           def remove_app(id)
             execute :remove_app, {}, appId: id
           end
         end
 
-        add_endpoint_method(:app_installed?, 'session/:session_id/appium/device/app_installed') do
+        add_endpoint_method(:app_installed?) do
           def app_installed?(app_id)
             execute :app_installed?, {}, bundleId: app_id
           end
         end
 
-        add_endpoint_method(:background_app, 'session/:session_id/appium/app/background') do
+        add_endpoint_method(:background_app) do
           def background_app(duration)
             execute :background_app, {}, seconds: duration
           end
@@ -178,18 +160,18 @@ module Appium
         #   start_activity app_package: 'io.appium.android.apis',
         #     app_activity: '.accessibility.AccessibilityNodeProviderActivity'
         #   ```
-        add_endpoint_method(:start_activity, 'session/:session_id/appium/device/start_activity') do
+        add_endpoint_method(:start_activity) do
           def start_activity(opts)
-            fail 'opts must be a hash' unless opts.is_a? Hash
+            raise 'opts must be a hash' unless opts.is_a? Hash
             app_package = opts[:app_package]
-            fail 'app_package is required' unless app_package
+            raise 'app_package is required' unless app_package
             app_activity = opts[:app_activity]
-            fail 'app_activity is required' unless opts[:app_activity]
+            raise 'app_activity is required' unless opts[:app_activity]
             app_wait_package  = opts.fetch(:app_wait_package, '')
             app_wait_activity = opts.fetch(:app_wait_activity, '')
 
             unknown_opts = opts.keys - [:app_package, :app_activity, :app_wait_package, :app_wait_activity]
-            fail "Unknown options #{unknown_opts}" unless unknown_opts.empty?
+            raise "Unknown options #{unknown_opts}" unless unknown_opts.empty?
 
             execute :start_activity, {}, appPackage: app_package,
                                          appActivity: app_activity,
@@ -198,13 +180,13 @@ module Appium
           end
         end
 
-        add_endpoint_method(:set_context, 'session/:session_id/context') do
+        add_endpoint_method(:set_context) do
           def set_context(context = null)
             execute :set_context, {}, name: context
           end
         end
 
-        add_endpoint_method(:hide_keyboard, 'session/:session_id/appium/device/hide_keyboard') do
+        add_endpoint_method(:hide_keyboard) do
           def hide_keyboard(close_key = nil)
             # Android can only tapOutside.
             if $driver.device_is_android?
@@ -222,7 +204,7 @@ module Appium
           end
         end
 
-        add_endpoint_method(:press_keycode, 'session/:session_id/appium/device/press_keycode') do
+        add_endpoint_method(:press_keycode) do
           def press_keycode(key, metastate = nil)
             args             = { keycode: key }
             args[:metastate] = metastate if metastate
@@ -230,7 +212,7 @@ module Appium
           end
         end
 
-        add_endpoint_method(:long_press_keycode, 'session/:session_id/appium/device/long_press_keycode') do
+        add_endpoint_method(:long_press_keycode) do
           def long_press_keycode(key, metastate = nil)
             args             = { keycode: key }
             args[:metastate] = metastate if metastate
@@ -239,20 +221,20 @@ module Appium
         end
 
         # TODO: TEST ME
-        add_endpoint_method(:set_immediate_value, 'session/:session_id/appium/element/:id/value') do
+        add_endpoint_method(:set_immediate_value) do
           def set_immediate_value(element, value)
             execute :set_immediate_value, { id: element.ref }, value: value
           end
         end
 
-        add_endpoint_method(:push_file, 'session/:session_id/appium/device/push_file') do
+        add_endpoint_method(:push_file) do
           def push_file(path, filedata)
             encoded_data = Base64.encode64 filedata
             execute :push_file, {}, path: path, data: encoded_data
           end
         end
 
-        add_endpoint_method(:pull_file, 'session/:session_id/appium/device/pull_file') do
+        add_endpoint_method(:pull_file) do
           def pull_file(path)
             data = execute :pull_file, {}, path: path
             Base64.decode64 data
@@ -260,7 +242,7 @@ module Appium
         end
 
         # TODO: TEST ME
-        add_endpoint_method(:pull_folder, 'session/:session_id/appium/device/pull_folder') do
+        add_endpoint_method(:pull_folder) do
           def pull_folder(path)
             data = execute :pull_folder, {}, path: path
             Base64.decode64 data
@@ -268,26 +250,26 @@ module Appium
         end
 
         # TODO: TEST ME
-        add_endpoint_method(:touch_id, 'session/:session_id/appium/simulator/touch_id') do
+        add_endpoint_method(:touch_id) do
           def touch_id(match = true)
             execute :touch_id, {}, match: match
           end
         end
 
         # TODO: TEST ME
-        add_endpoint_method(:end_coverage, 'session/:session_id/appium/app/end_test_coverage') do
+        add_endpoint_method(:end_coverage) do
           def end_coverage(path, intent)
             execute :end_coverage, {}, path: path, intent: intent
           end
         end
 
-        add_endpoint_method(:get_settings, 'session/:session_id/appium/settings', :get) do
+        add_endpoint_method(:get_settings) do
           def get_settings
             execute :get_settings, {}
           end
         end
 
-        add_endpoint_method(:update_settings, 'session/:session_id/appium/settings') do
+        add_endpoint_method(:update_settings) do
           def update_settings(settings)
             execute :update_settings, {}, settings: settings
           end
@@ -308,7 +290,7 @@ module Appium
         #   2 (Wifi only)      | 0    | 1    | 0
         #   0 (None)           | 0    | 0    | 0
         #
-        add_endpoint_method(:set_network_connection, 'session/:session_id/network_connection') do
+        add_endpoint_method(:set_network_connection) do
           def set_network_connection(mode)
             execute :set_network_connection, {}, type: mode
           end
@@ -322,13 +304,11 @@ module Appium
       # def extended
 
       # @private
-      def add_endpoint_method(method, path, verb = :post)
+      def add_endpoint_method(method)
         if block_given?
-          # &Proc.new with no args passes the passed_in block
-          # Because creating Procs from blocks is slow
-          create_bridge_command method, verb, path, &Proc.new
+          create_bridge_command method, &Proc.new
         else
-          create_bridge_command method, verb, path
+          create_bridge_command method
         end
 
         delegate_driver_method method
@@ -355,31 +335,7 @@ module Appium
       end
 
       # @private
-      def create_bridge_command(method, verb, path)
-        Selenium::WebDriver::Remote::Bridge.class_eval do
-          command method, verb, path
-          if block_given?
-            class_eval(&Proc.new)
-          else
-            define_method(method) { execute method }
-          end
-        end
-      end
-
-      # @private
-      def add_bridge_method(method)
-        if block_given?
-          create_bridge method, &Proc.new
-        else
-          create_bridge method
-        end
-
-        delegate_driver_method method
-        delegate_from_appium_driver method
-      end
-
-      # @private
-      def create_bridge(method)
+      def create_bridge_command(method)
         Selenium::WebDriver::Remote::Bridge.class_eval do
           if block_given?
             class_eval(&Proc.new)
@@ -399,19 +355,45 @@ module Appium
       #   ```
       def extend_search_contexts
         Selenium::WebDriver::SearchContext.class_eval do
-          Selenium::WebDriver::SearchContext::FINDERS[:accessibility_id] = 'accessibility id'
+          def find_element_with_appium(*args)
+            how, what = extract_args(args)
+
+            finders = ::Selenium::WebDriver::SearchContext::FINDERS.merge ::Appium::Driver::SearchContext::FINDERS
+            by = finders[how.to_sym]
+            raise ArgumentError, "cannot find element by #{how.inspect}" unless by
+
+            begin
+              bridge.find_element_by by, what.to_s, ref
+            rescue Selenium::WebDriver::Error::TimeOutError
+              raise Selenium::WebDriver::Error::NoSuchElementError
+            end
+          end
+
+          def find_elements_with_appium(*args)
+            how, what = extract_args(args)
+
+            finders = ::Selenium::WebDriver::SearchContext::FINDERS.merge ::Appium::Driver::SearchContext::FINDERS
+            by = finders[how.to_sym]
+            raise ArgumentError, "cannot find element by #{how.inspect}" unless by
+
+            begin
+              bridge.find_elements_by by, what.to_s, ref
+            rescue Selenium::WebDriver::Error::TimeOutError
+              raise Selenium::WebDriver::Error::NoSuchElementError
+            end
+          end
         end
       end
 
       def add_touch_actions
-        add_endpoint_method(:touch_actions, 'session/:session_id/touch/perform') do
+        add_endpoint_method(:touch_actions) do
           def touch_actions(actions)
             actions = { actions: [actions].flatten }
             execute :touch_actions, {}, actions
           end
         end
 
-        add_endpoint_method(:multi_touch, 'session/:session_id/touch/multi/perform') do
+        add_endpoint_method(:multi_touch) do
           def multi_touch(actions)
             execute :multi_touch, {}, actions: actions
           end
@@ -440,7 +422,7 @@ module Appium
         #   ```ruby
         #   ime_activate engine: 'com.android.inputmethod.latin/.LatinIME'
         #   ```
-        add_bridge_method(:ime_activate) do
+        add_endpoint_method(:ime_activate) do
           def ime_activate(ime_name)
             execute :imeActivateEngine, {}, engine: ime_name
           end
@@ -453,7 +435,7 @@ module Appium
         #   ```ruby
         #   ime_available_engines #=> Get the list of IME installed in the target device
         #   ```
-        add_bridge_method(:ime_available_engines) do
+        add_endpoint_method(:ime_available_engines) do
           def ime_available_engines
             execute :imeGetAvailableEngines
           end
@@ -466,7 +448,7 @@ module Appium
         #   ```ruby
         #   ime_active_engine #=> Get the current active IME such as 'com.android.inputmethod.latin/.LatinIME'
         #   ```
-        add_bridge_method(:ime_active_engine) do
+        add_endpoint_method(:ime_active_engine) do
           def ime_active_engine
             execute :imeGetActiveEngine
           end
@@ -479,7 +461,7 @@ module Appium
         #   ```ruby
         #   ime_activated #=> True if IME is activated
         #   ```
-        add_bridge_method(:ime_activated) do
+        add_endpoint_method(:ime_activated) do
           def ime_activated
             execute :imeIsActivated
           end
@@ -493,7 +475,7 @@ module Appium
         #   ```ruby
         #   ime_deactivate #=> Deactivate current IME engine
         #   ```
-        add_bridge_method(:ime_deactivate) do
+        add_endpoint_method(:ime_deactivate) do
           def ime_deactivate
             execute :imeDeactivate, {}
           end