iCuke 0.4.5

data/ext/iCuke/json/SBJsonWriter.m

@@ -0,0 +1,228 @@
+/*
+ Copyright (C) 2009 Stig Brautaset. All rights reserved.
+ 
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+ 
+ * Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+ 
+ * Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+ 
+ * Neither the name of the author nor the names of its contributors may be used
+   to endorse or promote products derived from this software without specific
+   prior written permission.
+ 
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+ FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#import "SBJsonWriter.h"
+
+@interface SBJsonWriter ()
+
+- (BOOL)appendValue:(id)fragment into:(NSMutableString*)json;
+- (BOOL)appendArray:(NSArray*)fragment into:(NSMutableString*)json;
+- (BOOL)appendDictionary:(NSDictionary*)fragment into:(NSMutableString*)json;
+- (BOOL)appendString:(NSString*)fragment into:(NSMutableString*)json;
+
+- (NSString*)indent;
+
+@end
+
+@implementation SBJsonWriter
+
+@synthesize sortKeys;
+@synthesize humanReadable;
+
+/**
+ @deprecated This exists in order to provide fragment support in older APIs in one more version.
+ It should be removed in the next major version.
+ */
+- (NSString*)stringWithFragment:(id)value {
+    [self clearErrorTrace];
+    depth = 0;
+    NSMutableString *json = [NSMutableString stringWithCapacity:128];
+    
+    if ([self appendValue:value into:json])
+        return json;
+    
+    return nil;
+}
+
+
+- (NSString*)stringWithObject:(id)value {
+    
+    if ([value isKindOfClass:[NSDictionary class]] || [value isKindOfClass:[NSArray class]]) {
+        return [self stringWithFragment:value];
+    }
+
+    [self clearErrorTrace];
+    [self addErrorWithCode:EFRAGMENT description:@"Not valid type for JSON"];
+    return nil;
+}
+
+
+- (NSString*)indent {
+    return [@"\n" stringByPaddingToLength:1 + 2 * depth withString:@" " startingAtIndex:0];
+}
+
+- (BOOL)appendValue:(id)fragment into:(NSMutableString*)json {
+    if ([fragment isKindOfClass:[NSDictionary class]]) {
+        if (![self appendDictionary:fragment into:json])
+            return NO;
+        
+    } else if ([fragment isKindOfClass:[NSArray class]]) {
+        if (![self appendArray:fragment into:json])
+            return NO;
+        
+    } else if ([fragment isKindOfClass:[NSString class]]) {
+        if (![self appendString:fragment into:json])
+            return NO;
+        
+    } else if ([fragment isKindOfClass:[NSNumber class]]) {
+        if ('c' == *[fragment objCType])
+            [json appendString:[fragment boolValue] ? @"true" : @"false"];
+        else
+            [json appendString:[fragment stringValue]];
+        
+    } else if ([fragment isKindOfClass:[NSNull class]]) {
+        [json appendString:@"null"];
+    } else if ([fragment respondsToSelector:@selector(proxyForJson)]) {
+        [self appendValue:[fragment proxyForJson] into:json];
+        
+    } else {
+        [self addErrorWithCode:EUNSUPPORTED description:[NSString stringWithFormat:@"JSON serialisation not supported for %@", [fragment class]]];
+        return NO;
+    }
+    return YES;
+}
+
+- (BOOL)appendArray:(NSArray*)fragment into:(NSMutableString*)json {
+    if (maxDepth && ++depth > maxDepth) {
+        [self addErrorWithCode:EDEPTH description: @"Nested too deep"];
+        return NO;
+    }
+    [json appendString:@"["];
+    
+    BOOL addComma = NO;    
+    for (id value in fragment) {
+        if (addComma)
+            [json appendString:@","];
+        else
+            addComma = YES;
+        
+        if ([self humanReadable])
+            [json appendString:[self indent]];
+        
+        if (![self appendValue:value into:json]) {
+            return NO;
+        }
+    }
+    
+    depth--;
+    if ([self humanReadable] && [fragment count])
+        [json appendString:[self indent]];
+    [json appendString:@"]"];
+    return YES;
+}
+
+- (BOOL)appendDictionary:(NSDictionary*)fragment into:(NSMutableString*)json {
+    if (maxDepth && ++depth > maxDepth) {
+        [self addErrorWithCode:EDEPTH description: @"Nested too deep"];
+        return NO;
+    }
+    [json appendString:@"{"];
+    
+    NSString *colon = [self humanReadable] ? @" : " : @":";
+    BOOL addComma = NO;
+    NSArray *keys = [fragment allKeys];
+    if (self.sortKeys)
+        keys = [keys sortedArrayUsingSelector:@selector(compare:)];
+    
+    for (id value in keys) {
+        if (addComma)
+            [json appendString:@","];
+        else
+            addComma = YES;
+        
+        if ([self humanReadable])
+            [json appendString:[self indent]];
+        
+        if (![value isKindOfClass:[NSString class]]) {
+            [self addErrorWithCode:EUNSUPPORTED description: @"JSON object key must be string"];
+            return NO;
+        }
+        
+        if (![self appendString:value into:json])
+            return NO;
+        
+        [json appendString:colon];
+        if (![self appendValue:[fragment objectForKey:value] into:json]) {
+            [self addErrorWithCode:EUNSUPPORTED description:[NSString stringWithFormat:@"Unsupported value for key %@ in object", value]];
+            return NO;
+        }
+    }
+    
+    depth--;
+    if ([self humanReadable] && [fragment count])
+        [json appendString:[self indent]];
+    [json appendString:@"}"];
+    return YES;    
+}
+
+- (BOOL)appendString:(NSString*)fragment into:(NSMutableString*)json {
+    
+    static NSMutableCharacterSet *kEscapeChars;
+    if( ! kEscapeChars ) {
+        kEscapeChars = [[NSMutableCharacterSet characterSetWithRange: NSMakeRange(0,32)] retain];
+        [kEscapeChars addCharactersInString: @"\"\\"];
+    }
+    
+    [json appendString:@"\""];
+    
+    NSRange esc = [fragment rangeOfCharacterFromSet:kEscapeChars];
+    if ( !esc.length ) {
+        // No special chars -- can just add the raw string:
+        [json appendString:fragment];
+        
+    } else {
+        NSUInteger length = [fragment length];
+        for (NSUInteger i = 0; i < length; i++) {
+            unichar uc = [fragment characterAtIndex:i];
+            switch (uc) {
+                case '"':   [json appendString:@"\\\""];       break;
+                case '\\':  [json appendString:@"\\\\"];       break;
+                case '\t':  [json appendString:@"\\t"];        break;
+                case '\n':  [json appendString:@"\\n"];        break;
+                case '\r':  [json appendString:@"\\r"];        break;
+                case '\b':  [json appendString:@"\\b"];        break;
+                case '\f':  [json appendString:@"\\f"];        break;
+                default:    
+                    if (uc < 0x20) {
+                        [json appendFormat:@"\\u%04x", uc];
+                    } else {
+                        CFStringAppendCharacters((CFMutableStringRef)json, &uc, 1);
+                    }
+                    break;
+                    
+            }
+        }
+    }
+    
+    [json appendString:@"\""];
+    return YES;
+}
+
+
+@end

data/features/icuke.feature

@@ -0,0 +1,17 @@
+Feature: Developer tests an application
+  In order to test my application
+  As a developer
+  I want to use some shiney cucumber steps
+  
+  Background:
+    Given "iCuke" from "app/iCuke/iCuke.xcodeproj" is loaded in the simulator
+  
+  Scenario: Press buttons and see stuff
+    Then I should see "iCuke"
+    When I tap "About"
+    Then I should see "About"
+    When I tap "Done"
+    Then I should see "iCuke"
+
+  Scenario: Type into a textfield
+    Then I type "fOo@Oo !# 54 x" in "Input"

data/features/support/env.rb

@@ -0,0 +1,3 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../../lib')
+
+require 'icuke/cucumber'

data/iCuke.gemspec

@@ -0,0 +1,113 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{iCuke}
+  s.version = "0.4.5"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Rob Holland"]
+  s.date = %q{2010-04-21}
+  s.description = %q{Cucumber support for iPhone applications}
+  s.email = %q{rob@the-it-refinery.co.uk}
+  s.extensions = ["ext/iCuke/Rakefile"]
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".gitignore",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "app/iCuke/.gitignore",
+     "app/iCuke/Classes/FlipsideView.h",
+     "app/iCuke/Classes/FlipsideView.m",
+     "app/iCuke/Classes/FlipsideViewController.h",
+     "app/iCuke/Classes/FlipsideViewController.m",
+     "app/iCuke/Classes/MainView.h",
+     "app/iCuke/Classes/MainView.m",
+     "app/iCuke/Classes/MainViewController.h",
+     "app/iCuke/Classes/MainViewController.m",
+     "app/iCuke/Classes/iCukeAppDelegate.h",
+     "app/iCuke/Classes/iCukeAppDelegate.m",
+     "app/iCuke/FlipsideView.xib",
+     "app/iCuke/MainView.xib",
+     "app/iCuke/MainWindow.xib",
+     "app/iCuke/SniffingView.h",
+     "app/iCuke/SniffingView.m",
+     "app/iCuke/iCuke-Info.plist",
+     "app/iCuke/iCuke.xcodeproj/project.pbxproj",
+     "app/iCuke/iCuke_Prefix.pch",
+     "app/iCuke/main.m",
+     "ext/iCuke/.gitignore",
+     "ext/iCuke/DefaultsResponse.h",
+     "ext/iCuke/DefaultsResponse.m",
+     "ext/iCuke/EventResponse.h",
+     "ext/iCuke/EventResponse.m",
+     "ext/iCuke/Rakefile",
+     "ext/iCuke/Recorder.h",
+     "ext/iCuke/Recorder.m",
+     "ext/iCuke/RecorderResponse.h",
+     "ext/iCuke/RecorderResponse.m",
+     "ext/iCuke/SynthesizeSingleton.h",
+     "ext/iCuke/ViewResponse.h",
+     "ext/iCuke/ViewResponse.m",
+     "ext/iCuke/Viewer.h",
+     "ext/iCuke/Viewer.m",
+     "ext/iCuke/iCukeHTTPResponseHandler.h",
+     "ext/iCuke/iCukeHTTPResponseHandler.m",
+     "ext/iCuke/iCukeHTTPServer.h",
+     "ext/iCuke/iCukeHTTPServer.m",
+     "ext/iCuke/iCukeServer.h",
+     "ext/iCuke/iCukeServer.m",
+     "ext/iCuke/json/JSON.h",
+     "ext/iCuke/json/NSObject+SBJSON.h",
+     "ext/iCuke/json/NSObject+SBJSON.m",
+     "ext/iCuke/json/NSString+SBJSON.h",
+     "ext/iCuke/json/NSString+SBJSON.m",
+     "ext/iCuke/json/SBJSON.h",
+     "ext/iCuke/json/SBJSON.m",
+     "ext/iCuke/json/SBJsonBase.h",
+     "ext/iCuke/json/SBJsonBase.m",
+     "ext/iCuke/json/SBJsonParser.h",
+     "ext/iCuke/json/SBJsonParser.m",
+     "ext/iCuke/json/SBJsonWriter.h",
+     "ext/iCuke/json/SBJsonWriter.m",
+     "features/icuke.feature",
+     "features/support/env.rb",
+     "iCuke.gemspec",
+     "lib/icuke.rb",
+     "lib/icuke/cucumber.rb",
+     "lib/icuke/simulate.rb",
+     "lib/icuke/simulator.rb"
+  ]
+  s.homepage = %q{http://github.com/unboxed/iCuke}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.6}
+  s.summary = %q{Cucumber support for iPhone applications}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<cucumber>, [">= 0"])
+      s.add_runtime_dependency(%q<rb-appscript>, [">= 0"])
+      s.add_runtime_dependency(%q<httparty>, [">= 0"])
+    else
+      s.add_dependency(%q<cucumber>, [">= 0"])
+      s.add_dependency(%q<rb-appscript>, [">= 0"])
+      s.add_dependency(%q<httparty>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<cucumber>, [">= 0"])
+    s.add_dependency(%q<rb-appscript>, [">= 0"])
+    s.add_dependency(%q<httparty>, [">= 0"])
+  end
+end
+

data/lib/icuke/cucumber.rb

@@ -0,0 +1,211 @@
+require 'nokogiri'
+
+require 'icuke/simulator'
+require 'icuke/simulate'
+
+class ICukeWorld
+  include ICuke::Simulate::Gestures
+  
+  attr_reader :response
+  
+  def initialize
+    @simulator = ICuke::Simulator.new
+  end
+  
+  def launch(application, options = {})
+    @simulator.launch(application, options)
+  end
+  
+  def quit
+    @simulator.quit
+  end
+  
+  def page
+    @xml ||= Nokogiri::XML::Document.parse(response).root
+  end
+  
+  def response
+    @response ||= @simulator.view
+  end
+  
+  def record
+    @simulator.record
+  end
+  
+  def can_see?(text)
+    page.xpath(%Q{//*[contains(., "#{text}") or contains(@label, "#{text}") or contains(@value, "#{text}")]}).any?
+  end
+  
+  def onscreen?(x, y)
+    return x >= 0 && y >= 0 && x < 320 && y < 480
+  end
+  
+  def tap(label, options = {}, &block)
+    options = {
+      :pause => true
+    }.merge(options)
+    
+    element =
+      page.xpath(
+        %Q{//*[#{trait(:button, :updates_frequently, :keyboard_key)} and @label="#{label}" and frame]},
+        %Q{//*[#{trait(:link)} and @value="#{label}" and frame]}
+      ).first
+    
+    raise %Q{No element labelled "#{label}" found in: #{response}} unless element
+    
+    # This seems brittle, revist how to fetch the frame without relying on it being the only child
+    frame = element.child
+    
+    # Hit the element in the middle
+    x = frame['x'].to_f + (frame['width'].to_f / 2)
+    y = frame['y'].to_f + (frame['height'].to_f / 2)
+    
+    raise %Q{Element "#{label}" is off screen in: #{response}} unless onscreen?(x, y)
+    
+    @simulator.fire_event(Tap.new(x, y, options))
+    
+    sleep(options[:pause] ? 1 : 0.2)
+    
+    refresh
+    
+    yield element if block_given?
+  end
+  
+  def swipe(direction, options = {})
+    modifier = [:up, :left].include?(direction) ? -1 : 1
+
+    # Just swipe from the middle of an iPhone-dimensioned screen for now
+    x = 320 / 2
+    y = 480 / 2
+    x2 = x
+    y2 = y
+    
+    if [:up, :down].include?(direction)
+      y2 = y + (100 * modifier)
+    else
+      x2 = x + (100 * modifier)
+    end
+    
+    @simulator.fire_event(Swipe.new(x, y, x2, y2, options))
+    
+    sleep(1)
+    
+    refresh
+  end
+  
+  def type(textfield, text, options = {})
+    tap(textfield, :hold_for => 0.75) do |field|
+      if field['value']
+        tap('Select All')
+        tap('Delete')
+      end
+    end
+    
+    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 = {})
+    previous_response = response.dup
+    while page.xpath(%Q{//*[contains(., "#{text}") or contains(@label, "#{text}") or contains(@value, "#{text}")]}).empty? do
+      scroll(options[:direction])
+      raise %Q{Content "#{text}" not found in: #{response}} if response == previous_response
+    end
+  end
+  
+  def scroll(direction)
+    swipe_directions = { :up => :down, :down => :up, :left => :right, :right => :left }
+    swipe(swipe_directions[direction])
+  end
+  
+  def set_application_defaults(defaults)
+    @simulator.set_defaults(defaults)
+  end
+  
+  private
+  
+  def trait(*traits)
+    "(#{traits.map { |t| %Q{contains(@traits, "#{t}")} }.join(' or ')})"
+  end
+  
+  def refresh
+    @response = nil
+    @xml = nil
+  end
+end
+
+World do
+  ICukeWorld.new
+end
+
+LIBICUKE = File.expand_path(File.dirname(__FILE__) + '/../../ext/iCuke/libicuke.dylib')
+
+Given /^(?:"([^\"]*)" from )?"([^\"]*)" is loaded in the simulator(?: using sdk (.*))?$/ do |target, project, sdk|
+  launch File.expand_path(project),
+         :target => target,
+         :env => { 'DYLD_INSERT_LIBRARIES' => LIBICUKE }
+end
+
+Then /^I should see "([^\"]*)"$/ do |text|
+  raise %Q{Content "#{text}" not found in: #{response}} unless can_see?(text)
+end
+
+Then /^I should not see "([^\"]*)"$/ do |text|
+  raise %Q{Content "#{text}" was found but was not expected in: #{response}} if can_see?(text)
+end
+
+When /^I tap "([^\"]*)"$/ do |label|
+  tap(label)
+end
+
+When /^I type "([^\"]*)" in "([^\"]*)"$/ do |text, textfield|
+  type(textfield, text)
+end
+
+When /^I scroll (down|up|left|right)(?: to "([^\"]*)")?$/ do |direction, text|
+  if text
+    scroll_to(text, :direction => direction.to_sym)
+  else
+    scroll(direction.to_sym)
+  end
+end
+
+Then /^I put the phone into recording mode$/ do
+  record
+end
+
+Then /^show me the screen$/ do
+  puts response
+end

data/lib/icuke/simulate.rb

@@ -0,0 +1,132 @@
+require 'json'
+
+module ICuke
+  module Simulate
+    module Events
+      class Event
+        attr_reader :hold_for, :event_time, :options
+        
+        def initialize(options = {})
+          @options = options
+          @hold_for = options[:hold_for] || 0.2
+          
+          @event_time = self.class.event_time
+          
+          self.class.hold_for(hold_for)
+        end
+        
+        def self.event_time
+          @time.to_i
+        end
+        
+        def self.hold_for(seconds)
+          @time = @time.to_i + (seconds * 1_000_000_000)
+        end
+      end
+      
+      class Touch < Event
+        GSEventHand = 3001
+        GSTouchDown = 1
+        GSTouchUp = 6
+        GSTouchMoved = 2
+        
+        TYPE = {
+          :down => GSTouchDown,
+          :up => GSTouchUp,
+          :moved => GSTouchMoved
+        }.freeze
+        
+        attr_accessor :type, :paths
+        
+        def initialize(type, paths, options = {})
+          super(options)
+          
+          @type = type
+          @paths = paths
+        end
+        
+        def averageX
+          paths.inject(0) { |s,p| s + p[0] } / paths.size
+        end
+        
+        def averageY
+          paths.inject(0) { |s,p| s + p[1] } / paths.size
+        end
+        
+        def to_json(*a)
+          {
+            'Type' => GSEventHand,
+            'Time' => event_time,
+            'WindowLocation' => { 'X' => averageX, 'Y' => averageY },
+            'Data' => {
+              'Delta' => { 'X' => paths.size, 'Y' => paths.size },
+              'Type' => TYPE[type],
+              'Paths' => paths.map { |p|
+                {
+                  'Location' => { 'X' => p[0], 'Y' => p[1] },
+                  'Size' => { 'X' => 1.0, 'Y' => 1.0 }
+                }
+              }
+            }
+          }.to_json(*a)
+        end
+      end
+    end
+
+    module Gestures
+      class Tap
+        attr_accessor :x, :y, :options
+        
+        def initialize(x, y, options = {})
+          @options = options
+          
+          @x = x
+          @y = y
+        end
+        
+        def to_json(*a)
+          [
+            ICuke::Simulate::Events::Touch.new(:down, [[x, y]], options),
+            ICuke::Simulate::Events::Touch.new(:up, [[x, y]])
+          ].to_json(*a)
+        end
+      end
+      
+      class Swipe
+        attr_accessor :x, :y, :x2, :y2, :options
+        
+        def initialize(x, y, x2, y2, options)
+          @options = options
+          
+          @x = x
+          @y = y
+          @x2 = x2
+          @y2 = y2
+        end
+        
+        def to_json(*a)
+          events = [ICuke::Simulate::Events::Touch.new(:down, [[x, y]], options.merge(:hold_for => 0.015))]
+          each_point([x, y], [x2, y2], 25) do |ix, iy|
+            events << ICuke::Simulate::Events::Touch.new(:moved, [[ix, iy]], :hold_for => 0.015)
+          end
+          events << ICuke::Simulate::Events::Touch.new(:up, [[x2, y2]], :hold_for => 0.015)
+          events.to_json(*a)
+        end
+        
+        private
+        
+        def each_point(start, finish, max_step)
+          dx = finish[0] - start[0]
+          dy = finish[1] - start[1]
+          hypotenuse = Math.sqrt(dx*dx + dy*dy)
+          step = max_step / hypotenuse
+          steps = hypotenuse / max_step
+
+          1.upto(steps) do |i|
+            yield start[0] + i * step * dx, start[1] + i * step * dy
+          end
+        end
+      end
+    end
+  end
+end