calabash-cucumber 0.19.2 → 0.20.0

data/lib/calabash-cucumber/automator/device_agent.rb

@@ -0,0 +1,424 @@
+# @!visibility private
+module Calabash
+  module Cucumber
+    module Automator
+
+      require "calabash-cucumber/automator/automator"
+
+      # @!visibility private
+      class DeviceAgent < Calabash::Cucumber::Automator::Automator
+
+        require "run_loop"
+        require "calabash-cucumber/map"
+
+        require "calabash-cucumber/query_helpers"
+        include Calabash::Cucumber::QueryHelpers
+
+        require "calabash-cucumber/status_bar_helpers"
+        include Calabash::Cucumber::StatusBarHelpers
+
+        require "calabash-cucumber/rotation_helpers"
+        include Calabash::Cucumber::RotationHelpers
+
+        require "calabash-cucumber/environment_helpers"
+        include Calabash::Cucumber::EnvironmentHelpers
+
+        require "calabash-cucumber/automator/coordinates"
+
+        # @!visibility private
+        def self.expect_valid_args(args)
+          if args.nil?
+            raise ArgumentError, "Expected args to be a non-nil Array"
+          end
+
+          if !args.is_a?(Array)
+            raise ArgumentError, %Q[Expected args to be an Array, found:
+
+args = #{args}
+
+]
+          end
+
+          if args.count != 1
+            raise(ArgumentError,
+                  %Q[Expected args to be an Array with one element, found:
+
+args = #{args}
+
+])
+          end
+
+          if !args[0].is_a?(RunLoop::DeviceAgent::Client)
+            raise(ArgumentError, %Q[
+Expected first element of args to be a RunLoop::DeviceAgent::Client instance, found:
+args[0] = #{args[0]}])
+          end
+
+          true
+        end
+
+        attr_reader :client
+
+        # @!visibility private
+        def initialize(*args)
+          DeviceAgent.expect_valid_args(args)
+          @client = args[0]
+        end
+
+        # @!visibility private
+        def name
+          :device_agent
+        end
+
+        # @!visibility private
+        def stop
+          client.send(:shutdown)
+        end
+
+        # @!visibility private
+        def running?
+          client.send(:running?)
+        end
+
+        # @!visibility private
+        def session_delete
+          client.send(:session_delete)
+        end
+
+        # @!visibility private
+        def touch(options)
+          hash = query_for_coordinates(options)
+
+          client.perform_coordinate_gesture("touch",
+                                            hash[:coordinates][:x],
+                                            hash[:coordinates][:y])
+          [hash[:view]]
+        end
+
+        # @!visibility private
+        def double_tap(options)
+          hash = query_for_coordinates(options)
+          client.perform_coordinate_gesture("double_tap",
+                                            hash[:coordinates][:x],
+                                            hash[:coordinates][:y])
+          [hash[:view]]
+        end
+
+        # @!visibility private
+        def two_finger_tap(options)
+          hash = query_for_coordinates(options)
+          client.perform_coordinate_gesture("two_finger_tap",
+                                            hash[:coordinates][:x],
+                                            hash[:coordinates][:y])
+          [hash[:view]]
+        end
+
+        # @!visibility private
+        def touch_hold(options)
+          hash = query_for_coordinates(options)
+
+          duration = options[:duration] || 3
+          client.perform_coordinate_gesture("touch",
+                                            hash[:coordinates][:x],
+                                            hash[:coordinates][:y],
+                                            {:duration => duration})
+          [hash[:view]]
+        end
+
+        # @!visibility private
+        def swipe(options)
+          dupped_options = options.dup
+
+          if dupped_options[:query].nil?
+            dupped_options[:query] = "*"
+          end
+
+          hash = query_for_coordinates(dupped_options)
+          from_point = hash[:coordinates]
+          element = hash[:view]
+
+          # DeviceAgent does not understand the :force. Does anyone?
+          force = dupped_options[:force]
+          case force
+            when :strong
+              duration = 0.2
+            when :normal
+              duration = 0.4
+            when :light
+              duration = 0.7
+            else
+              # Caller is responsible for validating the :force option.
+              duration = 0.5
+          end
+
+          gesture_options = {
+            :duration => duration
+          }
+
+          direction = dupped_options[:direction]
+          to_point = Coordinates.end_point_for_swipe(direction, element, force)
+          client.pan_between_coordinates(from_point, to_point, gesture_options)
+          [hash[:view]]
+        end
+
+        # @!visibility private
+        def pan(from_query, to_query, options)
+          dupped_options = options.dup
+
+          dupped_options[:query] = from_query
+          from_hash = query_for_coordinates(dupped_options)
+          from_point = from_hash[:coordinates]
+
+          dupped_options[:query] = to_query
+          to_hash = query_for_coordinates(dupped_options)
+          to_point = to_hash[:coordinates]
+
+          gesture_options = {
+            :duration => dupped_options[:duration]
+          }
+
+          client.pan_between_coordinates(from_point, to_point,
+                                         gesture_options)
+
+          [from_hash[:view], to_hash[:view]]
+        end
+
+        # @!visibility private
+        def pan_coordinates(from_point, to_point, options)
+
+          gesture_options = {
+            :duration => options[:duration]
+          }
+
+          client.pan_between_coordinates(from_point, to_point,
+                                         gesture_options)
+          [first_element_for_query("*")]
+        end
+
+        # @!visibility private
+        def flick(options)
+          gesture_options = {
+            duration: 0.2
+          }
+
+          delta = options[:delta]
+
+          # The UIA deltas are too small.
+          scaled_delta = {
+            :x => delta[:x] * 2.0,
+            :y => delta[:y] * 2.0
+          }
+
+          hash = query_for_coordinates(options)
+          view = hash[:view]
+
+          start_point = point_from(view)
+          end_point = point_from(view, {:offset => scaled_delta})
+
+          client.pan_between_coordinates(start_point,
+                                         end_point,
+                                         gesture_options)
+          [view]
+        end
+
+        # @!visibility private
+        def enter_text_with_keyboard(string, options={})
+          client.enter_text(string)
+        end
+
+        # @!visibility private
+        def enter_char_with_keyboard(char)
+          client.enter_text(char)
+        end
+
+        # @!visibility private
+        def char_for_keyboard_action(action_key)
+          SPECIAL_ACTION_CHARS[action_key]
+        end
+
+        # @!visibility private
+        def tap_keyboard_action_key
+          mark = mark_for_return_key_of_first_responder
+          if mark
+            begin
+              # The underlying query for coordinates always expects results.
+              value = client.touch({marked: mark})
+              return value
+            rescue RuntimeError => _
+              RunLoop.log_debug("Cannot find mark '#{mark}' with query; will send a newline")
+            end
+          else
+            RunLoop.log_debug("Cannot find keyboard return key type; sending a newline")
+          end
+
+          code = char_for_keyboard_action("Return")
+          client.enter_text(code)
+        end
+
+        # @!visibility private
+        def tap_keyboard_delete_key
+          client.touch({marked: "delete"})
+        end
+
+        # @!visibility private
+        def fast_enter_text(text)
+          client.enter_text(text)
+        end
+
+        # @!visibility private
+        #
+        # Stable across different keyboard languages.
+        def dismiss_ipad_keyboard
+          client.touch({marked: "Hide keyboard"})
+        end
+
+        # @!visibility private
+        def rotate(direction)
+          # Caller is responsible for normalizing and verifying direction.
+          current_orientation = status_bar_orientation.to_sym
+          key = orientation_key(direction, current_orientation)
+          position = orientation_for_key(key)
+          rotate_home_button_to(position)
+        end
+
+        # @!visibility private
+        def rotate_home_button_to(position)
+          # Caller is responsible for normalizing and verifying position.
+          client.rotate_home_button_to(position)
+          status_bar_orientation.to_sym
+        end
+
+        private
+
+        # @!visibility private
+        #
+        # Calls #point_from which applies any :offset supplied in the options.
+        def query_for_coordinates(options)
+          uiquery = options[:query]
+
+          if uiquery.nil?
+            offset = options[:offset]
+
+            if offset && offset[:x] && offset[:y]
+              {
+                :coordinates => offset,
+                :view => offset
+              }
+            else
+              raise ArgumentError, %Q[
+If query is nil, there must be a valid offset in the options.
+
+Expected: options[:offset] = {:x => NUMERIC, :y => NUMERIC}
+  Actual: options[:offset] = #{offset ? offset : "nil"}
+
+              ]
+            end
+          else
+
+            first_element = first_element_for_query(uiquery)
+
+            if first_element.nil?
+              msg = %Q[
+Could not find any views with query:
+
+  #{uiquery}
+
+Make sure your query returns at least one view.
+
+]
+              Calabash::Cucumber::Map.new.screenshot_and_raise(msg)
+            else
+              {
+                :coordinates => point_from(first_element, options),
+                :view => first_element
+              }
+            end
+          end
+        end
+
+        # @!visibility private
+        def first_element_for_query(uiquery)
+
+          if uiquery.nil?
+            raise ArgumentError, "Query cannot be nil"
+          end
+
+          # Will raise if response "outcome" is not SUCCESS
+          results = Calabash::Cucumber::Map.raw_map(uiquery, :query)["results"]
+
+          if results.empty?
+            nil
+          else
+            results[0]
+          end
+        end
+
+        # @!visibility private
+        #
+        # Don't change the double quotes.
+        SPECIAL_ACTION_CHARS = {
+          "Delete" => "\b",
+          "Return" => "\n"
+        }.freeze
+
+        # @!visibility private
+        #
+        # Keys are from the UIReturnKeyType enum.
+        #
+        # The values are localization independent identifiers - these are
+        # stable across localizations and keyboard languages.  The exception is
+        # Continue which is not stable.
+        RETURN_KEY_TYPE = {
+          0 => "Return",
+          1 => "Go",
+          2 => "Google",
+          # Needs special physical device vs simulator handling.
+          3 => "Join",
+          4 => "Next",
+          5 => "Route",
+          6 => "Search",
+          7 => "Send",
+          8 => "Yahoo",
+          9 => "Done",
+          10 => "Emergency call",
+          # https://xamarin.atlassian.net/browse/TCFW-344
+          # Localized!!! Apple bug.
+          11 => "Continue"
+        }.freeze
+
+        # @!visibility private
+        def mark_for_return_key_type(number)
+          # https://xamarin.atlassian.net/browse/TCFW-361
+          value = RETURN_KEY_TYPE[number]
+          if value == "Join" && !simulator?
+            "Join:"
+          else
+            value
+          end
+        end
+
+        # @!visibility private
+        def return_key_type_of_first_responder
+
+          ['textField', 'textView'].each do |ui_class|
+            query = "#{ui_class} isFirstResponder:1"
+            raw = Calabash::Cucumber::Map.raw_map(query, :query, :returnKeyType)
+            results = raw["results"]
+            if !results.empty?
+              return results.first
+            end
+          end
+
+          RunLoop.log_debug("Cannot find keyboard first responder to ask for its returnKeyType")
+          nil
+        end
+
+        # @!visibility private
+        def mark_for_return_key_of_first_responder
+          number = return_key_type_of_first_responder
+          mark_for_return_key_type(number)
+        end
+      end
+    end
+  end
+end

data/lib/calabash-cucumber/automator/instruments.rb

@@ -0,0 +1,441 @@
+module Calabash
+  module Cucumber
+    # @!visibility private
+    module Automator
+
+      require "calabash-cucumber/automator/automator"
+
+      # @!visibility private
+      class Instruments < Calabash::Cucumber::Automator::Automator
+
+        require "calabash-cucumber/uia"
+        include Calabash::Cucumber::UIA
+
+        require "calabash-cucumber/connection_helpers"
+        include Calabash::Cucumber::ConnectionHelpers
+
+        require "calabash-cucumber/query_helpers"
+        include Calabash::Cucumber::QueryHelpers
+
+        require "calabash-cucumber/status_bar_helpers"
+        include Calabash::Cucumber::StatusBarHelpers
+
+        require "calabash-cucumber/rotation_helpers"
+        include Calabash::Cucumber::RotationHelpers
+
+        require "calabash-cucumber/map"
+
+        # @!visibility private
+        UIA_STRATEGIES = [:preferences, :host, :shared_element]
+
+        attr_reader :run_loop
+
+        # @!visibility private
+        def self.expect_valid_init_args(args)
+          if args.nil?
+            raise(ArgumentError, "Expected non-nil argument for initializer")
+          end
+
+          if !args.is_a?(Array)
+            raise(ArgumentError, "Expected an array argument for initializer")
+          end
+
+          run_loop = args[0]
+
+          if run_loop.nil?
+            raise(ArgumentError,
+%Q[Expected first element of args to be non-nil:
+
+args = #{args}
+
+])
+          end
+
+          if args.count != 1
+            raise(ArgumentError,
+%Q[Expected args to have exactly one element but found:
+
+args = #{args}
+])
+          end
+
+          self.expect_valid_run_loop(run_loop)
+        end
+
+        # @!visibility private
+        def self.expect_valid_run_loop(run_loop)
+          if run_loop.nil?
+            raise(ArgumentError, "Expected run_loop arg to be non-nil")
+          end
+
+          if !run_loop.is_a?(Hash)
+            raise(ArgumentError, %Q[
+Expected run_loop arg to be a hash, but found:
+
+run_loop = #{run_loop} is_a => #{run_loop.class}
+
+])
+          end
+
+          automator = run_loop[:automator]
+          if automator && automator != :instruments
+            raise(ArgumentError, %Q[
+Invalid :@automator. Expected :instruments but found:
+
+#{automator}
+
+in
+
+#{run_loop}
+
+])
+          end
+
+          [:pid, :udid, :index, :log_file, :uia_strategy].each do |key|
+            if !run_loop[key]
+              raise(ArgumentError, %Q[
+Expected run_loop to have a truthy value for :#{key} but found:
+
+#{run_loop}
+
+])
+            end
+          end
+
+          strategy = run_loop[:uia_strategy]
+          if !self.valid_uia_strategy?(strategy)
+             raise(ArgumentError, %Q[
+Expected '#{strategy}' to be one of these supported strategies:
+
+#{UIA_STRATEGIES}
+
+])
+          end
+          true
+        end
+
+        # @!visibility private
+        def self.valid_uia_strategy?(strategy)
+         UIA_STRATEGIES.include?(strategy)
+        end
+
+        # @!visibility private
+        def initialize(*args)
+          Instruments.expect_valid_init_args(args)
+          @run_loop = args[0]
+        end
+
+        # @!visibility private
+        def name
+          :instruments
+        end
+
+        # @!visibility private
+        def stop
+          RunLoop.stop(run_loop)
+        end
+
+        # @!visibility private
+        def touch(options)
+          query_action(options, :uia_tap_offset)
+        end
+
+        # @!visibility private
+        def double_tap(options)
+          query_action(options, :uia_double_tap_offset)
+        end
+
+        # @!visibility private
+        def two_finger_tap(options)
+          query_action(options, :uia_two_finger_tap_offset)
+        end
+
+        # @!visibility private
+        def flick(options)
+          query_action(options) do |offset|
+            delta = {:offset => options[:delta] || {}}
+            uia_flick_offset(offset, point_from(offset, delta))
+          end
+        end
+
+        # @!visibility private
+        def touch_hold(options)
+          query_action(options) do |offset|
+            duration = options[:duration] || 3
+            uia_touch_hold_offset(duration, offset)
+          end
+        end
+
+        # @!visibility private
+        def swipe(options)
+          query_action(options, :uia_swipe_offset, options)
+        end
+
+        # @!visibility private
+        def pan(from, to, options={})
+          query_action(:query => from) do |from_offset|
+            query_action(:query => to) do |to_offset|
+              uia_pan_offset(from_offset, to_offset, options)
+            end
+          end
+        end
+
+        # @!visibility private
+        def pan_coordinates(from, to, options={})
+          uia_pan_offset(from, to, options)
+          [find_and_normalize("*")]
+        end
+
+        # @!visibility private
+        def pinch(in_out, options)
+          query_action(options) do |offset|
+            options[:duration] = options[:duration] || 0.5
+            uia_pinch_offset(in_out, offset, options)
+          end
+        end
+
+        # @!visibility private
+        def send_app_to_background(secs)
+          uia_send_app_to_background(secs)
+        end
+
+        # @!visibility private
+        def enter_text_with_keyboard(string, existing_text="")
+          uia_type_string(string, existing_text)
+        end
+
+        # @!visibility private
+        def fast_enter_text(text)
+          uia_set_responder_value(text)
+        end
+
+        # @!visibility private
+        # It is the caller's responsibility to ensure the keyboard is visible.
+        def enter_char_with_keyboard(char)
+          uia("uia.keyboard().typeString('#{char}')")
+        end
+
+        # @!visibility private
+        def char_for_keyboard_action(action_key)
+          SPECIAL_ACTION_CHARS[action_key]
+        end
+
+        # @!visibility private
+        # TODO Implement this in JavaScript?
+        # See the device_agent implementation of tap_keyboard_action_key and
+        # the tap_keyboard_delete_key of this class.
+        def tap_keyboard_action_key
+          code = char_for_keyboard_action("Return")
+          enter_char_with_keyboard(code)
+        end
+
+        # @!visibility private
+        def tap_keyboard_delete_key
+          js_tap_delete = %Q[(function() {
+var deleteElement = uia.keyboard().elements().firstWithName('Delete');
+if (deleteElement.isValid()) {
+  deleteElement.tap();
+} else {
+  uia.keyboard().elements().firstWithName('delete').tap();
+}
+})();].gsub!($-0, "")
+
+          uia(js_tap_delete)
+        end
+
+        # @!visibility private
+        def dismiss_ipad_keyboard
+          js = %Q[#{query_uia_hide_keyboard_button}.tap()]
+          uia(js)
+        end
+
+        # @!visibility private
+        def rotate(direction)
+          current_orientation = status_bar_orientation.to_sym
+          result = rotate_with_uia(direction, current_orientation)
+          recalibrate_after_rotation
+          ap result if RunLoop::Environment.debug?
+          status_bar_orientation.to_sym
+        end
+
+        # @!visibility private
+        def rotate_home_button_to(position)
+          rotate_to_uia_orientation(position)
+          recalibrate_after_rotation
+          status_bar_orientation.to_sym
+        end
+
+        private
+
+        # @!visibility private
+        #
+        # Calls #point_from which applies any :offset supplied in the options.
+        def query_for_coordinates(options)
+          ui_query = options[:query]
+
+          first_element, orientation = first_element_for_query(ui_query)
+
+          if first_element.nil?
+            msg = %Q[
+Could not find any views with query:
+
+#{ui_query}
+
+Try adjusting your query to return at least one view.
+
+]
+            Calabash::Cucumber::Map.new.screenshot_and_raise(msg)
+          else
+
+            normalize_rect_for_orientation!(orientation, first_element)
+
+            {
+              :coordinates => point_from(first_element, options),
+              :view => first_element
+            }
+          end
+        end
+
+        # @!visibility private
+        def first_element_for_query(ui_query)
+          # Will raise if response "outcome" is not SUCCESS
+          raw = Calabash::Cucumber::Map.raw_map(ui_query, :query)
+          results = raw["results"]
+          orientation = raw["status_bar_orientation"]
+
+          if results.empty?
+            return nil, nil
+          else
+            return results[0], orientation
+          end
+        end
+
+        # @!visibility private
+        # Data interface
+        # options[:query] or options[:offset]
+        def query_action(options, action=nil, *args, &block)
+          ui_query = options[:query]
+          offset = options[:offset]
+          if ui_query
+            res = find_and_normalize(ui_query)
+            return res if res.empty?
+            el = res.first
+            final_offset = point_from(el, options)
+            if block_given?
+              yield final_offset
+            else
+              self.send(action, final_offset, *args)
+            end
+            [el]
+          else
+            ##implies offset
+            if block_given?
+              yield offset
+            else
+              self.send(action, offset, *args)
+            end
+          end
+        end
+
+        # @!visibility private
+        def find_and_normalize(ui_query)
+          raw_result = Calabash::Cucumber::Map.raw_map(ui_query, :query)
+          orientation = raw_result["status_bar_orientation"]
+          res = raw_result["results"]
+
+          return res if res.empty?
+
+          first_res = res.first
+          normalize_rect_for_orientation!(orientation, first_res["rect"]) if first_res["rect"]
+
+          res
+        end
+
+        # @!visibility private
+        def normalize_rect_for_orientation!(orientation, rect)
+          orientation = orientation.to_sym
+          launcher = Calabash::Cucumber::Launcher.launcher
+          device = launcher.device
+
+          # Coordinate translations for orientation is handled in the server for iOS 8+
+          if device.ios_major_version.to_i >= 8
+            return
+          end
+
+          # We cannot use Device#screen_dimensions here because on iPads the height
+          # and width are the opposite of what we expect.
+          # @todo Move all coordinate/orientation translation into the server.
+          if device.ipad?
+            screen_size = { :width => 768, :height => 1024 }
+          elsif device.iphone_4in?
+            screen_size = { :width => 320, :height => 568 }
+          else
+            screen_size = { :width => 320, :height => 480 }
+          end
+
+          case orientation
+            when :right
+              cx = rect["center_x"]
+              rect["center_x"] = rect["center_y"]
+              rect["center_y"] = screen_size[:width] - cx
+            when :left
+              cx = rect["center_x"]
+              rect["center_x"] = screen_size[:height] - rect["center_y"]
+              rect["center_y"] = cx
+            when :up
+              cy = rect["center_y"]
+              cx = rect["center_x"]
+              rect["center_y"] = screen_size[:height] - cy
+              rect["center_x"] = screen_size[:width] - cx
+            else
+              # no-op by design.
+          end
+        end
+
+        # @!visibility private
+        def recalibrate_after_rotation
+          uia_query :window
+        end
+
+        # @!visibility private
+        def rotate_to_uia_orientation(orientation)
+          case orientation
+            when :down then key = :portrait
+            when :up then key = :upside_down
+            when :left then key = :landscape_right
+            when :right then key = :landscape_left
+            else
+              raise ArgumentError,
+                    "Expected '#{orientation}' to be :left, :right, :up, or :down"
+          end
+          value = orientation_for_key(key)
+          cmd = "UIATarget.localTarget().setDeviceOrientation(#{value})"
+          uia(cmd)
+        end
+
+        # @!visibility private
+        def rotate_with_uia(direction, current_orientation)
+          key = orientation_key(direction, current_orientation)
+          value = orientation_for_key(key)
+          cmd = "UIATarget.localTarget().setDeviceOrientation(#{value})"
+          uia(cmd)
+        end
+
+        # @!visibility private
+        # Returns a query string for finding the iPad 'Hide keyboard' button.
+        def query_uia_hide_keyboard_button
+          "uia.keyboard().buttons()['Hide keyboard']"
+        end
+
+        # @!visibility private
+        #
+        # Don't change the single single quotes.
+        SPECIAL_ACTION_CHARS = {
+          "Delete" => '\b',
+          "Return" => '\n'
+        }
+      end
+    end
+  end
+end
+