run_loop 2.1.7 → 2.1.8

data/lib/run_loop/device_agent/client.rb

@@ -0,0 +1,853 @@
+module RunLoop
+
+  # @!visibility private
+  module DeviceAgent
+
+    # @!visibility private
+    class Client
+
+      require "run_loop/shell"
+      include RunLoop::Shell
+
+      require "run_loop/encoding"
+      include RunLoop::Encoding
+
+      require "run_loop/cache"
+
+      class HTTPError < RuntimeError; end
+
+      # @!visibility private
+      #
+      # These defaults may change at any time.
+      DEFAULTS = {
+        :port => 27753,
+        :simulator_ip => "127.0.0.1",
+        :http_timeout => RunLoop::Environment.ci? ? 120 : 10,
+        :route_version => "1.0",
+        :shutdown_device_agent_before_launch => false
+      }
+
+      # @!visibility private
+      def self.run(options={})
+        # logger = options[:logger]
+        simctl = options[:sim_control] || options[:simctl] || RunLoop::Simctl.new
+        xcode = options[:xcode] || RunLoop::Xcode.new
+        instruments = options[:instruments] || RunLoop::Instruments.new
+
+        # Find the Device under test, the App under test, and reset options.
+        device = RunLoop::Device.detect_device(options, xcode, simctl, instruments)
+        app_details = RunLoop::DetectAUT.detect_app_under_test(options)
+        reset_options = RunLoop::Core.send(:detect_reset_options, options)
+
+        app = app_details[:app]
+        bundle_id = app_details[:bundle_id]
+
+        if device.simulator? && app
+          core_sim = RunLoop::CoreSimulator.new(device, app, :xcode => xcode)
+          if reset_options
+            core_sim.reset_app_sandbox
+          end
+
+          simctl.ensure_software_keyboard(device)
+          core_sim.install
+        end
+
+        cbx_launcher = Client.detect_cbx_launcher(options, device)
+
+        code_sign_identity = options[:code_sign_identity]
+        if !code_sign_identity
+          code_sign_identity = RunLoop::Environment::code_sign_identity
+        end
+
+        if device.physical_device? && cbx_launcher.name == :ios_device_manager
+          if !code_sign_identity
+            raise RuntimeError, %Q[
+Targeting a physical devices requires a code signing identity.
+
+Rerun your test with:
+
+$ CODE_SIGN_IDENTITY="iPhone Developer: Your Name (ABCDEF1234)" cucumber
+
+To see the valid code signing identities on your device run:
+
+$ xcrun security find-identity -v -p codesigning
+
+]
+          end
+        end
+
+        launch_options = options.merge({:code_sign_identity => code_sign_identity})
+        xcuitest = RunLoop::DeviceAgent::Client.new(bundle_id, device, cbx_launcher)
+        xcuitest.launch(launch_options)
+
+        if !RunLoop::Environment.xtc?
+          cache = {
+            :cbx_launcher => cbx_launcher.name,
+            :udid => device.udid,
+            :app => bundle_id,
+            :gesture_performer => :device_agent,
+            :code_sign_identity => code_sign_identity
+          }
+          RunLoop::Cache.default.write(cache)
+        end
+        xcuitest
+      end
+
+      # @!visibility private
+      #
+      # @param [RunLoop::Device] device the device under test
+      def self.default_cbx_launcher(device)
+        RunLoop::DeviceAgent::IOSDeviceManager.new(device)
+      end
+
+      # @!visibility private
+      # @param [Hash] options the options passed by the user
+      # @param [RunLoop::Device] device the device under test
+      def self.detect_cbx_launcher(options, device)
+        value = options[:cbx_launcher]
+        if value
+          if value == :xcodebuild
+            RunLoop::DeviceAgent::Xcodebuild.new(device)
+          elsif value == :ios_device_manager
+            RunLoop::DeviceAgent::IOSDeviceManager.new(device)
+          else
+            raise(ArgumentError,
+                  "Expected :cbx_launcher => #{value} to be :xcodebuild or :ios_device_manager")
+          end
+        else
+          Client.default_cbx_launcher(device)
+        end
+      end
+
+      attr_reader :bundle_id, :device, :cbx_launcher, :launch_options
+
+      # @!visibility private
+      #
+      # The app with `bundle_id` needs to be installed.
+      #
+      # @param [String] bundle_id The identifier of the app under test.
+      # @param [RunLoop::Device] device The device under test.
+      # @param [RunLoop::DeviceAgent::LauncherStrategy] cbx_launcher The entity that
+      #  launches the CBXRunner.
+      def initialize(bundle_id, device, cbx_launcher)
+        @bundle_id = bundle_id
+        @device = device
+        @cbx_launcher = cbx_launcher
+      end
+
+      # @!visibility private
+      def to_s
+        "#<DeviceAgent #{url} : #{bundle_id} : #{device} : #{cbx_launcher}>"
+      end
+
+      # @!visibility private
+      def inspect
+        to_s
+      end
+
+      # @!visibility private
+      def launch(options={})
+        @launch_options = options
+        start = Time.now
+        launch_cbx_runner(options)
+        launch_aut
+        elapsed = Time.now - start
+        RunLoop.log_debug("Took #{elapsed} seconds to launch #{bundle_id} on #{device}")
+        true
+      end
+
+      # @!visibility private
+      def running?
+        begin
+          health(ping_options)
+        rescue => _
+          nil
+        end
+      end
+
+      # @!visibility private
+      def stop
+        begin
+          shutdown
+        rescue => _
+          nil
+        end
+      end
+
+      # @!visibility private
+      def launch_other_app(bundle_id)
+        launch_aut(bundle_id)
+      end
+
+      # @!visibility private
+      def device_info
+        options = http_options
+        request = request("device")
+        client = client(options)
+        response = client.get(request)
+        expect_200_response(response)
+      end
+
+      # TODO Legacy API; remove once this branch is merged:
+      # https://github.com/calabash/DeviceAgent.iOS/pull/133
+      alias_method :runtime, :device_info
+
+      # @!visibility private
+      def server_pid
+        options = http_options
+        request = request("pid")
+        client = client(options)
+        response = client.get(request)
+        expect_200_response(response)
+      end
+
+      # @!visibility private
+      def server_version
+        options = http_options
+        request = request("version")
+        client = client(options)
+        response = client.get(request)
+        expect_200_response(response)
+      end
+
+      # @!visibility private
+      def session_identifier
+        options = http_options
+        request = request("sessionIdentifier")
+        client = client(options)
+        response = client.get(request)
+        expect_200_response(response)
+      end
+
+      # @!visibility private
+      def tree
+        options = http_options
+        request = request("tree")
+        client = client(options)
+        response = client.get(request)
+        expect_200_response(response)
+      end
+
+      # @!visibility private
+      def keyboard_visible?
+        options = http_options
+        parameters = { :type => "Keyboard" }
+        request = request("query", parameters)
+        client = client(options)
+        response = client.post(request)
+        hash = expect_200_response(response)
+        result = hash["result"]
+        result.count != 0
+      end
+
+      # @!visibility private
+      def enter_text(string)
+        if !keyboard_visible?
+          raise RuntimeError, "Keyboard must be visible"
+        end
+        options = http_options
+        parameters = {
+          :gesture => "enter_text",
+          :options => {
+            :string => string
+          }
+        }
+        request = request("gesture", parameters)
+        client = client(options)
+        response = client.post(request)
+        expect_200_response(response)
+      end
+
+      # @!visibility private
+      def query(mark, options={})
+        default_options = {
+          all: false,
+          specifier: :id
+        }
+        merged_options = default_options.merge(options)
+
+        parameters = { merged_options[:specifier] => mark }
+        request = request("query", parameters)
+        client = client(http_options)
+
+        RunLoop.log_debug %Q[Sending query with parameters:
+
+#{JSON.pretty_generate(parameters)}
+
+]
+
+        response = client.post(request)
+        hash = expect_200_response(response)
+        elements = hash["result"]
+
+        if merged_options[:all]
+          elements
+        else
+          elements.select do |element|
+            element["hitable"]
+          end
+        end
+      end
+
+      # @!visibility private
+      def alert_visible?
+        parameters = { :type => "Alert" }
+        request = request("query", parameters)
+        client = client(http_options)
+        response = client.post(request)
+        hash = expect_200_response(response)
+        !hash["result"].empty?
+      end
+
+      # @!visibility private
+      def query_for_coordinate(mark)
+        elements = query(mark)
+        coordinate_from_query_result(elements)
+      end
+
+      # @!visibility private
+      def touch(mark, options={})
+        coordinate = query_for_coordinate(mark)
+        perform_coordinate_gesture("touch",
+                                   coordinate[:x], coordinate[:y],
+                                   options)
+      end
+
+      alias_method :tap, :touch
+
+      # @!visibility private
+      def double_tap(mark, options={})
+        coordinate = query_for_coordinate(mark)
+        perform_coordinate_gesture("double_tap",
+                                   coordinate[:x], coordinate[:y],
+                                   options)
+      end
+
+      # @!visibility private
+      def two_finger_tap(mark, options={})
+        coordinate = query_for_coordinate(mark)
+        perform_coordinate_gesture("two_finger_tap",
+                                   coordinate[:x], coordinate[:y],
+                                   options)
+      end
+
+      # @!visibility private
+      def rotate_home_button_to(position, sleep_for=1.0)
+        orientation = normalize_orientation_position(position)
+        parameters = {
+          :orientation => orientation
+        }
+        request = request("rotate_home_button_to", parameters)
+        client = client(http_options)
+        response = client.post(request)
+        json = expect_200_response(response)
+        sleep(sleep_for)
+        json
+      end
+
+      # @!visibility private
+      def pan_between_coordinates(start_point, end_point, options={})
+        default_options = {
+          :num_fingers => 1,
+          :duration => 0.5
+        }
+
+        merged_options = default_options.merge(options)
+
+        parameters = {
+          :gesture => "drag",
+          :specifiers => {
+            :coordinates => [start_point, end_point]
+          },
+          :options => merged_options
+        }
+
+        make_gesture_request(parameters)
+      end
+
+      # @!visibility private
+      def perform_coordinate_gesture(gesture, x, y, options={})
+        parameters = {
+          :gesture => gesture,
+          :specifiers => {
+            :coordinate => {x: x, y: y}
+          },
+          :options => options
+        }
+
+        make_gesture_request(parameters)
+      end
+
+      # @!visibility private
+      def make_gesture_request(parameters)
+
+        RunLoop.log_debug %Q[Sending request to perform '#{parameters[:gesture]}' with:
+
+#{JSON.pretty_generate(parameters)}
+
+]
+        request = request("gesture", parameters)
+        client = client(http_options)
+        response = client.post(request)
+        expect_200_response(response)
+      end
+
+      # @!visibility private
+      def coordinate_from_query_result(matches)
+
+        if matches.nil? || matches.empty?
+          raise "Expected #{hash} to contain some results"
+        end
+
+        rect = matches.first["rect"]
+        h = rect["height"]
+        w = rect["width"]
+        x = rect["x"]
+        y = rect["y"]
+
+        touchx = x + (w/2.0)
+        touchy = y + (h/2.0)
+
+        new_rect = rect.dup
+        new_rect[:center_x] = touchx
+        new_rect[:center_y] = touchy
+
+        RunLoop.log_debug(%Q[Rect from query:
+
+#{JSON.pretty_generate(new_rect)}
+
+                          ])
+        {:x => touchx,
+         :y => touchy}
+      end
+
+
+      # @!visibility private
+      def change_volume(up_or_down)
+        string = up_or_down.to_s
+        parameters = {
+          :volume => string
+        }
+        request = request("volume", parameters)
+        client = client(http_options)
+        response = client.post(request)
+        json = expect_200_response(response)
+        # Set in the route
+        sleep(0.2)
+        json
+      end
+
+      private
+
+      # @!visibility private
+      def xcrun
+        RunLoop::Xcrun.new
+      end
+
+      # @!visibility private
+      def url
+        @url ||= detect_device_agent_url
+      end
+
+      # @!visibility private
+      def detect_device_agent_url
+        url_from_environment ||
+          url_for_simulator ||
+          url_from_device_endpoint ||
+          url_from_device_name
+      end
+
+      # @!visibility private
+      def url_from_environment
+        url = RunLoop::Environment.device_agent_url
+        return if url.nil?
+
+        if url.end_with?("/")
+          url
+        else
+          "#{url}/"
+        end
+      end
+
+      # @!visibility private
+      def url_for_simulator
+        if device.simulator?
+          "http://#{DEFAULTS[:simulator_ip]}:#{DEFAULTS[:port]}/"
+        else
+          nil
+        end
+      end
+
+      # @!visibility private
+      def url_from_device_endpoint
+        calabash_endpoint = RunLoop::Environment.device_endpoint
+        if calabash_endpoint
+          base = calabash_endpoint.split(":")[0..1].join(":")
+          "#{base}:#{DEFAULTS[:port]}/"
+        else
+          nil
+        end
+      end
+
+      # @!visibility private
+      # TODO This block is not well tested
+      # TODO extract to a module; Calabash can use to detect device endpoint
+      def url_from_device_name
+        # Transforms the default "Joshua's iPhone" to a DNS name.
+        device_name = device.name.gsub(/[']/, "").gsub(/[\s]/, "-")
+
+        # Replace diacritic markers and unknown characters.
+        transliterated = transliterate(device_name).tr("?", "")
+
+        # Anything that cannot be transliterated is a ?
+        replaced = transliterated.tr("?", "")
+
+        "http://#{replaced}.local:#{DEFAULTS[:port]}/"
+      end
+
+      # @!visibility private
+      def server
+        @server ||= RunLoop::HTTP::Server.new(url)
+      end
+
+      # @!visibility private
+      def client(options={})
+        RunLoop::HTTP::RetriableClient.new(server, options)
+      end
+
+      # @!visibility private
+      def versioned_route(route)
+        "#{DEFAULTS[:route_version]}/#{route}"
+      end
+
+      # @!visibility private
+      def request(route, parameters={})
+        versioned = versioned_route(route)
+        RunLoop::HTTP::Request.request(versioned, parameters)
+      end
+
+      # @!visibility private
+      def ping_options
+        @ping_options ||= { :timeout => 0.5, :retries => 1 }
+      end
+
+      # @!visibility private
+      def http_options
+        if cbx_launcher.name == :xcodebuild
+          timeout = DEFAULTS[:http_timeout] * 2
+          {
+            :timeout => timeout,
+            :interval => 0.1,
+            :retries => (timeout/0.1).to_i
+          }
+        else
+          {
+            :timeout => DEFAULTS[:http_timeout],
+            :interval => 0.1,
+            :retries => (DEFAULTS[:http_timeout]/0.1).to_i
+          }
+        end
+      end
+
+      # @!visibility private
+      def session_delete
+        # https://xamarin.atlassian.net/browse/TCFW-255
+        # httpclient is unable to send a valid DELETE
+        args = ["curl", "-X", "DELETE", %Q[#{url}#{versioned_route("session")}]]
+        run_shell_command(args, {:log_cmd => true})
+
+        # options = ping_options
+        # request = request("session")
+        # client = client(options)
+        # begin
+        #   response = client.delete(request)
+        #   body = expect_200_response(response)
+        #   RunLoop.log_debug("CBX-Runner says, #{body}")
+        #   body
+        # rescue => e
+        #   RunLoop.log_debug("CBX-Runner session delete error: #{e}")
+        #   nil
+        # end
+      end
+
+      # @!visibility private
+      # TODO expect 200 response and parse body (atm the body in not valid JSON)
+      def shutdown
+        session_delete
+        options = ping_options
+        request = request("shutdown")
+        client = client(options)
+        body = nil
+        begin
+          response = client.post(request)
+          body = response.body
+          RunLoop.log_debug("DeviceAgent-Runner says, \"#{body}\"")
+
+          now = Time.now
+          poll_until = now + 10.0
+          running = true
+          while Time.now < poll_until
+            running = !running?
+            break if running
+            sleep(0.1)
+          end
+
+          RunLoop.log_debug("Waited for #{Time.now - now} seconds for DeviceAgent to shutdown")
+          body
+        rescue => e
+          RunLoop.log_debug("DeviceAgent-Runner shutdown error: #{e}")
+        ensure
+          quit_options = { :timeout => 0.5 }
+          term_options = { :timeout => 0.5 }
+          kill_options = { :timeout => 0.5 }
+
+          process_name = "iOSDeviceManager"
+          RunLoop::ProcessWaiter.new(process_name).pids.each do |pid|
+            quit = RunLoop::ProcessTerminator.new(pid, "QUIT", process_name, quit_options)
+            if !quit.kill_process
+              term = RunLoop::ProcessTerminator.new(pid, "TERM", process_name, term_options)
+              if !term.kill_process
+                kill = RunLoop::ProcessTerminator.new(pid, "KILL", process_name, kill_options)
+                kill.kill_process
+              end
+            end
+          end
+        end
+        body
+      end
+
+      # @!visibility private
+      # TODO expect 200 response and parse body (atm the body is not valid JSON)
+      def health(options={})
+        merged_options = http_options.merge(options)
+        request = request("health")
+        client = client(merged_options)
+        response = client.get(request)
+        body = response.body
+        RunLoop.log_debug("CBX-Runner driver says, \"#{body}\"")
+        body
+      end
+
+
+      # TODO cbx_runner_stale? returns false always
+      def cbx_runner_stale?
+        false
+        # The RunLoop::Version class needs to be updated to handle timestamps.
+        #
+        # if cbx_launcher.name == :xcodebuild
+        #   return false
+        # end
+
+        # version_info = server_version
+        # running_bundle_version = RunLoop::Version.new(version_info[:bundle_version])
+        # bundle_version = RunLoop::App.new(cbx_launcher.runner.runner).bundle_version
+        #
+        # running_bundle_version < bundle_version
+      end
+
+      # @!visibility private
+      def launch_cbx_runner(options={})
+        merged_options = DEFAULTS.merge(options)
+
+        if merged_options[:shutdown_device_agent_before_launch]
+          RunLoop.log_debug("Launch options insist that the DeviceAgent be shutdown")
+          shutdown
+
+          if cbx_launcher.name == :xcodebuild
+            sleep(5.0)
+          end
+        end
+
+        if running?
+          RunLoop.log_debug("DeviceAgent is already running")
+          if cbx_runner_stale?
+            shutdown
+          else
+            # TODO: is it necessary to return the pid?  Or can we return true?
+            return server_pid
+          end
+        end
+
+        if cbx_launcher.name == :xcodebuild
+          RunLoop.log_debug("xcodebuild is the launcher - terminating existing xcodebuild processes")
+          term_options = { :timeout => 0.5 }
+          kill_options = { :timeout => 0.5 }
+          RunLoop::ProcessWaiter.new("xcodebuild").pids.each do |pid|
+            term = RunLoop::ProcessTerminator.new(pid, 'TERM', "xcodebuild", term_options)
+            killed = term.kill_process
+            unless killed
+              RunLoop::ProcessTerminator.new(pid, 'KILL', "xcodebuild", kill_options)
+            end
+          end
+          sleep(2.0)
+        end
+
+        start = Time.now
+        RunLoop.log_debug("Waiting for CBX-Runner to launch...")
+        pid = cbx_launcher.launch(options)
+
+        if cbx_launcher.name == :xcodebuild
+          sleep(2.0)
+        end
+
+        begin
+          timeout = RunLoop::Environment.ci? ? 120 : 60
+          health_options = {
+            :timeout => timeout,
+            :interval => 0.1,
+            :retries => (timeout/0.1).to_i
+          }
+
+          health(health_options)
+        rescue RunLoop::HTTP::Error => _
+          raise %Q[
+
+Could not connect to the DeviceAgent service.
+
+device: #{device}
+   url: #{url}
+
+To diagnose the problem tail the launcher log file:
+
+$ tail -1000 -F #{cbx_launcher.class.log_file}
+
+]
+        end
+
+        RunLoop.log_debug("Took #{Time.now - start} launch and respond to /health")
+
+        # TODO: is it necessary to return the pid?  Or can we return true?
+        pid
+      end
+
+      # @!visibility private
+      def launch_aut(bundle_id = @bundle_id)
+        client = client(http_options)
+        request = request("session", {:bundleID => bundle_id})
+
+        if device.simulator?
+          # Yes, we could use iOSDeviceManager to check, I dont understand the
+          # behavior yet - does it require the simulator be launched?
+          # CoreSimulator can check without launching the simulator.
+          installed = CoreSimulator.app_installed?(device, bundle_id)
+        else
+          if cbx_launcher.name == :xcodebuild
+            # :xcodebuild users are on their own.
+            RunLoop.log_debug("Detected :xcodebuild launcher; skipping app installed check")
+            installed = true
+          else
+            installed = cbx_launcher.app_installed?(bundle_id)
+          end
+        end
+
+        if !installed
+          raise RuntimeError, %Q[
+The app you are trying to launch is not installed on the target device:
+
+bundle identifier: #{bundle_id}
+           device: #{device}
+
+Please install it.
+
+]
+        end
+
+        begin
+          response = client.post(request)
+          RunLoop.log_debug("Launched #{bundle_id} on #{device}")
+          RunLoop.log_debug("#{response.body}")
+          if device.simulator?
+            # It is not clear yet whether we should do this.  There is a problem
+            # in the simulator_wait_for_stable_state; it waits too long.
+            # device.simulator_wait_for_stable_state
+          end
+          expect_200_response(response)
+        rescue => e
+          raise e.class, %Q[
+
+Could not launch #{bundle_id} on #{device}:
+
+#{e.message}
+
+Something went wrong.
+
+]
+        end
+      end
+
+      # @!visibility private
+      def response_body_to_hash(response)
+        body = response.body
+        begin
+          JSON.parse(body)
+        rescue TypeError, JSON::ParserError => _
+          raise RunLoop::DeviceAgent::Client::HTTPError,
+                "Could not parse response '#{body}'; the app has probably crashed"
+        end
+      end
+
+      # @!visibility private
+      def expect_200_response(response)
+        body = response_body_to_hash(response)
+        if response.status_code < 300 && !body["error"]
+          return body
+        end
+
+        if response.status_code > 300
+          raise RunLoop::DeviceAgent::Client::HTTPError,
+                %Q[Expected status code < 300, found #{response.status_code}.
+
+Server replied with:
+
+#{body}
+
+                ]
+        else
+          raise RunLoop::DeviceAgent::Client::HTTPError,
+                %Q[Expected JSON response with no error, but found
+
+#{body["error"]}
+
+                ]
+
+        end
+      end
+
+      # @!visibility private
+      def normalize_orientation_position(position)
+        if position.is_a?(Symbol)
+          orientation_for_position_symbol(position)
+        elsif position.is_a?(Fixnum)
+          position
+        else
+          raise ArgumentError, %Q[
+Expected #{position} to be a Symbol or Fixnum but found #{position.class}
+
+          ]
+        end
+      end
+
+      # @!visibility private
+      def orientation_for_position_symbol(position)
+        symbol = position.to_sym
+
+        case symbol
+          when :down, :bottom
+            return 1
+          when :up, :top
+            return 2
+          when :right
+            return 3
+          when :left
+            return 4
+          else
+            raise ArgumentError, %Q[
+Could not coerce '#{position}' into a valid orientation.
+
+Valid values are: :down, :up, :right, :left, :bottom, :top
+]
+        end
+      end
+    end
+  end
+end