calabash 2.0.0.pre1 → 2.0.0.prelegacy2

data/lib/calabash/android/environment.rb

@@ -15,6 +15,16 @@ module Calabash
       # @!visibility private
       class InvalidJavaSDKHome < RuntimeError; end
 
+      # A URI that points to the embedded Calabash server in the app under test.
+      #
+      # The default value is 'http://localhost:34777'.
+      #
+      # You can control the value of this variable by setting the `CAL_ENDPOINT`
+      # variable.
+      #
+      # @todo Maybe rename this to CAL_SERVER_URL or CAL_SERVER?
+      DEVICE_ENDPOINT = URI.parse((variable('CAL_ENDPOINT') || 'http://127.0.0.1:34777'))
+
       private
 
       def self.set_android_dependencies(android_dependencies)

data/lib/calabash/android/interactions.rb

@@ -3,6 +3,8 @@ require 'time'
 
 module Calabash
   module Android
+
+    # Interactions with your app that are specific to Android.
     module Interactions
       # Go back. If the keyboard is shown, it will be dismissed.
       def go_back

data/lib/calabash/android/legacy.rb

@@ -0,0 +1,149 @@
+if ENV["APP_PATH"]
+  Calabash::Environment::APP_PATH = ENV["APP_PATH"]
+end
+
+if ENV["TEST_APP_PATH"]
+  Calabash::Environment::TEST_SERVER_PATH = ENV["TEST_APP_PATH"]
+end
+
+
+module Calabash
+  module Android
+    class Device < Calabash::Device
+      def screen_on?
+        true
+      end
+
+      def installed_apps
+        packages = installed_packages
+
+        packages.map{|p| {package: p, path: ''}}
+      end
+
+      def md5_checksum(file_path)
+        "samplechecksum"
+      end
+
+      def adb_install_app(application)
+        @logger.log "Patch: Installing #{application.path}"
+
+        begin
+          result = adb.command("install #{application.path}", timeout: 60)
+        rescue ADB::ADBCallError => e
+          raise "Failed to install the application on device: '#{e.message}'"
+        end
+
+        if result.lines.last.downcase.chomp != 'success'
+          raise "Could not install app '#{application.identifier}': #{result.chomp}"
+        end
+
+        unless installed_packages.include?(application.identifier)
+          raise "App '#{application.identifier}' was not installed"
+        end
+      end
+
+      def _start_app(application, options={})
+        env_options = {}
+
+        options.fetch(:extras, {}).each do |k, v|
+          env_options[k] = v
+        end
+
+        env_options[:target_package] = application.identifier
+
+        if options[:activity]
+          env_options[:main_activity] = options[:activity]
+        end
+
+        env_options[:test_server_port] = server.test_server_port
+        env_options[:class] = options.fetch(:class, 'sh.calaba.instrumentationbackend.InstrumentationBackend')
+
+        if application.test_server.nil?
+          raise 'Invalid application. No test-server set.'
+        end
+
+        unless app_installed?(application.identifier)
+          raise "The application '#{application.identifier}' is not installed"
+        end
+
+        unless app_installed?(application.test_server.identifier)
+          raise "The test-server '#{application.test_server.identifier}' is not installed"
+        end
+
+        installed_app = installed_apps.find{|app| app[:package] == application.identifier}
+        installed_app_md5_checksum = md5_checksum(installed_app[:path])
+
+        if application.md5_checksum != installed_app_md5_checksum
+          raise "The specified app is not the same as the installed app (#{application.md5_checksum} != #{installed_app_md5_checksum})."
+        end
+
+        installed_test_server = installed_apps.find{|app| app[:package] == application.test_server.identifier}
+        installed_test_server_md5_checksum = md5_checksum(installed_test_server[:path])
+
+        if application.test_server.md5_checksum != installed_test_server_md5_checksum
+          raise "The specified test-server is not the same as the installed test-server (#{application.test_server.md5_checksum} != #{installed_test_server_md5_checksum})."
+        end
+
+        # We have to forward the port ourselves, as an old test-server could be
+        # running on the old port. If the retriable client was able to
+        # determine if the port had been forwarded, we would not need this.
+        port_forward(server.endpoint.port, server.test_server_port)
+
+        # For now, the test-server cannot rebind an existing socket.
+        # So we have to stop any running Calabash servers from the client
+        # for now.
+        if test_server_responding?
+          @logger.log("A test-server is already running on port #{server.test_server_port}")
+          @logger.log("Trying to stop it")
+
+          begin
+            _stop_app
+          rescue => _
+            raise 'Failed to stop old running test-server'
+          end
+        end
+
+        extras = ''
+
+        env_options.each_pair do |key, val|
+          extras = "#{extras} -e #{key.to_s} #{val.to_s}"
+        end
+
+        begin
+          instrument(application,
+                     'sh.calaba.instrumentationbackend.CalabashInstrumentationTestRunner',
+                     extras)
+        rescue ADB::ADBCallError => e
+          raise "Failed to start the application: '#{e.stderr.lines.first.chomp}'"
+        end
+
+        begin
+          Retriable.retriable(tries: 30, interval: 1, timeout: 30, on: RetryError) do
+            unless test_server_responding?
+              raise RetryError
+            end
+          end
+        rescue RetryError => _
+          @logger.log('Could not contact test-server', :error)
+          @logger.log('For information, see the adb logcat', :error)
+          raise 'Could not contact test-server'
+        end
+
+        begin
+          Retriable.retriable(tries: 10, interval: 1, timeout: 10) do
+            unless test_server_ready?
+              raise RetryError
+            end
+          end
+        rescue RetryError => _
+          @logger.log('Test-server was never ready', :error)
+          @logger.log('For information, see the adb logcat', :error)
+          raise 'Test-server was never ready'
+        end
+
+        # Return true to avoid cluttering the console
+        true
+      end
+    end
+  end
+end

data/lib/calabash/android/life_cycle.rb

@@ -1,5 +1,6 @@
 module Calabash
   module Android
+    # Android specific life cyle methods.
     module LifeCycle
       # Resume an application. If the application is already focused, nothing
       # will happen.

data/lib/calabash/android/physical_buttons.rb

@@ -7,35 +7,43 @@ module Calabash
     # @!visibility private
     module PhysicalButtons
 
+      # @!visibility private
       def press_button(key)
         Device.default.perform_action('press_key', key)
         true
       end
 
+      # @!visibility private
       def press_back_button
         press_button('KEYCODE_BACK')
       end
 
+      # @!visibility private
       def press_menu_button
         press_button('KEYCODE_MENU')
       end
 
+      # @!visibility private
       def press_down_button
         press_button('KEYCODE_DPAD_DOWN')
       end
 
+      # @!visibility private
       def press_up_button
         press_button('KEYCODE_DPAD_UP')
       end
 
+      # @!visibility private
       def press_left_button
         press_button('KEYCODE_DPAD_LEFT')
       end
 
+      # @!visibility private
       def press_right_button
         press_button('KEYCODE_DPAD_RIGHT')
       end
 
+      # @!visibility private
       def press_enter_button
         press_button('KEYCODE_ENTER')
       end

data/lib/calabash/android/screenshot.rb

@@ -2,6 +2,7 @@ module Calabash
   module Android
     # @!visibility private
     module Screenshot
+      # @!visibility private
       SCREENSHOT_JAR_PATH = File.join(File.dirname(__FILE__), 'lib', 'screenshot_taker.jar')
     end
   end

data/lib/calabash/android/scroll.rb

@@ -1,5 +1,115 @@
 module Calabash
   module Android
+    # Scrolling invokes methods on the views to get to the right items. This
+    # behaviour is not doable by the users. For real gestures interacting with
+    # the screen, see {Calabash::Gestures}.
+    module Scroll
+      # Scroll the first view matched by `query` in `direction`.
+      #
+      # @param [String, Hash, Calabash::Query] query A query describing the
+      # view to scroll.
+      # @param [Symbol] direction The direction to scroll. Valid directions are:
+      #  :up, :down, :left, and :right
+      def scroll(query, direction)
+        allowed_directions = [:up, :down, :left, :right]
 
+        dir_symbol = direction.to_sym
+
+        unless allowed_directions.include?(dir_symbol)
+          raise ArgumentError,
+                "Expected '#{direction}' to be one of #{allowed_directions.join(',')}"
+        end
+
+        view = wait_for_view(query, timeout: Calabash::Gestures::DEFAULT_GESTURE_WAIT_TIMEOUT)
+
+        result = query("#{Query.new(query)} index:0", :getFirstVisiblePosition)
+
+        if result.length == 0
+          raise "Failed to scroll view '#{query}'"
+        end
+
+        if result.first.is_a?(Hash) && result.first.has_key?("error")
+          # View is not of type android.widget.AbsListView
+          scroll_x = 0
+          scroll_y = 0
+          width = view['rect']['width']
+          height = view['rect']['height']
+
+          if direction == :up
+            scroll_y = -height / 2
+          elsif direction == :down
+            scroll_y = height / 2
+          elsif direction == :left
+            scroll_x = -width / 2
+          elsif direction == :right
+            scroll_x = width / 2
+          end
+
+          result = query("#{Query.new(query)} index:0", {scrollBy: [scroll_x.to_i, scroll_y.to_i]})
+
+          if result.length == 0
+            raise "Failed to scroll view '#{query}'"
+          end
+
+          if result.first.is_a?(Hash) && result.first.has_key?('error')
+            raise "Failed to scroll view: #{result.first['error']}"
+          end
+        else
+          # View is of type android.widget.AbsListView
+          unless [:up, :down].include?(dir_symbol)
+            raise ArgumentError,
+                  "Can only scroll listviews :up or :down, not #{direction}"
+          end
+
+          first_position = result.first.to_i
+          result = query("#{Query.new(query)} index:0", :getLastVisiblePosition)
+
+          if result.length == 0
+            raise "Failed to scroll view '#{Query.new(query)}'"
+          end
+
+          last_position = result.first.to_i
+
+
+          selection_index = if direction == :up
+                              [first_position + [first_position - last_position + 1, -1].min, 0].max
+                            elsif direction == :down
+                              first_position + [last_position - first_position, 1].max
+                            end
+
+          result = query("#{Query.new(query)} index:0", setSelection: selection_index)
+
+          if result.length == 0
+            raise "Failed to scroll view '#{query}'"
+          end
+        end
+
+        true
+      end
+
+      # Scroll to `item` in `query`. If `query` matches multiple views, the
+      # first view matching `query` is scrolled.
+      #
+      # @param [String, Hash, Calabash::Query] query A query describing the
+      #  view to scroll.
+      # @param [Numeric] item The item number to scroll to. This value is
+      #  0-indexed.
+      def scroll_to_row(query, item)
+        wait_for_view(query, timeout: Calabash::Gestures::DEFAULT_GESTURE_WAIT_TIMEOUT)
+        result = query("#{Query.new(query)} index:0", setSelection: item)
+
+        if result.length == 0
+          raise "Failed to scroll view '#{query}'"
+        end
+
+        result.length.times do |i|
+          if result[i].is_a?(Hash) && result[i].has_key?('error')
+            raise "Unable to scroll view number '#{i}' matching '#{query}'. #{result[i]['error']}"
+          end
+        end
+
+        true
+      end
+    end
   end
 end

data/lib/calabash/android/server.rb

@@ -2,8 +2,10 @@ module Calabash
   module Android
     # A representation of the Calabash Android test server.
     class Server < ::Calabash::Server
+      # The default Android test server.
       def self.default
-        Server.new(URI.parse('http://127.0.0.1:33765'))
+        endpoint = Environment::DEVICE_ENDPOINT
+        Server.new(endpoint)
       end
     end
   end

data/lib/calabash/android/text.rb

@@ -1,5 +1,6 @@
 module Calabash
   module Android
+    # Android specific text-related actions.
     module Text
       # Dismisses the current keyboard. This is equivalent to the user
       # pressing the back button if the keyboard is showing. If the keyboard is
@@ -41,6 +42,11 @@ module Calabash
           Device.default.perform_action('press_user_action_button', action_key.to_s)
         end
       end
+
+      # @!visibility private
+      def _keyboard_visible?
+        Device.default.keyboard_visible?
+      end
     end
   end
 end

data/lib/calabash/application.rb

@@ -21,6 +21,21 @@ module Calabash
 
     attr_reader :path
 
+    # Get the application from the default environment.
+    def self.default_from_environment
+      application_path = Environment::APP_PATH
+
+      if application_path.nil?
+        raise 'No application path is set. Specify application with environment variable CAL_APP'
+      end
+
+      unless File.exist?(application_path)
+        raise "Application '#{application_path}' does not exist"
+      end
+
+      Application.from_path(application_path)
+    end
+
     # Create an application from a path
     #
     # @return [Calabash::Android::Application, Calabash::IOS::Application] An
@@ -51,6 +66,20 @@ module Calabash
       ensure_application_path
     end
 
+    # Is this application an android application
+    #
+    # @return [Boolean] true if this application is an android application
+    def android_application?
+      false
+    end
+
+    # Is this application an iOS application
+    #
+    # @return [Boolean] true if this application is an iOS application
+    def ios_application?
+      false
+    end
+
     # @!visibility private
     def to_s
       "#<Application #{path}>"

data/lib/calabash/cli/build.rb

@@ -2,10 +2,24 @@ module Calabash
   module CLI
     # @!visibility private
     module Build
+      # @!visibility private
       def parse_build_arguments!
         fail('Should only build test-server for Android') unless @platform.nil? || @platform == :android
 
         application = @arguments.shift
+        test_server_path = nil
+
+        arg = @arguments.shift
+
+        if arg != nil
+          if arg == '-o'
+            test_server_path = @arguments.shift
+
+            if test_server_path == nil
+              raise 'Expected an output path for the test-server'
+            end
+          end
+        end
 
         if application.nil?
           fail('Must supply application as first parameter to build', :build)
@@ -18,7 +32,7 @@ module Calabash
           case extension
             when '.apk'
               set_platform!(:android)
-              Calabash::Android::Build::Builder.new(application_path).build
+              Calabash::Android::Build::Builder.new(application_path).build(test_server_path)
             when '.ipa', '.app'
               set_platform!(:ios)
               fail('Should only build test-server for Android')