mac_bacon 1.2.1 → 1.3

data/ChangeLog

@@ -1,3 +1,21 @@
+Sat Mar 12 15:47:27 2011 +0100  Eloy Duran <eloy.de.enige@gmail.com>
+  * Filter the backtraces.
+
+Sat Mar 12 15:34:41 2011 +0100  Eloy Duran <eloy.de.enige@gmail.com>
+  * Postponing blocks until a KVO message is received should work from before and after filters as well.
+
+Sat Mar 12 15:06:26 2011 +0100  Eloy Duran <eloy.de.enige@gmail.com>
+  * Postponing blocks until Context#resume is called should work from before and after filters as well.
+
+Sat Mar 12 14:52:41 2011 +0100  Eloy Duran <eloy.de.enige@gmail.com>
+  * Postponing blocks for a fixed period of time should work from before and after filters as well.
+
+Sat Mar 12 13:57:01 2011 +0100  Eloy Duran <eloy.de.enige@gmail.com>
+  * Add Context#wait_for_change(object_to_observe, key_path, timeout = 1), which resumes the postponed block until a KVO message is received.
+
+Sat Mar 12 12:41:10 2011 +0100  Eloy Duran <eloy.de.enige@gmail.com>
+  * Postpone a block until either Context#resume is called or the timeout has exceeded. The default timeout is 1s, or can be given by using Context#wait_max instead of Context#wait.
+
 Mon Feb 28 12:34:55 2011 +0100  Klaas Speller <klaasspeller@gmail.com>
   * Exit with other status than 0 on fails or errors
 

data/RDOX

@@ -55,8 +55,36 @@ describe arguments
   - should work with multiple arguments
 
 NSRunloop aware Bacon
+
+concerning `wait' with a fixed time
   - allows the user to postpone execution of a block for n seconds, which will halt any further execution of specs
 
+concerning `wait' without a fixed time
+  - allows the user to postpone execution of a block until Context#resume is called, from for instance a delegate callback
+  - has a default timeout of 1 second after which the spec will fail and further scheduled calls to the Context are cancelled [FAILED]
+  - takes an explicit timeout [FAILED]
+
+concerning `wait_for_change'
+  - resumes the postponed block once an observed value changes
+  - has a default timeout of 1 second [FAILED]
+  - takes an explicit timeout [FAILED]
+
+postponing blocks should work from before/after filters as well
+
+with `wait'
+
+and an explicit time
+  - starts later because of postponed blocks in the before filter
+  - starts even later because of the postponed blocks in the after filter
+
+and without explicit time
+  - starts later because of postponed blocks in the before filter
+  - starts even later because of the postponed blocks in the after filter
+
+with `wait_for_change'
+  - starts later because of postponed blocks in the before filter
+  - starts even later because of the postponed blocks in the after filter
+
 Nib helper
   - takes a NIB path and instantiates the NIB with the given `owner' object
   - also returns an array or other top level objects
@@ -84,18 +112,18 @@ Bacon::Context
 
 Bacon::Context empty
 
-Bacon::Error: not #<Proc:0x200b9d840 (lambda)>.raise?(Bacon::Error) failed
-	/Users/eloy/Documents/DEVELOPMENT/MacRuby/MacBacon/lib/mac_bacon.rb:426:in `satisfy': Bacon - should have should.be.close
-	/Users/eloy/Documents/DEVELOPMENT/MacRuby/MacBacon/lib/mac_bacon.rb:440:in `method_missing:'
-	/Users/eloy/Documents/DEVELOPMENT/MacRuby/MacBacon/test/spec_bacon.rb:9:in `block'
-	/Users/eloy/Documents/DEVELOPMENT/MacRuby/MacBacon/lib/mac_bacon.rb:423:in `satisfy'
-	/Users/eloy/Documents/DEVELOPMENT/MacRuby/MacBacon/lib/mac_bacon.rb:409:in `an:'
-	/Users/eloy/Documents/DEVELOPMENT/MacRuby/MacBacon/lib/mac_bacon.rb:375:in `should:'
-	/Users/eloy/Documents/DEVELOPMENT/MacRuby/MacBacon/test/spec_bacon.rb:182:in `block'
-	/Users/eloy/Documents/DEVELOPMENT/MacRuby/MacBacon/lib/mac_bacon.rb:158:in `block'
-	/Users/eloy/Documents/DEVELOPMENT/MacRuby/MacBacon/lib/mac_bacon.rb:195:in `execute_block'
-	/Users/eloy/Documents/DEVELOPMENT/MacRuby/MacBacon/lib/mac_bacon.rb:154:in `run'
-	/Users/eloy/Documents/DEVELOPMENT/MacRuby/MacBacon/lib/mac_bacon.rb:234:in `run'
-	/Users/eloy/Documents/DEVELOPMENT/MacRuby/MacBacon/bin/macbacon:118:in `<main>'
-
-52 specifications (387 requirements), 1 failures, 0 errors
+Bacon::Error: not #<Proc:0x200485980 (lambda)>.raise?(Bacon::Error) failed
+	/Users/eloy/code/MacRuby/MacBacon/test/spec_bacon.rb:9:in `block': Bacon - should have should.be.close
+	/Users/eloy/code/MacRuby/MacBacon/test/spec_bacon.rb:182:in `block'
+
+Bacon::Error: timeout exceeded: concerning `wait' without a fixed time - has a default timeout of 1 second after which the spec will fail and further scheduled calls to the Context are cancelled
+
+Bacon::Error: timeout exceeded: concerning `wait' without a fixed time - takes an explicit timeout
+
+Bacon::Error: timeout exceeded: concerning `wait_for_change' - has a default timeout of 1 second
+	/Users/eloy/code/MacRuby/MacBacon/test/spec_helper.rb:23:in `finish_spec': concerning `wait_for_change' - has a default timeout of 1 second
+
+Bacon::Error: timeout exceeded: concerning `wait_for_change' - takes an explicit timeout
+	/Users/eloy/code/MacRuby/MacBacon/test/spec_helper.rb:23:in `finish_spec': concerning `wait_for_change' - takes an explicit timeout
+
+64 specifications (411 requirements), 1 failures, 0 errors

data/{README → README.md}

@@ -1,6 +1,7 @@
-= MacBacon -- small RSpec clone.
+MacBacon -- small RSpec clone.
+------------------------------
 
-   "Truth will sooner come out from error than from confusion."
+    "Truth will sooner come out from error than from confusion."
                                                ---Francis Bacon
 
 Bacon is a small RSpec clone weighing less than 350 LoC but
@@ -9,9 +10,10 @@ nevertheless providing all essential features.
 This MacBacon fork is created and maintained by Eloy Durán (@alloy).
 It differs with regular Bacon in that it operates properly in a
 NSRunloop based environment. I.e. MacRuby/Objective-C. See the
-paragraph about the `wait` command for more info.
+Objective-C runloop macros section for more info.
 
-== Whirl-wind tour
+Whirl-wind tour
+===============
 
     require 'mac_bacon'
     
@@ -135,7 +137,8 @@ As of Bacon 1.1, it also supports Knock:
 (knock is available from http://github.com/chneukirchen/knock/)
 
 
-== Implemented assertions
+Implemented assertions
+======================
 
 * should.<predicate> and should.be.<predicate>
 * should.equal
@@ -147,7 +150,8 @@ As of Bacon 1.1, it also supports Knock:
 * should.satisfy { |object| }
 
 
-== Added core predicates
+Added core predicates
+=====================
 
 * Object#true?
 * Object#false?
@@ -157,7 +161,8 @@ As of Bacon 1.1, it also supports Knock:
 * Numeric#close?
 
 
-== before/after
+before/after
+============
 
 before and after need to be defined before the first specification in
 a context and are run before and after each specification.
@@ -165,7 +170,8 @@ a context and are run before and after each specification.
 As of Bacon 1.1, before and after do nest in nested contexts.
 
 
-== Shared contexts
+Shared contexts
+===============
 
 You can define shared contexts in Bacon like this:
 
@@ -186,59 +192,132 @@ behaves_like in other contexts.  You can use shared contexts to
 structure suites with many recurring specifications.
 
 
-== Matchers
+Matchers
+========
 
 Custom matchers are simply lambdas returning a boolean value, for
 example:
 
-  def shorter_than(max_size)
-    lambda { |obj| obj.size < max_size }
-  end
-
-  [1,2,3].should.be shorter_than(5)
+    def shorter_than(max_size)
+      lambda { |obj| obj.size < max_size }
+    end
+    
+    [1,2,3].should.be shorter_than(5)
 
 You can use modules and extend to group matchers for use in multiple
 contexts.
 
 
-== wait
+Objective-C runloop macros
+==========================
+
 
 Often in Objective-C apps, code will *not* execute immediately, but
 scheduled on a runloop for later execution. Therefor a mechanism is
-needed that will postpone execution of some assertions for a period of
-time. This is where the `wait` macro comes in:
+provided that will postpone execution of blocks for a period of time.
 
-      it 'should perform a long running operation' do
-        # Here a method call is scheduled to be performed ~0.5 seconds in the future
-        @ary.performSelector("addObject:", withObject:"soup", afterDelay:0.5)
-        wait 0.6 do
-          # This block is executed ~0.6 seconds in the future
-          @ary.size.should.be 1
-        end
+You can event nest these blocks. However, with the exception of `wait`
+with an explicit time, you can *not* have multiple at the same time.
+
+All these macros may be used in before and after filters as well.
+
+
+### `wait` with fixed period of time
+
+    it 'should perform a long running operation' do
+      # Here a method call is scheduled to be performed ~0.5 seconds in the future
+      @ary.performSelector("addObject:", withObject:"soup", afterDelay:0.5)
+      wait 0.6 do
+        # This block is executed ~0.6 seconds in the future
+        @ary.size.should.be 1
+      end
+    end
+
+
+### `wait` without fixed period of time, until `resume` is called
+
+By default this usage of `wait` will wait for 1 second. If `resume`
+has not been called by that time, the spec fails. If you want to
+specify the timeout use `wait_max(timeout, &block)` instead.
+
+    def aDelegateCallbackMethod(sender)
+      @delegateCallbackMethodCalled = true
+      resume
+    end
+
+    it 'should wait until notified' do
+      # Here a method is called that in the near future will result in the object calling back the delegate
+      @object.delegate = self
+      @object.startLongRunningMethod
+      wait do
+        # This block is executed once aDelegateCallbackMethod is called
+        @delegateCallbackMethodCalled.should == true
       end
+    end
+
 
-The postponed block does *not* halt the thread, but is scheduled on
-the runloop as well. This means that your runloop based code will have
-a chance to perform its job before the assertions in the block are
-executed.
+### `wait_for_change` (Key-Value Observing)
 
-You can schedule as many blocks as you’d want and even nest them.
+This macro makes the specification an observer of the key path of the
+given object for the duration of the specification.
 
+By default this usage of `wait_for_change` will wait for 1 second. If
+the KVO message has not arrived by that time, the spec fails. If you
+want to specify the timeout use
+`wait_for_change(observable, key_path, timeout)` instead.
 
-== bacon standalone runner
+    class AKeyValueObservableClass
+      attr_accessor :an_attribute
 
-  -s, --specdox            do AgileDox-like output (default)
-  -q, --quiet              do Test::Unit-like non-verbose output
-  -p, --tap                do TAP (Test Anything Protocol) output
-  -k, --knock              do Knock output
-  -o, --output FORMAT      do FORMAT (SpecDox/TestUnit/Tap) output
-  -Q, --no-backtrace       don't print backtraces  
-  -a, --automatic          gather tests from ./test/, include ./lib/
-  -n, --name NAME          runs tests matching regexp NAME
-  -t, --testcase TESTCASE  runs tests in TestCases matching regexp TESTCASE
+      def compute_an_attribute
+        # trust me, this takes a few ms
+      end
+    end
 
+    it 'should wait until AKeyValueObservableClass#an_attribute changes' do
+      # Here a method is called that in the near future will update the 'an_attribute' value of the object
+      observable.compute_an_attribute
+      wait_for_change observable, 'an_attribute' do
+        # This block is executed once 'an_attribute' has changed value
+        observable.an_attribute.should == 'changed'
+      end
+    end
 
-== Object#should
+
+Load NIBs
+=========
+
+In case you have a NIB that defines the UI for the controller you're testing,
+then you can use the `load_nib` method to easily do so:
+
+    describe "PreferencesController" do
+      before do
+        @controller = PreferencesController.new
+        nib_path = File.join(SRC_ROOT, 'app/views/PreferencesWindow.xib')
+        @top_level_objects = load_nib(nib_path, @controller)
+      end
+      
+      # tests...
+      
+    end
+
+
+bacon standalone runner
+=======================
+
+    -s, --specdox            do AgileDox-like output (default)
+    -q, --quiet              do Test::Unit-like non-verbose output
+    -p, --tap                do TAP (Test Anything Protocol) output
+    -k, --knock              do Knock output
+    -o, --output FORMAT      do FORMAT (SpecDox/TestUnit/Tap) output
+    -Q, --no-backtrace       don't print backtraces  
+    -a, --automatic          gather tests from ./test/, include ./lib/
+    -n, --name NAME          runs tests matching regexp NAME
+    -t, --testcase TESTCASE  runs tests in TestCases matching regexp TESTCASE
+
+
+Object#should
+=============
 
 You can use Object#should outside of contexts, where the result of
 assertion will be returned as a boolean.  This is nice for
@@ -251,7 +330,8 @@ demonstrations, quick checks and doctest tests.
     => false
 
 
-== Converting specs
+Converting specs
+================
 
 spec-converter is a simple tool to convert test-unit or dust style
 tests to test/spec specs.
@@ -259,7 +339,8 @@ tests to test/spec specs.
 It can be found at http://opensource.thinkrelevance.com/wiki/spec_converter.
 
 
-== Thanks to
+Thanks to
+=========
 
 * Michael Fellinger, for fixing Bacon for 1.9 and various improvements.
 * Gabriele Renzi, for implementing Context#should.
@@ -268,7 +349,8 @@ It can be found at http://opensource.thinkrelevance.com/wiki/spec_converter.
 * everyone contributing bug fixes.
 
 
-== History
+History
+=======
 
 * January 7, 2008: First public release 0.9.
 
@@ -288,10 +370,17 @@ It can be found at http://opensource.thinkrelevance.com/wiki/spec_converter.
 
 * January 10th, 2011: MacBacon fork release 1.1
   * Make it work in a NSRunloop environment
-  * Add `wait'
+  * Add `wait`
   * Remove extras, for now
 
-== Contact
+* March 12th, 2011: MacBacon fork release 1.3
+  * Add NIB helper
+  * exit with non-zero status when there were failures/errors
+  * Add `wait` without explicit time
+  * Add `wait_for_change`
+
+Contact
+=======
 
 Please mail bugs, suggestions and patches for Bacon to
 <mailto:chneukirchen@gmail.com>
@@ -307,18 +396,23 @@ And repository location:
 https://github.com/alloy/MacBacon
 git://github.com/alloy/MacBacon.git
 
-== Copying
+Copying
+=======
 
-Copyright (C) 2007, 2008 Christian Neukirchen <purl.org/net/chneukirchen>
+Copyright (C) 2007 - 2011 Christian Neukirchen <purl.org/net/chneukirchen>
+Copyright (C) 2011 Eloy Durán <eloy.de.enige@gmail.com>
 
 Bacon is freely distributable under the terms of an MIT-style license.
 See COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 
-== Links
+Links
+=====
 
 Behavior-Driven Development:: <http://behaviour-driven.org/>
 RSpec:: <http://rspec.rubyforge.org/>
 test/spec:: <http://test-spec.rubyforge.org/>
 
 Christian Neukirchen:: <http://chneukirchen.org/>
+Eloy Durán:: <http://soup.superalloy.nl/>
+

data/Rakefile

@@ -27,7 +27,7 @@ def git_tree_version
     #$: << "lib"
     #require 'mac_bacon'
     #@tree_version = Bacon::VERSION
-    @tree_version = "1.2.1"
+    @tree_version = "1.3"
   end
   @tree_version
 end
@@ -116,7 +116,7 @@ https://github.com/alloy/MacBacon
     s.executables     << 'macbacon'
     s.require_path    = 'lib'
     s.has_rdoc        = true
-    s.extra_rdoc_files = ['README', 'RDOX']
+    s.extra_rdoc_files = ['README.md', 'RDOX']
     s.test_files      = []
 
     s.author          = 'Eloy Durán'
@@ -137,11 +137,11 @@ end
 desc "Generate RDoc documentation"
 Rake::RDocTask.new(:rdoc) do |rdoc|
   rdoc.options << '--line-numbers' << '--inline-source' <<
-    '--main' << 'README' <<
+    '--main' << 'README.md' <<
     '--title' << 'Bacon Documentation' <<
     '--charset' << 'utf-8'
   rdoc.rdoc_dir = "doc"
-  rdoc.rdoc_files.include 'README'
+  rdoc.rdoc_files.include 'README.md'
   rdoc.rdoc_files.include 'COPYING'
   rdoc.rdoc_files.include 'RDOX'
   rdoc.rdoc_files.include('lib/mac_bacon.rb')

data/TODO

@@ -0,0 +1,2 @@
+* refactor
+* cleanup README.md

data/lib/mac_bacon.rb

@@ -11,7 +11,7 @@ framework "Cocoa"
 require "mac_bacon/helpers"
 
 module Bacon
-  VERSION = "1.2.1"
+  VERSION = "1.3"
 
   Counter = Hash.new(0)
   ErrorLog = ""
@@ -137,31 +137,43 @@ module Bacon
       @before_filters, @after_filters = before_filters.dup, after_filters.dup
 
       @postponed_blocks_count = 0
+      @ran_spec_block = false
+      @ran_after_filters = false
       @exception_occurred = false
       @error = ""
     end
 
+    def postponed?
+      @postponed_blocks_count != 0
+    end
+
     def run_before_filters
-      @before_filters.each { |f| @context.instance_eval(&f) }
+      execute_block { @before_filters.each { |f| @context.instance_eval(&f) } }
+    end
+
+    def run_spec_block
+      @ran_spec_block = true
+      # If an exception occurred, we definitely don't need to perform the actual spec anymore
+      unless @exception_occurred
+        execute_block { @context.instance_eval(&@block) }
+      end
+      finish_spec unless postponed?
     end
 
     def run_after_filters
-      @after_filters.each { |f| @context.instance_eval(&f) }
+      @ran_after_filters = true
+      execute_block { @after_filters.each { |f| @context.instance_eval(&f) } }
     end
 
     def run
       Bacon.handle_requirement_begin(@description)
-      execute_block do
-        Counter[:depth] += 1
-        run_before_filters
-        @number_of_requirements_before = Counter[:requirements]
-        @context.instance_eval(&@block)
-      end
-
-      finalize if @postponed_blocks_count == 0
+      Counter[:depth] += 1
+      run_before_filters
+      @number_of_requirements_before = Counter[:requirements]
+      run_spec_block unless postponed?
     end
 
-    def postpone_block(seconds, &block)
+    def schedule_block(seconds, &block)
       # If an exception occurred, we definitely don't need to schedule any more blocks
       unless @exception_occurred
         @postponed_blocks_count += 1
@@ -169,22 +181,97 @@ module Bacon
       end
     end
 
+    def postpone_block(timeout = 1, &block)
+      # If an exception occurred, we definitely don't need to schedule any more blocks
+      unless @exception_occurred
+        if @postponed_block
+          raise "Only one indefinite `wait' block at the same time is allowed!"
+        else
+          @postponed_blocks_count += 1
+          @postponed_block = block
+          performSelector("postponed_block_timeout_exceeded", withObject:nil, afterDelay:timeout)
+        end
+      end
+    end
+
+    def postpone_block_until_change(object_to_observe, key_path, timeout = 1, &block)
+      # If an exception occurred, we definitely don't need to schedule any more blocks
+      unless @exception_occurred
+        if @postponed_block
+          raise "Only one indefinite `wait' block at the same time is allowed!"
+        else
+          @postponed_blocks_count += 1
+          @postponed_block = block
+          @observed_object_and_key_path = [object_to_observe, key_path]
+          object_to_observe.addObserver(self, forKeyPath:key_path, options:0, context:nil)
+          performSelector("postponed_change_block_timeout_exceeded", withObject:nil, afterDelay:timeout)
+        end
+      end
+    end
+
+    def observeValueForKeyPath(key_path, ofObject:object, change:_, context:__)
+      resume
+    end
+
+    def postponed_change_block_timeout_exceeded
+      remove_observer!
+      postponed_block_timeout_exceeded
+    end
+
+    def remove_observer!
+      if @observed_object_and_key_path
+        object, key_path = @observed_object_and_key_path
+        object.removeObserver(self, forKeyPath:key_path)
+        @observed_object_and_key_path = nil
+      end
+    end
+
+    def postponed_block_timeout_exceeded
+      cancel_scheduled_requests!
+      execute_block { raise Error.new(:failed, "timeout exceeded: #{@context.name} - #{@description}") }
+      @postponed_blocks_count = 0
+      finish_spec
+    end
+
+    def resume
+      NSObject.cancelPreviousPerformRequestsWithTarget(self, selector:'postponed_block_timeout_exceeded', object:nil)
+      NSObject.cancelPreviousPerformRequestsWithTarget(self, selector:'postponed_change_block_timeout_exceeded', object:nil)
+      remove_observer!
+      block, @postponed_block = @postponed_block, nil
+      run_postponed_block(block)
+    end
+
     def run_postponed_block(block)
       # If an exception occurred, we definitely don't need execute any more blocks
       execute_block(&block) unless @exception_occurred
       @postponed_blocks_count -= 1
-      finalize if @postponed_blocks_count == 0
+      unless postponed?
+        if @ran_after_filters
+          exit_spec
+        elsif @ran_spec_block
+          finish_spec
+        else
+          run_spec_block
+        end
+      end
     end
 
-    def finalize
-      if Counter[:requirements] == @number_of_requirements_before
+    def finish_spec
+      if !@exception_occurred && Counter[:requirements] == @number_of_requirements_before
         # the specification did not contain any requirements, so it flunked
-        # TODO ugh, exceptions for control flow, need to clean this up
         execute_block { raise Error.new(:missing, "empty specification: #{@context.name} #{@description}") }
       end
+      run_after_filters
+      exit_spec unless postponed?
+    end
 
-      execute_block { run_after_filters }
+    def cancel_scheduled_requests!
+      NSObject.cancelPreviousPerformRequestsWithTarget(@context)
+      NSObject.cancelPreviousPerformRequestsWithTarget(self)
+    end
 
+    def exit_spec
+      cancel_scheduled_requests!
       Counter[:depth] -= 1
       Bacon.handle_requirement_end(@error)
       @context.specification_did_finish(self)
@@ -197,8 +284,8 @@ module Bacon
         @exception_occurred = true
 
         ErrorLog << "#{e.class}: #{e.message}\n"
-        e.backtrace.find_all { |line| line !~ /bin\/bacon|\/bacon\.rb:\d+/ }.
-          each_with_index { |line, i|
+        lines = $DEBUG ? e.backtrace : e.backtrace.find_all { |line| line !~ /bin\/macbacon|\/mac_bacon\.rb:\d+/ }
+        lines.each_with_index { |line, i|
           ErrorLog << "\t#{line}#{i==0 ? ": #{@context.name} - #{@description}" : ""}\n"
         }
         ErrorLog << "\n"
@@ -315,8 +402,24 @@ module Bacon
       context
     end
 
-    def wait(seconds, &block)
-      current_specification.postpone_block(seconds, &block)
+    def wait(seconds = nil, &block)
+      if seconds
+        current_specification.schedule_block(seconds, &block)
+      else
+        current_specification.postpone_block(&block)
+      end
+    end
+
+    def wait_max(timeout, &block)
+      current_specification.postpone_block(timeout, &block)
+    end
+
+    def wait_for_change(object_to_observe, key_path, timeout = 1, &block)
+      current_specification.postpone_block_until_change(object_to_observe, key_path, timeout, &block)
+    end
+
+    def resume
+      current_specification.resume
     end
 
     def raise?(*args, &block); block.raise?(*args); end

data/test/spec_helper.rb

@@ -1,2 +1,28 @@
 $:.unshift File.expand_path('../../lib', __FILE__)
 require 'mac_bacon'
+
+module Bacon
+  class Specification
+    alias_method :_real_finish_spec, :finish_spec
+  end
+
+  class Context
+    def failures_before
+      @failures_before
+    end
+
+    def expect_spec_to_fail!
+      @failures_before = Bacon::Counter[:failed]
+      Bacon::Specification.class_eval do
+        def finish_spec
+          @exception_occurred.should == true
+          @exception_occurred = nil
+          Bacon::Counter[:failed].should == @context.failures_before + 1
+          Bacon::Counter[:failed] = @context.failures_before
+          self.class.class_eval { alias_method :finish_spec, :_real_finish_spec }
+          _real_finish_spec
+        end
+      end
+    end
+  end
+end

data/test/spec_mac_bacon.rb

@@ -1,19 +1,204 @@
 require File.expand_path('../spec_helper', __FILE__)
 
+class MockObservable
+  attr_accessor :an_attribute
+end
+
 describe "NSRunloop aware Bacon" do
-  it "allows the user to postpone execution of a block for n seconds, which will halt any further execution of specs" do
-    started_at_1 = started_at_2 = started_at_3 = Time.now
-    number_of_specs_before = Bacon::Counter[:specifications]
+  describe "concerning `wait' with a fixed time" do
+    it "allows the user to postpone execution of a block for n seconds, which will halt any further execution of specs" do
+      started_at_1 = started_at_2 = started_at_3 = Time.now
+      number_of_specs_before = Bacon::Counter[:specifications]
+
+      wait 0.5 do
+        (Time.now - started_at_1).should.be.close(0.5, 0.5)
+      end
+      wait 1 do
+        (Time.now - started_at_2).should.be.close(1, 0.5)
+        wait 1.5 do
+          (Time.now - started_at_3).should.be.close(2.5, 0.5)
+          Bacon::Counter[:specifications].should == number_of_specs_before
+        end
+      end
+    end
+  end
+
+  describe "concerning `wait' without a fixed time" do
+    def delegateCallbackMethod
+      @delegateCallbackCalled = true
+      resume
+    end
+
+    it "allows the user to postpone execution of a block until Context#resume is called, from for instance a delegate callback" do
+      performSelector('delegateCallbackMethod', withObject:nil, afterDelay:0.1)
+      @delegateCallbackCalled.should == nil
+      wait do
+        @delegateCallbackCalled.should == true
+      end
+    end
+
+    def delegateCallbackTookTooLongMethod
+      raise "Oh noes, I must never be called!"
+    end
+
+    # This spec adds a failure to the ErrorLog!
+    it "has a default timeout of 1 second after which the spec will fail and further scheduled calls to the Context are cancelled" do
+      expect_spec_to_fail!
+      performSelector('delegateCallbackTookTooLongMethod', withObject:nil, afterDelay:1.2)
+      wait do
+        # we must never arrive here, because the default timeout of 1 second will have passed
+        raise "Oh noes, we shouldn't have arrived in this postponed block!"
+      end
+    end
+
+    # This spec adds a failure to the ErrorLog!
+    it "takes an explicit timeout" do
+      expect_spec_to_fail!
+      performSelector('delegateCallbackTookTooLongMethod', withObject:nil, afterDelay:0.8)
+      wait_max 0.3 do
+        # we must never arrive here, because the default timeout of 1 second will have passed
+        raise "Oh noes, we shouldn't have arrived in this postponed block!"
+      end
+    end
+  end
+
+  describe "concerning `wait_for_change'" do
+    before do
+      @observable = MockObservable.new
+    end
+
+    def triggerChange
+      @observable.an_attribute = 'changed'
+    end
+
+    it "resumes the postponed block once an observed value changes" do
+      wait_for_change @observable, 'an_attribute' do
+        @value = @observable.an_attribute
+      end
+      @value.should == nil
+      performSelector('triggerChange', withObject:nil, afterDelay:0.1)
+      wait 0.2 do
+        @value.should == 'changed'
+      end
+    end
+
+    # This spec adds a failure to the ErrorLog!
+    it "has a default timeout of 1 second" do
+      expect_spec_to_fail!
+      wait_for_change(@observable, 'an_attribute') do
+        raise "Oh noes, I must never be called!"
+      end
+      performSelector('triggerChange', withObject:nil, afterDelay:1.1)
+      wait 1.2 do
+        # we must never arrive here, because the default timeout of 1 second will have passed
+        raise "Oh noes, we shouldn't have arrived in this postponed block!"
+      end
+    end
+
+    # This spec adds a failure to the ErrorLog!
+    it "takes an explicit timeout" do
+      expect_spec_to_fail!
+      wait_for_change(@observable, 'an_attribute', 0.3) do
+        raise "Oh noes, I must never be called!"
+      end
+      performSelector('triggerChange', withObject:nil, afterDelay:0.8)
+      wait 0.9 do
+        # we must never arrive here, because the default timeout of 1 second will have passed
+        raise "Oh noes, we shouldn't have arrived in this postponed block!"
+      end
+    end
+  end
+
+  describe "postponing blocks should work from before/after filters as well" do
+    shared "waiting in before/after filters" do
+      it "starts later because of postponed blocks in the before filter" do
+        (Time.now - @started_at).should.be.close(1, 0.5)
+      end
+
+      it "starts even later because of the postponed blocks in the after filter" do
+        (Time.now - @started_at).should.be.close(3, 0.5)
+      end
+    end
+
+    describe "with `wait'" do
+      describe "and an explicit time" do
+        before do
+          @started_at ||= Time.now
+          wait 0.5 do
+            wait 0.5 do
+            end
+          end
+        end
+
+        after do
+          wait 0.5 do
+            wait 0.5 do
+              @time ||= 0
+              @time += 2
+              (Time.now - @started_at).should.be.close(@time, 0.2)
+            end
+          end
+        end
+
+        behaves_like "waiting in before/after filters"
+      end
+
+      describe "and without explicit time" do
+        before do
+          @started_at ||= Time.now
+          performSelector('resume', withObject:nil, afterDelay:0.5)
+          wait do
+            performSelector('resume', withObject:nil, afterDelay:0.5)
+            wait do
+            end
+          end
+        end
+
+        after do
+          performSelector('resume', withObject:nil, afterDelay:0.5)
+          wait do
+            performSelector('resume', withObject:nil, afterDelay:0.5)
+            wait do
+              @time ||= 0
+              @time += 2
+              (Time.now - @started_at).should.be.close(@time, 0.2)
+            end
+          end
+        end
 
-    wait 0.5 do
-      (Time.now - started_at_1).should.be.close(0.5, 0.5)
+        behaves_like "waiting in before/after filters"
+      end
     end
-    wait 1 do
-      (Time.now - started_at_2).should.be.close(1, 0.5)
-      wait 1.5 do
-        (Time.now - started_at_3).should.be.close(2.5, 0.5)
-        Bacon::Counter[:specifications].should == number_of_specs_before
+
+    describe "with `wait_for_change'" do
+      before do
+        @observable = MockObservable.new
+        @started_at ||= Time.now
+        performSelector('triggerChange', withObject:nil, afterDelay:0.5)
+        wait_for_change @observable, 'an_attribute' do
+          performSelector('triggerChange', withObject:nil, afterDelay:0.5)
+          wait_for_change @observable, 'an_attribute' do
+          end
+        end
+      end
+
+      after do
+        performSelector('triggerChange', withObject:nil, afterDelay:0.5)
+        wait_for_change @observable, 'an_attribute' do
+          performSelector('triggerChange', withObject:nil, afterDelay:0.5)
+          wait_for_change @observable, 'an_attribute' do
+            @time ||= 0
+            @time += 2
+            (Time.now - @started_at).should.be.close(@time, 1)
+          end
+        end
       end
+
+      def triggerChange
+        @observable.an_attribute = 'changed'
+      end
+
+      behaves_like "waiting in before/after filters"
     end
   end
 end

metadata

@@ -1,13 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: mac_bacon
 version: !ruby/object:Gem::Version 
-  hash: 29
-  prerelease: false
-  segments: 
-  - 1
-  - 2
-  - 1
-  version: 1.2.1
+  version: "1.3"
 platform: ruby
 authors: 
 - "Eloy Dur\xC3\xA1n"
@@ -15,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-03-01 00:00:00 +01:00
+date: 2011-03-12 00:00:00 +01:00
 default_executable: 
 dependencies: []
 
@@ -34,12 +28,13 @@ executables:
 extensions: []
 
 extra_rdoc_files: 
-- README
+- README.md
 - RDOX
 files: 
 - COPYING
-- README
+- README.md
 - Rakefile
+- TODO
 - bin/macbacon
 - lib/mac_bacon.rb
 - lib/mac_bacon/helpers.rb
@@ -63,27 +58,21 @@ rdoc_options: []
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
       version: "0"
+  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
       version: "0"
+  version: 
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.7
+rubygems_version: 1.3.5
 signing_key: 
 specification_version: 3
 summary: a small RSpec clone for MacRuby