testautoi 0.9.127

data/lib/calabash-cucumber/cucumber.rb

@@ -0,0 +1,8 @@
+require 'calabash-cucumber/wait_helpers'
+require 'calabash-cucumber/operations'
+
+World(Calabash::Cucumber::Operations)
+
+AfterConfiguration do
+  require 'calabash-cucumber/calabash_steps'
+end

data/lib/calabash-cucumber/ibase.rb

@@ -0,0 +1,45 @@
+require 'calabash-cucumber/core'
+require 'calabash-cucumber/operations'
+
+class Calabash::IBase
+  include Calabash::Cucumber::Operations
+
+  def initialize(world)
+    @world = world
+  end
+
+  def embed(*args)
+    @world.send(:embed,*args)
+  end
+
+  def puts(*args)
+    @world.send(:puts, *args)
+  end
+
+  def trait
+    "navigationItemView marked:'#{self.title}'"
+  end
+
+  def page(clz,*args)
+    clz.new(@world,*args)
+  end
+
+  def step(s)
+
+  end
+
+  def steps(ss)
+
+  end
+
+  def await(opts={})
+    wait_for_elements_exist([trait], opts)
+    self
+  end
+
+  def await_screenshot(wait_opts={},screenshot_opts={})
+    await(wait_opts)
+    screenshot_embed(screenshot_opts)
+  end
+
+end

data/lib/calabash-cucumber/keyboard_helpers.rb

@@ -0,0 +1,124 @@
+require 'calabash-cucumber/tests_helpers'
+
+module Calabash
+  module Cucumber
+    module KeyboardHelpers
+      include Calabash::Cucumber::Core
+      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
+        if ENV['POST_ENTER_KEYBOARD']
+          w = ENV['POST_ENTER_KEYBOARD'].to_f
+          if w > 0
+            sleep(w)
+          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 await_keyboard
+        wait_for_elements_exist(["view:'UIKBKeyplaneView'"])
+        sleep(0.3)
+      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

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

@@ -0,0 +1,297 @@
+require 'sim_launcher'
+require 'json'
+require 'run_loop'
+require 'net/http'
+require 'cfpropertylist'
+
+module Calabash
+  module Cucumber
+
+    module SimulatorHelper
+
+      class TimeoutErr < RuntimeError
+      end
+
+      DERIVED_DATA = File.expand_path("~/Library/Developer/Xcode/DerivedData")
+      DEFAULT_DERIVED_DATA_INFO = File.expand_path("#{DERIVED_DATA}/*/info.plist")
+
+      DEFAULT_SIM_WAIT = 30
+
+      DEFAULT_SIM_RETRY = 2
+
+      def self.relaunch(path, sdk = nil, version = 'iphone', args = nil)
+
+        app_bundle_path = app_bundle_or_raise(path)
+        ensure_connectivity(app_bundle_path, sdk, version, args)
+
+      end
+
+      def self.stop
+        simulator = SimLauncher::Simulator.new
+        simulator.quit_simulator
+      end
+
+
+      def self.derived_data_dir_for_project
+        dir = project_dir
+        xcode_workspace_name = ''
+        info_plist = Dir.glob(DEFAULT_DERIVED_DATA_INFO).find { |plist_file|
+          begin
+            plist = CFPropertyList::List.new(:file => plist_file)
+            hash = CFPropertyList.native_types(plist.value)
+            ws_dir = File.dirname(hash['WorkspacePath']).downcase
+            p_dir = dir.downcase
+            if (p_dir.include? ws_dir)
+              xcode_workspace_name = ws_dir.split('/').last
+            end
+            ws_dir == p_dir
+          rescue
+            false
+          end
+        }
+
+        if not info_plist.nil?
+          return File.dirname(info_plist)
+        else
+          res = Dir.glob("#{dir}/*.xcodeproj")
+          if res.empty?
+            raise "Unable to find *.xcodeproj in #{dir}"
+          elsif res.count > 1
+            raise "Unable to found several *.xcodeproj in #{dir}: #{res}"
+          end
+
+          xcode_proj_name = res.first.split(".xcodeproj")[0]
+
+          xcode_proj_name = File.basename(xcode_proj_name)
+
+          build_dirs = Dir.glob("#{DERIVED_DATA}/*").find_all do |xc_proj|
+            File.basename(xc_proj).start_with?(xcode_proj_name)
+          end
+
+          if (build_dirs.count == 0 && !xcode_workspace_name.empty?)
+            # check for directory named "workspace-{deriveddirectoryrandomcharacters}"
+            build_dirs = Dir.glob("#{DERIVED_DATA}/*").find_all do |xc_proj|
+              File.basename(xc_proj).downcase.start_with?(xcode_workspace_name)
+            end
+          end
+
+          if (build_dirs.count == 0)
+            msg = ["Unable to find your built app."]
+            msg << "This means that Calabash can't automatically launch iOS simulator."
+            msg << "Searched in Xcode 4.x default: #{DEFAULT_DERIVED_DATA_INFO}"
+            msg << ""
+            msg << "To fix there are a couple of options:\n"
+            msg << "Option 1) Make sure you are running this command from your project directory, "
+            msg << "i.e., the directory containing your .xcodeproj file."
+            msg << "In Xcode, build your calabash target for simulator."
+            msg << "Check that your app can be found in\n #{File.expand_path("~/Library/Developer/Xcode/DerivedData")}"
+            msg << "\n\nOption 2). In features/support/launch.rb set APP_BUNDLE_PATH to"
+            msg << "the path where Xcode has built your Calabash target."
+            msg << "Alternatively you can use the environment variable APP_BUNDLE_PATH.\n"
+            raise msg.join("\n")
+
+          elsif (build_dirs.count > 1)
+            msg = ["Unable to auto detect APP_BUNDLE_PATH."]
+            msg << "You have several projects with the same name: #{xcode_proj_name} in #{DERIVED_DATA}:\n"
+            msg << build_dirs.join("\n")
+
+            msg << "\nThis means that Calabash can't automatically launch iOS simulator."
+            msg << "Searched in Xcode 4.x default: #{DEFAULT_DERIVED_DATA_INFO}"
+            msg << "\nIn features/support/launch.rb set APP_BUNDLE_PATH to"
+            msg << "the path where Xcode has built your Calabash target."
+            msg << "Alternatively you can use the environment variable APP_BUNDLE_PATH.\n"
+            raise msg.join("\n")
+          else
+            puts "Found potential build dir: #{build_dirs.first}"
+            puts "Checking..."
+            return build_dirs.first
+          end
+        end
+      end
+
+      def self.project_dir
+        File.expand_path(ENV['PROJECT_DIR'] || Dir.pwd)
+      end
+
+      def self.app_bundle_or_raise(path)
+        bundle_path = nil
+        path = File.expand_path(path) if path
+
+        if path and not File.directory?(path)
+          puts "Unable to find .app bundle at #{path}. It should be an .app directory."
+          dd_dir = derived_data_dir_for_project
+          app_bundles = Dir.glob(File.join(dd_dir, "Build", "Products", "*", "*.app"))
+          msg = "Try setting APP_BUNDLE_PATH in features/support/launch.rb to one of:\n\n"
+          msg << app_bundles.join("\n")
+          raise msg
+        elsif path
+          bundle_path = path
+        else
+          dd_dir = derived_data_dir_for_project
+          sim_dirs = Dir.glob(File.join(dd_dir, "Build", "Products", "*-iphonesimulator", "*.app"))
+          if sim_dirs.empty?
+            msg = ["Unable to auto detect APP_BUNDLE_PATH."]
+            msg << "Have you built your app for simulator?."
+            msg << "Searched dir: #{dd_dir}/Build/Products"
+            msg << "Please build your app from Xcode"
+            msg << "You should build the -cal target."
+            msg << ""
+            msg << "Alternatively, specify APP_BUNDLE_PATH in features/support/launch.rb"
+            msg << "This should point to the location of your built app linked with calabash.\n"
+            raise msg.join("\n")
+          end
+          preferred_dir = find_preferred_dir(sim_dirs)
+          if preferred_dir.nil?
+            msg = ["Error... Unable to find APP_BUNDLE_PATH."]
+            msg << "Cannot find a built app that is linked with calabash.framework"
+            msg << "Please build your app from Xcode"
+            msg << "You should build your calabash target."
+            msg << ""
+            msg << "Alternatively, specify APP_BUNDLE_PATH in features/support/launch.rb"
+            msg << "This should point to the location of your built app linked with calabash.\n"
+            raise msg.join("\n")
+          end
+          puts("-"*37)
+          puts "Auto detected APP_BUNDLE_PATH:\n\n"
+
+          puts "APP_BUNDLE_PATH=#{preferred_dir || sim_dirs[0]}\n\n"
+          puts "Please verify!"
+          puts "If this is wrong please set it as APP_BUNDLE_PATH in features/support/launch.rb\n"
+          puts("-"*37)
+          bundle_path = sim_dirs[0]
+        end
+        bundle_path
+      end
+
+      def self.find_preferred_dir(sim_dirs)
+        sim_dirs.find do |d|
+          out = `otool "#{File.expand_path(d)}"/* -o 2> /dev/null | grep CalabashServer`
+          /CalabashServer/.match(out)
+        end
+      end
+
+      def self.ensure_connectivity(app_bundle_path, sdk, version, args = nil)
+        begin
+          max_retry_count = (ENV['MAX_CONNECT_RETRY'] || DEFAULT_SIM_RETRY).to_i
+          timeout = (ENV['CONNECT_TIMEOUT'] || DEFAULT_SIM_WAIT).to_i
+          retry_count = 0
+          connected = false
+          puts "Waiting at most #{timeout} seconds for simulator (CONNECT_TIMEOUT)"
+          puts "Retrying at most #{max_retry_count} times (MAX_CONNECT_RETRY)"
+          until connected do
+            raise "MAX_RETRIES" if retry_count == max_retry_count
+            retry_count += 1
+            puts "(#{retry_count}.) Start Simulator #{sdk}, #{version}, for #{app_bundle_path}"
+            begin
+              Timeout::timeout(timeout, TimeoutErr) do
+                simulator = launch(app_bundle_path, sdk, version, args)
+                until connected
+                  begin
+                    connected = (ping_app == '405')
+                    if ENV['POST_START_BREAK']
+                      puts "Environment var POST_START_BREAK is deprecated and should no longer be necessary."
+                      post_connect_sleep = (ENV['POST_START_BREAK'] || "2").to_f
+                      sleep(post_connect_sleep) unless post_connect_sleep <= 0
+                    end
+                    if connected
+                      server_version = get_version
+                      if server_version
+                        p server_version
+                        unless version_check(server_version)
+                          msgs = ["You're running an older version of Calabash server with a newer client",
+                                  "Client:#{Calabash::Cucumber::VERSION}",
+                                  "Server:#{server_version}",
+                                  "Minimum server version #{Calabash::Cucumber::FRAMEWORK_VERSION}",
+                                  "Update recommended:",
+                                  "https://github.com/calabash/calabash-ios/wiki/B1-Updating-your-Calabash-iOS-version"
+                          ]
+                          raise msgs.join("\n")
+                        end
+                      else
+                        connected = false
+                      end
+                    end
+                  rescue Exception => e
+
+                  ensure
+                    sleep 1 unless connected
+                  end
+                end
+              end
+            rescue TimeoutErr => e
+              puts "Timed out..."
+            end
+          end
+        rescue e
+          p e
+          msg = "Unable to make connection to Calabash Server at #{ENV['DEVICE_ENDPOINT']|| "http://localhost:37265/"}\n"
+          msg << "Make sure you've' linked correctly with calabash.framework and set Other Linker Flags.\n"
+          msg << "Make sure you don't have a firewall blocking traffic to #{ENV['DEVICE_ENDPOINT']|| "http://localhost:37265/"}.\n"
+          raise msg
+        end
+      end
+
+
+      def self.launch(app_bundle_path, sdk, version, args = nil)
+        simulator = SimLauncher::Simulator.new
+        simulator.quit_simulator
+        simulator.launch_ios_app(app_bundle_path, sdk, version) #, args wait for update to sim launcher
+        simulator
+      end
+
+      def self.ping_app
+        url = URI.parse(ENV['DEVICE_ENDPOINT']|| "http://localhost:37265/")
+        puts "Ping #{url}..."
+        http = Net::HTTP.new(url.host, url.port)
+        res = http.start do |sess|
+          sess.request Net::HTTP::Get.new url.path
+        end
+        status = res.code
+        begin
+          http.finish if http and http.started?
+        rescue
+
+        end
+        status
+      end
+
+      def self.get_version
+        endpoint = ENV['DEVICE_ENDPOINT']|| "http://localhost:37265"
+        endpoint += "/" unless endpoint.end_with? "/"
+        url = URI.parse("#{endpoint}version")
+
+        puts "Fetch version #{url}..."
+        begin
+          body = Net::HTTP.get_response(url).body
+          res = JSON.parse(body)
+          if res['iOS_version']
+            @ios_version = res['iOS_version']
+          end
+          res
+        rescue
+          nil
+        end
+      end
+
+      def self.ios_version
+        unless @ios_version
+          get_version
+        end
+        @ios_version
+      end
+
+      def self.ios_major_version
+        v = ios_version
+        if v
+          v.split(".")[0]
+        end
+      end
+
+      def self.version_check(version)
+        server_version = version["version"]
+        Calabash::Cucumber::FRAMEWORK_VERSION == server_version
+      end
+    end
+
+  end
+end