calabash 1.2.1 → 1.9.9.pre1

data/lib/calabash/http.rb

@@ -0,0 +1,8 @@
+module Calabash
+  # @!visibility private
+  module HTTP
+    require 'calabash/http/retriable_client'
+    require 'calabash/http/request'
+    require 'calabash/http/error'
+  end
+end

data/lib/calabash/http/error.rb

@@ -0,0 +1,15 @@
+module Calabash
+  module HTTP
+
+    # Raised when there is a problem communicating with the Calabash test
+    # server.
+    class Error < StandardError
+
+    end
+
+    # Raised when there is a problem creating an HTTP request.
+    class RequestError < StandardError
+
+    end
+  end
+end

data/lib/calabash/http/request.rb

@@ -0,0 +1,42 @@
+module Calabash
+  module HTTP
+
+    # A representation of an HTTP request that can be passed passed to the HTTP
+    # client as an argument for `get` or `post`.
+    class Request
+      attr_reader :route, :params
+
+      def initialize(route, params={})
+        @route = route
+        @params = params
+      end
+
+      # Create a new Request from `route` and `parameters`.
+      #
+      # @param [String] route The http route for the new request.
+      # @param [Array, Hash] parameters An Array or Hash of parameters.
+      # @return [Request] A new Request for `route` with `parameters`.
+      # @raise [RequestError] Raises an error if the parameters cannot be
+      #   converted to JSON
+      def self.request(route, parameters)
+        Request.new(route, Request.data(parameters))
+      end
+
+      private
+
+      # Converts `parameters` to JSON.
+      #
+      # @param [Array, Hash] parameters An Array or Hash of parameters.
+      # @return [String] A JSON formatted string that represents the parameters.
+      # @raise [RequestError] Raises an error if the parameters cannot be
+      #   converted to JSON
+      def self.data(parameters)
+        begin
+          JSON.generate(parameters)
+        rescue *[TypeError, JSON::GeneratorError] => e
+          raise RequestError, "#{e}: could not generate JSON from '#{parameters}'"
+        end
+      end
+    end
+  end
+end

data/lib/calabash/http/retriable_client.rb

@@ -0,0 +1,156 @@
+require 'httpclient'
+
+module Calabash
+  module HTTP
+
+    # An HTTP client that retries its connection on errors and can time out.
+    class RetriableClient
+      attr_reader :client
+
+      # @!visibility private
+       RETRY_ON =
+        [
+          # The connection, request, or response timed out
+          #HTTPClient::TimeoutError,
+          # The proxy could not connect to the server (Android)
+          #  or the server is not running (iOS)
+          HTTPClient::KeepAliveDisconnected,
+           # No proxy has been set up (Android)
+          Errno::ECONNREFUSED,
+          # The server sent a partial response
+          #Errno::ECONNRESET,
+          # Client sent TCP reset (RST) before server has accepted the
+          #  connection requested by client.
+          Errno::ECONNABORTED,
+          # The foreign function call call timed out
+          #Errno::ETIMEDOUT
+        ]
+
+      # @!visibility private
+      HEADER =
+            {
+                  'Content-Type' => 'application/json;charset=utf-8'
+            }
+
+      # Creates a new retriable client.
+      #
+      # This initializer takes multiple options.  If the option is not
+      # documented, it should be considered _private_. You use undocumented
+      # options at your own risk.
+      #
+      # @param [Calabash::Server] server The server to make the HTTP request
+      #  on.
+      # @param [Hash] options Control the retry, timeout, and interval.
+      # @option options [Number] :retries (5) How often to retry.
+      # @option options [Number] :timeout (5) How long to wait for a response
+      #  before timing out.
+      # @option options [Number] :interval (0.5) How long to sleep between
+      #  retries.
+      def initialize(server, options = {})
+        @client = options[:client] || ::HTTPClient.new
+        @server = server
+        @retries = options.fetch(:retries, 5)
+        @timeout = options.fetch(:timeout, 5)
+        @interval = options.fetch(:interval, 0.5)
+        @logger = options[:logger] || Calabash::Logger.new
+        @on_error = {}
+      end
+
+      def on_error(type, &block)
+        @on_error[type] = block
+      end
+
+      def change_server(new_server)
+        @server = new_server
+      end
+
+      # Make an HTTP get request.
+      #
+      # This method takes multiple options.  If the option is not documented,
+      # it should be considered _private_.  You use undocumented options at
+      # your own risk.
+      #
+      # @param [Calabash::HTTP::Request] request The request.
+      # @param [Hash] options Control the retry, timeout, and interval.
+      # @option options [Number] :retries (5) How often to retry.
+      # @option options [Number] :timeout (5) How long to wait for a response
+      #  before timing out.
+      # @option options [Number] :interval (0.5) How long to sleep between
+      #  retries.
+      def get(request, options={})
+        request(request, :get, options)
+      end
+
+      # Make an HTTP post request.
+      #
+      # This method takes multiple options.  If the option is not documented,
+      # it should be considered _private_.  You use undocumented options at
+      # your own risk.
+      #
+      # @param [Calabash::HTTP::Request] request The request.
+      # @param [Hash] options Control the retry, timeout, and interval.
+      # @option options [Number] :retries (5) How often to retry.
+      # @option options [Number] :timeout (5) How long to wait for a response
+      #  before timing out.
+      # @option options [Number] :interval (0.5) How long to sleep between
+      #  retries.
+      def post(request, options={})
+        request(request, :post, options)
+      end
+
+      private
+
+      def request(request, request_method, options={})
+        retries = options.fetch(:retries, @retries)
+        timeout = options.fetch(:timeout, @timeout)
+        interval = options.fetch(:interval, @interval)
+        header = options.fetch(:header, HEADER)
+
+        @logger.log "Getting: #{@server.endpoint + request.route}"
+
+        start_time = Time.now
+        last_error = nil
+
+        client = @client.dup
+        client.receive_timeout = timeout
+
+        retries.times do |i|
+          first_try = i == 0
+
+          # Subtract the aggregate time we've spent thus far to make sure we're
+          # not exceeding the request timeout across retries.
+          time_diff = start_time + timeout - Time.now
+
+          if time_diff <= 0
+            raise HTTP::Error, 'Timeout exceeded'
+          end
+
+          client.receive_timeout = [time_diff, client.receive_timeout].min
+
+          begin
+            return client.send(request_method, @server.endpoint + request.route,
+                               request.params, header)
+          rescue *RETRY_ON => e
+            @logger.log "Http error: #{e}"
+
+            if first_try
+              if @on_error[e.class]
+                @on_error[e.class].call(@server)
+              end
+            end
+
+            last_error = e
+            sleep interval
+          end
+        end
+
+        # We should raise helpful messages
+        if last_error.is_a?(HTTPClient::KeepAliveDisconnected)
+          raise HTTP::Error, "#{last_error}: It is likely your application has crashed"
+        end
+
+        raise HTTP::Error, last_error
+      end
+    end
+  end
+end

data/lib/calabash/interactions.rb

@@ -0,0 +1,105 @@
+module Calabash
+  module Interactions
+    # @todo Needs docs!
+    def query(query, *args)
+      Calabash::Device.default.map_route(Query.new(query), :query, *args)
+    end
+
+    # @todo Needs docs!
+    def flash(query)
+      Calabash::Device.default.map_route(Query.new(query), :flash)
+    end
+
+    # Evaluate javascript in a Web View. On iOS, an implicit return is
+    # inserted, on Android an explicit return is needed.
+    #
+    # @example
+    #  # iOS
+    #  evaluate_javascript_in("UIWebView", "2+2")
+    #  # Android
+    #  evaluate_javascript_in("WebView", "return 2+2"
+    #
+    # @example
+    #  # iOS
+    #  evaluate_javascript_in("WKWebView",
+    #         "document.body.style.backgroundColor = 'red';")
+    #
+    #  # Android
+    #  evaluate_javascript_in("XWalkContent",
+    #         "document.body.style.backgroundColor = 'red';")
+    #
+    # @note No error will be raised if the javascript given is invalid, or
+    #  throws an exception.
+    #
+    # @param [String, Hash, Calabash::Query] query Query that matches the view
+    # @param [String] javascript The javascript to evaluate
+    #
+    # @raise ViewNotFoundError If no views are found matching `query`
+    def evaluate_javascript_in(query, javascript)
+      wait_for_view(query,
+                    timeout: Calabash::Gestures::DEFAULT_GESTURE_WAIT_TIMEOUT)
+
+      _evaluate_javascript_in(query, javascript)
+    end
+
+    # Invoke a method in your application.
+    #
+    # This is an escape hatch for calling an arbitrary hook inside
+    # (the test build) of your app.  Commonly used to "go around" the UI for
+    # speed purposes or reset the app to a good known state.
+    #
+    # For iOS this method calls a method on the app's AppDelegate object.
+    #
+    # For Android this method tries to invoke a method on the current Activity
+    # instance. If the method is not defined in the current activity, Calabash
+    # tries to invoke the method on the current Application instance.
+    #
+    # @note The Android implementation accepts any number of arguments, of any
+    #  type including null (Ruby nil). The iOS implementation does not accept
+    #  more than one argument, of the type NSString (Ruby String) or
+    #  NSDictionary (Ruby Hash).
+    #
+    #
+    # ### For iOS
+    #
+    # You must create a method on you app delegate of the form:
+    #
+    #     - (NSString *) calabashBackdoor:(NSString *)aIgnorable;
+    #
+    # or if you want to pass parameters
+    #
+    #     - (NSString *) calabashBackdoor:(NSDictionary *)params;
+    #
+    # ### For Android
+    #
+    # You must create a public method in your current Activity or Application.
+    #
+    #     public <return type> calabashBackdoor(String param1, int param2)
+    #
+    # @example
+    #   # iOS
+    #   backdoor('calabashBackdoor:'', '')
+    #
+    # @example
+    #   # iOS
+    #   backdoor('calabashBackdoor:', {example:'param'})
+    #
+    # @example
+    #   # Android
+    #   backdoor('calabashBackdoor', 'first argument', 2)
+    #
+    # @param [String] name The selector/method name.
+    # @param [Object] *arguments A comma separated list of arguments to be
+    #  passed to the backdoor selector/method.
+    # @return [Object] the result of performing the selector/method with the
+    #  arguments (serialized)
+    def backdoor(name, *arguments)
+      Device.default.backdoor(name, *arguments)
+    end
+
+    # @!visibility private
+    def _evaluate_javascript_in(query, javascript)
+      abstract_method!
+    end
+  end
+end

data/lib/calabash/ios.rb

@@ -0,0 +1,37 @@
+module Calabash
+  # Contains the iOS implementations of the Calabash APIs.
+  module IOS
+    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/ios/environment'
+    require 'calabash/ios/application'
+    require 'calabash/ios/device'
+    require 'calabash/ios/conditions'
+    require 'calabash/ios/interactions'
+    require 'calabash/ios/orientation'
+    require 'calabash/ios/server'
+    require 'calabash/ios/text'
+    require 'calabash/ios/console_helpers'
+    require 'calabash/ios/uia'
+    require 'calabash/ios/scroll'
+
+    include Calabash::IOS::Conditions
+    include Calabash::IOS::Orientation
+    include Calabash::IOS::Interactions
+    include Calabash::IOS::Text
+    include Calabash::IOS::UIA
+    include Calabash::IOS::Scroll
+
+  end
+end

data/lib/calabash/ios/application.rb

@@ -0,0 +1,119 @@
+module Calabash
+  module IOS
+
+    # A class to represent an iOS application.  An application can be a
+    # simulator bundle (.app) or a device binary (.ipa).
+    class Application < Calabash::Application
+
+      # The path to the application under test deduced by analysing the
+      # environment.
+      #
+      # You can control the default application path by setting the `CAL_APP`
+      # environment variable.  This is the best way of ensuring Calabash
+      # can find your application.
+      #
+      # @todo We have a chicken and egg problem.  If the device under test
+      # is a simulator, we have been analyzing the Xcode or Xamarin Studio
+      # project for the likely location of the .app.  I think we still want
+      # to do this.  The problem is that Xcode buries the .app in a
+      # DerivedData directory deep in the user's ~/Library/ and the correct
+      # directory path is very difficult to find.  I overcome this problem
+      # with command-line build scripts that put the .app (or .ipa) in a
+      # directory local to my project.  Others devs use Xcode Custom Build
+      # locations.  I don't think we we want to branch here on whether or not
+      # the DEVICE_ID points to a simulator or physical device.  This is
+      # wicked expensive.
+      def self.default_from_environment
+        application_path = Environment::APP_PATH
+
+        if application_path.nil?
+          raise 'No application path is set'
+        end
+
+        Application.new(application_path)
+      end
+
+      # Create a new Application.
+      #
+      # @param [String] application_path The path to the ipa or app.
+      # @param [Hash] options Optional arguments.
+      # @option options [Calabash::Logger] :logger An optional logger.  It is
+      #  not recommended that you set this yourself.
+      # @return [Calabash::IOS::Application] A new application.
+      # @raise [RuntimeError] If the `application_path` does not indicate a
+      #  file that exists.
+      # @raise [RuntimeError] If the `application_path` does not end with .ipa
+      #  or .app.
+      def initialize(application_path, options = {})
+        super(application_path, options)
+
+        @simulator_bundle = File.extname(path) == '.app'
+        @device_binary = File.extname(path) == '.ipa'
+
+        unless @simulator_bundle || @device_binary
+          raise "Expected #{path} to be an .ipa or .app, but found '#{File.extname(path)}'"
+        end
+      end
+
+      # Return true if this application is for an iOS Simulator.
+      # @return [Boolean] Is this a .app?
+      def simulator_bundle?
+        @simulator_bundle
+      end
+
+      # Return true if this application is for a physical iOS device.
+      # @return [Boolean] Is this a .ipa?
+      def device_binary?
+        @device_binary
+      end
+
+      # Returns the sha1 of the directory or binary of this app's path.
+      # @return [String] A checksum.
+      def sha1
+        RunLoop::Directory.directory_digest(path)
+      end
+
+      # Does this app have the same checksum as another app?
+      # @param [Calabash::IOS::Application] other The other app to compare to.
+      # @return [Boolean] Is the checksum the same for the two apps?
+      def same_sha1_as?(other)
+        sha1 == other.sha1
+      end
+
+      private
+
+      # @!visibility private
+      def run_loop_ipa
+        @run_loop_ipa ||= lambda do
+          if device_binary?
+            RunLoop::Ipa.new(path)
+          else
+            nil
+          end
+        end.call
+      end
+
+      # @!visibility private
+      def run_loop_app
+        @run_loop_app ||= lambda do
+          if simulator_bundle?
+            RunLoop::App.new(path)
+          else
+            nil
+          end
+        end.call
+      end
+
+      # @!visibility private
+      def extract_identifier
+        if simulator_bundle?
+          run_loop_app.bundle_identifier
+        elsif device_binary?
+          run_loop_ipa.bundle_identifier
+        else
+          raise "Unknown app type '#{File.extname(path)}', cannot extract bundle identifier"
+        end
+      end
+    end
+  end
+end