calabash-cucumber 0.9.74 → 0.9.80.pre.1

data/lib/calabash-cucumber/launch/simulator_helper.rb

@@ -10,7 +10,7 @@ module Calabash
       DERIVED_DATA = File.expand_path("~/Library/Developer/Xcode/DerivedData")
       DEFAULT_DERIVED_DATA_INFO = File.expand_path("#{DERIVED_DATA}/*/info.plist")
 
-      DEFAULT_SIM_WAIT = "15"
+      DEFAULT_SIM_WAIT = 15
 
       MAX_PING_ATTEMPTS = 5
 
@@ -149,36 +149,29 @@ module Calabash
       end
 
       def self.find_preferred_dir(sim_dirs)
-
-        pref = sim_dirs.find do |d|
+        sim_dirs.find do |d|
           out = `otool "#{File.expand_path(d)}"/* -o 2> /dev/null | grep CalabashServer`
           /CalabashServer/.match(out)
         end
-
-        if pref.nil?
-          pref = sim_dirs.find {|d| /Calabash-iphonesimulator/.match(d)}
-        end
-        pref
       end
 
       def self.ensure_connectivity(app_bundle_path, sdk, version)
         begin
           timeout = (ENV['CONNECT_TIMEOUT'] || DEFAULT_SIM_WAIT).to_i
+          max_ping = (ENV['MAX_PING_ATTEMPTS'] || MAX_PING_ATTEMPTS).to_i
           Timeout::timeout(timeout) do
             connected = false
             until connected
               simulator = launch(app_bundle_path, sdk, version)
               num_pings = 0
-              until connected or (num_pings == MAX_PING_ATTEMPTS)
+              until connected or (num_pings == max_ping)
                 begin
                     connected = (ping_app == '405')
                 rescue Exception => e
-                  if (num_pings > 2) then p e end
+                  p e if num_pings > 2
                 ensure
                   num_pings += 1
-                  unless connected
-                    sleep 1
-                  end
+                  sleep 1 unless connected
                 end
               end
             end
@@ -209,13 +202,12 @@ module Calabash
         status = res.code
         begin
           http.finish if http and http.started?
-        rescue Exception => e
-          puts "Finish #{e}"
+        rescue
+
         end
         status
       end
     end
 
-
   end
 end

data/lib/calabash-cucumber/operations.rb

@@ -1,5 +1,13 @@
-require 'net/http/persistent'
+require 'calabash-cucumber/core'
+require 'calabash-cucumber/tests_helpers'
+require 'calabash-cucumber/keyboard_helpers'
+require 'calabash-cucumber/wait_helpers'
+require 'net/http'
+require 'test/unit/assertions'
 require 'json'
+require 'set'
+require 'calabash-cucumber/version'
+
 
 if not Object.const_defined?(:CALABASH_COUNT)
   #compatability with IRB
@@ -9,22 +17,13 @@ end
 
 module Calabash
   module Cucumber
-
     module Operations
+      include Test::Unit::Assertions
+      include Calabash::Cucumber::Core
+      include Calabash::Cucumber::TestsHelpers
+      include Calabash::Cucumber::WaitHelpers
+      include Calabash::Cucumber::KeyboardHelpers
 
-      DATA_PATH = File.expand_path(File.dirname(__FILE__))
-
-      KEYBOARD_SMALL_LETTERS = "Keyboard_Small-Letters"
-      KEYBOARD_CAPITAL_LETTERS = "Keyboard_Capital-Letters"
-      KEYBOARD_NUMBERS_AND_PUNCTUATION = "Keyboard_Numbers-And-Punctuation"
-
-      def macro(txt)
-        if self.respond_to? :step
-          step(txt)
-        else
-          Then txt
-        end
-      end
 
       def home_direction
         @current_rotation = @current_rotation || :down
@@ -40,57 +39,12 @@ module Calabash
         str.gsub("'", "\\\\'")
       end
 
-      def wait_for(timeout, &block)
-        begin
-          Timeout::timeout(timeout) do
-            until block.call
-              sleep 0.3
-            end
-          end
-        rescue Exception => e
-          screenshot_and_raise e
-        end
-      end
-
-      def wait_ready(timeout, times=2, sleep=0.3, &block)
-        raise "Times parameter must be greater than or equal 2" if times < 2
-        raise "Sleep parameter must be greater than 0" if sleep <= 0
-        begin
-          Timeout::timeout(timeout) do
-            while times > 0 do
-              if block.call
-                times -= 1
-              end
-              sleep 0.3
-            end
-          end
-        rescue Exception => e
-          screenshot_and_raise e
-        end
-      end
-
-      def query(uiquery, *args)
-        map(uiquery, :query, *args)
-      end
 
       def label(uiquery)
         query(uiquery, :accessibilityLabel)
       end
 
-      def screenshot_and_raise(msg)
-        screenshot
-        sleep 5
-        raise(msg)
-      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 simple_touch(label, *args)
         touch("view marked:'#{label}'", *args)
@@ -104,10 +58,6 @@ module Calabash
         query(q).map { |e| e['html'] }
       end
 
-      def ok
-        touch("view marked:'ok'")
-      end
-
       def set_text(uiquery, txt)
         text_fields_modified = map(uiquery, :setText, txt)
         screenshot_and_raise "could not find text field #{uiquery}" if text_fields_modified.empty?
@@ -115,294 +65,6 @@ module Calabash
       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 done
-        map(nil, :keyboard, load_playback_data("touch_done"))
-      end
-
-      #Possible values
-      # 'Dictation'
-      # 'Shift'
-      # 'Delete'
-      # 'International'
-      # 'More'
-      def keyboard_enter_char(chr)
-        map(nil, :keyboard, load_playback_data("touch_done"), chr)
-      end
-
-      def keyboard_change_keyplane(plane)
-        desc = query("view:'UIKBKeyplaneView'", "keyplane", "description")
-        return nil if desc.empty?
-        desc = desc.first
-        plane_exp = Regexp.new(plane)
-        if not plane_exp.match(desc)
-          keyboard_enter_char "Shift"
-          sleep(0.3)
-          desc = query("view:'UIKBKeyplaneView'", "keyplane", "description").first
-          if not plane_exp.match(desc)
-            keyboard_enter_char "Shift"
-            sleep(0.3)
-            return nil
-          end
-        end
-        desc
-      end
-
-      #TODO only letters now
-      def keyboard_enter_text(text)
-        text.each_char do |ch|
-          if /[a-z]/.match(ch)
-            keyboard_change_keyplane(KEYBOARD_SMALL_LETTERS)
-          elsif /\d/.match(ch)
-            #Todo - handle digits and special chars
-            raise "Digits and special chars not handled by keyboard_enter_text yet."
-          else
-            keyboard_change_keyplane(KEYBOARD_CAPITAL_LETTERS)
-          end
-          keyboard_enter_char(ch)
-          sleep(0.3)
-        end
-      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)
-        res = http({:method=>:post, :path=>'background'}, {:duration => secs})
-      end
-
-      def element_exists(uiquery)
-        !query(uiquery).empty?
-      end
-
-      def view_with_mark_exists(expected_mark)
-        element_exists("view marked:'#{expected_mark}'")
-      end
-
-      def check_element_exists(query)
-        if not element_exists(query)
-          screenshot_and_raise "No element found for query: #{query}"
-        end
-      end
-
-      def check_element_does_not_exist(query)
-        if element_exists(query)
-          screenshot_and_raise "Expected no elements to match query: #{query}"
-        end
-      end
-
-      def check_view_with_mark_exists(expected_mark)
-        check_element_exists("view marked:'#{expected_mark}'")
-      end
-
-      # a better name would be element_exists_and_is_not_hidden
-      def element_is_not_hidden(uiquery)
-        matches = query(uiquery, 'isHidden')
-        matches.delete(true)
-        !matches.empty?
-      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
 
       #not officially supported yet
       #def change_slider_value_to(q, value)
@@ -460,72 +122,7 @@ module Calabash
       #  file_name
       #end
 
-      def screenshot(prefix=nil, name=nil)
-        res = http({:method =>:get, :path => 'screenshot'})
-        prefix = prefix || ENV['SCREENSHOT_PATH'] || ""
-        name = "screenshot_#{CALABASH_COUNT[:step_line]}.png" if name.nil?
-        path = "#{prefix}#{name}"
-        File.open(path, 'wb') do |f|
-          f.write res
-        end
-        puts "Saved screenshot: #{path}"
-        path
-      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
-
-      def make_http_request(url, req)
-        @http = Net::HTTP.new(url.host, url.port)
-        res = @http.start do |sess|
-          sess.request req
-        end
-        body = res.body
-        begin
-          @http.finish if @http and @http.started?
-        rescue Exception => e
-          puts "Finish #{e}"
-        end
-        body
-      end
 
     end
-
-
   end
 end