iCuke 0.6.3 → 0.6.4

data/lib/icuke/sdk.rb

@@ -6,7 +6,7 @@ module ICuke
     
     def self.all
       @all ||= begin
-        `xcodebuild -showsdks`.grep(/iphonesimulator/).map do |s|
+        `xcodebuild -showsdks`.split(/\n/).grep(/iphonesimulator/).map do |s|
           s.sub(/.* iphonesimulator([0-9.]+).*/, '\1').chomp
         end.sort
       end
@@ -83,14 +83,10 @@ module ICuke
     end
     
     def self.dylib(name = 'libicuke')
-      require_sdk
-      
-      "#{name}-sdk#{minor_version}.dylib"
+      "#{name}.dylib"
     end
     
     def self.dylib_fullpath(name = 'libicuke')
-      require_sdk
-      
       File.join(ICUKE_EXT_DIR, dylib(name))
     end
     
@@ -98,26 +94,22 @@ module ICuke
       ICUKE_EXT_DIR
     end
     
-    def self.sdk_ext_dir
-      File.join(ext_dir, "sdk#{minor_version}")
-    end
-    
     def self.cflags
-      "#{CFLAGS} -isysroot #{root} -F/System/Library/PrivateFrameworks -D__IPHONE_OS_VERSION_MIN_REQUIRED=#{major_version == '3.1' ? '30000' : '40000'}"
+      "#{CFLAGS} -isysroot #{root} -F/System/Library/PrivateFrameworks -D__IPHONE_OS_VERSION_MIN_REQUIRED=30000"
     end
     
     def self.gcc
       if major_version == '4'
         abi_flags = "-fobjc-abi-version=2 -fobjc-legacy-dispatch"
       end
-      "xcrun -sdk #{fullname} gcc -I. -I#{sdk_ext_dir} -I#{sdk_ext_dir}/json #{cflags} -x objective-c #{abi_flags}"
+      "xcrun -sdk #{fullname} gcc -I. -I#{ext_dir} -I#{ext_dir}/json #{cflags} -x objective-c #{abi_flags}"
     end
     
     def self.ld
       if major_version == '4'
         abi_flags = "-Xlinker -objc_abi_version -Xlinker 2"
       end
-      "xcrun -sdk #{fullname} gcc -I. -I#{sdk_ext_dir} -I#{sdk_ext_dir}/json #{cflags} #{abi_flags}"
+      "xcrun -sdk #{fullname} gcc -I. -I#{ext_dir} -I#{ext_dir}/json #{cflags} #{abi_flags}"
     end
     
     def self.launch(application, family, environment = {})

data/lib/icuke/simulator_driver.rb

@@ -0,0 +1,201 @@
+require 'icuke/simulator'
+require 'icuke/simulate'
+require 'icuke/screen'
+require 'icuke/configuration'
+
+module ICuke
+  class SimulatorDriver
+  
+    DSL_METHODS = [:launch, :quit, :suspend, :resume, :screen,
+                 :response, :record, :tap, :swipe, :drag,
+                 :drag_with_source, :drag_slider_to, 
+                 :drag_slider_to_percentage, :type, :scroll_to,
+                 :scroll, :set_application_defaults]
+   
+    include ICuke::Simulate::Gestures
+    
+    def initialize(simulator, configuration)
+      @simulator = simulator
+      @configuration = configuration
+    end
+    
+    def self.default_driver(configuration)
+      new(ICuke::Simulator.new, configuration)
+    end
+    
+    def launch(application, options = {})
+      default_options = {:build_configuration => configuration[:build_configuration]}
+      process = ICuke::Simulator::Process.new(application, default_options.merge(options))
+      @simulator.launch(process)
+    end
+
+    def quit
+      @simulator.quit
+    end
+
+    def suspend
+      @simulator.suspend
+    end
+
+    def resume
+      @simulator.resume
+    end
+
+    def screen
+      @screen ||= Screen.new(response)
+    end
+
+    def response
+      @response ||= @simulator.view
+    end
+
+    def record
+      @simulator.record
+    end
+
+    def tap(label, options = {}, &block)
+      options = {
+        :pause => true
+      }.merge(options)
+
+      element = screen.first_tappable_element(label)
+      x, y = screen.element_center(element)
+
+      @simulator.fire_event(Tap.new(x, y, options))
+
+      sleep(options[:pause] ? 2 : 0.2)
+
+      refresh
+
+      yield element if block_given?
+    end
+
+    def swipe(direction, options = {})
+      x, y, x2, y2 = screen.swipe_coordinates(direction)
+      @simulator.fire_event(Swipe.new(x, y, x2, y2, 0.015, options))
+      sleep(1)
+      refresh
+    end
+
+    def drag(source_x, source_y, dest_x, dest_y, options = {})
+      @simulator.fire_event(Drag.new(source_x, source_y, dest_x, dest_y, 0.15, options))
+      sleep(1)
+      refresh
+    end
+
+    def drag_with_source(source, destination)
+      sources = source.split(',').collect {|val| val.strip.to_i}
+      destinations = destination.split(',').collect {|val| val.strip.to_i}
+      drag(sources[0], sources[1], destinations[0], destinations[1])
+    end
+
+    def drag_slider_to(label, direction, distance)
+      element = screen.first_slider_element(label)
+      x, y = screen.find_slider_button(element)
+
+      dest_x, dest_y = x, y
+      modifier = direction_modifier(direction)
+
+      if [:up, :down].include?(direction)
+        dest_y += modifier * distance
+      else
+        dest_x += modifier * distance
+      end
+
+      drag(x, y, dest_x, dest_y)
+    end
+
+    def drag_slider_to_percentage(label, percentage)
+      element = screen.first_slider_element(label)
+      x, y = screen.find_slider_button(element)
+      dest_x, dest_y = screen.find_slider_percentage_location(element, percentage)
+      drag(x, y, dest_x, dest_y)
+    end
+
+    def type(textfield, text, options = {})
+      tap(textfield, :hold_for => 0.75) do |field|
+        if field['value']
+          tap('Select All')
+          tap('Delete')
+        end
+      end
+
+      # Without this sleep fields which have auto-capitilisation/correction can
+      # miss the first keystroke for some reason.
+      sleep(0.5)
+
+      text.split('').each do |c|
+        begin
+          tap(c == ' ' ? 'space' : c, :pause => false)
+        rescue Exception => e
+          try_keyboards =
+            case c
+            when /[a-zA-Z]/
+              ['more, letters', 'shift']
+            when /[0-9]/
+              ['more, numbers']
+            else
+              ['more, numbers', 'more, symbols']
+            end
+          until try_keyboards.empty?
+            begin
+              tap(try_keyboards.shift, :pause => false)
+              retry
+            rescue
+            end
+          end
+          raise e
+        end
+      end
+
+      # From UIReturnKeyType
+      # Should probably sort these in rough order of likelyhood?
+      return_keys = ['return', 'go', 'google', 'join', 'next', 'route', 'search', 'send', 'yahoo', 'done', 'emergency call']
+      return_keys.each do |key|
+        begin
+          tap(key)
+          return
+        rescue
+        end
+      end
+    end
+
+    def scroll_to(text, options = {})
+      x, y, x2, y2 = screen.swipe_coordinates(swipe_direction(options[:direction]))
+      previous_response = response.dup
+      until screen.visible?(text) do
+        @simulator.fire_event(Swipe.new(x, y, x2, y2, 0.15, options))
+        refresh
+        raise %Q{Content "#{text}" not found in: #{screen}} if response == previous_response
+      end
+    end
+
+    def scroll(direction)
+      swipe(swipe_direction(direction))
+    end
+
+    def set_application_defaults(defaults)
+      @simulator.set_defaults(defaults)
+    end
+    
+    def refresh
+      @response = nil
+      @screen = nil
+    end
+
+    private
+
+    def swipe_direction(direction)
+      swipe_directions = { :up => :down, :down => :up, :left => :right, :right => :left }
+      swipe_directions[direction]
+    end
+
+    def direction_modifier(direction)
+      [:up, :left].include?(direction) ? -1 : 1
+    end
+    
+    def configuration
+      @configuration
+    end
+  end
+end

data/lib/icuke/waxsim.rb

@@ -6,14 +6,19 @@ module ICuke
     include Timeout
     
     attr_accessor :current_process
-    
+
     def launch(process)
-      process = process.with_options({
-        :configuration => 'Debug',
+      process = process.with_launch_options({
         :env => {
           'CFFIXED_USER_HOME' => Dir.mktmpdir
         }
       })
+
+      process.setup_commands.each do |cmd|
+        fail "Unable to run setup command #{cmd}" if !system(cmd)
+        fail "Setup command #{cmd} failed with exit status #{$?}" if $? != 0
+      end
+
       @simulator = BackgroundProcess.run(process.command)
       self.current_process = process
 
@@ -28,6 +33,7 @@ module ICuke
     end
     
     def quit
+      return unless @simulator
       get '/quit' rescue nil # results in a hard exit(0)
       @simulator.wait
       self.current_process = nil
@@ -44,28 +50,60 @@ module ICuke
     end
     
     class Process
+      DEFAULT_CONFIGURATION = 'Debug'
+
+      attr_reader :launch_options
+      
       def initialize(project_file, launch_options = {})
         @project_file = project_file
         @launch_options = launch_options
       end
       
       # returns a new Process, treat Process as an immutable value object
-      def with_options(options = {})
-        self.class.new(@project_file, options.merge(@launch_options))
+      def with_launch_options(options = {})
+        self.class.new(@project_file, @launch_options.deep_merge(options))
+      end
+
+      def setup_commands
+        cmds = []
+        cmds << simulate_device_command if @launch_options.has_key?(:retina)
+        cmds
       end
       
       def command
-        ICuke::SDK.launch("#{directory}/#{app_name}.app", @launch_options[:platform], @launch_options[:env])
+        ICuke::SDK.launch("#{directory}/#{target}.app", @launch_options[:platform], @launch_options[:env])
       end
       
       private
+
+      def simulate_device_command
+        "defaults write com.apple.iphonesimulator SimulateDevice '\"#{simulate_device}\"'"
+      end
+
+      def simulate_device
+        case @launch_options[:platform]
+        when :ipad
+          "iPad"
+        else
+          "iPhone"
+        end +
+        if @launch_options[:retina]
+          " (Retina)"
+        else
+          ""
+        end
+      end
+      
+      def target
+        @launch_options[:target] || File.basename(@project_file, '.xcodeproj')
+      end
       
-      def app_name
-        File.basename(@project_file, '.xcodeproj')
+      def build_configuration
+        @launch_options[:build_configuration] || DEFAULT_CONFIGURATION
       end
       
       def directory
-        "#{File.dirname(@project_file)}/build/#{@launch_options[:configuration]}-iphonesimulator"
+        "#{File.dirname(@project_file)}/build/#{build_configuration}-iphonesimulator"
       end
     end
   end

data/spec/cucumber_spec.rb

@@ -0,0 +1,130 @@
+require 'spec/spec_helper'
+require 'icuke'
+require 'cucumber/step_mother'
+require 'icuke/cucumber'
+require 'icuke/simulate'
+
+describe ICukeWorld do
+
+  before(:each) do
+    @simulator = []
+    @simulator.stub(:view)
+    @simulator.stub(:fire_event)
+    @cuke_world = ICuke::SimulatorDriver.new @simulator, ICuke::Configuration.new({
+      :build_configuration => 'Debug'
+    })
+    @cuke_world.stub!(:sleep)
+
+    xml = File.read('spec/fixtures/controls_page.xml')
+    @cuke_world.stub(:response).and_return(xml)
+
+  end
+
+  context "when performing a swipe" do
+
+    before(:each) do
+      @simulator.should_receive(:fire_event)
+    end
+    
+    it "should begin swipe at center of screen" do
+      center_x, center_y = 160, 240
+      ICuke::Simulate::Gestures::Swipe.should_receive(:new).
+        with(center_x, center_y, 160, 480, 0.015, {})
+      @cuke_world.swipe(:down)
+    end
+
+    it "should swipe to the bottom of the screen when swiping down" do
+      bottom_y = 480
+      ICuke::Simulate::Gestures::Swipe.should_receive(:new).
+        with(160, 240, 160, bottom_y, 0.015, {})
+      @cuke_world.swipe(:down)
+    end
+
+    it "should swipe to the top of the screen when swiping up" do
+      top_y = 0
+      ICuke::Simulate::Gestures::Swipe.should_receive(:new).
+        with(160, 240, 160, top_y, 0.015, {})
+      @cuke_world.swipe(:up)
+    end
+
+    it "should swipe to the left of the screen when swipping left" do
+      min_x = 0
+      ICuke::Simulate::Gestures::Swipe.should_receive(:new).
+        with(160, 240, min_x, 240, 0.015, {})
+      @cuke_world.swipe(:left)
+    end
+
+    it "should swipe to the right of the screen when swipping right" do
+      max_x = 320
+      ICuke::Simulate::Gestures::Swipe.should_receive(:new).
+        with(160, 240, max_x, 240, 0.015, {})
+      @cuke_world.swipe(:right)
+    end
+    
+  end
+  
+  context "when performing a drag" do
+
+    it "should fire an event" do
+      @simulator.should_receive(:fire_event)
+      @cuke_world.drag(1,2,3,4,{})
+    end
+
+    it "should simulate a swipe from source to destination" do
+      sx, sy, dx, dy = 10, 20, 30, 40
+      ICuke::Simulate::Gestures::Drag.should_receive(:new).
+        with(sx, sy, dx, dy, 0.15, {})
+      @cuke_world.drag(sx, sy, dx, dy, {})
+    end
+
+  end
+  
+  context "when performing a drag with a source" do
+
+    it "should parse the input values" do
+      ICuke::Simulate::Gestures::Drag.should_receive(:new).
+        with(12, 24, 34, 44, 0.15, {})
+      @cuke_world.drag_with_source("12,24", "34,44")
+    end
+    
+  end
+
+  context "when draging a slider" do
+    
+    before(:each) do
+      @screen = []
+      @screen.should_receive(:first_slider_element).at_least(:once)
+      @screen.should_receive(:find_slider_button).at_least(:once).and_return([244, 287])
+      Screen.should_receive(:new).at_least(:once).and_return(@screen)
+    end
+
+    it "should set the destination properly" do
+      {:up=>[244,267], :down=>[244,307], :right=>[264,287], :left=>[224,287]}.each do |d|
+        ICuke::Simulate::Gestures::Drag.should_receive(:new).
+          with(244, 287, d[1][0], d[1][1], 0.15, {})
+        @cuke_world.drag_slider_to('Label', d[0], 20)
+      end
+    end
+
+  end
+
+  context "when draging a slider to a percentage value" do
+    
+    before(:each) do
+      @element = []
+      @screen = []
+      @screen.should_receive(:first_slider_element).and_return(@element)
+      @screen.should_receive(:find_slider_button).and_return([244, 287])
+      Screen.should_receive(:new).and_return(@screen)
+    end
+
+    it "should identify the destination on the screen" do
+      @screen.should_receive(:find_slider_percentage_location).with(@element, 30).
+        and_return([230, 287])
+      ICuke::Simulate::Gestures::Drag.should_receive(:new).
+        with(244, 287, 230, 287, 0.15, {})
+      @cuke_world.drag_slider_to_percentage("label", 30)
+    end
+    
+  end
+end