calabash-cucumber 0.9.74 → 0.9.80.pre.1

data/Gemfile.lock

@@ -1,11 +1,10 @@
 PATH
   remote: .
   specs:
-    calabash-cucumber (0.9.74)
+    calabash-cucumber (0.9.80.pre.1)
       CFPropertyList
       cucumber
       json
-      net-http-persistent
       sim_launcher (= 0.3.8)
       slowhandcuke
 
@@ -23,7 +22,6 @@ GEM
     gherkin (2.11.1)
       json (>= 1.4.6)
     json (1.7.3)
-    net-http-persistent (2.7)
     rack (1.4.1)
     rack-protection (1.2.0)
       rack

data/bin/calabash-ios-build.rb

@@ -71,8 +71,9 @@ def run(options={:build_dir=>"Calabash",
 
   if ENV['NO_BUILD'] != "1"
     if !build(options)
-      msg("Info") do
+      msg("Error") do
         puts "Build failed. Please consult logs. Aborting."
+        exit(false)
       end
     end
   end
@@ -80,12 +81,19 @@ def run(options={:build_dir=>"Calabash",
   if ENV["NO_GEN"] != "1"
     if !File.directory?("features")
       calabash_scaffold
+    else
+      msg("Info") do
+        puts "Detected features folder, will not generate..."
+      end
     end
   end
 
   default_path = "#{options[:dstroot]}/#{options[:wrapper_name]}"
   cmd = %Q[APP_BUNDLE_PATH="#{ENV['APP_BUNDLE_PATH'] || default_path}" cucumber]
-  puts cmd
+  msg("Info") do
+    puts "Running command:"
+    puts cmd
+  end
   system(cmd)
   puts "Done..."
 end

data/bin/calabash-ios-helpers.rb

@@ -17,6 +17,8 @@ def print_usage
       prints more detailed help information.
     gen
       generate a features folder structure.
+    console
+      starts an interactive console to interact with your app via Calabash
     setup (EXPERIMENTAL) [opt path]?
       setup your XCode project for calabash-ios
     download [opt path]?
@@ -35,6 +37,7 @@ def print_usage
       change the default iOS Simulator device.
 EOF
 end
+
 def print_help
   file = File.join(File.dirname(__FILE__), '..', 'doc', 'calabash-ios-help.txt')
   system("less #{file}")

data/calabash-cucumber.gemspec

@@ -21,6 +21,5 @@ Gem::Specification.new do |s|
   s.add_dependency( "CFPropertyList" )
   s.add_dependency( "sim_launcher", "0.3.8") #Recommended by Pete for now
   s.add_dependency( "slowhandcuke" )
-  s.add_dependency( "net-http-persistent" )
 
 end

data/doc/calabash-ios-help.txt

@@ -14,7 +14,10 @@ Usage: calabash-ios <command-name> [parameters]
   gen creates a skeleton features dir. This is usually used once when
       setting up calabash to ensure that the features folder contains
       the right step definitions and environment to run with cucumber.
-
+  console
+      starts an interactive console to interact with your app via Calabash.
+      Copies the irb_ios5.sh and irb_ios4.sh scripts and the .irbrc file
+      then launches irb_ios5.sh.
   setup [path]? (EXPERIMENTAL) Automates setting up your iOS Xcode project
         with calabash-ios-server. It is your responsibility to ensure
         that your production build does not link with calabash.framework.

data/features/step_definitions/calabash_steps.rb

@@ -34,7 +34,7 @@ Then /^I (?:press|touch) the "([^\"]*)" button$/ do |name|
 end
 
 Then /^I (?:press|touch) the "([^\"]*)" (?:input|text) field$/ do |name|
-  touch("textField placeholder:'#{name}'")
+  touch("textField placeholdwer:'#{name}'")
   sleep(STEP_PAUSE)
 end
 

data/lib/calabash-cucumber.rb

@@ -1,2 +1,6 @@
+require 'calabash-cucumber/core'
+require 'calabash-cucumber/tests_helpers'
+require 'calabash-cucumber/keyboard_helpers'
+require 'calabash-cucumber/wait_helpers'
 require 'calabash-cucumber/operations'
-require 'calabash-cucumber/version'
+require 'calabash-cucumber/version'

data/lib/calabash-cucumber/core.rb

@@ -0,0 +1,310 @@
+module Calabash
+  module Cucumber
+    module Core
+
+      DATA_PATH = File.expand_path(File.dirname(__FILE__))
+
+      def macro(txt)
+        if self.respond_to? :step
+          step(txt)
+        else
+          Then txt
+        end
+      end
+
+      def query(uiquery, *args)
+        map(uiquery, :query, *args)
+      end
+
+      def touch(uiquery, options={})
+        options[:query] = uiquery
+        views_touched = playback("touch", options)
+        unless uiquery.nil?
+          screenshot_and_raise "could not find view to touch: '#{uiquery}', args: #{options}" if views_touched.empty?
+        end
+        views_touched
+      end
+
+      def swipe(dir, options={})
+        dir = dir.to_sym
+        @current_rotation = @current_rotation || :down
+        if @current_rotation == :left
+          case dir
+            when :left then
+              dir = :down
+            when :right then
+              dir = :up
+            when :up then
+              dir = :left
+            when :down then
+              dir = :right
+            else
+          end
+        end
+        if @current_rotation == :right
+          case dir
+            when :left then
+              dir = :up
+            when :right then
+              dir = :down
+            when :up then
+              dir = :right
+            when :down then
+              dir = :left
+            else
+          end
+        end
+        if @current_rotation == :up
+          case dir
+            when :left then
+              dir = :right
+            when :right then
+              dir = :left
+            when :up then
+              dir = :down
+            when :down then
+              dir = :up
+            else
+          end
+        end
+        playback("swipe_#{dir}", options)
+      end
+
+      def cell_swipe(options={})
+        playback("cell_swipe", options)
+      end
+
+      def scroll(uiquery, direction)
+        views_touched=map(uiquery, :scroll, direction)
+        screenshot_and_raise "could not find view to scroll: '#{uiquery}', args: #{direction}" if views_touched.empty?
+        views_touched
+      end
+
+      def scroll_to_row(uiquery, number)
+        views_touched=map(uiquery, :scrollToRow, number)
+        if views_touched.empty? or views_touched.member? "<VOID>"
+          screenshot_and_raise "Unable to scroll: '#{uiquery}' to: #{number}"
+        end
+        views_touched
+      end
+
+      def pinch(in_out, options={})
+        file = "pinch_in"
+        if in_out.to_sym==:out
+          file = "pinch_out"
+        end
+        playback(file, options)
+      end
+
+      def rotate(dir)
+        @current_rotation = @current_rotation || :down
+        rotate_cmd = nil
+        case dir
+          when :left then
+            if @current_rotation == :down
+              rotate_cmd = "left_home_down"
+              @current_rotation = :right
+            elsif @current_rotation == :right
+              rotate_cmd = "left_home_right"
+              @current_rotation = :up
+            elsif @current_rotation == :left
+              rotate_cmd = "left_home_left"
+              @current_rotation = :down
+            elsif @current_rotation == :up
+              rotate_cmd = "left_home_up"
+              @current_rotation = :left
+            end
+          when :right then
+            if @current_rotation == :down
+              rotate_cmd = "right_home_down"
+              @current_rotation = :left
+            elsif @current_rotation == :left
+              rotate_cmd = "right_home_left"
+              @current_rotation = :up
+            elsif @current_rotation == :right
+              rotate_cmd = "right_home_right"
+              @current_rotation = :down
+            elsif @current_rotation == :up
+              rotate_cmd = "right_home_up"
+              @current_rotation = :right
+            end
+        end
+
+        if rotate_cmd.nil?
+          screenshot_and_raise "Does not support rotating #{dir} when home button is pointing #{@current_rotation}"
+        end
+        playback("rotate_#{rotate_cmd}")
+      end
+
+      def background(secs)
+        http({:method => :post, :path => 'background'}, {:duration => secs})
+      end
+
+
+      def load_playback_data(recording, options={})
+        os = options["OS"] || ENV["OS"] || "ios5"
+        device = options["DEVICE"] || ENV["DEVICE"] || "iphone"
+
+        rec_dir = ENV['PLAYBACK_DIR'] || "#{Dir.pwd}/playback"
+        if !recording.end_with? ".base64"
+          recording = "#{recording}_#{os}_#{device}.base64"
+        end
+        data = nil
+        if (File.exists?(recording))
+          data = File.read(recording)
+        elsif (File.exists?("features/#{recording}"))
+          data = File.read("features/#{recording}")
+        elsif (File.exists?("#{rec_dir}/#{recording}"))
+          data = File.read("#{rec_dir}/#{recording}")
+        elsif (File.exists?("#{DATA_PATH}/resources/#{recording}"))
+          data = File.read("#{DATA_PATH}/resources/#{recording}")
+        else
+          screenshot_and_raise "Playback not found: #{recording} (searched for #{recording} in #{Dir.pwd}, #{rec_dir}, #{DATA_PATH}/resources"
+        end
+        data
+      end
+
+      def playback(recording, options={})
+        data = load_playback_data(recording)
+
+        post_data = %Q|{"events":"#{data}"|
+        post_data<< %Q|,"query":"#{escape_quotes(options[:query])}"| if options[:query]
+        post_data<< %Q|,"offset":#{options[:offset].to_json}| if options[:offset]
+        post_data<< %Q|,"reverse":#{options[:reverse]}| if options[:reverse]
+        post_data<< %Q|,"prototype":"#{options[:prototype]}"| if options[:prototype]
+        post_data << "}"
+
+        res = http({:method => :post, :raw => true, :path => 'play'}, post_data)
+
+        res = JSON.parse(res)
+        if res['outcome'] != 'SUCCESS'
+          screenshot_and_raise "playback failed because: #{res['reason']}\n#{res['details']}"
+        end
+        res['results']
+      end
+
+      def interpolate(recording, options={})
+        data = load_playback_data(recording)
+
+        post_data = %Q|{"events":"#{data}"|
+        post_data<< %Q|,"start":"#{escape_quotes(options[:start])}"| if options[:start]
+        post_data<< %Q|,"end":"#{escape_quotes(options[:end])}"| if options[:end]
+        post_data<< %Q|,"offset_start":#{options[:offset_start].to_json}| if options[:offset_start]
+        post_data<< %Q|,"offset_end":#{options[:offset_end].to_json}| if options[:offset_end]
+        post_data << "}"
+
+        res = http({:method => :post, :raw => true, :path => 'interpolate'}, post_data)
+
+        res = JSON.parse(res)
+        if res['outcome'] != 'SUCCESS'
+          screenshot_and_raise "interpolate failed because: #{res['reason']}\n#{res['details']}"
+        end
+        res['results']
+      end
+
+      def record_begin
+        http({:method => :post, :path => 'record'}, {:action => :start})
+      end
+
+      def record_end(file_name)
+        res = http({:method => :post, :path => 'record'}, {:action => :stop})
+        File.open("_recording.plist", 'wb') do |f|
+          f.write res
+        end
+        device = ENV['DEVICE'] || 'iphone'
+        os = ENV['OS'] || 'ios5'
+
+        file_name = "#{file_name}_#{os}_#{device}.base64"
+        system("/usr/bin/plutil -convert binary1 -o _recording_binary.plist _recording.plist")
+        system("openssl base64 -in _recording_binary.plist -out #{file_name}")
+        system("rm _recording.plist _recording_binary.plist")
+        file_name
+      end
+
+      def backdoor(sel, arg)
+        json = {
+            :selector => sel,
+            :arg => arg
+        }
+        res = http({:method => :post, :path => 'backdoor'}, json)
+        res = JSON.parse(res)
+        if res['outcome'] != 'SUCCESS'
+          screenshot_and_raise "backdoor #{json} failed because: #{res['reason']}\n#{res['details']}"
+        end
+        res['result']
+      end
+
+
+      def map(query, method_name, *method_args)
+        operation_map = {
+            :method_name => method_name,
+            :arguments => method_args
+        }
+        res = http({:method => :post, :path => 'map'},
+                   {:query => query, :operation => operation_map})
+        res = JSON.parse(res)
+        if res['outcome'] != 'SUCCESS'
+          screenshot_and_raise "map #{query}, #{method_name} failed because: #{res['reason']}\n#{res['details']}"
+        end
+
+        res['results']
+      end
+
+      def http(options, data=nil)
+        url = url_for(options[:path])
+        if options[:method] == :post
+          req = Net::HTTP::Post.new url.path
+          if options[:raw]
+            req.body=data
+          else
+            req.body = data.to_json
+          end
+
+        else
+          req = Net::HTTP::Get.new url.path
+        end
+        make_http_request(url, req)
+      end
+
+
+      def url_for(verb)
+        url = URI.parse(ENV['DEVICE_ENDPOINT']|| "http://localhost:37265/")
+        url.path = '/'+verb
+        url
+      end
+
+      CAL_HTTP_RETRY_COUNT=3
+
+      def make_http_request(url, req)
+        body = nil
+        CAL_HTTP_RETRY_COUNT.times do |count|
+          begin
+            if not (@http) or not (@http.started?)
+              @http = init_request(url)
+              @http.start
+            end
+            body = @http.request(req).body
+            break
+          rescue Exception => e
+            if count < CAL_HTTP_RETRY_COUNT-1
+              puts "Retrying.."
+            else
+              puts "Failing..."
+              raise e
+            end
+          end
+        end
+
+        body
+      end
+
+      def init_request(url)
+        http = Net::HTTP.new(url.host, url.port)
+        if http.respond_to? :open_timeout=
+          http.open_timeout==15
+        end
+        http
+      end
+    end
+  end
+end

data/lib/calabash-cucumber/cucumber.rb

@@ -1,7 +1,6 @@
-require 'calabash-cucumber/color_helper'
+require 'calabash-cucumber/wait_helpers'
 require 'calabash-cucumber/operations'
 
-World(Calabash::Cucumber::ColorHelper)
 World(Calabash::Cucumber::Operations)
 
 AfterConfiguration do

data/lib/calabash-cucumber/keyboard_helpers.rb

@@ -0,0 +1,112 @@
+require 'calabash-cucumber/tests_helpers'
+
+module Calabash
+  module Cucumber
+    module KeyboardHelpers
+      include Calabash::Cucumber::TestsHelpers
+
+      KEYPLANE_NAMES = {
+          :small_letters => "small-letters",
+          :capital_letters => "capital-letters",
+          :numbers_and_punctuation => "numbers-and-punctuation",
+          :first_alternate => "first-alternate",
+          :numbers_and_punctuation_alternate => "numbers-and-punctuation-alternate"
+      }
+
+      #Possible values
+      # 'Dictation'
+      # 'Shift'
+      # 'Delete'
+      # 'International'
+      # 'More'
+      # 'Return'
+      def keyboard_enter_char(chr, should_screenshot=true)
+        #map(nil, :keyboard, load_playback_data("touch_done"), chr)
+        res = http({:method => :post, :path => 'keyboard'},
+                   {:key => chr, :events => load_playback_data("touch_done")})
+        res = JSON.parse(res)
+        if res['outcome'] != 'SUCCESS'
+          msg = "Keyboard enter failed failed because: #{res['reason']}\n#{res['details']}"
+          if should_screenshot
+            screenshot_and_raise msg
+          else
+            raise msg
+          end
+        end
+        res['results']
+      end
+
+      def done
+        keyboard_enter_char "Return"
+      end
+
+
+      def current_keyplane
+        kp_arr = _do_keyplane(
+            lambda { query("view:'UIKBKeyplaneView'", "keyplane", "componentName") },
+            lambda { query("view:'UIKBKeyplaneView'", "keyplane", "name") })
+        kp_arr.first.downcase
+      end
+
+      def search_keyplanes_and_enter_char(chr, visited=Set.new)
+        cur_kp = current_keyplane
+        begin
+          keyboard_enter_char(chr, false)
+          return true #found
+        rescue
+          visited.add(cur_kp)
+
+          #figure out keyplane alternates
+          props = _do_keyplane(
+              lambda { query("view:'UIKBKeyplaneView'", "keyplane", "properties") },
+              lambda { query("view:'UIKBKeyplaneView'", "keyplane", "attributes", "dict") }
+          ).first
+
+          known = KEYPLANE_NAMES.values
+
+          found = false
+          ["shift", "more"].each do |key|
+            plane = props["#{key}-alternate"]
+            if (known.member?(plane) and
+                not visited.member?(plane))
+              keyboard_enter_char(key.capitalize, false)
+              found = search_keyplanes_and_enter_char(chr, visited)
+              return true if found
+              #not found => go back
+              keyboard_enter_char(key.capitalize, false)
+            end
+          end
+          return false
+        end
+      end
+
+      def keyboard_enter_text(text)
+        fail("No visible keyboard") if element_does_not_exist("view:'UIKBKeyplaneView'")
+
+        text.each_char do |ch|
+          begin
+            keyboard_enter_char(ch, false)
+          rescue
+            search_keyplanes_and_enter_char(ch)
+          end
+        end
+      end
+
+
+      def _do_keyplane(kbtree_proc, keyplane_proc)
+        desc = query("view:'UIKBKeyplaneView'", "keyplane")
+        fail("No keyplane (UIKBKeyplaneView keyplane)") if desc.empty?
+        fail("Several keyplanes (UIKBKeyplaneView keyplane)") if desc.count > 1
+        kp_desc = desc.first
+        if /^<UIKBTree/.match(kp_desc)
+          #ios5+
+          kbtree_proc.call
+        elsif /^<UIKBKeyplane/.match(kp_desc)
+          #ios4
+          keyplane_proc.call
+        end
+      end
+
+    end
+  end
+end