xctasks 0.0.2 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8db63f529626e3355fb3ae6f57b384b8e430a7ae
-  data.tar.gz: 83332db154670503b49a8efbd56736338b08044a
+  metadata.gz: e4e9db110bad3a10cdf968711f467637ea95f036
+  data.tar.gz: 73cf4abd0e9a47844c6281d9040f158c03c35af8
 SHA512:
-  metadata.gz: 8ac9293c4cea8e9c1b544f415562628d918beed532a1273c11d2e6f97f24a0e7e2d871d2c8e30c687c7d11a9307464266f36c55d56288e8f19041e6486d54d3b
-  data.tar.gz: c5f5d848b388301d63d7944dd0da6d309846ec2ef109b93f646baf24a62a7e10a00bb0a8abd229884087ccd689a5f69d1ef4c67fd3a85d3d0922636397eafd53
+  metadata.gz: b8a8fd14a1c5721a0c9803bc58a9dd249bfb6329561d59f5a205e102e182e042616d310950038e1f87381b429fb8659206f53ead410854a34c17870afd1d3b46
+  data.tar.gz: 43b8207d2f6ff79db039201d318ecfe152f3f355e58a562ec3694b4afb64713a96e48c5622919429f04f5b14ebd7febc6c6b8e0daebfe59b1e52f97bec8e1b30

data/.ruby-version

@@ -1 +1 @@
-2.0.0-p353
+2.0.0-p451

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    xctasks (0.0.1)
+    xctasks (0.0.2)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -17,11 +17,14 @@ XCTasks provides an interface for executing Xcode tests in a few ways using a un
 ```ruby
 require 'xctasks/test_task'
 XCTasks::TestTask.new(test: 'server:autostart') do |t|
-  t.workspace = 'LayerKit.xcworkspace'
-  t.ios_versions = %w{6.0 7.0}
-  t.schemes = { unit: 'LayerKit Tests' }
+  t.workspace = 'LayerKit.xcworkspace'  
   t.schemes_dir = 'Tests/Schemes' # Location where you store your shared schemes, will copy into workspace
   t.runner = :xctool # or :xcodebuild/:xcpretty
+  
+  t.subtask(unit: 'LayerKit Tests') do |s|
+    s.ios_versions = %w{7.0 7.1}
+  end
+  t.schemes = { unit: 'LayerKit Tests' }    
 end
 ```
 
@@ -37,6 +40,59 @@ rake test:unit:6.0  # Run unit tests against iOS Simulator 6.0
 rake test:unit:7.0  # Run unit tests against iOS Simulator 7.0
 ```
 
+#### Kiwi on iOS and OS X Example
+
+The following example is taken from [TransitionKit](http://github.com/blakewatters/TransitionKit) and executes a
+[Kiwi](https://github.com/allending/Kiwi) test suite on OS X and iOS.
+
+```ruby
+require 'xctasks/test_task'
+
+XCTasks::TestTask.new(:spec) do |t|
+  t.workspace = 'TransitionKit.xcworkspace'
+  t.schemes_dir = 'Specs/Schemes'
+  t.runner = :xcpretty
+  t.actions = %w{clean test}
+  
+  t.subtask(ios: 'iOS Specs') do |s|
+    s.sdk = :iphonesimulator
+  end
+  
+  t.subtask(osx: 'OS X Specs') do |s|
+    s.sdk = :macosx
+  end
+end
+```
+
+#### Running Tests on Multiple Destinations
+
+XCTasks supports a flexible syntax for specifying multiple destinations for your tests to execute on:
+
+```ruby
+XCTasks::TestTask.new(:spec) do |t|
+  t.workspace = 'LayerKit.xcworkspace'
+  t.runner = :xctool
+
+  t.subtask :functional do |s|
+    s.runner = :xcodebuild
+    s.scheme = 'Functional Tests'
+	
+	# Run on iOS Simulator, iPad, latest iOS
+    s.destination do |d|
+      d.platform = :iossimulator
+      d.name = 'iPad'
+      d.os = :latest
+    end
+	
+	# Specify a complete destination as a string
+    s.destination('platform=iOS Simulator,OS=7.1,name=iPhone Retina (4-inch)')
+	
+	# Quickly specify a physical device destination
+    s.destination platform: :ios, id: '437750527b43cff55a46f42ae86dbf870c7591b1'
+  end
+end
+```
+
 ## Credits
 
 Blake Watters

data/Rakefile

@@ -0,0 +1,5 @@
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/lib/xctasks/test_task.rb

@@ -2,11 +2,19 @@ require 'rake'
 require 'rake/tasklib'
 
 module XCTasks
+  module Command
+    def run(command, echo = true)
+      puts "Executing `#{command}`" if echo
+      system(command)
+    end
+    module_function :run
+  end
+  
   class TestReport
     include Singleton
     
     def initialize
-      @namespaces = {}
+      @subtask_results = {}
       @success = true
       
       at_exit do
@@ -14,9 +22,9 @@ module XCTasks
       end
     end
     
-    def add_result(namespace, ios_version, success)
-      @namespaces[namespace] ||= {}
-      @namespaces[namespace][ios_version] = success
+    def add_result(subtask, options, success)
+      @subtask_results[subtask] ||= {}
+      @subtask_results[subtask][options] = success
       @success = false unless success
     end
     
@@ -33,9 +41,9 @@ module XCTasks
     end
     
     def report
-      @namespaces.each do |namespace, version_status|
-        version_status.each do |ios_version, success|
-          puts "\033[0;31m!! #{namespace} tests failed under iOS #{ios_version}" unless success
+      @subtask_results.each do |subtask, options_results|
+        options_results.each do |options, success|
+          puts "\033[0;31m!! #{subtask.name} tests failed with options #{options}" unless success
         end
       end
       puts "\033[0;32m** All tests executed successfully" if success?
@@ -44,56 +52,241 @@ module XCTasks
   
   class TestTask < Rake::TaskLib
     class Destination
+      # Common Keys
       attr_accessor :platform, :name
       
+      # OS X attributes
+      attr_accessor :arch
+      
+      # iOS keys
+      attr_accessor :id
+      
+      # iOS Simulator keys
+      attr_accessor :os
+      
+      def initialize(options = {})
+        options.each { |k,v| self[k] = v }
+      end
+      
+      def platform=(platform)
+        valid_platforms = {osx: 'OS X', ios: 'iOS', iossimulator: 'iOS Simulator'}
+        raise ArgumentError, "Platform must be one of :osx, :ios, or :iossimulator" if platform.kind_of?(Symbol) && !valid_platforms.keys.include?(platform)
+        raise ArgumentError, "Platform must be one of 'OS X', 'iOS', or 'iOS Simulator'" if platform.kind_of?(String) && !valid_platforms.values.include?(platform)        
+        @platform = platform.kind_of?(Symbol) ? valid_platforms[platform] : platform
+      end
+      
+      def [](key)
+        send(key)
+      end
+      
+      def []=(key, value)
+        send("#{key}=", value)
+      end            
+      
+      def to_s
+        keys = [:platform, :name, :arch, :id, :os].reject { |k| self[k].nil? }
+        keys.map { |k| "#{key_name(k)}='#{self[k].to_s.shellescape}'" }.join(',')
+      end
+      
+      private
+      def key_name(attr)
+        attr == :os ? 'OS' : attr.to_s
+      end
+    end
+    
+    class ConfigurationError < RuntimeError; end    
+    class Configuration
+      SETTINGS = [:workspace, :schemes_dir, :sdk, :runner, :xctool_path, 
+                  :xcodebuild_path, :settings, :destinations, :actions,
+                  :scheme, :ios_versions]
+      HELPERS = [:destination, :xctool?, :xcpretty?, :xcodebuild?]
+      
+      # Configures delegations to pass through configuration accessor when extended
+      module Delegations
+        def self.extended(base)
+          base.extend Forwardable
+          accessors = SETTINGS.map { |attr| [attr, "#{attr}=".to_sym] }.flatten
+          base.def_delegators :@config, *accessors
+          base.def_delegators :@config, *HELPERS
+        end        
+      end
+      attr_accessor(*SETTINGS)
+      
       def initialize
+        @sdk = :iphonesimulator
+        @schemes_dir = nil
+        @xctool_path = '/usr/local/bin/xctool'
+        @xcodebuild_path = '/usr/bin/xcodebuild'
+        @runner = :xcodebuild
+        @settings = {}
         @platform = 'iOS Simulator'
-        @name = 'iPhone Retina (4-inch)'
+        @destinations = []
+        @actions = %w{clean build test}
+      end
+      
+      def runner=(runner)
+        raise ConfigurationError, "Must be :xcodebuild, :xctool or :xcpretty" unless %w{xctool xcodebuild xcpretty}.include?(runner.to_s)
+        @runner = runner.to_sym
+      end
+      
+      def sdk=(sdk)
+        raise ArgumentError, "Can only assign sdk from a String or Symbol" unless sdk.kind_of?(String) || sdk.kind_of?(Symbol)
+        @sdk = sdk.to_sym
+      end
+      
+      def destination(specifier = {})
+        if specifier.kind_of?(String)
+          raise ArgumentError, "Cannot configure a destination via a block when a complete String specifier is provided" if block_given?
+          @destinations << specifier.shellescape
+        elsif specifier.kind_of?(Hash)
+          destination = Destination.new(specifier)
+          yield destination if block_given?
+          @destinations << destination
+        else
+          raise ArgumentError, "Cannot configure a destination with a #{specifier}"
+        end
+      end
+      
+      def validate!
+        raise ConfigurationError, "Cannot specify iOS versions with an SDK of :macosx" if sdk == :macosx && ios_versions
+      end
+      
+      def xctool?
+        runner == :xctool
+      end
+
+      def xcodebuild?
+        runner == :xcodebuild
+      end
+    
+      def xcpretty?
+        runner == :xcpretty
+      end
+      
+      # Deep copy any nested structures
+      def dup
+        copy = super
+        copy.settings = settings.dup
+        copy.destinations = destinations.dup
+        return copy
+      end
+    end
+    
+    class Subtask
+      extend Configuration::Delegations
+      include ::Rake::DSL if defined?(::Rake::DSL)
+      
+      attr_reader :name, :config
+      
+      def initialize(name_options, config)
+        @config = config.dup        
+        self.name = name_options.kind_of?(Hash) ? name_options.keys.first : name_options.to_s
+        self.scheme = name_options.values.first if name_options.kind_of?(Hash)        
+      end
+      
+      def name=(name)
+        @name = name.to_s
+      end
+      
+      def define_rake_tasks
+        @config.validate!
+        
+        if namespaced?
+          namespace(name) do
+            ios_versions.each do |ios_version|
+              desc "Run #{name} tests against iOS Simulator #{ios_version} SDK"
+              task ios_version => :prepare do
+                run_tests(ios_version: ios_version)
+              end
+            end
+          end
+          
+          desc "Run #{name} tests against iOS Simulator #{ios_versions.join(', ')}"
+          task name => ios_versions.map { |ios_version| "#{name}:#{ios_version}" }
+        else
+          desc "Run #{name} tests"
+          task self.name => :prepare do
+            run_tests
+          end
+        end
       end
       
-      def to_arg(os_version)
-        "platform='#{platform}',OS=#{os_version},name='#{name}'"
+      private
+      
+      def namespaced?
+        ios_versions && ios_versions.any?
+      end            
+    
+      def run_tests(options = {})        
+        ios_version = options[:ios_version]
+        XCTasks::Command.run(%q{killall "iPhone Simulator"}, false) if sdk == :iphonesimulator
+      
+        success = if xctool?
+          actions_arg << " -freshSimulator" if ios_version
+          Command.run("#{xctool_path} -workspace #{workspace} -scheme '#{scheme}' -sdk #{sdk}#{ios_version}#{destination_arg}#{actions_arg}#{settings_arg}".strip)
+        elsif xcodebuild?
+          Command.run("#{xcodebuild_path} -workspace #{workspace} -scheme '#{scheme}' -sdk #{sdk}#{ios_version}#{destination_arg}#{actions_arg}#{settings_arg}".strip)
+        elsif xcpretty?
+          Command.run("#{xcodebuild_path} -workspace #{workspace} -scheme '#{scheme}' -sdk #{sdk}#{ios_version}#{destination_arg}#{actions_arg}#{settings_arg} | xcpretty -c ; exit ${PIPESTATUS[0]}".strip)
+        end
+        
+        XCTasks::TestReport.instance.add_result(self, options, success)
+      end
+      
+      def settings_arg
+        if settings.any?
+          " " << settings.map { |k,v| "#{k}=#{v}"}.join(' ')
+        else
+          nil
+        end
+      end
+      
+      def actions_arg
+        " " << actions.join(' ')
+      end
+      
+      def destination_arg
+        if destinations.any?
+          " " << destinations.map { |d| "-destination #{d}" }.join(' ')
+        else
+          nil
+        end
       end
     end
     
     include ::Rake::DSL if defined?(::Rake::DSL)
     
-    attr_reader :namespace_name, :prepare_dependency
-    attr_accessor :workspace, :schemes_dir, :schemes, :ios_versions
-    attr_accessor :runner, :xctool_path, :xcodebuild_path
-    attr_accessor :ios_versions, :destination, :settings, :actions
+    attr_reader :namespace_name, :prepare_dependency, :config, :subtasks
+    extend Configuration::Delegations
     
     def initialize(namespace_name = :test)
-      @namespace_name = namespace_name.is_a?(Hash) ? namespace_name.keys.first : namespace_name
-      @prepare_dependency = namespace_name.is_a?(Hash) ? namespace_name.values.first : nil
-      @schemes_dir = nil
-      @ios_versions = %w{7.0}
-      @xctool_path = '/usr/local/bin/xctool'
-      @xcodebuild_path = '/usr/bin/xcodebuild'
-      @runner = :xcodebuild
-      @destination = "platform='iOS Simulator',name='iPhone Retina (4-inch)'"
-      @settings = {}
-      @platform = 'iOS Simulator'
-      @destination = Destination.new
-      @actions = %w{clean build test}
+      @namespace_name = namespace_name
+      @config = Configuration.new
+      @subtasks = []
+      @namespace_name = namespace_name.kind_of?(Hash) ? namespace_name.keys.first : namespace_name
+      @prepare_dependency = namespace_name.kind_of?(Hash) ? namespace_name.values.first : nil      
       
       yield self if block_given?
-      raise "A workspace must be configured" unless workspace
-      raise "At least one scheme must be configured" unless schemes
-      define_tasks
+      raise ConfigurationError, "A workspace must be configured" unless workspace
+      raise ConfigurationError, "At least one subtask must be configured" if subtasks.empty?
+      define_rake_tasks
     end
     
-    def runner=(runner)
-      raise ArgumentError, "Must be :xcodebuild, :xctool or :xcpretty" unless %w{xctool xcodebuild xcpretty}.include?(runner.to_s)
-      @runner = runner.to_sym
+    def subtasks=(subtasks)
+      if subtasks.kind_of?(Hash)
+        subtasks.each { |name, scheme| subtask(name => scheme) }
+      else
+        raise ArgumentError, "Cannot assign subtasks from a #{subtasks.class}"
+      end
     end
     
-    def destination
-      yield @destination if block_given?
-      @destination
+    def subtask(name_options)
+      subtask = Subtask.new(name_options, config)
+      yield subtask if block_given?
+      @subtasks << subtask
     end
     
-    def define_tasks
+    def define_rake_tasks
       namespace self.namespace_name do
         task (prepare_dependency ? { prepare: prepare_dependency} : :prepare ) do
           if schemes_dir
@@ -102,63 +295,14 @@ module XCTasks
           end
         end
         
-        # Iterate across the schemes and define a task for each version of iOS and an aggregate task
-        schemes.each do |scheme_namespace, scheme_name|
-          namespace scheme_namespace do
-            ios_versions.each do |ios_version|
-              desc "Run #{scheme_namespace} tests against iOS Simulator #{ios_version} SDK"
-              task ios_version => :prepare do
-                test_scheme(scheme_name, namespace: scheme_namespace, ios_version: ios_version)
-              end
-            end                        
-          end
-          
-          desc "Run #{scheme_namespace} tests against iOS Simulator #{ios_versions.join(', ')}"
-          task scheme_namespace => ios_versions.map { |ios_version| "#{scheme_namespace}:#{ios_version}" }
-        end                
+        subtasks.each { |subtask| subtask.define_rake_tasks }
       end
       
-      desc "Run the #{schemes.keys.join(', ')} tests"
-      task namespace_name => schemes.keys.map { |scheme| "#{namespace_name}:#{scheme}" } do
+      subtask_names = subtasks.map { |subtask| subtask.name }
+      desc "Run all tests (#{subtask_names.join(', ')})"
+      task namespace_name => subtask_names.map { |subtask_name| "#{namespace_name}:#{subtask_name}" } do
         XCTasks::TestReport.instance.report
       end
     end
-    
-  private
-    def run(command)
-      puts "Executing `#{command}`"
-      system(command)
-    end
-    
-    def test_scheme(scheme, options)
-      system(%q{killall "iPhone Simulator"})
-      namespace = options[:namespace]
-      ios_version = options[:ios_version]
-      test_sdk = "#{ios_version}"      
-      
-      settings_arg = settings.map { |k,v| "#{k}=#{v}"}.join(' ')
-      destination_arg = destination.to_arg(ios_version)
-      actions_arg = actions.join(' ')
-      success = if xctool?
-        run("#{xctool_path} -workspace #{workspace} -scheme '#{scheme}' -sdk iphonesimulator #{actions_arg} -freshSimulator -destination #{destination_arg} #{settings_arg}")
-      elsif xcodebuild?
-        run("#{xcodebuild_path} -workspace #{workspace} -scheme '#{scheme}' -sdk iphonesimulator #{actions_arg} -destination #{destination_arg} #{settings_arg}")
-      elsif xcpretty?
-        run("#{xcodebuild_path} -workspace #{workspace} -scheme '#{scheme}' -sdk iphonesimulator #{actions_arg} -destination #{destination_arg} #{settings_arg} | xcpretty -c ; exit ${PIPESTATUS[0]}")
-      end      
-      XCTasks::TestReport.instance.add_result(namespace, ios_version, success)
-    end
-    
-    def xctool?
-      runner == :xctool
-    end
-
-    def xcodebuild?
-      runner == :xcodebuild
-    end
-    
-    def xcpretty?
-      runner == :xcpretty
-    end
   end
 end

data/lib/xctasks/version.rb

@@ -1,3 +1,3 @@
 module XCTasks
-  VERSION = "0.0.2"
+  VERSION = "0.1.0"
 end

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+require 'bundler/setup'
+Bundler.setup
+
+require 'xctasks'
+
+require 'debugger'
+Debugger.start
+
+RSpec.configure do |config|
+  # some (optional) config here
+end

data/spec/test_task_spec.rb

@@ -0,0 +1,291 @@
+require 'spec_helper'
+require 'xctasks/test_task'
+
+describe XCTasks::TestTask do
+  before(:each) do
+    @commands = []
+    XCTasks::Command.stub(:run) do |command|
+      @commands << command
+    end
+    FileUtils::Verbose.stub(:mkdir_p) do |path|
+      @commands << "mkdir -p #{path}"
+    end
+    FileUtils::Verbose.stub(:cp) do |src, dst|
+      @commands << "cp #{src} #{dst}"
+    end
+    
+    Rake.application = rake
+  end
+  
+  let(:rake) { Rake::Application.new }
+  
+  describe 'simple task' do
+    let!(:task) do
+      XCTasks::TestTask.new do |t|
+        t.workspace = 'LayerKit.xcworkspace'    
+        t.schemes_dir = 'Tests/Schemes'    
+        t.runner = :xcpretty
+        t.subtasks = { unit: 'Unit Tests', functional: 'Functional Tests' }
+      end
+    end
+    
+    it "configures the workspace" do
+      task.workspace.should == 'LayerKit.xcworkspace'
+    end
+    
+    it "configures the schemes dir" do
+      task.schemes_dir.should == 'Tests/Schemes'
+    end
+    
+    it "configures the runner" do
+      task.runner.should == :xcpretty
+    end
+    
+    it "configures the tasks" do
+      expect(task.subtasks.count).to eq(2)
+      task.subtasks.map { |t| t.name }.should == ["unit", "functional"]
+    end
+    
+    it "configures xcpretty for all tasks" do
+      task.subtasks.map { |t| t.runner }.should == [:xcpretty, :xcpretty]
+    end
+    
+    describe 'tasks' do
+      describe 'spec:unit' do
+        subject { Rake.application['test:unit'] }
+        
+        it "executes the appropriate commands" do
+          subject.invoke
+          @commands.should == ["mkdir -p LayerKit.xcworkspace/xcshareddata/xcschemes", 
+                               "cp [] LayerKit.xcworkspace/xcshareddata/xcschemes", 
+                               "killall \"iPhone Simulator\"", 
+                               "/usr/bin/xcodebuild -workspace LayerKit.xcworkspace -scheme 'Unit Tests' -sdk iphonesimulator clean build test | xcpretty -c ; exit ${PIPESTATUS[0]}"]
+        end
+      end
+      
+      describe 'spec:functional' do
+        subject { Rake.application['test:functional'] }
+        
+        it "executes the appropriate commands" do
+          subject.invoke
+          @commands.should == ["mkdir -p LayerKit.xcworkspace/xcshareddata/xcschemes", 
+                               "cp [] LayerKit.xcworkspace/xcshareddata/xcschemes", 
+                               "killall \"iPhone Simulator\"",
+                               "/usr/bin/xcodebuild -workspace LayerKit.xcworkspace -scheme 'Functional Tests' -sdk iphonesimulator clean build test | xcpretty -c ; exit ${PIPESTATUS[0]}"]
+        end
+      end
+    end
+  end
+  
+  describe 'advanced task' do
+    let!(:task) do
+      XCTasks::TestTask.new do |t|
+        t.workspace = 'LayerKit.xcworkspace'
+        t.runner = :xctool
+    
+        t.subtask(unit: 'Unit Tests') do |s|
+          s.ios_versions = %w{7.0 7.1}
+        end
+            
+        t.subtask :functional do |s|
+          s.runner = :xcodebuild
+          s.scheme = 'Functional Tests'
+        end
+      end
+    end
+    
+    context "when the task overrides base options" do
+      it "uses the original runner by default" do
+        subtask = task.subtasks.detect { |t| t.name == 'unit' }
+        subtask.runner.should == :xctool
+      end
+      
+      it "respects the override" do
+        subtask = task.subtasks.detect { |t| t.name == 'functional' }
+        subtask.runner.should == :xcodebuild
+      end
+    end
+    
+    describe 'tasks' do
+      describe 'test:unit' do
+        subject { Rake.application['test:unit'] }
+        
+        it "executes the appropriate commands" do
+          subject.invoke
+          @commands.should == [
+            "killall \"iPhone Simulator\"", 
+            "/usr/local/bin/xctool -workspace LayerKit.xcworkspace -scheme 'Unit Tests' -sdk iphonesimulator7.0 clean build test", 
+            "killall \"iPhone Simulator\"", 
+            "/usr/local/bin/xctool -workspace LayerKit.xcworkspace -scheme 'Unit Tests' -sdk iphonesimulator7.1 clean build test"
+          ]
+        end
+      end
+      
+      describe 'test:functional' do
+        subject { Rake.application['test:functional'] }
+        
+        it "executes the appropriate commands" do
+          subject.invoke
+          @commands.should == [
+            "killall \"iPhone Simulator\"",
+            "/usr/bin/xcodebuild -workspace LayerKit.xcworkspace -scheme 'Functional Tests' -sdk iphonesimulator clean build test"
+          ]
+        end
+      end
+    end
+  end
+  
+  describe 'Destination Configuration' do
+    let!(:task) do
+      XCTasks::TestTask.new(:spec) do |t|
+        t.workspace = 'LayerKit.xcworkspace'
+        t.runner = :xctool
+    
+        t.subtask(unit: 'Unit Tests') do |s|
+          s.ios_versions = %w{7.0 7.1}
+        end
+            
+        t.subtask :functional do |s|
+          s.runner = :xcodebuild
+          s.scheme = 'Functional Tests'
+          s.destination do |d|
+            d.platform = :iossimulator
+            d.name = 'iPad'
+            d.os = :latest
+          end
+          s.destination('platform=iOS Simulator,OS=7.1,name=iPhone Retina (4-inch)')
+          s.destination platform: :ios, id: '437750527b43cff55a46f42ae86dbf870c7591b1'
+        end
+      end
+    end
+    
+    describe 'spec:unit' do
+      subject { Rake.application['spec:unit'] }
+      
+      it "executes the appropriate commands" do
+        subject.invoke
+        @commands.should == [
+          "killall \"iPhone Simulator\"", 
+          "/usr/local/bin/xctool -workspace LayerKit.xcworkspace -scheme 'Unit Tests' -sdk iphonesimulator7.0 clean build test", 
+          "killall \"iPhone Simulator\"", 
+          "/usr/local/bin/xctool -workspace LayerKit.xcworkspace -scheme 'Unit Tests' -sdk iphonesimulator7.1 clean build test"
+        ]
+      end
+    end
+    
+    describe 'spec:functional' do
+      subject { Rake.application['spec:functional'] }
+      
+      it "executes the appropriate commands" do
+        subject.invoke
+        @commands.should == [
+          "killall \"iPhone Simulator\"", 
+          "/usr/bin/xcodebuild -workspace LayerKit.xcworkspace -scheme 'Functional Tests' -sdk iphonesimulator -destination platform='iOS\\ Simulator',name='iPad',OS='latest' -destination platform\\=iOS\\ Simulator,OS\\=7.1,name\\=iPhone\\ Retina\\ \\(4-inch\\) -destination platform='iOS',id='437750527b43cff55a46f42ae86dbf870c7591b1' clean build test"]
+      end
+    end
+  end
+  
+  describe 'SDK Configuration' do
+    let!(:task) do
+      XCTasks::TestTask.new(:spec) do |t|
+        t.workspace = 'LayerKit.xcworkspace'
+        t.runner = :xctool
+    
+        t.subtask(unit: 'Unit Tests') do |s|
+          s.sdk = :macosx
+        end
+      end
+    end
+    
+    subject { Rake.application['spec:unit'] }
+    
+    it "executes the appropriate commands" do
+      subject.invoke
+      @commands.should == ["/usr/local/bin/xctool -workspace LayerKit.xcworkspace -scheme 'Unit Tests' -sdk macosx clean build test"]
+    end
+  end
+  
+  describe 'validations' do
+    it "raises an exception when an invalid value is assigned to the sdk" do
+      expect do
+        XCTasks::TestTask.new do |t|
+          t.sdk = []
+        end
+      end.to raise_error(ArgumentError, "Can only assign sdk from a String or Symbol")
+    end
+    
+    context "when an invalid runner is specified" do
+      it "raises an exception" do
+        expect do
+          XCTasks::TestTask.new do |t|
+            t.runner = 'phantomjs'
+          end
+        end.to raise_error(XCTasks::TestTask::ConfigurationError, "Must be :xcodebuild, :xctool or :xcpretty")
+      end
+    end
+    
+    context "when a workspace is not configured" do
+      it "raises an exception" do
+        expect do
+          XCTasks::TestTask.new do |t|
+            t.workspace = nil
+          end
+        end.to raise_error(XCTasks::TestTask::ConfigurationError, "A workspace must be configured")
+      end
+    end
+    
+    context "when an SDK of macosx and ios versions is specified" do
+      it "raises an exception" do
+        expect do
+          XCTasks::TestTask.new do |t|
+            t.workspace = 'Workspace.workspace'
+            t.sdk = :macosx
+            t.ios_versions = %w{7.0}            
+            t.subtasks = {unit: 'MyWorkspaceTests'}
+          end
+        end.to raise_error(XCTasks::TestTask::ConfigurationError, "Cannot specify iOS versions with an SDK of :macosx")
+      end
+    end
+  end
+  
+  describe XCTasks::TestTask::Destination do
+    let(:destination) { XCTasks::TestTask::Destination.new }
+    
+    describe '#platform=' do
+      it "allows assignment of :osx" do
+        destination.platform = :osx
+        expect(destination.platform).to eq('OS X')
+      end
+      
+      it "allows assignment of 'OS X'" do
+        destination.platform = 'OS X'
+        expect(destination.platform).to eq('OS X')
+      end
+      
+      it "allows assignment of :ios" do
+        destination.platform = :ios
+        expect(destination.platform).to eq('iOS')
+      end
+      
+      it "allows assignment of 'iOS'" do
+        destination.platform = 'iOS'
+        expect(destination.platform).to eq('iOS')
+      end
+      
+      it "allows assignment of :iossimulator" do
+        destination.platform = :iossimulator
+        expect(destination.platform).to eq('iOS Simulator')
+      end
+      
+      it "allows assignment of 'iOS Simulator'" do
+        destination.platform = 'iOS Simulator'
+        expect(destination.platform).to eq('iOS Simulator')
+      end
+      
+      it "disallows other values" do
+        expect { destination.platform = 'sdadsa' }.to raise_error(ArgumentError)
+      end
+    end
+    
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: xctasks
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.1.0
 platform: ruby
 authors:
 - Blake Watters
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-08 00:00:00.000000000 Z
+date: 2014-03-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -139,6 +139,8 @@ files:
 - lib/xctasks.rb
 - lib/xctasks/test_task.rb
 - lib/xctasks/version.rb
+- spec/spec_helper.rb
+- spec/test_task_spec.rb
 - xctasks.gemspec
 homepage: http://github.com/layerhq/xctasks
 licenses:
@@ -164,4 +166,6 @@ rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Provides a rich library of automation tasks for Xcode
-test_files: []
+test_files:
+- spec/spec_helper.rb
+- spec/test_task_spec.rb