calabash 1.2.1 → 1.9.9.pre1

data/lib/calabash/android.rb

@@ -0,0 +1,64 @@
+module Calabash
+  # Contains the Android implementations of the Calabash APIs.
+  module Android
+    TEST_SERVER_CODE_PATH = File.join(File.dirname(__FILE__), '..', '..', 'android', 'test-server')
+    UNSIGNED_TEST_SERVER_APK = File.join(File.dirname(__FILE__), 'android', 'lib', 'TestServer.apk')
+    ANDROID_MANIFEST_PATH = File.join(File.dirname(__FILE__), 'android', 'lib', 'AndroidManifest.xml')
+
+    require 'calabash'
+    include Calabash
+
+    # @!visibility private
+    def self.extended(base)
+      Calabash.send(:extended, base)
+    end
+
+    # @!visibility private
+    def self.included(base)
+      Calabash.send(:included, base)
+    end
+
+    require 'calabash/android/environment'
+
+    require 'calabash/android/application'
+    require 'calabash/android/build'
+    require 'calabash/android/device'
+    require 'calabash/android/screenshot'
+    require 'calabash/android/server'
+    require 'calabash/android/adb'
+    require 'calabash/android/gestures'
+    require 'calabash/android/interactions'
+    require 'calabash/android/orientation'
+    require 'calabash/android/physical_buttons'
+    require 'calabash/android/text'
+    require 'calabash/android/console_helpers'
+    require 'calabash/android/life_cycle'
+
+    include Calabash::Android::Gestures
+    include Calabash::Android::Interactions
+    include Calabash::Android::LifeCycle
+    include Calabash::Android::Orientation
+    include Calabash::Android::PhysicalButtons
+    include Calabash::Android::Text
+
+    # @!visibility private
+    def self.binary_location(name, abi, using_pie)
+      binary_name = if using_pie
+                      "#{name}-pie"
+                    else
+                      name
+                    end
+
+      file = File.join(File.dirname(__FILE__), 'android', 'lib', name, abi, binary_name)
+
+      unless File.exist?(file)
+        raise "No such file '#{file}'"
+      end
+
+      file
+    end
+  end
+end
+
+# Setup environment on load
+Calabash::Android::Environment.setup

data/lib/calabash/android/adb.rb

@@ -0,0 +1,277 @@
+require 'timeout'
+require 'open3'
+
+module Calabash
+  module Android
+    # @!visibility private
+    class ADB
+      # @!visibility private
+      class ADBCallError < StandardError
+        attr_reader :stderr, :stdout
+
+        def initialize(message, stderr=nil, stdout=nil)
+          super(message)
+
+          @stderr = stderr
+          @stdout = stdout
+        end
+      end
+
+      PROCESS_WAIT_TIME = 10
+
+      def self.open_pipe_with_timeout(timeout, *cmd, &block)
+        begin
+          i, o, e, t, pid = nil
+
+          Timeout.timeout(timeout, ProcessDidNotExitError) do
+            i, o, e, t = Open3.popen3(*cmd)
+            i.sync = true
+            o.sync = true
+            e.sync = true
+            pid = t.pid
+            block.call(i, o, e)
+
+            t.value.exitstatus
+          end
+        rescue ProcessDidNotExitError => _
+          raise ADBCallError, 'ADB process did not exit'
+        ensure
+          i.close unless i.nil? || i.closed?
+          o.close unless o.nil? || o.closed?
+          e.close unless e.nil? || e.closed?
+
+          if pid
+            begin
+              Process.kill(9, pid)
+            rescue Errno::ESRCH => _
+              # do nothing
+            end
+          end
+
+          t.join if t
+        end
+      end
+
+      def self.open_adb_pipe(*cmd, **options, &block)
+        timeout = options.fetch(:timeout, PROCESS_WAIT_TIME)
+
+        open_pipe_with_timeout(timeout, Environment.adb_path, *cmd) do |i, o, e|
+          block.call(i, o, e) if block
+        end
+      end
+
+      DAEMON_STARTED_MESSAGE = "* daemon not running. starting it now on port 5037 *\n* daemon started successfully *\n"
+
+      def self.command(*cmd, **args)
+        Logger.debug("ADB Command: #{cmd.join(', ')}")
+        Logger.debug("ADB input: #{args[:input]}")
+        stderr = nil
+        stdout = nil
+        exit_code = nil
+
+        input = args[:input]
+
+        begin
+          exit_code = open_adb_pipe(*cmd, args) do |i, o, e|
+            if input
+              input.each do |p_cmd|
+                begin
+                  i.puts p_cmd
+                rescue Errno::EPIPE => err
+                  i.close
+                  stderr = e.readlines.join
+                  stdout = o.readlines.join
+                  raise ADBCallError.new(err, stderr, stdout)
+                end
+              end
+
+              i.close
+            end
+
+            unless args.fetch(:no_read, false)
+              stdout = o.readlines.join
+              stderr = e.readlines.join
+            end
+
+            if stdout && stdout.start_with?(DAEMON_STARTED_MESSAGE)
+              stdout = stdout[DAEMON_STARTED_MESSAGE.length..-1]
+            end
+          end
+        rescue IOError => e
+          raise ADBCallError, e
+        end
+
+        if exit_code != 0
+          Logger.debug("Adb process exited with #{exit_code}")
+          Logger.debug("Error message from ADB: ")
+          Logger.debug(stderr)
+
+          stderr_output = if stderr && !stderr.empty?
+                            ": #{dot_string(stderr.lines.first, 100)}"
+                          else
+                            ''
+                          end
+
+          raise ADBCallError.new(
+                "Adb process exited with #{exit_code}#{stderr_output}", stderr, stdout)
+        end
+
+        stdout
+      end
+
+      attr_reader :serial
+
+      def initialize(serial)
+        @serial = serial
+      end
+
+      def command(*argv, **args)
+        cmd = argv.dup
+
+        if serial
+          cmd.unshift('-s', serial)
+        end
+
+        ADB.command(*cmd, args)
+      end
+
+      END_STRING = '__CAL_END__'
+
+      def shell(shell_cmd, options={})
+        if shell_cmd.nil? || shell_cmd.empty?
+          raise ArgumentError, "Invalid shell command '#{shell_cmd}'"
+        end
+
+        input =
+            [
+                "#{shell_cmd}; echo \"#{END_STRING}$?\"; exit 0"
+            ]
+
+        args = options.merge(input: input)
+
+        result = command('shell', args)
+
+        # We get a result like this:
+        #
+        # [0] "getprop ro.build.version.release; echo \"\r\n",
+        # [1] "$?\"; exit 0\r\n",
+        # [2] "shell@hammerhead:/ $ getprop ro.build.version.release; echo \"\r\r\n",
+        # [3] "> $?\"; exit 0\r\r\n",
+        # [4] "4.4\r\n",
+        # [5] "\r\n",
+        # [6] "0\r\n"
+        #
+        # out =
+        # [4] "4.4\r\n"
+        # [5] "\r\n",
+        # [6] "0\r\n"
+        #
+        # command_result =
+        # [4] "4.4\r\n"
+        # [5] "\r\n",
+        #
+        # exit_code_s =
+        # [6] "0\r\n"
+
+        index = result.lines.index {|line| line.start_with?(shell_name)}
+
+        if index.nil?
+          raise ADBCallError.new("Could not parse output #{ADB.dot_string(result, 100)}", result)
+        end
+
+        # Remove the commands
+        out = result.lines[index+1..-1]
+
+        last_line = out.last
+        end_index = nil
+
+        15.times do |i|
+          if last_line[-(END_STRING.length+i-1)..-i] == END_STRING
+            end_index = -i
+            break
+          end
+        end
+
+        if end_index.nil?
+          raise ADBCallError.new("Could not parse output #{ADB.dot_string(result, 100)}", result)
+        end
+
+        # Get the result from the command
+        command_result = out[0..-2].join + last_line[0..(end_index - END_STRING.length)]
+
+        # Get the exit code
+        exit_code_s = out[-1][end_index+1..-1]
+
+        unless options[:no_exit_code_check]
+          unless exit_code_s.to_i.to_s == exit_code_s.chomp
+            raise ADBCallError,
+                  "Unable to obtain exit code. Result: '#{exit_code_s}'"
+          end
+
+          exit_code = exit_code_s.to_i
+
+          if exit_code != 0
+            Logger.debug("Adb shell command exited with #{exit_code}")
+            Logger.debug("Error message from ADB: ")
+            Logger.debug(command_result)
+
+            stderr_output = if command_result && !command_result.empty?
+                              ": #{ADB.dot_string(command_result.lines.first, 100)}"
+                            else
+                              ''
+                            end
+
+            raise ADBCallError.new(
+                      "Adb shell command exited with #{exit_code}#{stderr_output}", command_result)
+          end
+        end
+
+        command_result
+      end
+
+      private
+
+      def self.dot_string(string, length)
+        if string.length > length
+          "#{string[0, length-3]}..."
+        else
+          string
+        end
+      end
+
+      def shell_name
+        if @shell_name
+          @shell_name
+        else
+          result = command('shell', input: ['echo "test"; exit 0'])
+
+          # result.lines =
+          # [
+          #     [0] "echo \"foo\"; exit 0\r\n",
+          #     [1] "shell@hammerhead:/ $ echo \"foo\"; exit 0\r\r\n",
+          #     [2] "foo\r\n"
+          # ]
+          #
+          # OR
+          #
+          # result.lines =
+          # [
+          #     [1] "shell@hammerhead:/ $ echo \"foo\"; exit 0\r\r\n",
+          #     [2] "foo\r\n"
+          # ]
+
+          #result.lines.index {|line| !line.start_with?('echo')}
+
+          # "shell@hammerhead:/ $ echo \"foo\"; exit 0\r\r\n"
+          shell_name_line = result.lines[-2]
+
+          # "shell@hammerhead:/ $ "
+          @shell_name = shell_name_line.split('echo').first
+        end
+      end
+
+      # @!visibility private
+      class ProcessDidNotExitError < RuntimeError; end
+    end
+  end
+end

data/lib/calabash/android/application.rb

@@ -0,0 +1,110 @@
+module Calabash
+  module Android
+    # A class to represent an Android application (.apk).
+    class Application < Calabash::Application
+      attr_reader :test_server
+
+      def self.default_from_environment
+        application_path = Environment::APP_PATH
+
+        if application_path.nil?
+          raise 'No application path is set'
+        end
+
+        unless File.exist?(application_path)
+          raise "Application '#{application_path}' does not exist"
+        end
+
+        if File.directory?(application_path)
+          raise "Application '#{application_path}' is not a file"
+        end
+
+        build_test_server = Build::TestServer.new(application_path)
+        test_server_path = Environment::TEST_SERVER_PATH ||
+            build_test_server.path
+
+        unless File.exist?(test_server_path)
+          Logger.error "Test-server '#{test_server_path}' does not exist."
+          Logger.error "Build it using: 'calabash build \"#{application_path}\"'"
+          Logger.error ''
+          raise "Test-server '#{test_server_path}' does not exist."
+        end
+
+        Application.new(application_path, test_server_path)
+      end
+
+      def initialize(application_path, test_server_path, options = {})
+        super(application_path, options)
+        @test_server = Application.new(test_server_path, nil, options) if test_server_path
+      end
+
+      def extract_identifier
+        package_line = aapt_dump('package').first
+        raise "'package' not found in aapt output" unless package_line
+        m = package_line.match(/name='([^']+)'/)
+        raise "Unexpected output from aapt: #{package_line}" unless m
+        m[1]
+      end
+
+      def main_activity
+        begin
+          @logger.log("Trying to find launchable activity")
+          launchable_activity_line = aapt_dump('launchable-activity').first
+          raise "'launchable-activity' not found in aapt output" unless launchable_activity_line
+          m = launchable_activity_line.match(/name='([^']+)'/)
+          raise "Unexpected output from aapt: #{launchable_activity_line}" unless m
+          @logger.log("Found launchable activity '#{m[1]}'")
+          m[1]
+        rescue => e
+          @logger.log("Could not find launchable activity, trying to parse raw AndroidManifest. #{e.message}")
+
+          manifest_data = `"#{Environment.aapt_path}/aapt" dump xmltree "#{@path}" AndroidManifest.xml`
+          regex = /^\s*A:[\s*]android:name\(\w+\)\=\"android.intent.category.LAUNCHER\"/
+          lines = manifest_data.lines.collect(&:strip)
+          indicator_line = nil
+
+          lines.each_with_index do |line, index|
+            match = line.match(regex)
+
+            unless match.nil?
+              raise 'More than one launchable activity in AndroidManifest' unless indicator_line.nil?
+              indicator_line = index
+            end
+          end
+
+          raise 'No launchable activity found in AndroidManifest' unless indicator_line
+
+          intent_filter_found = false
+
+          (0..indicator_line).reverse_each do |index|
+            if intent_filter_found
+              match = lines[index].match(/\s*E:\s*activity-alias/)
+
+              raise 'Could not find target activity in activity alias' if match
+
+              match = lines[index].match(/^\s*A:\s*android:targetActivity\(\w*\)\=\"([^\"]+)/){$1}
+
+              if match
+                @logger.log("Found launchable activity '#{match}'")
+
+                return match
+              end
+            else
+              unless lines[index].match(/\s*E: intent-filter/).nil?
+                @logger.log("Read intent filter")
+                intent_filter_found = true
+              end
+            end
+          end
+
+          raise 'Could not find launchable activity'
+        end
+      end
+
+      def aapt_dump(key)
+        lines = `"#{Environment.aapt_path}" dump badging "#{path}"`.lines.collect(&:strip)
+        lines.select { |l| l.start_with?("#{key}:") }
+      end
+    end
+  end
+end