calabash 2.0.0.pre11 → 2.0.0.prelegacy

data/lib/calabash/http/retriable_client.rb

@@ -33,9 +33,6 @@ module Calabash
                   'Content-Type' => 'application/json;charset=utf-8'
             }
 
-      # @!visibility private
-      attr_accessor :port_forward
-
       # Creates a new retriable client.
       #
       # This initializer takes multiple options.  If the option is not
@@ -110,7 +107,7 @@ module Calabash
         retries = options.fetch(:retries, @retries)
         timeout = options.fetch(:timeout, @timeout)
         interval = options.fetch(:interval, @interval)
-        header = HEADER.merge(options.fetch(:header, {}))
+        header = options.fetch(:header, HEADER)
 
         @logger.log "Getting: #{@server.endpoint + request.route} #{options}"
 
@@ -134,20 +131,8 @@ module Calabash
           client.receive_timeout = [time_diff, client.receive_timeout].min
 
           begin
-            if request_method == :get
-              return client.send(request_method, @server.endpoint + request.route,
-                                 request.params, header)
-            else
-              if request.params.is_a?(Hash)
-                if request.params.key?(:json)
-                  return client.send(request_method, @server.endpoint + request.route,
-                                     {body: request.params[:json]}.merge(header: header))
-                end
-              end
-
-              return client.send(request_method, @server.endpoint + request.route,
-                                 {body: request.params}.merge(header: header))
-            end
+            return client.send(request_method, @server.endpoint + request.route,
+                               request.params, header)
           rescue *RETRY_ON => e
             @logger.log "Http error: #{e}"
 

data/lib/calabash/http.rb

@@ -2,7 +2,6 @@ module Calabash
   # @!visibility private
   module HTTP
     require 'calabash/http/retriable_client'
-    require 'calabash/http/forwarding_client'
     require 'calabash/http/request'
     require 'calabash/http/error'
   end

data/lib/calabash/interactions.rb

@@ -62,7 +62,7 @@ module Calabash
     #
     # @return [Calabash::QueryResult] A result of the query
     def query(query, *args)
-      Calabash::Internal.with_default_device {|device| device.map_route(Query.new(query), :query, *args)}
+      Calabash::Device.default.map_route(Query.new(query), :query, *args)
     end
 
     # Flashes any views matching `query`. Only one view is flashed at a time,
@@ -71,7 +71,39 @@ module Calabash
     # @param [String, Hash, Calabash::Query] query The query to match the
     #  view(s)
     def flash(query)
-      Calabash::Internal.with_default_device {|device| device.map_route(Query.new(query), :flash)}
+      Calabash::Device.default.map_route(Query.new(query), :flash)
+    end
+
+    # Evaluate javascript in a Web View. On iOS, an implicit return is
+    # inserted, on Android an explicit return is needed.
+    #
+    # @example
+    #  # iOS
+    #  evaluate_javascript_in("UIWebView", "2+2")
+    #  # Android
+    #  evaluate_javascript_in("WebView", "return 2+2")
+    #
+    # @example
+    #  # iOS
+    #  evaluate_javascript_in("WKWebView",
+    #         "document.body.style.backgroundColor = 'red';")
+    #
+    #  # Android
+    #  evaluate_javascript_in("XWalkContent",
+    #         "document.body.style.backgroundColor = 'red';")
+    #
+    # @note No error will be raised if the javascript given is invalid, or
+    #  throws an exception.
+    #
+    # @param [String, Hash, Calabash::Query] query Query that matches the view
+    # @param [String] javascript The javascript to evaluate
+    #
+    # @raise ViewNotFoundError If no views are found matching `query`
+    def evaluate_javascript_in(query, javascript)
+      wait_for_view(query,
+                    timeout: Calabash::Gestures::DEFAULT_GESTURE_WAIT_TIMEOUT)
+
+      _evaluate_javascript_in(query, javascript)
     end
 
     # Invoke a method in your application.
@@ -126,7 +158,12 @@ module Calabash
     # @return [Object] the result of performing the selector/method with the
     #  arguments (serialized)
     def backdoor(name, *arguments)
-      Calabash::Internal.with_default_device {|device| device.backdoor(name, *arguments)}
+      Device.default.backdoor(name, *arguments)
+    end
+
+    # @!visibility private
+    def _evaluate_javascript_in(query, javascript)
+      abstract_method!
     end
   end
 end

data/lib/calabash/ios/conditions.rb

@@ -72,7 +72,7 @@ module Calabash
       # @return [nil] When the condition is satisfied.
       # @raise [Calabash::Wait::TimeoutError] When the timeout is exceeded.
       def wait_for_condition(condition, timeout, timeout_message, query='*')
-        unless Calabash::Internal.with_default_device(required_os: :ios) {|device| device.condition_route(condition, timeout, query)}
+        unless Device.default.condition_route(condition, timeout, query)
           raise Calabash::Wait::TimeoutError, timeout_message
         end
         true

data/lib/calabash/ios/console_helpers.rb

@@ -55,7 +55,7 @@ module Calabash
       Calabash::Device.default = device
 
       begin
-        Calabash::Internal.with_default_device(required_os: :ios) {|device| device.ensure_test_server_ready({:timeout => 4})}
+        Calabash::Device.default.ensure_test_server_ready({:timeout => 4})
       rescue RuntimeError => e
         if e.to_s == 'Calabash server did not respond'
           raise RuntimeError, 'You can only attach to a running Calabash iOS App'
@@ -65,7 +65,7 @@ module Calabash
       end
 
       run_loop_device = device.send(:run_loop_device)
-      result = Calabash::Internal.with_default_device(required_os: :ios) {|device| device.send(:attach_to_run_loop, run_loop_device, uia_strategy)}
+      result = Calabash::Device.default.send(:attach_to_run_loop, run_loop_device, uia_strategy)
       result[:application] = Calabash::Application.default
       result
     end

data/lib/calabash/ios/date_picker.rb

@@ -378,16 +378,14 @@ module Calabash
         objc_format = date_picker_objc_date_format
         target_date_string = date_time.strftime(ruby_format).squeeze(' ').strip
 
-        Calabash::Internal.with_default_device(required_os: :ios) do |device|
-          device.map_route(query,
-                           :changeDatePickerDate,
-                           target_date_string,
-                           objc_format,
-                           # notify targets
-                           true,
-                           # animate
-                           true)
-        end
+        Device.default.map_route(query,
+                                 :changeDatePickerDate,
+                                 target_date_string,
+                                 objc_format,
+                                 # notify targets
+                                 true,
+                                 # animate
+                                 true)
       end
 
       private

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

@@ -17,11 +17,13 @@ module Calabash
       include Calabash::IOS::RotationMixin
       include Calabash::IOS::KeyboardMixin
       include Calabash::IOS::UIAKeyboardMixin
+      include Calabash::IOS::TextMixin
       include Calabash::IOS::UIAMixin
       include Calabash::IOS::IPadMixin
       include Calabash::IOS::GesturesMixin
 
       attr_reader :run_loop
+      attr_reader :uia_strategy
       attr_reader :start_options
 
       # Returns the default simulator identifier.  The string that is return
@@ -48,7 +50,7 @@ module Calabash
           if run_loop_device.nil?
             raise "Could not find a simulator with a UDID or name matching '#{identifier}'"
           end
-          run_loop_device.instruments_identifier(RunLoop::SimControl.new.xcode)
+          run_loop_device.instruments_identifier
         end
       end
 
@@ -82,14 +84,14 @@ module Calabash
           elsif connected_devices.count > 1
             raise 'There is more than one physical devices connected.  Use CAL_DEVICE_ID to indicate which you want to connect to.'
           else
-            connected_devices.first.instruments_identifier(RunLoop::SimControl.new.xcode)
+            connected_devices.first.instruments_identifier
           end
         else
           run_loop_device = Device.fetch_matching_physical_device(identifier)
           if run_loop_device.nil?
             raise "Could not find a physical device with a UDID or name matching '#{identifier}'"
           end
-          run_loop_device.instruments_identifier(RunLoop::SimControl.new.xcode)
+          run_loop_device.instruments_identifier
         end
       end
 
@@ -343,7 +345,8 @@ module Calabash
 
         {
            :device => self,
-           :application => application
+           :application => application,
+           :uia_strategy => uia_strategy
         }
       end
 
@@ -391,7 +394,7 @@ module Calabash
       def start_app_with_device_and_options(application, run_loop_device, user_defined_options)
         start_options = merge_start_options!(application, run_loop_device, user_defined_options)
         @run_loop = RunLoop.run(start_options)
-        @automator = Calabash::IOS::Automator::DeviceAgent.new(@run_loop)
+        @uia_strategy = @run_loop[:uia_strategy]
       end
 
       # @!visibility private
@@ -525,6 +528,12 @@ module Calabash
         end
       end
 
+      # @!visibility private
+      def enter_text(text)
+        # @todo implement this
+        raise 'ni'
+      end
+
       # @!visibility private
       def clear_app_data_on_simulator(application, run_loop_device, bridge)
         begin
@@ -621,8 +630,9 @@ module Calabash
       # @!visibility private
       # Expensive!
       def Device.fetch_matching_simulator(udid_or_name)
-        RunLoop::SimControl.new.simulators.detect do |sim|
-          sim.instruments_identifier(RunLoop::SimControl.new.xcode) == udid_or_name ||
+        sim_control = RunLoop::SimControl.new
+        sim_control.simulators.detect do |sim|
+          sim.instruments_identifier == udid_or_name ||
                 sim.udid == udid_or_name
         end
       end
@@ -652,7 +662,7 @@ module Calabash
             Logger.error('which resolves to a physical device.')
             Logger.error("The server endpoint '#{server.endpoint}' is for an iOS Simulator.")
             Logger.error('Use CAL_ENDPOINT to specify the IP address of your device')
-            Logger.error("Ex. $ CAL_ENDPOINT=http://10.0.1.2:37265 CAL_DEVICE_ID=#{identifier} #{Calabash::Utility.bundle_exec_prepend}calabash ...")
+            Logger.error("Ex. $ CAL_ENDPOINT=http://10.0.1.2:37265 CAL_DEVICE_ID=#{identifier} be calabash ...")
             raise "Invalid device endpoint '#{server.endpoint}'"
           end
         end
@@ -693,7 +703,7 @@ module Calabash
               {
                     :app => application.path,
                     :bundle_id => application.identifier,
-                    :device_target => run_loop_device.instruments_identifier(RunLoop::SimControl.new.xcode),
+                    :device_target => run_loop_device.instruments_identifier,
                     :uia_strategy => strategy
               }
         @start_options = default_options.merge(options_from_user)
@@ -765,11 +775,13 @@ module Calabash
 
         if strategy == :host
           @run_loop = RunLoop::HostCache.default.read
+          @uia_strategy = :host
         else
           pid = instruments_pid
           @run_loop = {}
           @run_loop[:uia_strategy] = strategy
           @run_loop[:pid] = pid
+          @uia_strategy = strategy
         end
 
         # populate the @runtime_attributes

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

@@ -96,33 +96,36 @@ module Calabash
 
       # @!visibility private
       def _tap(query, options={})
-        view_to_touch = _gesture_waiter.wait_for_view(query, timeout: options[:timeout])
+        view_to_touch = _gesture_waiter.wait_for_view(query, options)
 
         rect = view_to_touch['rect']
         x = rect['x'] + (rect['width'] * (options[:at][:x] / 100.0)).to_i
         y = rect['y'] + (rect['height'] * (options[:at][:y] / 100.0)).to_i
 
-        @automator.touch({coordinates: coordinate(x, y)})
+        offset = coordinate(x, y)
+
+        uia_serialize_and_call(:tapOffset, offset, options)
 
         Calabash::QueryResult.create([view_to_touch], query)
       end
 
       # @!visibility private
       def _double_tap(query, options={})
-        view_to_touch = _gesture_waiter.wait_for_view(query, timeout: options[:timeout])
+        view_to_touch = _gesture_waiter.wait_for_view(query, options)
 
         rect = view_to_touch['rect']
         x = rect['x'] + (rect['width'] * (options[:at][:x] / 100.0)).to_i
         y = rect['y'] + (rect['height'] * (options[:at][:y] / 100.0)).to_i
 
-        @automator.double_tap({coordinates: coordinate(x, y)})
+        offset = coordinate(x, y)
+
+        uia_serialize_and_call(:doubleTapOffset, offset, options)
 
         Calabash::QueryResult.create([view_to_touch], query)
       end
 
       # @!visibility private
       def _long_press(query, options={})
-        options[:duration] += 0.2
 
         begin
           _expect_valid_duration(options)
@@ -130,66 +133,39 @@ module Calabash
           raise ArgumentError e
         end
 
-        view_to_touch = _gesture_waiter.wait_for_view(query, timeout: options[:timeout])
+        view_to_touch = _gesture_waiter.wait_for_view(query, options)
 
         rect = view_to_touch['rect']
         x = rect['x'] + (rect['width'] * (options[:at][:x] / 100.0)).to_i
         y = rect['y'] + (rect['height'] * (options[:at][:y] / 100.0)).to_i
 
-        @automator.touch_hold({coordinates: coordinate(x, y), duration: options[:duration]})
+        offset = coordinate(x, y)
+
+        uia_serialize_and_call(:touchHoldOffset, options[:duration], offset)
 
         Calabash::QueryResult.create([view_to_touch], query)
       end
 
       # @!visibility private
       def _pan_between(query_from, query_to, options={})
-        from_query_result = nil
-        to_query_result  = nil
-        from = coordinate(0, 0)
-        to = coordinate(0, 0)
-
-        unless query_from.nil?
-          from_view = _gesture_waiter.wait_for_view(query_from, timeout: options[:timeout])
-          from = coordinate(from_view['rect']['center_x'], from_view['rect']['center_y'])
-          from_query_result = Calabash::QueryResult.create([from_view], query_from)
-        end
 
-        unless query_to.nil?
-          to_view = _gesture_waiter.wait_for_view(query_to, timeout: options[:timeout])
-          to = coordinate(to_view['rect']['center_x'], to_view['rect']['center_y'])
-          Calabash::QueryResult.create([to_view], query_to)
+        begin
+          _expect_valid_duration(options)
+        rescue ArgumentError => e
+          raise ArgumentError e
         end
 
-        offset = options[:offset]
-
-        if offset
-          from_offset = offset[:from]
-
-          if from_offset
-            x, y = from_offset[:x], from_offset[:y]
+        from_view = _gesture_waiter.wait_for_view(query_from, options)
+        to_view = _gesture_waiter.wait_for_view(query_to, options)
 
-            from[:x] += x || 0
-            from[:y] += y || 0
-          end
-
-          to_offset = offset[:to]
-
-          if from_offset
-            x, y = to_offset[:x], to_offset[:y]
-
-            to[:x] += x || 0
-            to[:y] += y || 0
-          end
-        end
+        from_offset = uia_center_of_view(from_view)
+        to_offset = uia_center_of_view(to_view)
 
-        @automator.pan({coordinates:
-                            {from: from,
-                             to: to},
-                        duration: options[:duration]})
+        uia_serialize_and_call(:panOffset, from_offset, to_offset, options)
 
         {
-          :from => from_query_result,
-          :to => to_query_result
+          :from => Calabash::QueryResult.create([from_view], query_from),
+          :to => Calabash::QueryResult.create([to_view], query_to)
         }
       end
 
@@ -202,24 +178,50 @@ module Calabash
       # If the view has a UINavigationBar or UITabBar, the defaults *might*
       # cause vertical gestures to start and/or end on one of these bars.
       def _pan(query, from, to, options={})
+
+        begin
+          _expect_valid_duration(options)
+        rescue ArgumentError => e
+          raise ArgumentError, e
+        end
+
         gesture_waiter = _gesture_waiter
-        view_to_pan = gesture_waiter.wait_for_view(query, timeout: options[:timeout])
+        view_to_pan = gesture_waiter.wait_for_view(query, options)
+
+        begin
+          check_for_broken_uia_automation(query, view_to_pan, gesture_waiter)
+        rescue => e
+          raise "Could not pan with query: #{query}\n#{e.message}"
+        end
 
         rect = view_to_pan['rect']
 
         from_x = rect['width'] * (from[:x]/100.0)
         from_y = rect['height'] * (from[:y]/100.0)
+        from_offset = coordinate(from_x, from_y)
 
         to_x = rect['width'] * (to[:x]/100.0)
         to_y = rect['height'] * (to[:y]/100.0)
+        to_offset = coordinate(to_x, to_y)
 
-        @automator.pan({coordinates: {from: coordinate(from_x, from_y), to: coordinate(to_x, to_y)},
-                               duration: options[:duration]})
-
+        uia_serialize_and_call(:panOffset, from_offset, to_offset)
 
         Calabash::QueryResult.create([view_to_pan], query)
       end
 
+      # @!visibility private
+      def pan_screen(view_to_pan, from_offset, to_offset, options)
+        begin
+          _expect_valid_duration(options)
+        rescue ArgumentError => e
+          raise ArgumentError, e
+        end
+
+        uia_serialize_and_call(:panOffset, from_offset, to_offset, options)
+
+        Calabash::QueryResult.create([view_to_pan], '*')
+      end
+
       # @!visibility private
       # @todo The default to and from for the screen_* methods are not good for iOS.
       #
@@ -236,7 +238,7 @@ module Calabash
         end
 
         gesture_waiter = _gesture_waiter
-        view_to_flick = gesture_waiter.wait_for_view(query, timeout: options[:timeout])
+        view_to_flick = gesture_waiter.wait_for_view(query, options)
 
         begin
           check_for_broken_uia_automation(query, view_to_flick, gesture_waiter)
@@ -285,7 +287,7 @@ module Calabash
 
         gesture_waiter = _gesture_waiter
 
-        view_to_pinch = gesture_waiter.wait_for_view(query, timeout: options[:timeout])
+        view_to_pinch = gesture_waiter.wait_for_view(query, options)
         offset = uia_center_of_view(view_to_pinch)
 
         gesture_direction = direction == :in ? :out : :in

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

@@ -3,12 +3,6 @@ module Calabash
 
     # @!visibility private
     module KeyboardMixin
-      # Enter `text` into the currently focused view.
-      # @see Calabash::Text#enter_text
-      # @!visibility private
-      def enter_text(text, options={})
-        @automator.enter_text_with_keyboard(text, options)
-      end
 
       # Returns true if a docked keyboard is visible.
       #
@@ -67,21 +61,6 @@ module Calabash
         docked_keyboard_visible? || undocked_keyboard_visible? || split_keyboard_visible?
       end
 
-      def tap_keyboard_delete_key(options={})
-        @automator.tap_keyboard_delete_key
-      end
-
-      def tap_keyboard_action_key
-        results = keyboard_waiter.query("* isFirstResponder:1", :returnKeyType)
-
-        if results.empty?
-          RunLoop.log_debug("Cannot find keyboard first responder to ask for its returnKeyType")
-          raise 'Cannot tap_keyboard_action_key. No view has focus'
-        end
-
-        @automator.tap_keyboard_action_key(results.first)
-      end
-
       # Returns the the text in the first responder.
       #
       # The first responder will be the UITextField or UITextView instance

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

@@ -14,14 +14,55 @@ module Calabash
           wait_for_server_to_start({:timeout => 1})
         end
 
-        orientation = status_bar_orientation.to_sym
+        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
 
-        @automator.rotate(direction, orientation)
+        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,
@@ -42,7 +83,28 @@ module Calabash
           return orientation
         end
 
-        @automator.rotate_home_button_to(position, status_bar_orientation)
+        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.
+          #
+          # Can't wait for animations because there might be animations other
+          # than rotation on the screen.
+          sleep(0.4)
+
+          orientation = status_bar_orientation.to_sym
+          if orientation == position
+            return orientation.to_s
+          end
+        end
 
         orientation.to_s
       end

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

@@ -0,0 +1,21 @@
+module Calabash
+  module IOS
+    # @!visibility private
+    module TextMixin
+
+      # @!visibility private
+      def enter_text(text)
+        wait_for_keyboard(Calabash::Wait.default_options[:timeout])
+        existing_text = text_from_keyboard_first_responder
+        options = { existing_text: existing_text }
+        uia_type_string(text, options)
+      end
+
+      # @!visibility private
+      def _enter_text_in(query, text)
+        _tap(query)
+        enter_text(text)
+      end
+    end
+  end
+end

data/lib/calabash/ios/device.rb

@@ -16,6 +16,7 @@ module Calabash
     require 'calabash/ios/device/rotation_mixin'
     require 'calabash/ios/device/keyboard_mixin'
     require 'calabash/ios/device/uia_keyboard_mixin'
+    require 'calabash/ios/device/text_mixin'
     require 'calabash/ios/device/uia_mixin'
     require 'calabash/ios/device/ipad_1x_2x_mixin'
     require 'calabash/ios/device/device_implementation'