honeydew 0.10.0 → 0.11.0

data/lib/honeydew/device_actions.rb

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

data/lib/honeydew/device_commands.rb

@@ -6,7 +6,7 @@ module Honeydew
     end
 
     def dump_window_hierarchy(local_path)
-      path_in_device = perform_action('dump_window_hierarchy')['description']
+      path_in_device = perform_action(:action => 'dump_window_hierarchy')['description']
       adb "pull #{path_in_device} #{local_path}"
     end
 
@@ -41,7 +41,7 @@ module Honeydew
     def start_automation_server
       Thread.new do
         adb "push #{automation_server_jar_path} /data/local/tmp"
-        adb "shell uiautomator runtest #{automation_test_jar_name} -c com.amplify.honeydew_server.TestRunner"
+        adb "shell uiautomator runtest #{automation_test_jar_name} -c com.uiautomator_cucumber.android_server.TestRunner"
         log "Device: #{serial} initiated the start of automation server"
       end
       at_exit do
@@ -81,4 +81,4 @@ module Honeydew
     end
 
   end
-end
+end

data/lib/honeydew/device_matchers.rb

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

data/lib/honeydew/step_definitions.rb

@@ -0,0 +1,75 @@
+Given /^I unlock$/ do
+  Honeydew.current_device.unlock
+end
+
+Given /^I launch app "(.*?)"$/ do |app_name|
+  Honeydew.current_device.launch_application app_name
+end
+
+Given /^I launch home$/ do
+  Honeydew.current_device.launch_home
+end
+
+When /^I press back$/ do
+  Honeydew.current_device.press_back
+end
+
+Given /^I select "(.*?)" in the Settings view$/ do |menu_item|
+  Honeydew.current_device.launch_settings_item menu_item
+end
+
+Given /^I select app "(.*?)" from the Apps list in the Settings view$/ do |app_name|
+  Honeydew.current_device.launch_settings_app app_name
+end
+
+Given /^I should see text containing "(.*?)"$/ do |expected_text|
+  Honeydew.current_device.should have_textview_text expected_text
+end
+
+Given /^I enter text "(.*?)" into field with description "(.*?)"$/ do |text, field_description|
+  Honeydew.current_device.fill_in field_description, with: text
+end
+
+Given /^I press the "(.*?)" button$/ do |button_text|
+  Honeydew.current_device.click_button button_text
+end
+
+Given /^I press the "(.*?)" text$/ do |text|
+  Honeydew.current_device.click_text text
+end
+
+Given /^I press the element with description "(.*?)"$/ do |element_description|
+  Honeydew.current_device.click_element element_description
+end
+
+Given /^I long press the element with description "(.*?)"$/ do |element_description|
+  Honeydew.current_device.long_click_element element_description
+end
+
+When /^I wait up to (\d+) seconds for "(.*?)" to appear$/ do |timeout, text|
+  Honeydew.current_device.should have_textview_text text, timeout
+end
+
+When /^I wait up to (\d+) seconds for "(.*?)" to appear in edit text$/ do |timeout, text|
+  Honeydew.current_device.should have_edit_text text, timeout
+end
+
+Given /I uninstall the app "(.*?)" using ADB$/ do |pacakge_name|
+  Honeydew.current_device.uninstall_app pacakge_name
+end
+
+Given /I install the app "(.*?)" using ADB$/ do |apk_location|
+  Honeydew.current_device.install_app apk_location
+end
+
+Given /I reboot the device using ADB$/ do
+  Honeydew.current_device.reboot
+end
+
+Then /I see the app "(.*?)" installed using ADB$/ do |package_name|
+  Honeydew.current_device.should have_app_installed package_name
+end
+
+Then /I should see a button "(.*?)" with (package|description) as "(.*?)"$/ do |button_text, condition, package_name|
+  Honeydew.current_device.should have_button button_text
+end

data/lib/honeydew/version.rb

@@ -1,3 +1,3 @@
 module Honeydew
-  VERSION = "0.10.0"
+  VERSION = "0.11.0"
 end

data/lib/honeydew.rb

@@ -3,8 +3,8 @@ require 'bundler/setup'
 require 'restclient'
 require 'active_support/core_ext'
 
-require 'honeydew/version'
-require 'honeydew/device'
+require "honeydew/version"
+require "honeydew/device"
 
 module Honeydew
   class Configuration

data/lib/tasks/honeydew.rake

@@ -0,0 +1,7 @@
+require 'honeydew'
+require 'cucumber/rake/task'
+
+Cucumber::Rake::Task.new(:honeydew, 'Run honeydew cucumber tests') do |t|
+  t.profile = 'honeydew'
+  t.cucumber_opts = "--tags @honeydew"
+end

data/spec/honeydew/device_matchers_spec.rb

@@ -1,37 +1,58 @@
 require 'spec_helper'
 
 describe Honeydew::DeviceMatchers do
-  let(:device) do
-    Class.new do
-      include Honeydew::DeviceMatchers
-      def perform_assertion; end
-    end.new
+
+  class DeviceTest
+    include Honeydew::DeviceMatchers
+    def perform_action; end
   end
 
-  describe '#has_textview_text' do
-    let(:text) { 'some text' }
+  let (:device) { DeviceTest.new }
+
+  describe "#has_textview_text" do
+    let (:text) { "some text" }
+
+    it "should perform action for is_text_present" do
+      device.should_receive(:perform_action).with(hash_including({action: "is_text_present"}))
+
+      device.has_textview_text? text
+    end
+
+    it "should retry for a default timeout" do
+      device.should_receive(:perform_action).with(hash_including({retry_until: Honeydew.config.timeout}))
+
+      device.has_textview_text? text
+    end
 
-    it 'should perform action for is_text_present' do
-      device.should_receive(:perform_assertion)
-        .with(:is_text_present,
-              hash_including(text: text, type: 'TextView'),
-              timeout: Honeydew.config.timeout)
+    it "should pass the arguments for the text view" do
+      device.should_receive(:perform_action).with(hash_including({arguments: { text: text, type: 'TextView'}}))
 
       device.has_textview_text? text
     end
+
   end
 
-  describe '#has_textview_with_text_and_description' do
-    let(:text) { 'some text' }
-    let(:description) { 'some description' }
+  describe "#has_textview_with_text_and_description" do
+    let (:text) { "some text" }
+    let (:description) { "some description" }
+
+    it "should perform action for is_text_present" do
+      device.should_receive(:perform_action).with(hash_including({action: "is_text_present"}))
+
+      device.has_textview_with_text_and_description? text, description
+    end
+
+    it "should retry for a default timeout" do
+      device.should_receive(:perform_action).with(hash_including({retry_until: Honeydew.config.timeout}))
 
-    it 'performs the is_text_present action' do
-      device.should_receive(:perform_assertion)
-        .with(:is_text_present,
-              hash_including(text: text, type: 'TextView'),
-              timeout: Honeydew.config.timeout)
+      device.has_textview_with_text_and_description? text, description
+    end
+
+    it "should pass the arguments for the text view" do
+      device.should_receive(:perform_action).with(hash_including({arguments: { text: text, description: description, type: 'TextView'}}))
 
       device.has_textview_with_text_and_description? text, description
     end
+
   end
-end
+end

data/spec/honeydew/device_spec.rb

@@ -1,68 +1,66 @@
 require 'spec_helper'
 
 describe Honeydew::Device, :silence_puts do
-  let(:response) { '{"success": true }' }
-  let(:device)   { Honeydew::Device.new('ABC123DEF') }
-  let(:device_end_point) do
-    "http://127.0.0.1:#{device.port}"
-  end
+  let(:response) { "{ \"success\": true }" }
+  let(:command)  { {"action" => '', "arguments" => {}} }
+  let(:serial)   { "ABC123DEF" }
 
   before do
-    RestClient.stub(:get).and_return(response)
+    @device =  Honeydew::Device.new serial
+    @device_end_point = "http://127.0.0.1:#{@device.port}"
+    RestClient.stub(:get).with(@device_end_point, params: { "command" => command}).and_return(response)
   end
 
-  describe '#contains_textview_text?' do
-    let(:text)     { 'Ok' }
-    let(:command)  do
-      {'action' => 'is_text_present',
-       'arguments' => {'text' => text, 'type' => 'TextView'}}
-    end
+  describe "contains_textview_text?" do
+    let(:text)     { "Ok" }
+    let(:command)  { {"action" => 'is_text_present', "arguments" => {"text" => text, "type" => 'TextView'}} }
 
-    it 'should make the call with command is_text_present' do
-      RestClient.should_receive(:get).with(device_end_point, params: {'command' => command})
-      device.contains_textview_text?(text)
+    it "should make the call with command is_text_present" do
+      RestClient.should_receive(:get).with(@device_end_point, params: { "command" => command}).and_return(response)
+      @device.contains_textview_text?(text)
     end
 
-    context 'on successful response' do
-      let(:response) { '{ "success": true }' }
+    context "on successful response" do
+      let(:response) { "{ \"success\": true }" }
 
-      it 'should return true' do
-        device.contains_textview_text?(text).should be_true
+      it "should return true" do
+        @device.contains_textview_text?(text).should be_true
       end
     end
 
-    context 'on failure response' do
-      let(:response) { '{ "success": false }' }
+    context "on failure response" do
+      let(:response) { "{ \"success\": false }" }
 
-      it 'should return false' do
-        device.contains_textview_text?(text).should be_false
+      it "should return false" do
+        @device.contains_textview_text?(text).should be_false
       end
     end
   end
 
-  describe '#contains_button?' do
-    let(:text)     { 'Ok' }
-    let(:command)  { {'action' => 'is_button_present', 'arguments' => {'text' => text}} }
+  describe "contains_button?" do
+    let(:text)     { "Ok" }
+    let(:command)  { {"action" => 'is_button_present', "arguments" => {"text" => text}} }
 
-    it 'should make the call with command is_button_present' do
-      RestClient.should_receive(:get).with(device_end_point, params: {'command' => command})
-      device.contains_button?(text)
+    it "should make the call with command is_button_present" do
+      RestClient.should_receive(:get).with(@device_end_point, params: { "command" => command}).and_return(response)
+      @device.contains_button?(text)
     end
 
-    context 'on successful response' do
-      let(:response) { '{ "success": true }' }
+    context "on successful response" do
+      let(:response) { "{ \"success\": true }" }
 
-      it 'should return true' do
-        device.contains_button?(text).should be_true
+      it "should return true" do
+        @device.contains_button?(text).should be_true
       end
     end
 
-    context 'on failure response' do
-      let(:response) { '{ "success": false }' }
+    context "on failure response" do
+      let(:response) { "{ \"success\": false }" }
 
-      it 'should return false' do
-        device.contains_button?(text).should be_false
+      it "should return false" do
+        @device.contains_button?(text).should be_false
       end
     end
   end
+
 end