calabash 1.2.1 → 1.9.9.pre1

data/lib/calabash/ios/device/rotation_mixin.rb

@@ -0,0 +1,124 @@
+module Calabash
+  module IOS
+
+    # !@visibility private
+    module RotationMixin
+
+      def rotate(direction)
+        # If we are in the console, we want to be able to rotate without
+        # calling start_app.  However, if the Device in the console has not
+        # connected with the server, the runtime attributes will not be
+        # available. It *might* make sense for the console to do this.
+        if defined?(IRB)
+          wait_for_server_to_start({:timeout => 1})
+        end
+
+        family = device_family
+
+        current_orientation = status_bar_orientation.to_sym
+        recording_name = nil
+        case direction
+          when :left
+            if current_orientation == :down
+              recording_name = 'left_home_down'
+            elsif current_orientation == :right
+              recording_name = 'left_home_right'
+            elsif current_orientation == :left
+              recording_name = 'left_home_left'
+            elsif current_orientation == :up
+              recording_name = 'left_home_up'
+            end
+          when :right
+            if current_orientation == :down
+              recording_name = 'right_home_down'
+            elsif current_orientation == :left
+              recording_name = 'right_home_left'
+            elsif current_orientation == :right
+              recording_name = 'right_home_right'
+            elsif current_orientation == :up
+              recording_name = 'right_home_up'
+            end
+          else
+            # Caller should have guarded us against this case.
+            raise ArgumentError, "Expected '#{direction}' to be :left or :right"
+        end
+
+        if family == 'iPad'
+          form_factor = 'ipad'
+        else
+          form_factor = 'iphone'
+        end
+
+        if recording_name.nil?
+          raise "Could not rotate device in direction '#{direction}' " \
+                "with orientation '#{current_orientation}'"
+        end
+
+        recording_name = "rotate_#{recording_name}"
+        playback_route(recording_name, form_factor)
+      end
+
+      # !@visibility private
+      # Caller must pass position one of these positions down, left, right, up
+      def rotate_home_button_to(position)
+
+        valid_positions = ['down', 'left', 'right', 'up']
+        unless valid_positions.include?(position)
+          raise ArgumentError,
+                "Expected '#{position}' to be on of #{valid_positions.join(', ')}"
+        end
+
+        # If we are in the console, we want to be able to rotate without
+        # calling start_app.  However, if the Device in the console has not
+        # connected with the server, the runtime attributes will not be
+        # available. It *might* make sense for the console to do this.
+        if defined?(IRB)
+          wait_for_server_to_start({:timeout => 1})
+        end
+
+        orientation = status_bar_orientation
+
+        if orientation == position
+          return orientation
+        end
+
+        family = device_family
+
+        if family == 'iPad'
+          form_factor = 'ipad'
+        else
+          form_factor = 'iphone'
+        end
+
+        ROTATION_CANDIDATES.each do |recording_name|
+          playback_route(recording_name, form_factor)
+
+          # Wait for rotation animation.
+          timeout = 1.0
+          condition_route('NONE_ANIMATING', timeout, '*')
+
+          orientation = status_bar_orientation
+          if orientation == position
+            return orientation
+          end
+        end
+
+        orientation
+      end
+
+      private
+
+      ROTATION_CANDIDATES =
+            [
+                  'rotate_left_home_down',
+                  'rotate_left_home_left',
+                  'rotate_left_home_right',
+                  'rotate_left_home_up',
+                  'rotate_right_home_down',
+                  'rotate_right_home_left',
+                  'rotate_right_home_right',
+                  'rotate_right_home_up'
+            ]
+    end
+  end
+end

data/lib/calabash/ios/device/routes/backdoor_route_mixin.rb

@@ -0,0 +1,86 @@
+module Calabash
+  module IOS
+
+    # @!visibility private
+    class BackdoorError < StandardError;  end
+
+    # @!visibility private
+    module Routes
+      # @!visibility private
+      module BackdoorRouteMixin
+
+
+        # @!visibility private
+        def backdoor(selector_name, *arguments)
+          request = make_backdoor_request(selector_name, arguments)
+          response = route_post_request(request)
+          handle_backdoor_response(selector_name, arguments, response)
+        end
+
+        private
+
+        def make_backdoor_parameters(selector_name, arguments)
+          if arguments.length > 1
+            message = 'Calabash iOS does not support backdoor selectors with ' \
+                      "more than one argument. Received #{arguments}"
+            raise ArgumentError, message
+          end
+
+          if arguments.length < 1
+            message = 'Calabash iOS does not support backdoor selectors with no arguments.'
+            raise ArgumentError, message
+          end
+
+           unless selector_name.end_with?(':')
+             messages =
+               [
+                 "Selector '#{selector_name}' is missing a trailing ':'",
+                 'Valid backdoor selectors must take one argument.',
+                 '',
+                 'http://developer.xamarin.com/guides/testcloud/calabash/working-with/backdoors/#backdoor_in_iOS',
+                 ''
+               ]
+               raise ArgumentError, messages.join("\n")
+           end
+
+          {
+             :selector => selector_name,
+             :arg => arguments.first
+          }
+        end
+
+        def make_backdoor_request(selector_name, arguments)
+           parameters = make_backdoor_parameters(selector_name, arguments)
+          begin
+            Calabash::HTTP::Request.request('backdoor', parameters)
+          rescue => e
+            raise RouteError, e
+          end
+        end
+
+        def handle_backdoor_response(selector_name, arguments, response)
+          hash = parse_response_body(response)
+
+          outcome = hash['outcome']
+
+          case outcome
+            when 'FAILURE'
+              message = "Calling backdoor '#{selector_name}' with arguments '#{arguments}'" \
+                "failed because:\n\n#{hash['reason']}\n#{hash['details']}"
+              raise Calabash::IOS::RouteError, message
+            when 'SUCCESS'
+              # Legacy API: will be removed in iOS Server > 0.14.3
+              if hash.has_key?('results')
+                return hash['results']
+              else
+                return hash['result']
+              end
+            else
+              raise RouteError, "Server responded with an invalid outcome: '#{hash['outcome']}'"
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/calabash/ios/device/routes/condition_route_mixin.rb

@@ -0,0 +1,62 @@
+module Calabash
+  module IOS
+    # @!visibility private
+    module Routes
+      # @!visibility private
+      module ConditionRouteMixin
+
+        def condition_route(condition, timeout, query)
+          request = make_condition_request(condition, timeout, query)
+          response = route_post_request(request)
+          handle_condition_response(response)
+        end
+
+        private
+
+        #                         server
+        #    key                  default   description
+        # :condition    required
+        # :timeout      optional     *     how long to wait
+        # :duration     optional    0.2    time after which condition can be considered met
+        # :frequency    optional    0.2    how often to check condition
+        # :query           !        n/a    apply condition to matched views
+        #
+        # * => 6.0 for none animating and 30.0 for network indicator
+        # ! => query is required for none animating!
+        #
+        # The :duration and :frequency are not part of the public API.
+        def make_condition_parameters(condition, timeout, query)
+          {
+                :condition => condition,
+                :timeout => timeout,
+                :query => query
+          }
+        end
+
+        def make_condition_request(condition, timeout, query)
+          parameters = make_condition_parameters(condition, timeout, query)
+          begin
+            Calabash::HTTP::Request.request('condition', parameters)
+          rescue => e
+            raise Calabash::IOS::RouteError, e
+          end
+        end
+
+        def handle_condition_response(response)
+          hash = parse_response_body(response)
+
+          outcome = hash['outcome']
+
+          case outcome
+            when 'FAILURE'
+              false
+            when 'SUCCESS'
+              true
+            else
+              nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/calabash/ios/device/routes/error.rb

@@ -0,0 +1,8 @@
+module Calabash
+  module IOS
+
+    # Raised when there is a problem handling an HTTP route.
+    class RouteError < StandardError; end
+
+  end
+end

data/lib/calabash/ios/device/routes/handle_route_mixin.rb

@@ -0,0 +1,102 @@
+module Calabash
+  module IOS
+    # @!visibility private
+    module Routes
+      # @!visibility private
+      module HandleRouteMixin
+
+        private
+
+        def route_post_request(request)
+          begin
+            http_client.post(request)
+          rescue => e
+            raise Calabash::IOS::RouteError, e
+          end
+        end
+
+        def route_handle_response(response, query)
+          hash = parse_response_body(response)
+
+          outcome = hash['outcome']
+
+          case outcome
+            when 'FAILURE'
+              route_failure(hash, query)
+            when 'SUCCESS'
+              route_success(hash, query)
+            else
+              raise Calabash::IOS::RouteError, "Server responded with an invalid outcome: '#{hash['outcome']}'"
+          end
+        end
+
+        def route_failure(hash, query)
+
+          fetch_value = lambda do |key|
+            value = hash[key]
+            if value.nil? || value.empty?
+              'unknown'
+            else
+              value
+            end
+          end
+
+          reason = fetch_value.call('reason')
+          details = fetch_value.call('details')
+          raise Calabash::IOS::RouteError, "Map failed reason: '#{reason}' details: '#{details}' for query '#{query}'"
+        end
+
+        # TODO: handle invalid results
+        #
+        # So far, cases like this have been handled individually.
+        #
+        # Briar tests the 0.x behavior for every map call.
+        #
+        # These are the docs from 0.x assert_map_results
+        #
+        #  # Asserts the result of a calabash `map` call and raises an error with
+        #  # `msg` if no valid results are found.
+        #  #
+        #  # Casual gem users should never need to call this method; this is a
+        #  # convenience method for gem maintainers.
+        #  #
+        #  # Raises an error if `map_results`:
+        #  #
+        #  #              is an empty list #=> []
+        #  #    contains a '<VOID>' string #=> [ "<VOID>" ]
+        #  #       contains '*****' string #=> [ "*****"  ]
+        #  #         contains a single nil #=> [ nil ]
+        #  #
+        #  # When evaluating whether a `map` call is successful it is important to
+        #  # note that sometimes a <tt>[ nil ]</tt> or <tt>[nil, <val>, nil]</tt> is
+        #  # a valid result.
+        #  #
+        #  # Consider a controller with 3 labels:
+        #  #
+        #  #    label @ index 0 has text "foo"
+        #  #    label @ index 1 has text nil (the [label text] => nil)
+        #  #    label @ index 2 has text "bar"
+        #  #
+        #  #    map('label', :text) => ['foo', nil, 'bar']
+        #  #    map('label index:1', :text) => [nil]
+        #  #
+        #  # In other cases, <tt>[ nil ]</tt> should be treated as an invalid result
+        #  #
+        #  #    # invalid
+        #  #    > mark = 'mark does not exist'
+        #  #    > map('tableView', :scrollToRowWithMark, mark, args) => [ nil ]
+        #  #
+        #  # Here a <tt>[ nil ]</tt> should be considered invalid because the
+        #  # the operation could not be performed because there is not row that
+        #  # matches `mark`
+        def route_success(hash, query)
+          if query.nil?
+            hash['results']
+          else
+            Calabash::QueryResult.create(hash['results'], query)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/calabash/ios/device/routes/map_route_mixin.rb

@@ -0,0 +1,38 @@
+module Calabash
+  module IOS
+    # @!visibility private
+    module Routes
+      # @!visibility private
+      module MapRouteMixin
+
+        def map_route(query, method_name, *method_args)
+          request = make_map_request(query, method_name, *method_args)
+          response = route_post_request(request)
+          route_handle_response(response, query)
+        end
+
+        private
+
+        def make_map_parameters(query, method_name, *method_args)
+          {
+                :operation =>
+                      {
+                            :method_name => method_name,
+                            :arguments => method_args
+                      },
+                :query => query
+          }
+        end
+
+        def make_map_request(query, method_name, *method_args)
+          parameters = make_map_parameters(query, method_name, *method_args)
+          begin
+            Calabash::HTTP::Request.request('map', parameters)
+          rescue => e
+            raise Calabash::IOS::RouteError, e
+          end
+        end
+      end
+    end
+  end
+end

data/lib/calabash/ios/device/routes/playback_route_mixin.rb

@@ -0,0 +1,70 @@
+module Calabash
+  module IOS
+    module Routes
+
+      # !@visibility private
+      module PlaybackRouteMixin
+
+        # This is a Legacy API and is only used to support rotations.
+        #
+        # form_factor is iphone | ipad
+        #
+        # **NOTE** If we revive this API, move the call to
+        # recalibrate_after_rotation closer to the actually implementation of
+        # rotate; it is (probably?) not necessary for all recordings.
+        def playback_route(recording_name, form_factor)
+          request = make_playback_request(recording_name, form_factor)
+          response = route_post_request(request)
+          result = playback_route_handle_response(response)
+
+          # The first query after a rotation will have incorrect coordinates!
+          # We have to make a uia query to force an update.
+          recalibrate_after_rotation
+          result
+        end
+
+        private
+
+        PLAYBACK_DIR = File.expand_path(File.join(File.dirname(__FILE__),
+                                                  '..', '..', 'lib', 'recordings'))
+
+        def path_to_recording(basename, form_factor)
+          name = "#{basename}_#{form_factor}.base64"
+          File.join(PLAYBACK_DIR, name)
+        end
+
+        def read_recording(path)
+          unless File.exist?(path)
+            raise "Expected file '#{path}' to exist. Can't load recording."
+          end
+
+          File.read(path)
+        end
+
+        def make_playback_parameters(data)
+          %Q|{"events":"#{data}"}|
+        end
+
+        def make_playback_request(recording_basename, form_factor)
+          path = path_to_recording(recording_basename, form_factor)
+          data = read_recording(path)
+          to_post = make_playback_parameters(data)
+          Calabash::HTTP::Request.new('play', to_post)
+        end
+
+        def playback_route_handle_response(response)
+          hash = parse_response_body(response)
+          if hash['outcome'] == 'SUCCESS'
+            hash['results']
+          else
+            raise "Playback failed because:\n#{hash['reason']}\n#{hash['details']}"
+          end
+        end
+
+        def recalibrate_after_rotation
+          uia_serialize_and_call(:query, 'window')
+        end
+      end
+    end
+  end
+end