rspec 0.1.6 → 0.1.7

data/CHANGES

@@ -13,51 +13,62 @@
 * Make sure the PKG_VERSION constant in Rakefile.rb is
   consistent with the latest version in this document.
 
-* IMPORTANT! A bug in XForge requires at least one * (change) to be present 
-  for each release, or it will include the release notes for the previous
-  version!!
+== Version 0.1.7
+
+This release improves installation and documentation, mock integration and error reporting.
+
+* Comparison errors now print the class name too.
+* Mocks now take an optional +options+ parameter to specify behaviour.
+* Removed __expects in favour of should_receive
+* Added line number reporting in mock error messages for unreceived message expectations (AH).
+* Added should_match and should_not_match (AH).
+* Added a +mock+ method to Spec::Context which will create mocks that autoverify (no need to call __verify) (AH).
+* Mocks now require names in the constructor to ensure sensible error messages (AH).
+* Made 'spec' executable and updated usage instructions in README accordingly (AH).
+* Made more parts of the Spec::Context API private to avoid accidental usage (AH).
+* Added more RDoc to Spec::Context.
 
 == Version 0.1.6
 
 More should methods.
 
-* Added should_match and should_not_match
+* Added should_match and should_not_match (AH).
 
 == Version 0.1.5
 
-Included examples and tests in gem.
+Included examples and tests in gem (AH).
 
 == Version 0.1.4
 
-More tests on block based Mock expectations
+More tests on block based Mock expectations.
 
 == Version 0.1.3
 
 Improved mocking:
 
-* block based Mock expectations
+* block based Mock expectations.
 
 == Version 0.1.2
 
 This release adds some improvements to the mock API and minor syntax improvements
 
-* Added Mock.should_expect for a more consistent DSL
-* Added MockExpectation.and_returns for a better DSL
-* Made Mock behave as a null object after a call to Mock.ignore_missing
-* Internal syntax improvements
-* Improved exception trace by adding exception class name to error message
-* Renamed some tests for better consistency
+* Added Mock.should_expect for a more consistent DSL (AH).
+* Added MockExpectation.and_returns for a better DSL (AH).
+* Made Mock behave as a null object after a call to Mock.ignore_missing (AH)
+* Internal syntax improvements (AH).
+* Improved exception trace by adding exception class name to error message (AH).
+* Renamed some tests for better consistency (AH).
 
 == Version 0.1.1
 
 This release adds some shoulds and improves error reporting
 
-* Added should_be_same_as and should_not_be_same_as
-* Improved error reporting for comparison expectations
+* Added should_be_same_as and should_not_be_same_as (AH).
+* Improved error reporting for comparison expectations (AH).
 
 == Version 0.1.0
 
 This is the first preview release of RSpec, a Behaviour-Driven Development library for Ruby 
 
-* Added Rake script with tasks for gems, rdoc etc.
-* Added an XForge task to make release go easier.
+* Added Rake script with tasks for gems, rdoc etc (AH).
+* Added an XForge task to make release go easier (AH).

data/README

@@ -11,10 +11,35 @@ from Dave himself.
 
 == Download/Installation
 
+=== Using RubyGems
+
+  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.
 
     * monotone --db=database db init
     * monotone --db=database pull goliath.fundynet.ca org.rubyforge.rspec
     * monotone --db=database --branch=org.rubyforge.rspec checkout RSpec
 
+The gem can be created and installed from sources as follows:
+
+  rake gem; sudo gem install pkg/rspec_x.y.z.gem
+
 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.
+
+== Usage
+
+This will also install a new executable for you, 'spec'. Now you
+
+Do a fun dance.
+
+  spec movie_spec.rb
+
+Do another dance.
+
+  spec *_spec.rb
+
+This is the coolest part.  Dance harder.  Now drink.
+

data/Rakefile.rb

@@ -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.1.6"
+PKG_VERSION = "0.1.7"
 PKG_FILE_NAME = "#{PKG_NAME}-#{PKG_VERSION}"
 PKG_FILES = FileList[
   '[A-Z]*',
@@ -29,14 +29,66 @@ PKG_FILES = FileList[
   'doc/**/*'
 ]
 
-task :default => [:test]
+task :default => [:test, :test_craps_collector, :test_movie_collector,
+	:test_rspec_craps, :test_rspec_movie, :test_rspec_craps_and_movie,
+	:test_text_runner]
 
 Rake::TestTask.new do |t|
   t.libs << "test"
-  t.test_files = FileList['**/*_test.rb']
+  t.test_files = FileList['**/*_test.rb'].exclude("test/*_collector_test.rb",
+		"test/rspec_*.rb", "test/text_runner_test.rb")
   t.verbose = true
 end
 
+# collector tests need to run individually
+
+Rake::TestTask.new(:test_craps_collector) do |t|
+	t.libs << "test"
+	t.libs << "examples"
+	t.test_files = FileList['test/craps_collector_test.rb']
+	t.verbose = true
+end
+
+Rake::TestTask.new(:test_movie_collector) do |t|
+	t.libs << "test"
+	t.libs << "examples"
+	t.test_files = FileList['test/movie_collector_test.rb']
+	t.verbose = true
+end
+
+# rspec tests need to run individually
+
+Rake::TestTask.new(:test_rspec_craps) do |t|
+	t.libs << "test"
+	t.libs << "examples"
+	t.test_files = FileList['test/rspec_craps_test.rb']
+	t.verbose = true
+end
+
+Rake::TestTask.new(:test_rspec_movie) do |t|
+	t.libs << "test"
+	t.libs << "examples"
+	t.test_files = FileList['test/rspec_movie_test.rb']
+	t.verbose = true
+end
+
+Rake::TestTask.new(:test_rspec_craps_and_movie) do |t|
+	t.libs << "test"
+	t.libs << "examples"
+	t.test_files = FileList['test/rspec_craps_and_movie_test.rb']
+	t.verbose = true
+end
+
+# text runner tests need to run individually
+
+Rake::TestTask.new(:test_text_runner) do |t|
+	t.libs << "test"
+	t.libs << "examples"
+	t.test_files = FileList['test/text_runner_test.rb']
+	t.verbose = true
+end
+
+
 # Create a task to build the RDOC documentation tree.
 rd = Rake::RDocTask.new("rdoc") do |rdoc|
   rdoc.rdoc_dir = 'html'
@@ -79,6 +131,14 @@ spec = Gem::Specification.new do |s|
   
   s.test_files = Dir.glob('test/tc_*.rb')
 
+  #### Make executable
+  s.require_path = 'lib'
+  s.autorequire = 'spec'
+
+  s.bindir = "bin"
+  s.executables = ["spec"]
+  s.default_executable = "spec"
+
   #### Author and project details.
 
   s.author = "Steven Baker" 

data/TODO

@@ -0,0 +1,9 @@
+ - Rakefile should have an install target.
+ - Spec CLI needs to have a way to specify a runner.
+ - Rake tasks for spec running (see TestTask).
+ - Write specifications for the spec CLI.
+ - Avoid using both the 'rspec' and 'spec' names in sources and doco. It's confusing. Consider how to align with Dan North's JBehave effort in terms of name and vocabulary (AH).
+ - Decide whether mocks should expect messages in a particular order or not. -Or make it configurable. Ex: mock("foo", :order => "strict") (AH).
+ - Do we want to use an issue tracker? The one at RubyForge maybe?
+ - Create first class result objects instead of just Strings. This can be used to generate XML/YAML reports
+   which in turn can be transformed to e.g. HTML reports.

data/bin/spec

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+require 'spec'
+
+ARGV.each do |file|
+  require file
+end
+
+runner = Spec::TextRunner.new
+runner.run

data/examples/craps_spec.rb

@@ -4,16 +4,11 @@ require 'craps'
 class CrapsSpecification < Spec::Context
 
   def setup
-    @die1 = Mock.new
-    @die2 = Mock.new
+    @die1 = mock "die1"
+    @die2 = mock "die2"
     @game = Craps.new(@die1, @die2)
   end
   
-  def teardown
-    @die1.__verify
-    @die2.__verify
-  end
-  
   # coming out roll of 7
   
   def come_out_roll_of_1_6_wins

data/lib/spec.rb

@@ -3,3 +3,4 @@ require 'spec/expectations'
 require 'spec/exceptions'
 require 'spec/text_runner'
 require 'spec/mock'
+require 'spec/collector'

data/lib/spec/collector.rb

@@ -0,0 +1,17 @@
+require 'spec'
+
+
+module Spec
+	class Collector
+
+		def self.collection
+			collection = []
+			ObjectSpace.each_object(Class) do |cls|
+				collection << cls.collection if cls < Spec::Context
+			end
+			collection.flatten
+		end
+
+	end
+end
+

data/lib/spec/context.rb

@@ -1,32 +1,33 @@
 require 'spec'
 
 module Spec
+  # TODO: Could we try to make this a mixin (Module) instead? It would make it easier to
+  # create extensions that can be mixed and matched (AH).
   class Context
   
     def initialize(specification=nil)
       @specification = specification
+      @mocks = []
     end
 
-    def run(result_listener)
-      result = false
-    
-      result_listener.spec(@specification)
-      setup
-      begin
-        __send__(@specification)
-        result_listener.pass(@specification)
-      rescue Exception
-        result_listener.failure(@specification, $!)
-      end
-      teardown
-      
-      return result
+    def setup
     end
 
-    def setup
+    def teardown
     end
     
-    def teardown
+    # Creates a new named mock that will be automatically verified after #teardown
+    # has run. By using this method instead of Mock#new you don't have to worry about
+    # forgetting to verify your mocks.
+    def mock(name)
+      mock = Mock.new(name)
+      @mocks << mock
+      mock
+    end
+
+    # Immediately violates the current specification with +message+.
+    def violated(message="")
+      raise Spec::Exceptions::ExpectationNotMetError.new(message)
     end
 
     def self.collection
@@ -34,26 +35,46 @@ module Spec
       self.specifications.each do |spec|
         specs << self.new(spec.to_sym)
       end
-      
+
       return specs
     end
-  
-    def self.specifications
-      return self.my_methods.select {|spec| self.specification_name?(spec)}
+
+    def run(result_listener)
+      result = false
+
+      result_listener.spec(@specification)
+      setup
+      begin
+        __send__(@specification)
+        result_listener.pass(@specification)
+      rescue Exception
+        result_listener.failure(@specification, $!)
+      ensure
+        teardown
+        verify_mocks
+      end
+
+      return result
     end
 
+  private
+  
     def self.my_methods
       self.instance_methods - self.superclass.instance_methods
     end
 
     def self.specification_name?(name)
-      return false if not self.new.method(name).arity == 0
+      return false unless self.new.method(name).arity == 0
       return false if name[0..0] == '_'
-      return true
+      true
     end
-    
-    def violated
-      raise Spec::Exceptions::ExpectationNotMetError.new
+
+    def self.specifications
+      return self.my_methods.select {|spec| self.specification_name?(spec)}
+    end
+
+    def verify_mocks
+      @mocks.each{|m| m.__verify}
     end
 
   end

data/lib/spec/exceptions.rb

@@ -5,7 +5,5 @@ module Spec
     
     class MockExpectationError < StandardError
     end
-    
-    
   end
 end

data/lib/spec/expectations.rb

@@ -9,7 +9,7 @@ module Spec
     end
     
     def default_message(expectation, expected)
-      "<#{self}>\n#{expectation}:\n<#{expected}>"
+      "<#{self.inspect}:#{self.class}>\n#{expectation}:\n<#{expected.inspect}:#{expected.class}>"
     end
 
     def should_equal(expected, message=nil)

data/lib/spec/mock.rb

@@ -1,97 +1,127 @@
 require 'spec'
 
-
 class Mock
 
-  def initialize(identifier="")
-    @expectations = Hash.new
+  DEFAULT_OPTIONS = {
+    :null_object => false
+  }
+  # Creates a new mock with a +name+ (that will be used in error messages only)
+  # Options:
+  # * :null_object - if true, the mock object acts as a forgiving null object allowing any message to be sent to it.
+  def initialize(name, options={})
+    @name = name
+    @options = DEFAULT_OPTIONS.dup.merge(options)
+    @expectations = []
   end
-  
-  # How about renaming this to should_expect. This would be well aligned with the rest of
-  # the API, as well as the recommendation to use should as prefix for methods (Aslak)
-  def __expects(sym, &block)
-    @expectations[sym] = MockExpectation.new(block_given? ? block : nil)
-    @expectations[sym]
+
+  # AH: How about renaming this to should_receive. This would be:
+  #   * well aligned with the rest of the API (should)
+  #   * emphasize the dynamic oo lingo from smalltalk using 'message' instead of 'method' 
+  def should_receive(sym, &block)
+    expected_from = caller(1)[0]
+    expectation = MessageExpectation.new(@name, expected_from, sym, block_given? ? block : nil)
+    @expectations << expectation
+    expectation
   end
-  alias :should_expect :__expects
 
   def __verify
-    @expectations.keys.each do |method|
-      @expectations[method].verify(method.to_s) 
+    @expectations.each do |expectation|
+      expectation.verify_messages_received
     end
   end
-  
-  # Tell the mock to act as a forgiving null object on missing methods, in which
-  # case it will return itself.
-  def ignore_missing
-    @ignore_missing = true
-  end
 
   def method_missing(sym, *args, &block)
-    if expectation = @expectations[sym]
-      expectation.verify_call(sym.to_s,args,block)
+    # TODO: use find_expectation(sym, args) which will lookup based on sym, args and strict mode.
+    if expectation = find_matching_expectation(sym, *args)
+      expectation.verify_message(args, block)
     else
       begin
         # act as null object if method is missing and we ignore them. return value too!
-        @ignore_missing ? self : super(sym, *args, &block)
+        @options[:null_object] ? self : super(sym, *args, &block)
       rescue NoMethodError
-        raise Spec::Exceptions::MockExpectationError, "Unexpected method '#{sym.to_s}' called."
+        raise Spec::Exceptions::MockExpectationError, "Mock '#{@name}' received unexpected message '#{sym.to_s}'"
       end
     end
   end
 
+private
+
+  def find_matching_expectation(sym, *args)
+    expectation = @expectations.find {|expectation| expectation.matches(sym, *args)}
+    expectation
+  end
+
 end
 
+# Represents the expection of the reception of a message
+class MessageExpectation
 
-class MockExpectation
+  def initialize(mock_name, expected_from, sym, block)
+    @mock_name = mock_name
+    @expected_from = expected_from
+    @sym = sym
+    @method_block = block
+    @block = proc {}
+    @received_count = 0
+    @expected_received_count = 1
+    @expected_params = nil
+  end
+  
+  def matches(sym, *args)
+    @sym == sym
+  end
 
-  def verify(message)
-    unless @expected_call_count == @call_count
-      raise Spec::Exceptions::MockExpectationError, 
-        message+": Expected #{@expected_call_count} calls, got #{@call_count} calls"
+  # 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"
+
+      raise Spec::Exceptions::MockExpectationError, message
     end
   end
-  
-  def verify_call(message,args,block)
+
+  # This method is called when a method is invoked on a mock
+  def verify_message(args, block)
     unless @method_block.nil?
       begin
         result = @method_block.call(*args)
       rescue Spec::Exceptions::ExpectationNotMetError => detail
         raise Spec::Exceptions::MockExpectationError, "Call expectation violated with: " + $!
       end
-      @call_count = @call_count + 1
+      @received_count += 1
       return result
     end
     
     unless @expected_params.nil? or @expected_params == args
       raise Spec::Exceptions::MockExpectationError,
-        message+": Parameter mismatch: Expected <#{@expected_params}>, got <#{@args}>" 
+        "#{@sym}: Parameter mismatch: Expected <#{@expected_params}>, got <#{@args}>" 
     end
     args << block unless block.nil?
-    @call_count = @call_count + 1
+    @received_count += 1
     @block.call(*args)
   end
 
-  def initialize(block)
-    @method_block = block
-    @block = proc {}
-    @expected_call_count = 1
-    @call_count = 0
-    @expected_params = nil
-  end
-
   def with(*args)
     @expected_params = args
     self
   end
-  
+
   def with_no_args
     @expected_params = []
     self
   end
   
   def with_any_args
-    @expected_params = nill
+    @expected_params = nil
     self
   end
   
@@ -100,25 +130,28 @@ class MockExpectation
   end
   
   def never
-    @expected_call_count = 0
+    @expected_received_count = 0
     self
   end
   
   def once
-    @expected_call_count = 1
+    @expected_received_count = 1
     self
   end
   
   def twice
-    @expected_call_count = 2
+    @expected_received_count = 2
     self
   end
   
   def returns(value=nil,&block)
     @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
-  # this reads better: (AH)
-  # uri_specs.should_expect(:[]).with(:overview).and_return("http://some.host/look_here/\#{path}")
   
 end
+
+class Counter
+end

data/lib/spec/text_runner.rb

@@ -1,24 +1,15 @@
 module Spec
   class TextRunner
-
-    def initialize
-      common_initialization
-      @output = $stdout
-    end
-  
-    def initialize(appendable)
-      common_initialization
-      @output = appendable
-    end
-
-    def common_initialization
+ 
+    def initialize(appendable = $stdout)
       @failures = Array.new
       @specification_count = 0
       @expectation_count = 0
       @failure_count = 0
+      @output = appendable
     end
-  
-    def run(context_or_collection)
+
+    def run(context_or_collection = Spec::Collector)
       start_run
       context_or_collection.collection.each {|context| context.run(self)}
       end_run

data/test/craps_collector_test.rb

@@ -0,0 +1,17 @@
+require 'test/unit'
+
+require 'spec'
+
+
+class CrapsCollectorTest < Test::Unit::TestCase
+	
+	def setup
+		require 'examples/craps_spec'
+	end
+
+	def test_should_collect_only_craps_specification
+		assert_equal CrapsSpecification.specifications.length, Spec::Collector.collection.length
+	end
+
+end
+

data/test/error_reporting_test.rb

@@ -171,21 +171,21 @@ class ErrorReportingTest < Test::Unit::TestCase
   # should_equal
   
   def test_should_report_standard_message_for_should_equal
-    assert @runner.dump_failures.include?("<Object>\nshould be equal to:\n<Class>")
+    assert @runner.dump_failures.include?("<Object:Class>\nshould be equal to:\n<Class:Class>"), @runner.dump_failures
   end
 
   def test_should_report_provided_message_for_should_equal
-    assert @runner.dump_failures.include?("provided for should_equal")
+    assert @runner.dump_failures.include?("provided for should_equal"), @runner.dump_failures
   end
 
   # should_not_equal
   
   def test_should_report_standard_message_for_should_not_equal
-    assert @runner.dump_failures.include?("<Object>\nshould not be equal to:\n<Object>")
+    assert @runner.dump_failures.include?("<Object:Class>\nshould not be equal to:\n<Object:Class>"), @runner.dump_failures
   end
   
   def test_should_report_provided_message_for_should_not_equal
-    assert @runner.dump_failures.include?("provided for should_not_equal")
+    assert @runner.dump_failures.include?("provided for should_not_equal"), @runner.dump_failures
   end
   
   # should_be_nil

data/test/expectations_test.rb

@@ -342,9 +342,9 @@ class ExpectationsTest < Test::Unit::TestCase
   # violated
   
   def test_violated_should_raise
-    assert_raise  (Spec::Exceptions::ExpectationNotMetError) do
+    assert_raise(Spec::Exceptions::ExpectationNotMetError) do
       c = Spec::Context.new
-      c.violated
+      c.violated "boo"
     end
   end
   

data/test/get_classes.rb

@@ -0,0 +1,6 @@
+def get_classes
+  classes = []
+  ObjectSpace.each_object(Class) {|cls| classes << cls.to_s}
+  classes
+end
+

data/test/mock_test.rb

@@ -1,39 +1,51 @@
+require 'test/unit'
 require 'spec'
 
-
 class MockTest < Test::Unit::TestCase
 
   def setup
-    @mock = Mock.new
+    @mock = Mock.new("test mock")
+  end
+
+  def test_should_report_line_number_of_expectaion_of_unreceived_message
+    @mock.should_receive(:wont_happen).with("x", 3)
+
+    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"
+    end
+    
   end
 
   def test_should_allow_block_to_calculate_return_values
-    @mock.__expects(:random_call).with("a","b","c").returns { |a,b,c| c+b+a }
-    assert_equal "cba",@mock.random_call("a","b","c")
+    @mock.should_receive(:random_call).with("a","b","c").and_return { |a,b,c| c+b+a }
+    assert_equal "cba", @mock.random_call("a","b","c")
+    # TODO: remove __verify when migrating to self-hosting. Verify happens transparently in teardown. (AH)
     @mock.__verify
   end
 
   def test_should_allow_parameter_as_return_value
-    @mock.__expects(:random_call).with("a","b","c").returns("booh")
-    assert_equal "booh",@mock.random_call("a","b","c")
+    @mock.should_receive(:random_call).with("a","b","c").and_return("booh")
+    assert_equal "booh", @mock.random_call("a","b","c")
     @mock.__verify
   end
 
   def test_return_nil_if_no_return_value_set
-    @mock.__expects(:random_call).with("a","b","c")
+    @mock.should_receive(:random_call).with("a","b","c")
     assert_nil @mock.random_call("a","b","c")
     @mock.__verify
   end
 
-   def test_should_test_multiple_calls_to_method_with_same_parameters
-      @mock.__expects(:random_call).twice.with("a","b","c")
-      @mock.random_call("a","b","c")
-      @mock.random_call("a","b","c")
-      @mock.__verify
-   end
+  def test_should_test_multiple_calls_to_method_with_same_parameters
+    @mock.should_receive(:random_call).twice.with("a","b","c")
+    @mock.random_call("a","b","c")
+    @mock.random_call("a","b","c")
+    @mock.__verify
+  end
 
   def test_should_raise_exception_if_parameters_dont_match_when_method_called
-    @mock.__expects(:random_call).with("a","b","c").returns("booh")
+    @mock.should_receive(:random_call).with("a","b","c").and_return("booh")
     assert_raise(Spec::Exceptions::MockExpectationError) {
       @mock.random_call("a","d","c")
     }
@@ -46,12 +58,14 @@ class MockTest < Test::Unit::TestCase
   end
   
   def test_should_allow_unexpected_methods_if_ignore_missing_set
-    @mock.ignore_missing
-    @mock.random_call("a","d","c")
+    m = Mock.new("null_object", :null_object=>true)
+    m.random_call("a","d","c")
+    m.__verify
   end 
   
+  # TODO: rename to should_raise_exception_telling_what_message_was_not_received
   def test_should_raise_exception_on_verify_if_call_counts_not_as_expected
-    @mock.__expects(:random_call).twice.with("a","b","c").returns("booh")
+    @mock.should_receive(:random_call).twice.with("a","b","c").and_return("booh")
     @mock.random_call("a","b","c")
     assert_raise(Spec::Exceptions::MockExpectationError) do
       @mock.__verify
@@ -59,16 +73,17 @@ class MockTest < Test::Unit::TestCase
   end
 
   def test_should_use_block_for_expectation_if_provided
-    @mock.__expects(:random_call) do | a, b |
+    @mock.should_receive(:random_call) do | a, b |
       a.should_equal("a")
       b.should_equal("b")
       "booh"
     end
     assert_equal("booh", @mock.random_call("a", "b"))
+    @mock.__verify
   end
   
   def test_failing_expectation_block_throws
-    @mock.__expects(:random_call) {| a | a.should_be_true}
+    @mock.should_receive(:random_call) {| a | a.should_be_true}
     assert_raise(Spec::Exceptions::MockExpectationError) do
       @mock.random_call false
     end

data/test/movie_collector_test.rb

@@ -0,0 +1,19 @@
+require 'test/unit'
+
+require 'spec'
+
+
+class MovieCollectorTest < Test::Unit::TestCase
+
+	def setup
+		require 'examples/movie_spec'
+	end
+
+	def test_should_collect_only_movie_specs
+		specifications = EmptyMovieList.specifications.length 
+		specifications += OneMovieList.specifications.length
+		assert_equal specifications, Spec::Collector.collection.length
+	end
+
+end
+

data/test/rspec_craps_and_movie_test.rb

@@ -0,0 +1,32 @@
+require 'test/unit'
+
+require 'rspec'
+require 'get_classes'
+
+class RSpecCrapsAndMovieTest < Test::Unit::TestCase
+
+	def setup
+    @rspec = RSpec.new(["examples/craps_spec.rb", "examples/movie_spec.rb"])
+	end
+
+  def test_should_load_craps_and_movie_specs
+    assert_equal true, get_classes.include?('CrapsSpecification')
+    assert_equal true, get_classes.include?('EmptyMovieList')
+    assert_equal true, get_classes.include?('OneMovieList')
+  end
+
+	def test_should_include_all_specifications
+		specifications = CrapsSpecification.collection.length
+		specifications += EmptyMovieList.collection.length
+		specifications += OneMovieList.collection.length
+		assert_equal specifications, Spec::Collector.collection.length
+	end
+
+	def test_should_run_all_specifications
+		buffer = ""
+		@rspec.run(Spec::TextRunner.new(buffer))
+		assert_equal true, buffer.include?("16 specifications, 16 expectations, 0 failures")
+	end
+
+end
+

data/test/rspec_craps_test.rb

@@ -0,0 +1,35 @@
+require 'test/unit'
+
+require 'spec'
+
+require 'rspec'
+
+require 'get_classes'
+
+class RSpecCrapsTest < Test::Unit::TestCase
+
+	def setup
+		@rspec = RSpec.new(["examples/craps_spec.rb"])
+	end
+
+  def test_should_load_craps_spec  
+    assert_equal true, get_classes.include?('CrapsSpecification')
+	end
+	
+	def test_should_not_load_movie_specs
+		assert_equal false, get_classes.include?('OneMovieList')
+		assert_equal false, get_classes.include?('EmptyMovieList')
+  end
+
+	def test_should_include_craps_specifications
+		assert_equal CrapsSpecification.collection.length, Spec::Collector.collection.length
+	end
+
+	def test_should_run_craps_specifications
+		buffer = ""
+		@rspec.run(Spec::TextRunner.new(buffer))
+		assert_equal true, buffer.include?("12 specifications, 12 expectations, 0 failures")
+	end
+
+end
+

data/test/rspec_movie_test.rb

@@ -0,0 +1,33 @@
+require 'test/unit'
+
+require 'rspec'
+require 'get_classes'
+
+class RSpecMovieTest < Test::Unit::TestCase
+
+	def setup
+    @rspec = RSpec.new(["examples/movie_spec.rb"])
+	end
+
+  def test_should_load_movie_spec
+    assert_equal true, get_classes.include?('EmptyMovieList')
+    assert_equal true, get_classes.include?('OneMovieList')
+  end
+
+	def test_should_not_load_craps_spec
+		assert_equal false, get_classes.include?('CrapsSpecification')
+	end
+
+	def test_should_include_movie_specifications
+		specifications = EmptyMovieList.collection.length + OneMovieList.collection.length
+		assert_equal specifications, Spec::Collector.collection.length
+	end
+
+	def test_should_run_movie_specifications
+		buffer = ""
+		@rspec.run(Spec::TextRunner.new(buffer))
+		assert_equal true, buffer.include?("4 specifications, 4 expectations, 0 failures")
+	end
+
+end
+

data/test/text_runner_test.rb

@@ -100,6 +100,16 @@ class TestTextRunner < Test::Unit::TestCase
     assert_buffer_includes "3 specifications, 3 expectations, 0 failures"
   end
   
+	def test_should_run_all_specifications
+		@runner.run(Spec::Collector)
+		assert_buffer_includes "9 specifications, 9 expectations, 6 failures"
+	end
+
+	def test_should_run_all_specifications_when_no_args_provided
+		@runner.run
+		assert_buffer_includes "9 specifications, 9 expectations, 6 failures"
+	end
+
   def assert_buffer_includes(substring)
     assert(@buffer.include?(substring), _buffer_message(substring))
   end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.11
 specification_version: 1
 name: rspec
 version: !ruby/object:Gem::Version 
-  version: 0.1.6
-date: 2005-08-22 00:00:00 -04:00
+  version: 0.1.7
+date: 2005-08-30 00:00:00 -04:00
 summary: Behaviour Specification Framework for Ruby
 require_paths: 
   - lib
@@ -15,8 +15,8 @@ description: "RSpec is a behaviour specification framework for Ruby.  RSpec was
   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."
-autorequire: 
-default_executable: 
+autorequire: spec
+default_executable: spec
 bindir: bin
 has_rdoc: true
 required_ruby_version: !ruby/object:Gem::Version::Requirement 
@@ -36,8 +36,9 @@ files:
   - MT
   - Rakefile.rb
   - README
-  - lib/rspec.rb
+  - TODO
   - lib/spec.rb
+  - lib/spec/collector.rb
   - lib/spec/context.rb
   - lib/spec/exceptions.rb
   - lib/spec/expectations.rb
@@ -45,10 +46,15 @@ files:
   - lib/spec/text_runner.rb
   - test/context_fixtures_test.rb
   - test/context_run_test.rb
+  - test/craps_collector_test.rb
   - test/error_reporting_test.rb
   - test/expectations_test.rb
+  - test/get_classes.rb
   - test/mock_test.rb
-  - test/rspec_test.rb
+  - test/movie_collector_test.rb
+  - test/rspec_craps_and_movie_test.rb
+  - test/rspec_craps_test.rb
+  - test/rspec_movie_test.rb
   - test/spec_collection_test.rb
   - test/specification_identification_test.rb
   - test/test_unit_ext_spec.rb
@@ -68,7 +74,8 @@ rdoc_options:
 extra_rdoc_files: 
   - README
   - CHANGES
-executables: []
+executables: 
+  - spec
 extensions: []
 requirements: []
 dependencies: []

data/lib/rspec.rb

@@ -1,9 +0,0 @@
-class RSpec
-
-  def initialize(args)
-    args.each do |file|
-      require file
-    end
-  end
-
-end

data/test/rspec_test.rb

@@ -1,35 +0,0 @@
-require 'test/unit'
-
-require 'rspec'
-
-$: << 'examples/'
-
-class RSpecTest < Test::Unit::TestCase
-
-  def test_should_load_craps_spec
-    rspec = RSpec.new(["examples/craps_spec.rb"])
-    assert_equal true, get_classes.include?('CrapsSpecification')
-  end
-  
-  def test_should_load_movie_spec
-    rspec = RSpec.new(["examples/movie_spec.rb"])
-    assert_equal true, get_classes.include?('EmptyMovieList')
-    assert_equal true, get_classes.include?('OneMovieList')
-  end
-  
-  def test_should_load_craps_and_movie_specs
-    rspec = RSpec.new(["examples/craps_spec.rb", "examples/movie_spec.rb"])
-    assert_equal true, get_classes.include?('CrapsSpecification')
-    assert_equal true, get_classes.include?('EmptyMovieList')
-    assert_equal true, get_classes.include?('OneMovieList')
-  end
-
-private
-
-  def get_classes
-    classes = []
-    ObjectSpace.each_object(Class) {|cls| classes << cls.to_s}
-    classes
-  end
-
-end