honeydew 0.12.0 → 0.14.0

data/lib/honeydew/device_actions.rb

@@ -4,148 +4,80 @@ module Honeydew
   module DeviceActions
     include Honeydew::DeviceCommands
 
-    def click_button(button_text)
-      perform_action :action => 'click', :arguments => {:text => button_text, :type => 'Button'}
+    def scroll_to_text text, index = '0'
+      perform_action :scroll_to_text_by_index, :text => text, :index => index
     end
 
-    def click_button_and_wait(button_text)
-      perform_action :action => 'click_and_wait_for_new_window', :arguments => {:text => button_text, :type => 'Button'}
+    def click_button button_text
+      perform_action :click, :text => button_text, :type => 'Button'
     end
 
-    def click_text(text)
-      perform_action :action => 'click', :arguments => {:text => text, :type => 'TextView'}
+    def click_button_and_wait button_text
+      perform_action :click_and_wait_for_new_window, :text => button_text, :type => 'Button'
     end
 
-    def click_text_and_wait(text)
-      perform_action :action => 'click_and_wait_for_new_window', :arguments => {:text => text, :type => 'TextView'}
+    def click_text text
+      perform_action :click, :text => text, :type => 'TextView'
     end
 
-    def click_element(element_description)
-      perform_action :action => 'click', :arguments => {:description => element_description}
+    def click_text_and_wait text
+      perform_action :click_and_wait_for_new_window, :text => text, :type => 'TextView'
     end
 
-    def click_element_and_wait(element_description)
-      perform_action :action => 'click_and_wait_for_new_window', :arguments => {:description => element_description}
+    def click_element element_description
+      perform_action :click, :description => element_description
+    end
+
+    def click_element_and_wait element_description
+      perform_action :click_and_wait_for_new_window, :description => element_description
     end
 
     def fill_in field_description, options = {with: ''}
-      perform_action :action => 'set_text', :arguments => {:description => field_description, :text => options[:with]}
+      perform_action :set_text, :description => field_description, :text => options[:with]
     end
 
     def fill_in_by_label field_label, options = {with: ''}
-      perform_action :action => 'set_text_by_label', :arguments => {:label => field_label, :text => options[:with]}
+      perform_action :set_text_by_label, :label => field_label, :text => options[:with]
     end
 
     def fill_in_by_index index, options = {with: ''}
-      perform_action :action => 'set_text_by_index', :arguments => {:index => index, :text => options[:with]}
+      perform_action :set_text_by_index, :index => index, :text => options[:with]
     end
 
     def launch_home
-      perform_action :action => 'launch_home'
+      perform_action :launch_home
     end
 
-    def launch_settings_app(app_name)
-      perform_action :action => 'select_from_apps_list', :arguments => {:appName => app_name}
+    def launch_settings_app app_name
+      perform_action :select_from_apps_list, :appName => app_name
     end
 
-    def launch_application(application_name)
-      perform_action :action => 'launch_app', :arguments => {:appName => application_name}, :attempts => 3
+    def launch_application application_name
+      perform_action :launch_app, :appName => application_name
     end
 
-    def long_click_element(element_description)
-      perform_action :action => 'long_click', :arguments => {:description => element_description}
+    def long_click_element element_description
+      perform_action :long_click, :description => element_description
     end
 
-    def launch_settings_item(item_name)
-      perform_action :action => 'select_menu_in_settings', :arguments => {:menuName => item_name}
+    def launch_settings_item item_name
+      perform_action :select_menu_in_settings, :menuName => item_name
     end
 
-
     def press_back
-      perform_action :action => 'press_back'
+      perform_action :press_back
     end
 
     def press_enter
-      perform_action :action => 'press_enter'
+      perform_action :press_enter
     end
 
     def unlock
-      perform_action :action => 'unlock'
+      perform_action :unlock
     end
 
     def wake_up
-      perform_action :action => 'wake_up'
-    end
-
-    def perform_action(options)
-      ensure_tablet_ready
-
-      command = options.slice(:action, :arguments)
-      timeout = options[:retry_until]
-      attempts = options[:attempts]
-
-      response =
-          if timeout
-            retry_until_timeout(timeout, command)
-          elsif attempts
-            retry_until_success(attempts, command)
-          else
-            execute_command(command)
-          end
-      log_action(command, response)
-      raise "Device: #{serial} :Action #{options} failed." unless response['success']
-      response
-    end
-
-    private
-
-    def retry_until_success(attempts, command)
-      completed = false
-      response = nil
-      tries = 0
-      until completed || (tries >= attempts) do
-        response = execute_command(command)
-        completed = response['success']
-        return response if completed
-        tries += 1
-        sleep 1
-      end
-      log_action(command, response)
-      raise "Device: #{serial} : All #{attempts} attempts failed while performing #{command[:action]}, with arguments: #{command[:arguments]}"
-    end
-
-    def retry_until_timeout(timeout, command)
-      completed = false
-      response = nil
-      Timeout.timeout(timeout.to_i) do
-        until completed do
-          sleep 1
-          response = execute_command(command)
-          completed = response['success']
-        end
-      end
-      return response
-    rescue Timeout::Error
-      log_action(command, response)
-      raise "Device: #{serial} :Timeout while performing #{command[:action]}, with arguments: #{command[:arguments]}"
-    end
-
-    def execute_command(command)
-      response = RestClient.get(device_endpoint, :params => stringify_keys(:command => command))
-      JSON.parse(response)
-    end
-
-    def log_action(command, response)
-      log "Device: #{serial} : executing command: #{command}"
-      log "Device: #{serial} : responded with: #{response}"
-    end
-
-    def stringify_keys(options)
-      JSON.parse(options.to_json)
-    end
-
-    def log(message)
-      puts message
+      perform_action :wake_up
     end
   end
 end

data/lib/honeydew/device_commands.rb

@@ -1,12 +1,24 @@
+require 'net/http'
+require 'uri'
+
 module Honeydew
   module DeviceCommands
 
-    def device_endpoint
-      "http://127.0.0.1:#{port}"
+    def is_app_installed?(package_name)
+      has_app_installed?(package_name)
+    end
+
+    def clear_directory(directory)
+      all_files_in_directory_path = [directory.chomp('/'), '/*'].join
+      adb "shell rm -r #{all_files_in_directory_path}"
+    end
+
+    def device_endpoint action
+      URI.join("http://localhost:#{port}", action)
     end
 
     def dump_window_hierarchy(local_path)
-      path_in_device = perform_action(:action => 'dump_window_hierarchy')['description']
+      path_in_device = perform_action('dump_window_hierarchy')['description']
       adb "pull #{path_in_device} #{local_path}"
     end
 
@@ -16,41 +28,39 @@ module Honeydew
       adb "pull #{path_in_device} #{local_path}"
     end
 
-    def start_uiautomator_server
+    def start_honeydew_server
       forwarding_port
-      terminate_uiautomator_server
-      log "Device: #{serial} : Starting server on the device"
+      terminate_honeydew_server
       start_automation_server
     end
 
-    def terminate_uiautomator_server
-      log 'Terminating server'
-      RestClient.get("#{device_endpoint}/terminate")
-    rescue
+    def terminate_honeydew_server
+      log "terminating honeydew-server"
+      Net::HTTP.post_form device_endpoint('/terminate'), {}
+    rescue Errno::ECONNREFUSED, Errno::ECONNRESET, EOFError
       # Swallow
     end
 
-    def automation_test_jar_name
-      "android-server-0.0.1-SNAPSHOT.jar"
+    def honeydew_server_package
+      "honeydew-server-#{Honeydew::VERSION}.jar"
     end
 
-    def automation_server_jar_path
-      File.absolute_path(File.join(File.dirname(__FILE__), "../../android-server/target/#{automation_test_jar_name}"))
+    def honeydew_server_file
+      File.absolute_path(File.join(File.dirname(__FILE__), "../../server/target/#{honeydew_server_package}"))
     end
 
     def start_automation_server
+      log "starting honeydew-server on the device"
       Thread.new do
-        adb "push #{automation_server_jar_path} /data/local/tmp"
-        adb "shell uiautomator runtest #{automation_test_jar_name} -c com.uiautomator_cucumber.android_server.TestRunner"
-        log "Device: #{serial} initiated the start of automation server"
+        adb "push #{honeydew_server_file} /data/local/tmp"
+        adb "shell uiautomator runtest #{honeydew_server_package} -c com.amplify.honeydew_server.TestRunner"
       end
       at_exit do
-        terminate_uiautomator_server
+        terminate_honeydew_server
       end
     end
 
     def forwarding_port
-      log "Device: #{serial} : Forwarding port #{port} to device"
       adb "forward tcp:#{port} tcp:7120"
     end
 
@@ -76,9 +86,12 @@ module Honeydew
 
     def adb(command)
       adb_command = "adb -s #{serial} #{command}"
-      log "Device: #{serial} :Executing '#{adb_command}'"
-      `#{adb_command}`.tap { raise 'ADB command failed' unless $?.success? }
+      log "executing '#{adb_command}'"
+      `#{adb_command} 2>/dev/null`.tap do
+        if $?.exitstatus != 0
+          raise "ADB command '#{command}' failed"
+        end
+      end
     end
-
   end
-end
+end

data/lib/honeydew/device_matchers.rb

@@ -1,36 +1,40 @@
 module Honeydew
   module DeviceMatchers
-
-    def has_text?(text, timeout = Honeydew.config.timeout)
-      perform_action :action => 'is_text_present', :arguments => {:text => text}, :retry_until => timeout
+    def has_text?(text)
+      perform_assertion :is_text_present, :text => text
     end
 
-    def has_element_with_description?(description, timeout = Honeydew.config.timeout)
-      perform_action :action => 'is_text_present', :arguments => {:description => description}, :retry_until => timeout
+    def has_element_with_description?(description)
+      perform_assertion :is_text_present, :description => description
     end
 
-    def has_edit_text?(text, timeout = Honeydew.config.timeout)
-      perform_action :action => 'is_text_present', :arguments => {:text => text, :type => 'EditText'}, :retry_until => timeout
+    def has_edit_text?(text)
+      perform_assertion :is_text_present, :text => text, :type => 'EditText'
     end
 
-    def has_textview_text?(text, timeout = Honeydew.config.timeout)
-      perform_action :action => 'is_text_present', :arguments => {:text => text, :type => 'TextView'}, :retry_until => timeout
+    def has_textview_text?(text)
+      perform_assertion :is_text_present, :text => text, :type => 'TextView'
     end
 
-    def has_textview_with_text_and_description?(text, description, timeout=Honeydew.config.timeout)
-      perform_action :action => 'is_text_present', :arguments => {:text => text, :description => description, :type => 'TextView'}, :retry_until => timeout
+    def has_textview_with_text_and_description?(text, description)
+      perform_assertion :is_text_present, :text => text, :description => description, :type => 'TextView'
     end
 
-    def has_button?(button_text, timeout = Honeydew.config.timeout)
-      perform_action(:action => 'is_button_present', :arguments => {:text => button_text}, :retry_until => timeout)
+    def has_button?(button_text)
+      perform_assertion :is_button_present, :text => button_text
     end
 
-    def has_child_count?(parent_element_description, child_element_description, child_count, timeout = Honeydew.config.timeout)
-      perform_action(:action => 'is_child_count_equal_to', :arguments => {:parent_description => parent_element_description, :child_description => child_element_description, :child_count => child_count}, :retry_until => timeout)
+    def has_child_count?(parent_element_description, child_element_description, child_count)
+      perform_assertion :is_child_count_equal_to,
+        :parent_description => parent_element_description,
+         :child_description => child_element_description,
+         :child_count => child_count
     end
 
-    def has_element_with_nested_text?(parent_description, child_text, timeout = Honeydew.config.timeout)
-      perform_action(:action => 'is_element_with_nested_text_present', :arguments => {:parent_description => parent_description, :child_text => child_text}, :retry_until => timeout)
+    def has_element_with_nested_text?(parent_description, child_text)
+      perform_assertion :is_element_with_nested_text_present,
+        :parent_description => parent_description,
+         :child_text => child_text
     end
 
     def has_app_installed?(package_name)
@@ -38,15 +42,18 @@ module Honeydew
     end
 
     def is_option_in_setting_enabled?(item_name, option_names)
-      perform_action :action => 'is_option_in_settings_menu_enabled', :arguments => {:menuName => item_name, :optionNames => option_names}
+      perform_assertion :is_option_in_settings_menu_enabled,
+        :menuName => item_name, :optionNames => option_names
     end
 
     def is_option_in_setting_disabled?(item_name, option_names)
-      perform_action :action => 'is_option_in_settings_menu_disabled', :arguments => {:menuName => item_name, :optionNames => option_names}
+      perform_assertion :is_option_in_settings_menu_disabled,
+        :menuName => item_name, :optionNames => option_names
     end
 
-    def has_settings_menu_item?(item_name, timeout = 10)
-      perform_action(:action => 'has_settings_menu_item', :arguments => {:menuName => item_name}, :retry_until => timeout)
+    def has_settings_menu_item?(item_name)
+      perform_assertion :has_settings_menu_item,
+        :menuName => item_name
     end
   end
-end
+end

data/lib/honeydew/dsl.rb

@@ -1,6 +1,6 @@
 module Honeydew
   module DSL
-    def use_device(name, serial)
+    def use_device(name, serial = nil)
       define_singleton_method name.to_sym do |*args, &block|
         Honeydew.using_device(serial, &block)
       end

data/lib/honeydew/honeydew.rb

@@ -0,0 +1,82 @@
+require 'active_support/core_ext'
+
+require 'honeydew/version'
+require 'honeydew/device'
+
+module Honeydew
+  class Configuration
+    attr_accessor :debug,
+      :server_timeout,
+      :timeout,
+      :port
+
+    def initialize
+      @port = 7120
+      @debug = true
+      @timeout = 5.seconds
+      @server_timeout = 30.seconds
+    end
+
+    def obtain_new_port
+      @port.tap { @port += 1 }
+    end
+  end
+
+  class <<self
+    attr_accessor :config
+
+    def config
+      return @config if @config
+      configure
+      @config
+    end
+
+    def configure
+      @config ||= Configuration.new
+      yield(@config) if block_given?
+    end
+
+    def attached_devices
+      @attached_devices ||= begin
+        `adb devices`.split("\n").drop(1).collect {|line| line.split[0].chomp}
+      end
+    end
+
+    def default_device_serial
+      attached_devices.first
+    end
+
+    def default_device
+      @default_device ||= device[default_device_serial]
+    end
+
+    def current_device
+      @current_device ||= default_device
+    end
+
+    def using_device(serial, &block)
+      original_device = current_device
+      use_device(serial || Honeydew.default_device_serial).tap do |device|
+        device.instance_eval(&block) if block_given?
+      end
+    ensure
+      @current_device = original_device
+    end
+
+    def devices
+      @devices
+    end
+
+    private
+
+    def use_device(serial)
+      @current_device = device[serial]
+    end
+
+    def device
+      @devices ||= Hash.new do |hash, serial|
+        hash[serial] = Device.new(serial)
+      end
+    end
+  end
+end