calabash 1.2.1 → 1.9.9.pre1

data/lib/calabash/console_helpers.rb

@@ -0,0 +1,90 @@
+require 'clipboard'
+
+module Calabash
+  module ConsoleHelpers
+    # Outputs all visible elements as a tree
+    def tree
+      ConsoleHelpers.dump(Device.default.dump)
+      true
+    end
+
+    def self.save_old_readline_history
+      file_name = IRB.conf[:HISTORY_FILE]
+
+      if File.exist?(file_name)
+        @@start_readline_history = File.readlines(file_name).map(&:chomp)
+      end
+    end
+
+    def self.extended(base)
+      save_old_readline_history
+    end
+
+    def classes
+      query("*").map{|e| e['class']}.uniq
+    end
+
+    def ids
+      query("*").map{|e| e['id']}.compact
+    end
+
+    def copy
+      ConsoleHelpers.copy
+      true
+    end
+
+    def self.copy
+      commands = filter_commands(current_console_history)
+      string = commands.join($INPUT_RECORD_SEPARATOR)
+      Clipboard.copy(string)
+    end
+
+    def self.current_console_history
+      length = readline_history.length - @@start_readline_history.length
+
+      readline_history.last(length)
+    end
+
+    FILTER_REGEX = Regexp.union(/\s*copy(\(|\z)/, /\s*tree(\(|\z)/,
+                                /\s*flash(\(|\z)/, /\s*classes(\(|\z)/,
+                                /\s*ids(\(|\z)/, /\s*start_app(\(|\z)/,
+                                /\s*install_app(\(|\z)/,
+                                /\s*ensure_app_installed(\(|\z)/,
+                                /\s*uninstall_app(\(|\z)/,
+                                /\s*clear_app(\(|\z)/,
+                                /\s*stop_app(\(|\z)/)
+
+    def self.filter_commands(commands)
+      commands.reject {|command| command =~ FILTER_REGEX}
+    end
+
+    def self.readline_history
+      Readline::HISTORY.to_a
+    end
+
+    def self.dump(json_data)
+      json_data['children'].each {|child| write_child(child)}
+    end
+
+    def self.write_child(data, indentation=0)
+      render(data, indentation)
+
+      data['children'].each do |child|
+        write_child(child, indentation+1)
+      end
+    end
+
+    def self.render(data, indentation)
+      raise AbstractMethodError
+    end
+
+    def self.output(string, indentation)
+      (indentation*2).times {print " "}
+      print "#{string}"
+    end
+
+    def self.visible?(data)
+      raise AbstractMethodError
+    end
+  end
+end

data/lib/calabash/defaults.rb

@@ -0,0 +1,56 @@
+module Calabash
+  module Defaults
+    # Get the default device. The device represents a physical device,
+    # an emulator, or a simulator. Calabash will communicate with this
+    # device by default.
+    #
+    # @return [Calabash::Device] The default device
+    def default_device
+      Device.default
+    end
+
+    # Set the default device.
+    #
+    # @see #Calabash::Defaults#default_device
+    def default_device=(device)
+      Device.default = device
+    end
+
+    # Get the default application. The application represents an .ipa, .app, or
+    # .apk. For Android, the application can represent a test-server along side
+    # the application under test. Calabash will use this application by
+    # default, for example when calling install_app.
+    #
+    # @return [Calabash::Application] The default application
+    def default_application
+      Application.default
+    end
+
+    # Set the default application.
+    #
+    # @see #Calabash::Defaults.default_application
+    def default_application=(application)
+      Application.default = application
+    end
+
+    # Get the default server. The default server is the test-server
+    # of the `#default_device`.
+    #
+    # @raise [RuntimeError] If default device is not set
+    def default_server
+      if default_device.nil?
+        raise 'No default device set'
+      end
+
+      default_device.server
+    end
+
+    # Set the default server.
+    #
+    # @see #Calabash::Defaults.default_server
+    # @raise [RuntimeError] If default device is not set
+    def default_server=(server)
+      default_device.change_server(server)
+    end
+  end
+end

data/lib/calabash/device.rb

@@ -0,0 +1,401 @@
+module Calabash
+  class Device
+    include Utility
+
+    @@default = nil
+
+    def self.default
+      @@default
+    end
+
+    def self.default=(value)
+      @@default = value
+    end
+
+    attr_reader :identifier, :server, :http_client, :logger
+
+    # Create a new device.
+    # @param [String] identifier A token that uniquely identifies the device.
+    #   On iOS, this is the device UDID, or a simulator name or UDID returned by
+    #   `$ xcrun instruments -s devices`.
+    #   On Android, this is the serial of the device, emulator or simulator
+    #   returned by `$ adb devices`.
+    # @param [Server] server A server object.
+    #
+    # @return [Device] A device.
+    def initialize(identifier, server, options={})
+      @identifier = identifier
+      @server = server
+      @logger = options[:logger] || Calabash::Logger.new
+      @http_client = HTTP::RetriableClient.new(server, options.fetch(:http_options, {}))
+    end
+
+    def change_server(new_server)
+      @server = new_server
+      @http_client.change_server(new_server)
+    end
+
+    # Start the application and the test server
+    def start_app(path_or_application, options={})
+      application = parse_path_or_app_parameters(path_or_application)
+
+      _start_app(application, options)
+    end
+
+    # Shutdown the application and the test server
+    def stop_app
+      _stop_app
+    end
+
+    # @see Screenshot#screenshot
+    def screenshot(name=nil)
+      path = Screenshot.obtain_screenshot_path!(name)
+
+      _screenshot(path)
+    end
+
+    def install_app(path_or_application)
+      application = parse_path_or_app_parameters(path_or_application)
+
+      _install_app(application)
+    end
+
+    def ensure_app_installed(path_or_application)
+      application = parse_path_or_app_parameters(path_or_application)
+
+      _ensure_app_installed(application)
+    end
+
+    def uninstall_app(path_or_application)
+      application = parse_path_or_app_parameters(path_or_application)
+
+      _uninstall_app(application)
+    end
+
+    def clear_app_data(path_or_application)
+      application = parse_path_or_app_parameters(path_or_application)
+
+      _clear_app_data(application)
+    end
+
+    def set_location(location)
+      abstract_method!
+    end
+
+    def dump
+      request = HTTP::Request.new('/dump')
+
+      JSON.parse(http_client.get(request, timeout: 60).body)
+    end
+
+    # @!visibility private
+    class EnsureTestServerReadyTimeoutError < RuntimeError; end
+
+    # Ensures the test server is ready
+    #
+    # @raise [RuntimeError] Raises error when the server does not respond
+    def ensure_test_server_ready(options={})
+      begin
+        Timeout.timeout(options.fetch(:timeout, 30), EnsureTestServerReadyTimeoutError) do
+          loop do
+            break if test_server_responding?
+          end
+        end
+      rescue EnsureTestServerReadyTimeoutError => _
+        raise 'Calabash server did not respond'
+      end
+    end
+
+    # @!visibility private
+    def test_server_responding?
+      abstract_method!
+    end
+
+    # Performs a `tap` on the (first) view that matches `query`.
+    # @see Calabash::Gestures#tap
+    def tap(query, options={})
+      Query.ensure_valid_query(query)
+
+      gesture_options = options.dup
+      gesture_options[:at] ||= {}
+      gesture_options[:at][:x] ||= 50
+      gesture_options[:at][:y] ||= 50
+      gesture_options[:offset] ||= {}
+      gesture_options[:offset][:x] ||= 0
+      gesture_options[:offset][:y] ||= 0
+      gesture_options[:timeout] ||= Calabash::Gestures::DEFAULT_GESTURE_WAIT_TIMEOUT
+
+      _tap(query, gesture_options)
+    end
+
+    # Performs a `double_tap` on the (first) view that matches `query`.
+    # @see Calabash::Gestures#double_tap
+    def double_tap(query, options={})
+      Query.ensure_valid_query(query)
+
+      gesture_options = options.dup
+      gesture_options[:at] ||= {}
+      gesture_options[:at][:x] ||= 50
+      gesture_options[:at][:y] ||= 50
+      gesture_options[:offset] ||= {}
+      gesture_options[:offset][:x] ||= 0
+      gesture_options[:offset][:y] ||= 0
+      gesture_options[:timeout] ||= Calabash::Gestures::DEFAULT_GESTURE_WAIT_TIMEOUT
+
+      _double_tap(query, gesture_options)
+    end
+
+    # Performs a `long_press` on the (first) view that matches `query`.
+    # @see Calabash::Gestures#long_press
+    def long_press(query, options={})
+      Query.ensure_valid_query(query)
+
+      gesture_options = options.dup
+      gesture_options[:at] ||= {}
+      gesture_options[:at][:x] ||= 50
+      gesture_options[:at][:y] ||= 50
+      gesture_options[:offset] ||= {}
+      gesture_options[:offset][:x] ||= 0
+      gesture_options[:offset][:y] ||= 0
+      gesture_options[:timeout] ||= Calabash::Gestures::DEFAULT_GESTURE_WAIT_TIMEOUT
+      gesture_options[:duration] ||= 1
+
+      _long_press(query, gesture_options)
+    end
+
+    # Performs a `pan` on the (first) view that matches `query`.
+    # @see Calabash::Gestures#pan
+    def pan(query, from, to, options={})
+      Query.ensure_valid_query(query)
+
+      ensure_valid_swipe_params(from, to)
+
+      gesture_options = options.dup
+      gesture_options[:duration] ||= 0.5
+      gesture_options[:timeout] ||= Calabash::Gestures::DEFAULT_GESTURE_WAIT_TIMEOUT
+
+      _pan(query, from, to, gesture_options)
+    end
+
+    # Performs a `pan` between two elements.
+    # @see Calabash::Gestures#pan_between
+    def pan_between(query_from, query_to, options={})
+      Query.ensure_valid_query(query_from)
+      Query.ensure_valid_query(query_to)
+
+      gesture_options = options.dup
+      gesture_options[:duration] ||= 1
+      gesture_options[:timeout] ||= Calabash::Gestures::DEFAULT_GESTURE_WAIT_TIMEOUT
+
+      _pan_between(query_from, query_to, gesture_options)
+    end
+
+    # Performs a `flick` on the (first) view that matches `query`.
+    # @see Calabash::Gestures#flick
+    def flick(query, from, to, options={})
+      Query.ensure_valid_query(query)
+
+      ensure_valid_swipe_params(from, to)
+
+      gesture_options = options.dup
+      gesture_options[:duration] ||= 0.5
+      gesture_options[:timeout] ||= Calabash::Gestures::DEFAULT_GESTURE_WAIT_TIMEOUT
+
+      _flick(query, from, to, gesture_options)
+    end
+
+    # @see Calabash::Gestures#pinch
+    def pinch(direction, query, options={})
+      Query.ensure_valid_query(query)
+
+      unless direction == :out || direction == :in
+        raise ArgumentError, "Invalid direction '#{direction}'"
+      end
+
+      gesture_options = options.dup
+      gesture_options[:timeout] ||= Calabash::Gestures::DEFAULT_GESTURE_WAIT_TIMEOUT
+
+      _pinch(direction, query, gesture_options)
+    end
+
+    # Enter `text` into the currently focused view.
+    # @see Calabash::Text#enter_text
+    def enter_text(text)
+      abstract_method!
+    end
+
+    # @!visibility private
+    def map_route(query, method_name, *method_args)
+      abstract_method!
+    end
+
+    # @!visibility private
+    def backdoor(method, *arguments)
+      abstract_method!
+    end
+
+    private
+
+    # @!visibility private
+    def _start_app(application, options={})
+      abstract_method!
+    end
+
+    # @!visibility private
+    def _stop_app
+      abstract_method!
+    end
+
+    # @!visibility private
+    def _screenshot(path)
+      abstract_method!
+    end
+
+    # @!visibility private
+    def _install_app(application)
+      abstract_method!
+    end
+
+    # @!visibility private
+    def _ensure_app_installed(application)
+      abstract_method!
+    end
+
+    # @!visibility private
+    def _uninstall_app(application)
+      abstract_method!
+    end
+
+    # @!visibility private
+    def _clear_app_data(application)
+      abstract_method!
+    end
+
+    # @!visibility private
+    def parse_path_or_app_parameters(path_or_application)
+      if path_or_application.is_a?(String)
+        Calabash::Application.from_path(path_or_application)
+      elsif path_or_application.is_a?(Calabash::Application)
+        path_or_application
+      else
+        raise ArgumentError, "Expected a String or Calabash::Application, got #{path_or_application.class}"
+      end
+    end
+
+    # @!visibility private
+    def parse_identifier_or_app_parameters(identifier_or_application)
+      if identifier_or_application.is_a?(String)
+        identifier_or_application
+      elsif identifier_or_application.is_a?(Calabash::Application)
+        identifier_or_application.identifier
+      else
+        raise ArgumentError, "Expected a String or Calabash::Application, got #{identifier_or_application.class}"
+      end
+    end
+
+    # @!visibility private
+    def ensure_valid_swipe_params(from, to)
+      unless from.is_a?(Hash)
+        message = "Invalid 'from' (#{from}). Expected a hash"
+        raise ArgumentError, message
+      end
+
+      unless from.include?(:x)
+        message = 'No from[:x] given. Expected a number between 0 and 100'
+        raise ArgumentError, message
+      end
+
+      unless from.include?(:y)
+        message = 'No from[:y] given. Expected a number between 0 and 100'
+        raise ArgumentError, message
+      end
+
+      unless (0..100).include?(from[:x])
+        message = 'Invalid from[:x] given. Expected a number between 0 and 100'
+        raise ArgumentError, message
+      end
+
+      unless (0..100).include?(from[:y])
+        message = 'Invalid from[:y] given. Expected a number between 0 and 100'
+        raise ArgumentError, message
+      end
+
+      unless to.is_a?(Hash)
+        message = "Invalid 'to' (#{to}). Expected a hash"
+        raise ArgumentError, message
+      end
+
+      unless to.include?(:x)
+        message = 'No to[:x] given. Expected a number between 0 and 100'
+        raise ArgumentError, message
+      end
+
+      unless to.include?(:y)
+        message = 'No to[:y] given. Expected a number between 0 and 100'
+        raise ArgumentError, message
+      end
+
+      unless (0..100).include?(to[:x])
+        message = 'Invalid to[:x] given. Expected a number between 0 and 100'
+        raise ArgumentError, message
+      end
+
+      unless (0..100).include?(to[:y])
+        message = 'Invalid to[:y] given. Expected a number between 0 and 100'
+        raise ArgumentError, message
+      end
+    end
+
+    # @!visibility private
+    def _tap(query, options={})
+        abstract_method!
+    end
+
+    # @!visibility private
+    def _double_tap(query, options={})
+        abstract_method!
+    end
+
+    # @!visibility private
+    def _long_press(query, options={})
+        abstract_method!
+    end
+
+    # @!visibility private
+    def _pan(query, from, to, options={})
+        abstract_method!
+    end
+
+    # @!visibility private
+    def _pan_between(query_from, query_to, options={})
+      abstract_method!
+    end
+
+    # @!visibility private
+    def _flick(query, from, to, options={})
+      abstract_method!
+    end
+
+    # @!visibility private
+    def _pinch(direction, query, options={})
+      abstract_method!
+    end
+
+    # Do not keep a reference to this module
+    def world_for_device
+      @new_module = world_module.clone
+
+      device = self
+
+      @new_module.send(:define_singleton_method, :default_device) do
+        device
+      end
+
+      @new_module
+    end
+
+    def world_module
+      abstract_method!
+    end
+  end
+end