calabash 1.9.9.pre3 → 2.0.0.prelegacy

data/lib/calabash/android/legacy.rb

@@ -0,0 +1,143 @@
+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 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,16 +1,19 @@
 module Calabash
   module Android
-    # @!visibility private
+    # Android specific life cyle methods.
     module LifeCycle
       # Resume an application. If the application is already focused, nothing
       # will happen.
       #
       # @example
       #  go_home
+      #  # Do something
       #  resume_app
       #
-      # @param [String, Calabash::Application] path_or_application The
-      #  application to resume.
+      # @param [String, Calabash::Application] path_or_application A path to the
+      #  application, or an instance of {Calabash::Application}.
+      #  Defaults to
+      #  {Calabash::Defaults#default_application Calabash.default_application}
       def resume_app(path_or_application = nil)
         path_or_application ||= Application.default
 
@@ -23,7 +26,6 @@ module Calabash
         true
       end
 
-
       # @!visibility private
       def _send_current_app_to_background(for_seconds)
         package = focused_package

data/lib/calabash/android/physical_buttons.rb

@@ -1,38 +1,49 @@
 module Calabash
   module Android
+    # Simulates pressing a *physical* button on the device. Use these methods
+    # carefully, as only a few devices have hardware key input. They can,
+    # however, be very useful for testing behaviour that would be hard to
+    # replicate otherwise.
     # @!visibility private
     module PhysicalButtons
 
-      # @todo: Add note about this class being easily abused
+      # @!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

@@ -0,0 +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,31 +1,13 @@
 module Calabash
   module Android
-    # @!visibility private
+    # 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
+      # already hidden/dismissed, nothing is done.
       def dismiss_keyboard
         Device.default.perform_action('hide_soft_keyboard')
-      end
-
-      # Taps a keyboard action key on the keyboard. Notice that Calabash does
-      # not ensure that this particular action key is actually available on the
-      # current keyboard.
-      #
-      # @example
-      #  tap_keyboard_action_key(:normal)
-      #  tap_keyboard_action_key(:unspecified)
-      #  tap_keyboard_action_key(:none)
-      #  tap_keyboard_action_key(:go)
-      #  tap_keyboard_action_key(:search)
-      #  tap_keyboard_action_key(:send)
-      #  tap_keyboard_action_key(:next)
-      #  tap_keyboard_action_key(:done)
-      #  tap_keyboard_action_key(:previous)
-      #
-      # @see http://developer.android.com/reference/android/view/inputmethod/EditorInfo.html
-      #
-      # @param [Symbol] action_key The key to press.
-      def tap_keyboard_action_key(action_key)
-        Device.default.perform_action('press_user_action_button', action_key.to_s)
+        sleep 0.5
       end
 
       # @!visibility private
@@ -53,8 +35,17 @@ module Calabash
       end
 
       # @!visibility private
-      def _tap_current_keyboard_action_key
-        Device.default.perform_action('press_user_action_button')
+      def _tap_keyboard_action_key(action_key)
+        if action_key.nil?
+          Device.default.perform_action('press_user_action_button')
+        else
+          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

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}>"