rspec 0.2.0 → 0.3.0

data/CHANGES

@@ -13,6 +13,15 @@
 * Make sure the PKG_VERSION constant in Rakefile.rb is
   consistent with the latest version in this document.
 
+== Version 0.3.0
+
+It's been a while since last release, lots of new stuff is available.  For instance:
+
+ * improvements to the runners
+ * addition of should_raise expectation (thanks to Brian Takita)
+ * some documentation improvements
+ * RSpec usable as a DSL
+
 == Version 0.2.0
 
 This release provides a tutorial for new users wishing to get started with

data/README

@@ -1,45 +1,38 @@
 = RSpec - Behaviour Specification Framework for Ruby
 
-RSpec is a behaviour specification framework for Ruby.  RSpec was created in
-response to Dave Astels' article _A New Look at Test Driven Development_ which
-can be read at: http://daveastels.com/index.php?p=5  RSpec is intended to
-provide the features discussed in Dave's article.
+RSpec is a behaviour specification framework for Ruby.  RSpec was created in response to Dave Astels' article _A New Look at Test Driven Development_ which can be read at: http://daveastels.com/index.php?p=5  RSpec is intended to provide the features discussed in Dave's article.
 
-RSpec was first explored by Steven Baker <srbaker@pobox.com> and Gabriel
-Bauman <gbauman@gmail.com>, and has since received numerous contributions
-from Dave himself.
+RSpec is primarily developed by Steven Baker <srbaker@pobox.com>, and was inspired by and contributed to by Dave Astels.  Special thanks also to Aslak Hellesoy for many significant contributions.
+
+RSpec's included mocking framework is based on SchMock by Ben Griffiths.  SchMock can be found at http://rubyforge.org/projects/schmock/.
 
 == Download/Installation
 
 === Using RubyGems
 
-  sudo gem install rspec
+  $ sudo gem install rspec
 
 === Getting the latest sources
 
-RSpec is currently being hosted in the Monotone distributed version control system. To checkout RSpec, please download and install Monotone according to the documentation on the monotone website. Then use the following set of commands to grab the latest RSpec sources.
+RSpec was previously hosted under the Monotone distributed version control system.  Due to the increasing popularity of RSpec, and the fact that a large part of the world hasn't yet discovered how wonderful Monotone is, we have succumbed to peer pressure and moved the repository to Subversion.
 
-    * monotone --db=database db init
-    * monotone --db=database pull goliath.fundynet.ca org.rubyforge.rspec
-    * monotone --db=database --branch=org.rubyforge.rspec checkout RSpec
+RSpec's repository is located at svn://svn.behaviourdriven.org/rspec
 
-The gem can be created and installed from sources as follows:
+== Creating a Gem
 
-  rake gem; sudo gem install pkg/rspec_x.y.z.gem
+If you have checked out the sources from version control, you can create a Gem from the checked out version with the 'gem' rake task, like so:
 
-Please visit this page periodically, it will be updated with more information as it is made available including documentation, mailing lists, bug tracking, and more. Special thanks to RubyForge for hosting this project site.
+  $ rake gem
 
-== Usage
+This will create a gem in the pkg/ subdirectory.  To install the created gem, simply run 'gem install' as root (preferably using sudo(1)):
 
-This will also install a new executable for you, 'spec'. Now you
+  $ sudo gem install pkg/rspec_x.y.z.gem
 
-Do a fun dance.
+Please visit the RSpec web site periodically, it will be updated with more information as it is made available including documentation, mailing lists, bug tracking, and more. Special thanks to RubyForge for hosting the project site.
 
-  spec movie_spec.rb
+== Usage
 
-Do another dance.
+This will also install a new executable for you, 'spec'. Now you can
 
+  spec movie_spec.rb
   spec *_spec.rb
-
-This is the coolest part.  Dance harder.  Now drink.
-

data/{Rakefile.rb → Rakefile}

@@ -19,7 +19,7 @@ PKG_NAME = "rspec"
 # (This is subject to change - AH)
 #
 # REMEMBER TO KEEP PKG_VERSION IN SYNC WITH CHANGELOG
-PKG_VERSION = "0.2.0"
+PKG_VERSION = "0.3.0"
 PKG_FILE_NAME = "#{PKG_NAME}-#{PKG_VERSION}"
 PKG_FILES = FileList[
   '[A-Z]*',

data/TUTORIAL

@@ -40,12 +40,13 @@ ready for use!
 == Expectations
 
 The simplest part of your set of specifications will be an expectation. An
-expectation tells RSpec what the expected result of a piece code is. Your set of
-specifications is simply a collection of expectations about how your code should
-behave.
+expectation tells RSpec what the expected result of a piece code is. Your set
+of specifications is simply a collection of expectations about how your code
+should behave.
 
-In RSpec, the expectations are methods that are available on every object in the
-system. If I want to set an expectation that the value of 1 is 1, I would write:
+In RSpec, the expectations are methods that are available on every object in
+the system. If I want to set an expectation that the value of 1 is 1, I would
+write:
 
     1.should_equal 1
 
@@ -63,8 +64,8 @@ not equal 2, write the following:
 
 These examples are extremely simple, but they accurately convey the simplicity
 with which expectations can be written. When specifying your software, you are
-simply writing expectations that specify how your software will behave. The rest
-of the constructs in RSpec exist entirely to help you organize your
+simply writing expectations that specify how your software will behave. The
+rest of the constructs in RSpec exist entirely to help you organize your
 expectations, and to provide accurate and helpful reporting when these
 expectations are not met.
 
@@ -72,11 +73,11 @@ Eventually, writing expectations for addition and subtraction of numbers will
 get boring. When that happens, you can start writing expectations for your own
 code. Let's try a slightly more involved example.
 
-We have been asked to write a robot which will start at a given X, Y coordinate,
-and will move in for directions a given number of units. If no starting
-coordinate is given, the robot will start at 0,0. When the robot is moved, a
-two-element array should be returned with the x and y coordinates. Some
-expectations you might write for this robot might be the following:
+We have been asked to write a robot which will start at a given X, Y
+coordinate, and will move in for directions a given number of units. If no
+starting coordinate is given, the robot will start at 0,0. When the robot is
+moved, a two-element array should be returned with the x and y coordinates.
+Some expectations you might write for this robot might be the following:
 
     rob = Robot.new
 
@@ -94,9 +95,9 @@ expectations you might write for this robot might be the following:
 The code example above isn't intended to demonstrate good design, but has been
 created explicitly to demonstrate the use of the expectation methods.
 
-Also note that these expectations would be written iteratively, but the purpose
-of this document is to serve as an introduction to the RSpec framework, not to
-Behaviour Driven Development itself.
+Also note that these expectations would be written iteratively, but the
+purpose of this document is to serve as an introduction to the RSpec
+framework, not to Behaviour Driven Development itself.
 
 As you can see, writing expectations can be rather verbose, even for a simple
 project like the example above. For clarity, your expectations will be grouped
@@ -104,11 +105,12 @@ into specifications, which are described in the next section.
 
 == Specifications
 
-Your software will be specified by writing expectations, which were explained in
-the previous section. Your expectations will be grouped into specifications for
-clarity. A specification is simply a method that contains expectations. The name
-of your specification will be used by the Spec Runner (see Running and
-Reporting) to inform you of unmet expectations, so choose your names wisely.
+Your software will be specified by writing expectations, which were explained
+in the previous section. Your expectations will be grouped into specifications
+for clarity. A specification is simply a method that contains expectations.
+The name of your specification will be used by the Spec Runner (see Running
+and Reporting) to inform you of unmet expectations, so choose your names
+wisely.
 
 Consider the robot example from the previous example, but divided into
 specification methods:
@@ -137,40 +139,37 @@ specification methods:
       rob.move_west(15).should_equal [-5, 5]
     end
 
-By dividing expectations into specification methods, our specifications for the
-behaviour of our software are far easier to read and clearly express the intent.
-Even those who are unfamiliar with Ruby specifically (and perhaps even some who
-are relatively unfamiliar with software development in general) can easily read
-our specifications.
+By dividing expectations into specification methods, our specifications for
+the behaviour of our software are far easier to read and clearly express the
+intent. Even those who are unfamiliar with Ruby specifically (and perhaps even
+some who are relatively unfamiliar with software development in general) can
+easily read our specifications.
 
-== Fixtures
+== Contexts
 
 As you can see, there is some duplicated code in the example from the last
 section in the creation of the Robot objects. You will find that the
-initialization of objects will often be duplicated when writing specifications.
+initialization of objects will often be duplicated when writing
+specifications.
+
 RSpec provides you with a way of setting up this data ahead of time, by
 providing two methods: setup and teardown.
 
 The setup method is called before invoking each specification to allow you to
 set up resources which are required for each specification, and the teardown
 method is called after invoking each specification, to allow you to
-appropriately deallocate or close resources wich were required for the
+appropriately deallocate or close resources which were required for the
 specifications.
 
-The example in the next section include a demonstration of the usage of fixtures
-in Contexts.
-
-== Contexts
-
 The specifications described in the Specifications example are absolutely
-useless if they're not placed in a context. Because you will be writing a large
-number of specifications for your software, you will want a way to divide them
-into logical groups. Specification methods are grouped within subclasses of
-Context. You can define as many contexts as you wish, and you are encouraged to
-divide your software into many well-defined contexts.
+useless if they're not placed in a context. Because you will be writing a
+large number of specifications for your software, you will want a way to
+divide them into logical groups. Specification methods are grouped within
+subclasses of Context. You can define as many contexts as you wish, and you
+are encouraged to divide your software into many well-defined contexts.
 
-The following Context is a complete specification for the movement of the robot,
-and if it were run, would produce useful output.
+The following Context is a complete specification for the movement of the
+robot, and if it were run, would produce useful output.
 
     require 'spec'
     class RobotMovement < Spec::Context
@@ -193,16 +192,16 @@ and if it were run, would produce useful output.
 === Specification Naming
 
 RSpec does not require the use of a specific naming scheme for specifications.
-When a context is run, all of the public methods which you define in the context
-will be executed. The only exceptions are currently methods which are used
-internally by RSpec. The forbidden names are initialize, mock, violated, and
-run. Because of Ruby's dynamic nature, you will not see a warning if you
+When a context is run, all of the public methods which you define in the
+context will be executed. The only exceptions are currently methods which are
+used internally by RSpec. The forbidden names are initialize, mock, violated,
+and run. Because of Ruby's dynamic nature, you will not see a warning if you
 override any of these methods, and unexpected behaviour may ensue.
 
 In addition to the four aforementioned forbidden specification method names,
-methods named with a leading underscore will also not be run as specifications.
-This allows you a way to define methods for your own use within the Context and
-not have them run as specifications.
+methods named with a leading underscore will also not be run as
+specifications. This allows you a way to define methods for your own use
+within the Context and not have them run as specifications.
 
 == Running and Reporting
 
@@ -223,10 +222,11 @@ examples, you will get the following output:
 
 The spec runner counts the specification as it executes them by printing a
 single dot (.) to the screen. It indicates a failure with an X. For every
-failure, the specification runner will provide a backtrace indicating where the
-failure occured. A failure is basically a raised exception. Either an exception
-raised by the software you're specifying, by Ruby itself (such as SyntaxError or
-RuntimeError), or it will be an unmet expectation (ExpectationNotMet).
+failure, the specification runner will provide a backtrace indicating where
+the failure occurred. A failure is basically a raised exception. Either an
+exception raised by the software you're specifying, by Ruby itself (such as
+SyntaxError or RuntimeError), or it will be an unmet expectation
+(ExpectationNotMet).
 
 For instance, if you expect "Space Balls" to be in OneMovieList which actually
 includes "Star Wars", you will get the following error:
@@ -244,8 +244,8 @@ includes "Star Wars", you will get the following error:
 
     4 specifications, 4 expectations, 1 failures
 
-This informs you that the MovieList object should include "Space Balls", but got
-an ExpectationNotMet error. The backtrace also informs you that the unmet
+This informs you that the MovieList object should include "Space Balls", but
+got an ExpectationNotMet error. The backtrace also informs you that the unmet
 expectation can be found in the file 'movie_spec.rb' on line 34, in the
 `should_include_space_balls' method.
 
@@ -253,7 +253,7 @@ expectation can be found in the file 'movie_spec.rb' on line 34, in the
 
 This document was by no means intended to provide an exhaustive overview of
 Behaviour Driven Development in general, or RSpec specifically. It is intended
-as a tutorial to get you started with specifying the behaviour of your software
-with RSpec. More information can be found in the API documentation of RSpec
-itself. Further documentation on BDD, and RSpec is on the way.
+as a tutorial to get you started with specifying the behaviour of your
+software with RSpec. More information can be found in the API documentation of
+RSpec itself. Further documentation on BDD, and RSpec is on the way.
 

data/examples/add_specification_spec.rb

@@ -0,0 +1,15 @@
+require 'spec'
+
+class AddSpecification < Spec::Context
+
+  def a_passing_spec
+    true.should_equal true
+  end
+  
+  def a_failing_spec
+    true.should_equal false
+  end
+  
+end
+
+AddSpecification.add_specification('another_failing_spec') { false.should_equal true }

data/examples/dsl_spec.rb

@@ -0,0 +1,8 @@
+specification "failing_spec" do
+  true.should_equal false
+end
+
+
+specification "passing_spec" do
+  true.should_equal true
+end

data/lib/spec.rb

@@ -2,5 +2,7 @@ require 'spec/context'
 require 'spec/expectations'
 require 'spec/exceptions'
 require 'spec/text_runner'
+require 'spec/gui_runner'
 require 'spec/mock'
 require 'spec/collector'
+require 'spec/dsl'

data/lib/spec/context.rb

@@ -50,13 +50,21 @@ module Spec
       rescue Exception
         result_listener.failure(@specification, $!)
       ensure
-        teardown
-        verify_mocks
+        begin
+          teardown
+          verify_mocks
+        rescue Exception
+          result_listener.failure(@specification, $!)
+        end
       end
 
       return result
     end
 
+    def self.add_specification(name, &block)
+      self.send(:define_method, name.to_sym, Proc.new { || block.call })
+    end
+
   private
   
     def self.my_methods

data/lib/spec/dsl.rb

@@ -0,0 +1,23 @@
+require 'spec'
+
+module DSLExtensions
+
+  def context(name)
+    eval "$#{name} = Class.new(Spec::Context)"
+    $current_context = eval "$#{name}"
+  end
+
+  def specification(name, &block)
+    $default_context ||= Class.new(Spec::Context)
+    $current_context = $default_context if $current_context.nil?
+
+    $current_context.add_specification(name.to_sym, &block)
+  end
+
+end
+
+class Object
+  include DSLExtensions
+end
+
+alias example specification if ENV['USER'] == 'marick'

data/lib/spec/expectations.rb

@@ -1,6 +1,5 @@
 module Spec
-  module Expectations
-
+  module ExpectationHelperMethods
     def should(message=nil)
       message ||= "Expectation not met."
       if (! yield)
@@ -11,6 +10,10 @@ module Spec
     def default_message(expectation, expected)
       "<#{self.inspect}:#{self.class}>\n#{expectation}:\n<#{expected.inspect}:#{expected.class}>"
     end
+  end
+  
+  module ObjectExpectations
+    include ExpectationHelperMethods
 
     def should_equal(expected, message=nil)
       message ||= default_message("should be equal to", expected)
@@ -81,11 +84,50 @@ module Spec
       message ||= "<#{self}> should be false"
       should(message) { not self }
     end
+    
   end
-
+  
+  
+  module ProcExpectations
+    include ExpectationHelperMethods
+    
+    def should_raise(exception=Exception, message=nil)
+      message ||= default_message("should raise", exception.class.to_s)
+      should(message) do
+        begin
+          self.call
+          false
+        rescue exception
+          true
+        rescue
+          false
+        end
+      end
+    end
+    
+    def should_not_raise(exception=Exception, message=nil)
+      message ||= default_message("should not raise", exception.class.to_s)
+      should(message) do
+        begin
+          self.call
+          true
+        rescue exception
+          false
+        rescue
+          true
+        end
+      end
+    end
+  
+  end
+  
 end
 
 
 class Object
-  include Spec::Expectations
+  include Spec::ObjectExpectations
+end
+
+class Proc
+  include Spec::ProcExpectations
 end

data/lib/spec/gui_runner.rb

@@ -0,0 +1,59 @@
+require 'socket' 
+@socket
+module Spec
+  class GuiRunner
+ 
+    def initialize(port)
+      @failures = Array.new
+      @specification_count = 0
+      @failure_count = 0
+      @failed = false
+      @socket = TCPSocket.new("127.0.0.1", port)
+			@socket << "connected\n"
+    end
+
+    def run(context_or_collection = Spec::Collector)
+			specs = context_or_collection.collection
+      start_run specs.size
+      specs.each {|spec| spec.run(self)}
+      end_run
+			@socket.shutdown
+    end
+
+    def spec(spec)
+      @failed = false
+    end
+  
+    def pass(spec)
+      @socket << "passed\n"
+    end
+
+    def failure(spec, exception)
+			return if @failed
+      @socket << "failed\n"
+      @failed = true
+      dump_failure(exception)
+    end
+  
+    def start_run(number_of_specs)
+      @socket << "start #{number_of_specs.to_i}\n"
+    end
+  
+    def end_run
+      @socket << "end\n"
+    end    
+
+    def dump_failure(exception)
+   		@socket << "#{exception.message} (#{exception.class.name})\n"
+      dump_backtrace(exception.backtrace)
+			@socket << "!\n"
+    end
+
+    def dump_backtrace(trace)
+    	lines = trace.reject {|line| line.include? "lib/spec"}.reject {|line | line.include? "./spec:"}
+      @socket << lines.join("\n")
+			@socket << "\n"
+    end
+    
+  end
+end

data/lib/spec/mock.rb

@@ -39,7 +39,7 @@ class Mock
         # act as null object if method is missing and we ignore them. return value too!
         @options[:null_object] ? self : super(sym, *args, &block)
       rescue NoMethodError
-        raise Spec::Exceptions::MockExpectationError, "Mock '#{@name}' received unexpected message '#{sym.to_s}'"
+        raise Spec::Exceptions::MockExpectationError, "Mock '#{@name}' received unexpected message '#{sym.to_s}' with " + (args.collect{|arg| "<#{arg}:#{arg.class.name}>"}.join(", "))
       end
     end
   end
@@ -47,7 +47,7 @@ class Mock
 private
 
   def find_matching_expectation(sym, *args)
-    expectation = @expectations.find {|expectation| expectation.matches(sym, *args)}
+    expectation = @expectations.find {|expectation| expectation.matches(sym, args)}
     expectation
   end
 
@@ -65,28 +65,38 @@ class MessageExpectation
     @received_count = 0
     @expected_received_count = 1
     @expected_params = nil
+    @consecutive = false
   end
   
-  def matches(sym, *args)
-    @sym == sym
+  def matches(sym, args)
+    @sym == sym and (@expected_params.nil? or @expected_params == args)
   end
 
   # This method is called at the end of a spec, after teardown.
   def verify_messages_received
     # TODO: this doesn't provide good enough error messages to fix the error.
     # Error msg should tell exactly what went wrong. (AH).
-    unless @expected_received_count == @received_count
-      expected_signature = nil
-      if @expected_params.nil?
-        expected_signature = @sym
-      else
-        params = @expected_params.collect{|param| "<#{param}:#{param.class.name}>"}.join(", ")
-        expected_signature = "#{@sym}(#{params})"
-      end
-      message = "#{@expected_from}: Mock '#{@mock_name}' expected #{expected_signature} #{@expected_received_count} times, but received it #{@received_count} times"
+    
+    return if @expected_received_count == -2
+    return if (@expected_received_count == -1) && (@received_count > 0)
+    return if @expected_received_count == @received_count
+    
+    expected_signature = nil
+    if @expected_params.nil?
+      expected_signature = @sym
+    else
+      params = @expected_params.collect{|param| "<#{param}:#{param.class.name}>"}.join(", ")
+      expected_signature = "#{@sym}(#{params})"
+    end
+    
+    count_message = "{@expected_received_count} times"
+    count_message = "at least once" if (@expected_received_count == -1)
+    count_message = "never" if (@expected_received_count == 0)
+    count_message = "once" if (@expected_received_count == 1)
+    count_message = "twice" if (@expected_received_count == 2)
 
+    message = "#{@expected_from}: Mock '#{@mock_name}' expected #{expected_signature} #{count_message}, but received it #{@received_count} times"
       raise Spec::Exceptions::MockExpectationError, message
-    end
   end
 
   # This method is called when a method is invoked on a mock
@@ -103,11 +113,15 @@ class MessageExpectation
     
     unless @expected_params.nil? or @expected_params == args
       raise Spec::Exceptions::MockExpectationError,
-        "#{@sym}: Parameter mismatch: Expected <#{@expected_params}>, got <#{@args}>" 
+        "#{@sym}: Parameter mismatch: Expected <#{@expected_params}>, got <#{args}>" 
     end
     args << block unless block.nil?
     @received_count += 1
-    @block.call(*args)
+    value = @block.call(*args)
+    
+    return value unless @consecutive
+    
+    value[[@received_count, value.size].min - 1]
   end
 
   def with(*args)
@@ -126,8 +140,14 @@ class MessageExpectation
   end
   
   def at_least_once
+    @expected_received_count = -1
     self
   end
+
+   def any_number_of_times
+     @expected_received_count = -2
+     self
+   end
   
   def never
     @expected_received_count = 0
@@ -147,9 +167,16 @@ class MessageExpectation
   def returns(value=nil,&block)
     @block = block_given? ? block : proc { value }
   end
+
+  def returns_consecutively(value=[nil],&block)
+    @consecutive = true
+    @block = block_given? ? block : proc { value }
+  end
+  
   # this reads better in English IMHO: (AH)
   # uri_specs.should_receive(:[]).with(:overview).and_return("http://some.host/look_here/\#{path}")
   alias :and_return :returns
+  alias :and_return_consecutively :returns_consecutively
   
 end
 

data/lib/spec/text_runner.rb

@@ -4,8 +4,8 @@ module Spec
     def initialize(appendable = $stdout)
       @failures = Array.new
       @specification_count = 0
-      @expectation_count = 0
       @failure_count = 0
+      @failed = false
       @output = appendable
     end
 
@@ -14,22 +14,23 @@ module Spec
       context_or_collection.collection.each {|context| context.run(self)}
       end_run
     end
+
+    def spec(spec)
+      @specification_count += 1
+      @failed = false
+    end
   
     def pass(spec)
       @output << "."
-      @expectation_count += 1
     end
 
     def failure(spec, exception)
-      @output << "X"
-      @expectation_count += 1
+      @output << "X" unless @failed
+      @failure_count += 1 unless @failed
+      @failed = true
       @failures << exception
     end
   
-    def spec(spec)
-      @specification_count += 1
-    end
-  
     def start_run
       @output << "\n"
       @start_time = Time.new
@@ -67,8 +68,7 @@ module Spec
     
     def dump_counts
       @output << "\n" << @specification_count.to_s << " specifications, "
-      @output << @expectation_count.to_s << " expectations, "
-      @output << @failures.length.to_s << " failures\n"
+      @output << @failure_count.to_s << " failures\n"
     end
     
   end

data/test/dsl_test.rb

@@ -0,0 +1,48 @@
+require 'test/unit'
+
+require 'spec'
+
+class DSLTest < Test::Unit::TestCase
+  
+  def setup
+    $default_context = nil
+    $current_context = nil
+  end
+  
+  def test_should_have_specification_method_defined
+    assert_equal true, Object.public_method_defined?(:specification)
+  end
+  
+  def test_should_add_specification_to_default_context
+    specification('foobar') { true.should_equal true }
+    
+    assert_equal true, $default_context.specifications.include?('foobar')
+  end
+  
+  def test_should_create_new_context
+    context 'my_context'
+    
+    assert_equal Spec::Context, $my_context.superclass
+  end
+  
+  def test_should_set_current_context_to_new_context
+    context 'bar'
+    
+    assert_equal $current_context, $bar
+  end
+  
+  def test_should_add_bar_specification_to_foo_context
+    context 'foo'
+    specification('bar') { true.should_equal true }
+    
+    assert_equal true, $foo.specifications.include?('bar')
+  end
+  
+  def test_should_add_bar_specification_to_current_context
+    context 'foo'
+    specification('bar') { true.should_equal true }
+    
+    assert_equal true, $current_context.specifications.include?('bar')
+  end
+
+end

data/test/expectations_test.rb

@@ -423,5 +423,45 @@ class ExpectationsTest < Test::Unit::TestCase
       self.should_be_false
     end
   end
+  
+  # should_raise
+  
+  def test_should_raise_should_pass_when_proper_exception_is_raised
+    assert_nothing_raised do
+      proc { ''.nonexistant_method }.should_raise(NoMethodError)
+    end
+  end
+  
+  def test_should_raise_should_not_pass_when_wrong_exception_is_raised
+    assert_raise(Spec::Exceptions::ExpectationNotMetError) do
+      proc { ''.nonexistant_method }.should_raise(SyntaxError)
+    end
+  end
+  
+  def test_should_raise_should_not_pass_with_no_exception
+    assert_raise(Spec::Exceptions::ExpectationNotMetError) do
+      not proc {''.to_s}.should_raise(NoMethodError)
+    end
+  end
+  
+  # should_not_raise
+  
+  def test_should_not_raise_should_pass_when_proper_exception_is_raised
+    assert_raise(Spec::Exceptions::ExpectationNotMetError) do
+      proc { ''.nonexistant_method }.should_not_raise(NoMethodError)
+    end
+  end
+  
+  def test_should_not_raise_should_not_pass_when_wrong_exception_is_raised
+    assert_nothing_raised do
+      proc { ''.nonexistant_method }.should_not_raise(SyntaxError)
+    end
+  end
+  
+  def test_should_not_raise_should_not_pass_with_no_exception
+    assert_nothing_raised do
+      not proc { ''.to_s }.should_not_raise(NoMethodError)
+    end
+  end
 
 end

data/test/gui_runner_test.rb

@@ -0,0 +1,162 @@
+require 'test/unit'
+require 'socket'
+require 'spec'
+
+class PassingCon < Spec::Context
+
+  def ex1
+    true.should_be_true
+  end
+
+  def ex2
+    true.should_be_true
+  end
+
+  def ex3
+    true.should_be_true
+  end
+
+end
+
+
+class FailingCon < Spec::Context
+
+  def fail1
+    false.should_be_true
+  end
+
+  def fail2
+    false.should_be_true
+  end
+
+  def fail3
+    false.should_be_true
+  end
+
+end
+
+
+class ErringCon < Spec::Context
+
+  def error1
+    raise "boom"
+  end
+
+  def error2
+    raise "boom"
+  end
+
+  def error3
+    raise "boom"
+  end
+
+end
+
+class SocketListener
+
+	def initialize(port)
+	  @server_socket = TCPServer.new("127.0.0.1", port)
+		@expectations = Array.new
+		@next_expectation_index = 0 
+		@expectations_met = false
+	end
+	
+	def shutdown
+		@th.kill
+		@server_socket.shutdown
+	end
+	
+	def expects(expected_regex)
+		@expectations << expected_regex
+	end
+	
+	def verify
+		sleep 1
+		return if @expectations_met
+		msg = "Nothing matching /#{@expectations[@next_expectation_index].source}/ was seen"
+		raise  Test::Unit::AssertionFailedError.new(msg)
+	end
+	
+	def run
+		@socket = @server_socket.accept
+		@th = Thread.new("socket listener") do
+			until @expectations_met
+				msg, sender = @socket.readline
+				msg.chomp!
+				next unless @expectations[@next_expectation_index] =~ msg
+				@next_expectation_index += 1
+				remaining = @expectations.size - @next_expectation_index
+				@expectations_met = (remaining == 0)
+			end
+		end
+	end
+end
+
+class TestGuiRunner < Test::Unit::TestCase
+
+  def setup
+		port = 13001
+		@listener = SocketListener.new(port)
+		@listener.expects /connected/
+    @runner = Spec::GuiRunner.new(port)
+  end
+
+	def teardown
+		@listener.shutdown
+	end
+
+	def test_size_on_start
+		@listener.expects /start 3/
+		@listener.run
+		@runner.run(PassingCon)
+		@listener.verify
+	end
+	
+  def test_passing_example_outputs_period
+		@listener.expects /start/
+		@listener.expects /passed/
+		@listener.expects /passed/
+		@listener.expects /passed/
+		@listener.expects /end/
+		@listener.run
+    @runner.run(PassingCon)
+    @listener.verify
+  end
+
+  def test_failing_example_outputs_X
+		@listener.expects /start/
+		@listener.expects /failed/
+		@listener.expects /failed/
+		@listener.expects /failed/
+		@listener.expects /end/
+		@listener.run
+    @runner.run(FailingCon)
+    @listener.verify
+  end
+
+  def test_erring_example_outputs_X
+		@listener.expects /start/
+		@listener.expects /failed/
+		@listener.expects /failed/
+		@listener.expects /failed/
+		@listener.expects /end/
+		@listener.run
+    @runner.run(ErringCon)
+    @listener.verify
+  end
+  
+  def test_failure_backtrace
+		@listener.expects /.*in `fail1'.*/
+		@listener.run
+    @runner.run(FailingCon)
+    @listener.verify
+  end
+
+  def test_error_backtrace
+		@listener.expects /.*in `error3'.*/
+		@listener.run
+    @runner.run(ErringCon)
+    @listener.verify
+  end
+
+end

data/test/mock_test.rb

@@ -13,7 +13,7 @@ class MockTest < Test::Unit::TestCase
     begin
       @mock.__verify
     rescue Spec::Exceptions::MockExpectationError => e
-      e.message.should_equal "./test/mock_test.rb:11:in `test_should_report_line_number_of_expectaion_of_unreceived_message': Mock 'test mock' expected wont_happen(<x:String>, <3:Fixnum>) 1 times, but received it 0 times"
+      e.message.should_equal "./test/mock_test.rb:11:in `test_should_report_line_number_of_expectaion_of_unreceived_message': Mock 'test mock' expected wont_happen(<x:String>, <3:Fixnum>) once, but received it 0 times"
     end
     
   end
@@ -89,4 +89,69 @@ class MockTest < Test::Unit::TestCase
     end
   end
   
+  def test_two_return_values
+    @mock.should_receive(:multi_call).twice.with_no_args.and_return_consecutively([1, 2])
+    assert_equal(1, @mock.multi_call)
+    assert_equal(2, @mock.multi_call)
+    @mock.__verify
+  end
+  
+  def test_repeating_final_return_value
+    @mock.should_receive(:multi_call).at_least_once.with_no_args.and_return_consecutively([1, 2])
+    assert_equal(1, @mock.multi_call)
+    assert_equal(2, @mock.multi_call)
+    assert_equal(2, @mock.multi_call)
+    @mock.__verify
+  end
+  
+  def test_should_throw_on_call_of_never_method
+    @mock.should_receive(:random_call).never
+    assert_raise(Spec::Exceptions::MockExpectationError) do
+      @mock.random_call
+      @mock.__verify
+    end
+  end
+  
+  def test_should_throw_if_at_least_once_method_not_called
+    @mock.should_receive(:random_call).at_least_once
+    assert_raise(Spec::Exceptions::MockExpectationError) do
+      @mock.__verify
+    end
+  end
+  
+  def test_should_not_throw_if_any_number_of_times_method_not_called
+    @mock.should_receive(:random_call).any_number_of_times
+    @mock.__verify
+  end
+  
+  def test_should_not_throw_if_any_number_of_times_method_is_called
+    @mock.should_receive(:random_call).any_number_of_times
+    @mock.random_call
+    @mock.__verify
+  end
+  
+  def test_should_not_throw_if_at_least_once_method_is_called_twice
+    @mock.should_receive(:random_call).at_least_once
+    @mock.random_call
+    @mock.random_call
+    @mock.__verify
+  end
+  
+  def test_should_support_mutiple_calls_with_different_args
+    @mock.should_receive(:random_call).once.with(1)
+    @mock.should_receive(:random_call).once.with(2)
+    @mock.random_call(1)
+    @mock.random_call(2)
+    @mock.__verify
+  end
+  
+  def test_should_support_multiple_calls_with_different_args_and_counts
+    @mock.should_receive(:random_call).twice.with(1)
+    @mock.should_receive(:random_call).once.with(2)
+    @mock.random_call(1)
+    @mock.random_call(2)
+    @mock.random_call(1)
+    @mock.__verify
+  end
+  
 end

data/test/specification_addition_test.rb

@@ -0,0 +1,29 @@
+require 'test/unit'
+
+require 'spec'
+
+
+class AddToMe < Spec::Context
+  
+  def orig_spec
+    true.should_equal true
+  end
+  
+end
+
+
+class SpecificationAdditionTest < Test::Unit::TestCase
+
+  def test_should_add_foo_specification_to_context
+    AddToMe.add_specification(:added_spec) { false.should_equal false }
+    
+    assert_equal true, AddToMe.specifications.include?('added_spec')
+  end
+  
+  def test_should_add_another_specification_to_context
+    AddToMe.add_specification(:another_added_spec) { true.should_equal false }
+    
+    assert_equal true, AddToMe.specifications.include?('another_added_spec')
+  end
+  
+end

data/test/text_runner_test.rb

@@ -97,19 +97,44 @@ class TestTextRunner < Test::Unit::TestCase
 
   def test_summary_with_no_failures
     @runner.run(PassingCon)
-    assert_buffer_includes "3 specifications, 3 expectations, 0 failures"
+    assert_buffer_includes "3 specifications, 0 failures"
   end
   
 	def test_should_run_all_specifications
 		@runner.run(Spec::Collector)
-		assert_buffer_includes "9 specifications, 9 expectations, 6 failures"
+		assert_buffer_includes "9 specifications, 6 failures"
 	end
 
 	def test_should_run_all_specifications_when_no_args_provided
 		@runner.run
-		assert_buffer_includes "9 specifications, 9 expectations, 6 failures"
+		assert_buffer_includes "9 specifications, 6 failures"
 	end
 
+  def test_should_only_report_first_failure
+    ex = Spec::Exceptions::ExpectationNotMetError.new("1")
+    ex.set_backtrace(["1", "2"])
+    @runner.start_run
+    @runner.spec(nil)
+    @runner.failure(nil, ex)
+    @runner.failure(nil, ex)
+    @runner.end_run
+    assert_buffer_includes "1 specifications, 1 failure"
+  end
+
+  def test_should_only_report_first_failure_over_multiple_specs
+    ex = Spec::Exceptions::ExpectationNotMetError.new("1")
+    ex.set_backtrace(["1", "2"])
+    @runner.start_run
+    @runner.spec(nil)
+    @runner.failure(nil, ex)
+    @runner.failure(nil, ex)
+    @runner.spec(nil)
+    @runner.failure(nil, ex)
+    @runner.failure(nil, ex)
+    @runner.end_run
+    assert_buffer_includes "2 specifications, 2 failure"
+  end
+
   def assert_buffer_includes(substring)
     assert(@buffer.include?(substring), _buffer_message(substring))
   end

metadata

@@ -1,10 +1,10 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.8.10
+rubygems_version: 0.8.11
 specification_version: 1
 name: rspec
 version: !ruby/object:Gem::Version 
-  version: 0.2.0
-date: 2005-09-27
+  version: 0.3.0
+date: 2006-01-20 00:00:00 -08:00
 summary: Behaviour Specification Framework for Ruby
 require_paths: 
   - lib
@@ -27,33 +27,41 @@ required_ruby_version: !ruby/object:Gem::Version::Requirement
         version: 0.0.0
   version: 
 platform: ruby
+signing_key: 
+cert_chain: 
 authors: 
   - Steven Baker
 files: 
   - CHANGES
-  - MT
-  - Rakefile.rb
+  - Rakefile
   - README
   - TODO
   - TUTORIAL
   - lib/spec.rb
   - lib/spec/collector.rb
   - lib/spec/context.rb
+  - lib/spec/dsl.rb
   - lib/spec/exceptions.rb
   - lib/spec/expectations.rb
+  - lib/spec/gui_runner.rb
   - lib/spec/mock.rb
   - lib/spec/text_runner.rb
   - test/context_fixtures_test.rb
   - test/context_run_test.rb
+  - test/dsl_test.rb
   - test/error_reporting_test.rb
   - test/expectations_test.rb
   - test/get_classes.rb
+  - test/gui_runner_test.rb
   - test/mock_test.rb
   - test/spec_collection_test.rb
+  - test/specification_addition_test.rb
   - test/specification_identification_test.rb
   - test/text_runner_test.rb
+  - examples/add_specification_spec.rb
   - examples/craps.rb
   - examples/craps_spec.rb
+  - examples/dsl_spec.rb
   - examples/movie.rb
   - examples/movie_list.rb
   - examples/movie_spec.rb