calabash-cucumber 0.9.169.pre2 → 0.9.169.pre5

data/lib/calabash-cucumber/utils/xctools.rb

@@ -0,0 +1,95 @@
+require 'open3'
+
+module Calabash
+  module Cucumber
+
+    # methods for interacting with the xcode tools
+    module XcodeTools
+
+      # returns the path to the current developer directory
+      #
+      # $ man xcode-select
+      # DEVELOPER_DIR
+      # Overrides the active developer directory. When DEVELOPER_DIR is set, its value
+      # will be used instead of the system-wide active developer directory.
+      #
+      # @return [String] path to current developer directory
+      def xcode_developer_dir
+        # respect DEVELOPER_DIR
+        return ENV['DEVELOPER_DIR'] if ENV['DEVELOPER_DIR']
+        # fall back to xcode-select
+        `xcode-select --print-path`.chomp
+      end
+
+      # returns the path to the current developer usr/bin directory
+      # @return [String] path to the current xcode binaries
+      def xcode_bin_dir
+        "#{xcode_developer_dir}/usr/bin"
+      end
+
+      # method for interacting with instruments
+      #
+      #              instruments #=> /Applications/Xcode.app/Contents/Developer/usr/bin/instruments
+      #    instruments(:version) #=> 5.1.1
+      #       instruments(:sims) #=> < list of known simulators >
+      #
+      # @param [String] cmd controls the return value.  currently accepts nil,
+      #   :sims, and :version as valid parameters
+      # @return [String] based on the value of +cmd+ version, a list known
+      #   simulators, or the path to the instruments binary
+      # @raise [ArgumentError] if invalid +cmd+ is passed
+      def instruments(cmd=nil)
+        instruments = "#{xcode_bin_dir}/instruments"
+        return instruments if cmd == nil
+
+        case cmd
+          when :version
+            # instruments, version 5.1.1 (55045)
+            # noinspection RubyUnusedLocalVariable
+            Open3.popen3("#{instruments}") do |stdin, stdout, stderr, wait_thr|
+              stderr.read.chomp.split(' ')[2]
+            end
+          when :sims
+            devices = `#{instruments} -s devices`.chomp.split("\n")
+            devices.select { |device| device.downcase.include?('simulator') }
+          else
+            candidates = [:version, :sims]
+            raise(ArgumentError, "expected '#{cmd}' to be one of '#{candidates}'")
+        end
+      end
+
+      # does the instruments +version+ accept the -s (devices) flag?
+      #
+      #     instruments_supports_hyphen_s?('4.6.3') #=> false
+      #     instruments_supports_hyphen_s?('5.0.2') #=> true
+      #       instruments_supports_hyphen_s?('5.1') #=> true
+      #
+      # @param [String] version a major.minor.{patch} version string - defaults
+      #  to the currently active instruments binary
+      # @return [Boolean] true iff the version is >= 5.*
+      def instruments_supports_hyphen_s?(version=instruments(:version))
+        tokens = version.split('.')
+        return false if tokens[0].to_i < 5
+        return false if tokens[1].to_i < 1
+        true
+      end
+
+      # returns a list of installed simulators by calling:
+      #
+      #    $ instruments -s devices
+      #
+      # and parsing the output
+      # @return [Array<String>] an array of simulator names suitable for passing
+      #   to instruments or xcodebuild
+      # @raise [RuntimeError] if the currently active instruments version does
+      #   not support the -s flag
+      def installed_simulators
+        unless instruments_supports_hyphen_s?
+          raise(RuntimeError, "instruments '#{instruments(:version)}' does not support '-s devices' arguments")
+        end
+        instruments(:sims)
+      end
+
+    end
+  end
+end

data/lib/calabash-cucumber/version.rb

@@ -1,6 +1,201 @@
 module Calabash
   module Cucumber
-    VERSION = '0.9.169.pre2'
-    FRAMEWORK_VERSION = '0.9.169.pre2'
+    VERSION = '0.9.169.pre5'
+    MIN_SERVER_VERSION = '0.9.169.pre2'
+
+    class Version
+
+      attr_accessor :major
+      attr_accessor :minor
+      attr_accessor :patch
+      attr_accessor :pre
+      attr_accessor :pre_version
+
+      def initialize(version)
+        tokens = version.split('.')
+        count = tokens.count
+        if count == 4
+          @pre = tokens[3]
+          pre_tokens = @pre.scan(/\D+|\d+/)
+          @pre_version = pre_tokens[1].to_i if pre_tokens.count == 2
+        end
+
+        @major, @minor, @patch = version.split('.').map(&:to_i)
+      end
+
+      def to_s
+        str = [@major, @minor, @patch].join('.')
+        str = "#{str}.#{@pre}" if @pre
+        str
+      end
+
+      def == (other)
+        compare(self, other) == 0
+      end
+
+      def != (other)
+        compare(self, other) != 0
+      end
+
+      def < (other)
+        compare(self, other) < 0
+      end
+
+      def > (other)
+        compare(self, other) > 0
+      end
+
+      def <= (other)
+        compare(self, other) <= 0
+      end
+
+      def >= (other)
+        compare(self, other) >= 0
+      end
+
+      def compare(a, b)
+
+        if a.major != b.major
+          return a.major > b.major ? 1 : -1
+        end
+
+        if a.minor != b.minor
+          return a.minor > b.minor ? 1 : -1
+        end
+
+        if a.patch != b.patch
+          return a.patch > b.patch ? 1 : -1
+        end
+
+        return 1 if a.pre and (not b.pre)
+        return -1 if (not a.pre) and b.pre
+
+        return 1 if a.pre_version and (not b.pre_version)
+        return -1 if (not a.pre_version) and b.pre_version
+
+        if a.pre_version != b.pre_version
+          return a.pre_version > b.pre_version ? 1 : -1
+        end
+
+        0
+
+      end
+    end
   end
 end
+
+if __FILE__ == $0
+  require 'test/unit'
+
+  class LocalTest < Test::Unit::TestCase
+    include Calabash::Cucumber
+
+    def test_version
+      a = Version.new('0.9.169')
+      assert_equal(0, a.major)
+      assert_equal(9, a.minor)
+      assert_equal(169, a.patch)
+      assert_nil(a.pre)
+      assert_nil(a.pre_version)
+    end
+
+    def test_unnumbered_prerelease
+      a = Version.new('0.9.169.pre')
+      assert_equal('pre', a.pre)
+      assert_nil(a.pre_version)
+    end
+
+    def test_numbered_prerelease
+      a = Version.new('0.9.169.pre1')
+      assert_equal('pre1', a.pre)
+      assert_equal(1, a.pre_version)
+    end
+
+    def test_compare_equal
+      a = Version.new('0.9.169')
+      b = Version.new('0.9.169')
+      assert(a == b)
+
+      a = Version.new('0.9.169.pre')
+      b = Version.new('0.9.169.pre')
+      assert(a == b)
+
+      a = Version.new('0.9.169.pre2')
+      b = Version.new('0.9.169.pre2')
+      assert(a == b)
+
+    end
+
+    def test_compare_not_equal
+      a = Version.new('0.9.168')
+      b = Version.new('0.9.169')
+      assert(a != b)
+
+
+      a = Version.new('0.9.169')
+      b = Version.new('0.9.169.pre1')
+      assert(a != b)
+
+      a = Version.new('0.9.169.pre')
+      b = Version.new('0.9.169.pre1')
+      assert(a != b)
+
+      a = Version.new('0.9.169.pre1')
+      b = Version.new('0.9.169.pre2')
+      assert(a != b)
+    end
+
+    def test_compare_lt
+      a = Version.new('0.9.168')
+      b = Version.new('0.9.169')
+      assert(a < b)
+
+      a = Version.new('0.9.169')
+      b = Version.new('0.9.169.pre')
+      assert(a < b)
+
+      a = Version.new('0.9.169.pre')
+      b = Version.new('0.9.169.pre1')
+      assert(a < b)
+
+      a = Version.new('0.9.169.pre1')
+      b = Version.new('0.9.169.pre2')
+      assert(a < b)
+    end
+
+    def test_compare_gt
+      a = Version.new('0.9.169')
+      b = Version.new('0.9.168')
+      assert(a > b)
+
+      a = Version.new('0.9.169.pre')
+      b = Version.new('0.9.169')
+      assert(a > b)
+
+      a = Version.new('0.9.169.pre1')
+      b = Version.new('0.9.169.pre')
+      assert(a > b)
+
+      a = Version.new('0.9.169.pre2')
+      b = Version.new('0.9.169.pre1')
+      assert(a > b)
+    end
+
+    def test_compare_lte
+      a = Version.new('0.9.168')
+      b = Version.new('0.9.169')
+      assert(a <= b)
+      a = Version.new('0.9.169')
+      assert(a <= b)
+    end
+
+    def test_compare_gte
+      a = Version.new('0.9.169')
+      b = Version.new('0.9.168')
+      assert(a >= b)
+      b = Version.new('0.9.169')
+      assert(a >= b)
+    end
+
+  end
+end

data/lib/calabash-cucumber/wait_helpers.rb

@@ -1,15 +1,15 @@
 require 'calabash-cucumber/core'
 require 'calabash-cucumber/tests_helpers'
 require 'fileutils'
+require 'calabash-cucumber/utils/logging'
 
 module Calabash
   module Cucumber
     module WaitHelpers
+      include Calabash::Cucumber::Logging
       include Calabash::Cucumber::Core
       include Calabash::Cucumber::TestsHelpers
 
-      CLIENT_TIMEOUT_ADDITION = 5
-
       class WaitError < RuntimeError
       end
 
@@ -114,11 +114,8 @@ module Calabash
       end
 
       def wait_for_condition(options = {})
-        timeout = options[:timeout]
-        unless timeout && timeout > 0
-          timeout = 30
-        end
-        options[:query] = options[:query] || '*'
+        options[:timeout] = options[:timeout] || 30
+        options[:query] = options[:query] || "view"
         if options.has_key?(:condition)
           opt_condition = options[:condition]
           if opt_condition.is_a?(Symbol)
@@ -130,23 +127,22 @@ module Calabash
         end
         options[:condition] = options[:condition] || CALABASH_CONDITIONS[:none_animating]
         options[:post_timeout] = options[:post_timeout] || 0
-
-        retry_frequency = options[:frequency] = options[:frequency] || 0.2
-        timeout_message = options[:timeout_message] = options[:timeout_message] || "Timeout waiting (#{options[:timeout]}) for condition (#{options[:condition]})"
-        screenshot_on_error = true
-        if options.key?(:screenshot_on_error)
-          screenshot_on_error = options[:screenshot_on_error]
-        end
+        options[:frequency] = options[:frequency] || 0.3
+        retry_frequency = options[:retry_frequency] = options[:retry_frequency] || 0.3
+        options[:count] = options[:count] || 2
+        timeout_message = options[:timeout_message] = options[:timeout_message] || "Timeout waiting for condition (#{options[:condition]})"
+        screenshot_on_error = options[:screenshot_on_error] = options[:screenshot_on_error] || true
 
         begin
-          Timeout::timeout(timeout+CLIENT_TIMEOUT_ADDITION, WaitError) do
+          Timeout::timeout(options[:timeout],WaitError) do
+            loop do
               res = http({:method => :post, :path => 'condition'},
                          options)
               res = JSON.parse(res)
-              unless res['outcome'] == 'SUCCESS'
-                raise WaitError.new(res['reason'])
-              end
-              sleep(options[:post_timeout]) if options[:post_timeout] > 0
+              break if res['outcome'] == 'SUCCESS'
+              sleep(options[:retry_frequency]) if options[:retry_frequency] > 0
+            end
+            sleep(options[:post_timeout]) if options[:post_timeout] > 0
           end
         rescue WaitError => e
           msg = timeout_message || e
@@ -162,7 +158,7 @@ module Calabash
             raise wait_error(msg)
           end
         rescue Exception => e
-          handle_error_with_options(e,nil, screenshot_on_error)
+          handle_error_with_options(e,nil, options[:screenshot_on_error])
         end
       end
 

data/scripts/.irbrc

@@ -4,22 +4,27 @@ require 'irb/ext/save-history'
 require 'awesome_print'
 AwesomePrint.irb!
 
-ARGV.concat [ "--readline",
-              "--prompt-mode",
-              "simple" ]
+ARGV.concat [ '--readline',
+              '--prompt-mode',
+              'simple']
 
 # 25 entries in the list
 IRB.conf[:SAVE_HISTORY] = 50
 
 # Store results in home directory with specified file name
-IRB.conf[:HISTORY_FILE] = ".irb-history"
+IRB.conf[:HISTORY_FILE] = '.irb-history'
 
 require 'calabash-cucumber/operations'
+
+# legacy support - module was deprecated 0.9.169
+# and replaced with simulator_launcher
 require 'calabash-cucumber/launch/simulator_helper'
-SIM=Calabash::Cucumber::SimulatorHelper
+
+require 'calabash-cucumber/launch/simulator_launcher'
+SIM=Calabash::Cucumber::SimulatorLauncher.new()
 
 extend Calabash::Cucumber::Operations
 
 def embed(x,y=nil,z=nil)
-   puts "Screenshot at #{x}"
+  puts "Screenshot at #{x}"
 end

data/scripts/launch.rb

@@ -43,6 +43,6 @@ end
 at_exit do
   launcher = Calabash::Cucumber::Launcher.new
   if launcher.simulator_target?
-    Calabash::Cucumber::SimulatorHelper.stop unless launcher.calabash_no_stop?
+    launcher.simulator_launcher.stop unless launcher.calabash_no_stop?
   end
 end

data/spec/bin/calabash_ios_sim_spec.rb

@@ -0,0 +1,24 @@
+require File.expand_path(File.join(__FILE__, '..', '..', 'spec_helper'))
+require File.expand_path(File.join(__FILE__, '..', '..', '..', 'bin', 'calabash-ios-sim'))
+require 'calabash-cucumber/utils/simulator_accessibility'
+require 'calabash-cucumber/wait_helpers'
+
+include Calabash::Cucumber::WaitHelpers
+
+describe 'calabash ios sim cli' do
+
+  it 'should deprecate the sim_quit method' do
+    out = capture_stderr do
+      quit_sim
+    end
+    tokens = out.string.split("\n")
+    puts tokens
+    expect(tokens[1]).to be == "WARN: deprecated '0.9.169' - 'use Calabash::Cucumber::SimulatorAccessibility.quit_simulator'"
+  end
+
+  it 'should be able to reset the content and settings of the simulator' do
+    calabash_sim_reset
+    expect(simulator_support_sdk_dirs.count).to be == 1
+  end
+
+end

data/spec/launcher_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+require 'calabash-cucumber/launcher'
+
+describe 'Calabash Launcher' do
+
+  before(:each) do
+    @launcher = Calabash::Cucumber::Launcher.new
+  end
+
+  describe 'simulator_target? should respond correctly to DEVICE_TARGET' do
+
+    before(:each) do
+      ENV['DEVICE_TARGET'] = nil
+    end
+
+    def set_device_target(val)
+      ENV['DEVICE_TARGET'] = val
+    end
+
+    it 'should return true if DEVICE_TARGET is nil' do
+      expect(@launcher.simulator_target?).to be == false
+    end
+
+    it 'should return true if DEVICE_TARGET is simulator' do
+      set_device_target('simulator')
+      expect(@launcher.simulator_target?).to be == true
+    end
+
+    it 'should return false if DEVICE_TARGET is device' do
+      set_device_target('device')
+      expect(@launcher.simulator_target?).to be == false
+    end
+
+    it 'should return false if DEVICE_TARGET is udid' do
+      # noinspection SpellCheckingInspection
+      set_device_target('66h3hfgc466836ehcg72738eh8f322842855d2fd')
+      expect(@launcher.simulator_target?).to be == false
+    end
+
+    it 'should return true for Xcode 5.1 style simulator names' do
+      set_device_target('iPhone Retina (4-inch) - Simulator - iOS 7.1')
+      expect(@launcher.simulator_target?).to be == true
+
+      set_device_target('iPhone - Simulator - iOS 6.1')
+      expect(@launcher.simulator_target?).to be == true
+
+      set_device_target('iPad Retina (64-bit) - Simulator - iOS 7.0')
+      expect(@launcher.simulator_target?).to be == true
+    end
+
+    it 'should return true when passed a hash with :device_target => a simulator' do
+      hash = {:device_target => 'simulator'}
+      expect(@launcher.simulator_target?(hash)).to be == true
+
+      hash = {:device_target => 'iPhone Retina (4-inch) - Simulator - iOS 7.1'}
+      expect(@launcher.simulator_target?(hash)).to be == true
+    end
+
+    it 'should return false when passed a hash with :device_target != a simulator' do
+      hash = {:device_target => 'device'}
+      expect(@launcher.simulator_target?(hash)).to be == false
+
+      hash = {:device_target => '66h3hfgc466836ehcg72738eh8f322842855d2fd'}
+      expect(@launcher.simulator_target?(hash)).to be == false
+
+      hash = {:device_target => 'foobar'}
+      expect(@launcher.simulator_target?(hash)).to be == false
+    end
+
+    it 'should return false when passed a hash with no :device_target key' do
+      hash = {:foobar => 'foobar'}
+      expect(@launcher.simulator_target?(hash)).to be == false
+    end
+
+  end
+end