rspec 1.0.3 → 1.0.4

data/CHANGES

@@ -1,3 +1,15 @@
+== Version 1.0.4
+The getting ready for JRuby release.
+
+* Fixed [#11181] behaviour_type scoping of config.before(:each) is not working
+* added mock argument constraint matchers (anything(), boolean(), an_instance_of(Type)) which work with rspec or mocha
+* added mock argument constraint matchers (any_args(), no_args()) which only work with rspec
+* deprecated rspec's symbol mock argument constraint matchers (:any_args, :no_args, :anything, :boolean, :numeric, :string)
+* Added tarball of rspec_on_rails to the release build to support folks working behind a firewall that blocks svn access.
+* Fixed [#11137] rspec incorrectly handles flash after resetting the session
+* Fixed [#11143] Views code for ActionController::Base#render broke between 1.0.0 and 1.0.3 on Rails Edge r6731
+* Added raise_controller_errors for controller examples in Spec::Rails
+
 == Version 1.0.3
 Bug fixes.
 

data/EXAMPLES.rd

@@ -103,6 +103,6 @@
 # * RSpec should be able to access TestCase methods
 # * RSpec should be able to accept included modules
 
-Finished in 0.024365 seconds
+Finished in 0.026702 seconds
 
 77 examples, 0 failures, 2 not implemented

data/Rakefile

@@ -157,19 +157,18 @@ task :tag do
   from = `svn info #{File.dirname(__FILE__)}`.match(/URL: (.*)\/rspec/n)[1]
   to = from.gsub(/trunk/, "tags/#{Spec::VERSION::TAG}")
   current = from.gsub(/trunk/, "tags/CURRENT")
-  tag_cmd = "svn cp #{from} #{to} -m \"Tag release #{Spec::VERSION::FULL_VERSION}\""
-  remove_current_cmd = "svn rm #{current}"
-  commit_current_cmd = "svn ci #{current} -m \"Remove tags/CURRENT\""
-  create_current_cmd = "svn cp #{to} #{current} -m \"Copy #{Spec::VERSION::TAG} to tags/CURRENT\""
-  raise "Can't tag to the same place: #{tag_cmd}" if to == from
+
   puts "Creating tag in SVN"
-  `#{tag_cmd}`
+  tag_cmd = "svn cp #{from} #{to} -m \"Tag release #{Spec::VERSION::FULL_VERSION}\""
+  `#{tag_cmd}` ; raise "ERROR: #{tag_cmd}" unless $? == 0
+
   puts "Removing CURRENT"
-  `#{remove_current_cmd}`
-  `#{commit_current_cmd}`
+  remove_current_cmd = "svn rm #{current} -m \"Remove tags/CURRENT\""
+  `#{remove_current_cmd}` ; raise "ERROR: #{remove_current_cmd}" unless $? == 0
+
   puts "Re-Creating CURRENT"
-  `#{create_current_cmd}`
-  raise "Tagging failed" unless $? == 0
+  create_current_cmd = "svn cp #{to} #{current} -m \"Copy #{Spec::VERSION::TAG} to tags/CURRENT\""
+  `#{create_current_cmd}` ; "ERROR: #{create_current_cmd}" unless $? == 0
 end
 
 desc "Run this task before you commit. You should see 'OK TO COMMIT'"
@@ -210,6 +209,17 @@ task :archive_website => [:verify_user, :website] do
   publisher.upload
 end
 
+desc "Package the Rails plugin"
+task :package_rspec_on_rails do
+  mkdir 'pkg' rescue nil
+  rm_rf 'pkg/rspec_on_rails' rescue nil
+  `svn export ../rspec_on_rails pkg/rspec_on_rails-#{PKG_VERSION}`
+  Dir.chdir 'pkg' do
+    `tar cvzf rspec_on_rails-#{PKG_VERSION}.tgz rspec_on_rails-#{PKG_VERSION}`
+  end
+end
+task :pkg => :package_rspec_on_rails
+
 desc "Package the RSpec.tmbundle"
 task :package_tmbundle do
   mkdir 'pkg' rescue nil

data/lib/spec/dsl/behaviour.rb

@@ -31,8 +31,12 @@ module Spec
       end
       
     private
-
+    
       def init_description(*args)
+        unless self.class == Behaviour
+          args << {} unless Hash === args.last
+          args.last[:behaviour_class] = self.class
+        end
         @description = Description.new(*args)
       end
       
@@ -118,12 +122,12 @@ module Spec
         end
       end
 
-    protected
-
       def behaviour_type #:nodoc:
         @description[:behaviour_type]
       end
 
+    protected
+
       # Messages that this class does not understand
       # are passed directly to the @eval_module.
       def method_missing(sym, *args, &block)

data/lib/spec/dsl/behaviour_eval.rb

@@ -71,10 +71,16 @@ module Spec
         #   predicate_matchers[matcher_name] = [method1_on_object, method2_on_object]
         #
         # Dynamically generates a custom matcher that will match
-        # a predicate on your class. RSpec uses this itself to allow you
-        # to say File.should exist("path/to/file").
+        # a predicate on your class. RSpec provides a couple of these
+        # out of the box:
         #
-        # == Example
+        #   exist (or state expectations)
+        #     File.should exist("path/to/file")
+        #
+        #   an_instance_of (for mock argument constraints)
+        #     mock.should_receive(:message).with(an_instance_of(String))
+        #
+        # == Examples
         #
         #   class Fish
         #     def can_swim?
@@ -89,7 +95,7 @@ module Spec
         #     end
         #   end
         def predicate_matchers
-          @predicate_matchers ||= {:exist => :exist?}
+          @predicate_matchers ||= {:exist => :exist?, :an_instance_of => :is_a?}
         end
         
         def define_predicate_matchers(hash=nil) # :nodoc:
@@ -112,7 +118,7 @@ module Spec
         end
         
         # Alias for it.
-        def specify(description, opts={}, &block)
+        def specify(description=:__generate_description, opts={}, &block)
           it(description, opts, &block)
         end
 

data/lib/spec/dsl/description.rb

@@ -18,8 +18,9 @@ module Spec
       
       def initialize(*args)
         args, @options = args_and_options(*args)
-        @described_type = args.first unless args.first.is_a?(String)
-        @description = self.class.generate_description(*args)
+        init_behaviour_type(@options)
+        init_described_type(args)
+        init_description(*args)
       end
   
       def [](key)
@@ -40,6 +41,28 @@ module Spec
           @description == value
         end
       end
+      
+    private
+      def init_behaviour_type(options)
+        # NOTE - BE CAREFUL IF CHANGING THIS NEXT LINE:
+        #   this line is as it is to satisfy JRuby - the original version
+        #   read, simply: "if options[:behaviour_class]", which passed against ruby, but failed against jruby
+        if options[:behaviour_class] && options[:behaviour_class].ancestors.include?(Behaviour)
+          options[:behaviour_type] = parse_behaviour_type(@options[:behaviour_class])
+        end
+      end
+      
+      def init_description(*args)
+        @description = self.class.generate_description(*args)
+      end
+      
+      def init_described_type(args)
+        @described_type = args.first unless args.first.is_a?(String)
+      end
+    
+      def parse_behaviour_type(behaviour_class)
+        behaviour_class.to_s.split("::").reverse[0].gsub!('Behaviour', '').downcase.to_sym
+      end
 
     end
   end

data/lib/spec/mocks.rb

@@ -129,13 +129,12 @@ module Spec
   # In addition, Spec::Mocks adds some keyword Symbols that you can use to
   # specify certain kinds of arguments:
   #
-  #   my_mock.should_receive(:sym).with(:no_args)
-  #   my_mock.should_receive(:sym).with(:any_args)
-  #   my_mock.should_receive(:sym).with(1, :numeric, "b") #2nd argument can any type of Numeric
-  #   my_mock.should_receive(:sym).with(1, :boolean, "b") #2nd argument can true or false
-  #   my_mock.should_receive(:sym).with(1, :string, "b") #2nd argument can be any String
+  #   my_mock.should_receive(:sym).with(no_args())
+  #   my_mock.should_receive(:sym).with(any_args())
+  #   my_mock.should_receive(:sym).with(1, an_instance_of(Numeric), "b") #2nd argument can any type of Numeric
+  #   my_mock.should_receive(:sym).with(1, boolean(), "b") #2nd argument can true or false
   #   my_mock.should_receive(:sym).with(1, /abc/, "b") #2nd argument can be any String matching the submitted Regexp
-  #   my_mock.should_receive(:sym).with(1, :anything, "b") #2nd argument can be anything at all
+  #   my_mock.should_receive(:sym).with(1, anything(), "b") #2nd argument can be anything at all
   #   my_mock.should_receive(:sym).with(1, ducktype(:abs, :div), "b")
   #                            #2nd argument can be object that responds to #abs and #div
   #                                                                       

data/lib/spec/mocks/argument_constraint_matchers.rb

@@ -4,9 +4,24 @@ module Spec
 
       # Shortcut for creating an instance of Spec::Mocks::DuckTypeArgConstraint
       def duck_type(*args)
-        return Spec::Mocks::DuckTypeArgConstraint.new(*args)
+        DuckTypeArgConstraint.new(*args)
       end
 
+      def any_args
+        AnyArgsConstraint.new
+      end
+      
+      def anything
+        AnyArgConstraint.new(nil)
+      end
+      
+      def boolean
+        BooleanArgConstraint.new(nil)
+      end
+      
+      def no_args
+        NoArgsConstraint.new
+      end
     end
   end
 end

data/lib/spec/mocks/argument_expectation.rb

@@ -36,11 +36,32 @@ module Spec
       def initialize(ignore)
       end
       
+      def ==(other)
+        true
+      end
+      
+      # TODO - need this?
       def matches?(value)
         true
       end
     end
     
+    class AnyArgsConstraint
+      def description
+        "any args"
+      end
+    end
+    
+    class NoArgsConstraint
+      def description
+        "no args"
+      end
+      
+      def ==(args)
+        args == []
+      end
+    end
+    
     class NumericArgConstraint
       def initialize(ignore)
       end
@@ -54,6 +75,10 @@ module Spec
       def initialize(ignore)
       end
       
+      def ==(value)
+        matches?(value)
+      end
+      
       def matches?(value)
         return true if value.is_a?(TrueClass)
         return true if value.is_a?(FalseClass)
@@ -94,8 +119,14 @@ module Spec
       
       def initialize(args)
         @args = args
-        if [:any_args] == args then @expected_params = nil
-        elsif [:no_args] == args then @expected_params = []
+        if [:any_args] == args
+          @expected_params = nil
+          warn_deprecated(:any_args.inspect, "any_args()")
+        elsif args.length == 1 && args[0].is_a?(AnyArgsConstraint) then @expected_params = nil
+        elsif [:no_args] == args
+          @expected_params = []
+          warn_deprecated(:no_args.inspect, "no_args()")
+        elsif args.length == 1 && args[0].is_a?(NoArgsConstraint) then @expected_params = []
         else @expected_params = process_arg_constraints(args)
         end
       end
@@ -106,8 +137,25 @@ module Spec
         end
       end
       
+      def warn_deprecated(deprecated_method, instead)
+        STDERR.puts "The #{deprecated_method} constraint is deprecated. Use #{instead} instead."
+      end
+      
       def convert_constraint(constraint)
-        return @@constraint_classes[constraint].new(constraint) if constraint.is_a?(Symbol)
+        if [:anything, :numeric, :boolean, :string].include?(constraint)
+          case constraint
+          when :anything
+            instead = "anything()"
+          when :boolean
+            instead = "boolean()"
+          when :numeric
+            instead = "an_instance_of(Numeric)"
+          when :string
+            instead = "an_instance_of(String)"
+          end
+          warn_deprecated(constraint.inspect, instead)
+          return @@constraint_classes[constraint].new(constraint)
+        end
         return MatcherConstraint.new(constraint) if is_matcher?(constraint)
         return RegexpArgConstraint.new(constraint) if constraint.is_a?(Regexp)
         return LiteralArgConstraint.new(constraint)

data/lib/spec/mocks/error_generator.rb

@@ -17,8 +17,7 @@ module Spec
       end
       
       def raise_unexpected_message_args_error(expectation, *args)
-        #this is either :no_args or an Array
-        expected_args = (expectation.expected_args == :no_args ? "(no args)" : format_args(*expectation.expected_args))
+        expected_args = format_args(*expectation.expected_args)
         actual_args = args.empty? ? "(no args)" : format_args(*args)
         __raise "#{intro} expected #{expectation.sym.inspect} with #{expected_args} but received it with #{actual_args}"
       end

data/lib/spec/mocks/message_expectation.rb

@@ -13,7 +13,7 @@ module Spec
         @return_block = lambda {}
         @received_count = 0
         @expected_received_count = expected_received_count
-        @args_expectation = ArgumentExpectation.new([:any_args])
+        @args_expectation = ArgumentExpectation.new([AnyArgsConstraint.new])
         @consecutive = false
         @exception_to_raise = nil
         @symbol_to_throw = nil

data/lib/spec/version.rb

@@ -3,11 +3,11 @@ module Spec
     unless defined? MAJOR
       MAJOR  = 1
       MINOR  = 0
-      TINY   = 3
+      TINY   = 4
       RELEASE_CANDIDATE = nil
 
-      # RANDOM_TOKEN: 0.135908585165873
-      REV = "$LastChangedRevision: 2035 $".match(/LastChangedRevision: (\d+)/)[1]
+      # RANDOM_TOKEN: 0.691783562403103
+      REV = "$LastChangedRevision: 2054 $".match(/LastChangedRevision: (\d+)/)[1]
 
       STRING = [MAJOR, MINOR, TINY].join('.')
       TAG = "REL_#{[MAJOR, MINOR, TINY, RELEASE_CANDIDATE].compact.join('_')}".upcase.gsub(/\.|-/, '_')

data/spec/spec/dsl/behaviour_spec.rb

@@ -312,8 +312,8 @@ module Spec
       end
 
       it "after callbacks are ordered from local to global" do
-        @reporter.should_receive(:add_behaviour).with :any_args
-        @reporter.should_receive(:example_finished).with :any_args
+        @reporter.should_receive(:add_behaviour).with any_args()
+        @reporter.should_receive(:example_finished).with any_args()
 
         fiddle = []
         super_class = Class.new do
@@ -400,8 +400,8 @@ module Spec
       end
     
       it "should have accessible instance methods from included module" do
-        @reporter.should_receive(:add_behaviour).with :any_args
-        @reporter.should_receive(:example_finished).with :any_args
+        @reporter.should_receive(:add_behaviour).with any_args()
+        @reporter.should_receive(:example_finished).with any_args()
     
         mod1_method_called = false
         mod1 = Module.new do
@@ -598,6 +598,10 @@ module Spec
         BehaviourSubclass.new(Example){}.described_type.should == Example
       end
       
+      it "should figure out its behaviour_type based on its name ()" do
+        BehaviourSubclass.new(Object){}.behaviour_type.should == :subclass
+      end
+      
       # TODO - add an example about shared behaviours
     end
     

data/spec/spec/dsl/example_instance_spec.rb

@@ -148,7 +148,7 @@ module Spec
         example = Example.new(:__generate_description) {
           5.should == 5
         }
-        @reporter.should_receive(:example_finished).with("should == 5", :anything, :anything, false)
+        @reporter.should_receive(:example_finished).with("should == 5", anything(), anything(), false)
         example.run(@reporter, nil, nil, nil, Object.new)
       end
 

data/spec/spec/dsl/shared_behaviour_spec.rb

@@ -4,12 +4,12 @@ module Spec
   module DSL
     describe Behaviour, ", with :shared => true" do
       
-      before do
+      before(:each) do
         @formatter = Spec::Mocks::Mock.new("formatter", :null_object => true)
         @behaviour = behaviour_class.new("behaviour") {}
       end
 
-      after do
+      after(:each) do
         @formatter.rspec_verify
         @behaviour_class = nil
         $shared_behaviours.clear unless $shared_behaviours.nil?
@@ -24,11 +24,15 @@ module Spec
         @behaviour_class
       end
 
-      def make_shared_behaviour(name, opts, &block)
-        behaviour = behaviour_class.new(name, opts, &block)
+      def make_shared_behaviour(name, opts=nil, &block)
+        behaviour = behaviour_class.new(name, :shared => true, &block)
         behaviour_class.add_shared_behaviour(behaviour)
         behaviour
       end
+      
+      def non_shared_behaviour()
+        @non_shared_behaviour ||= behaviour_class.new("behaviour") {}
+      end
 
       it "should accept an optional options hash" do
         lambda { behaviour_class.new("context") {} }.should_not raise_error(Exception)
@@ -36,49 +40,52 @@ module Spec
       end
 
       it "should return all shared behaviours" do
-        make_shared_behaviour("b1", :shared => true) {}
-        make_shared_behaviour("b2", :shared => true) {}
+        b1 = make_shared_behaviour("b1", :shared => true) {}
+        b2 = make_shared_behaviour("b2", :shared => true) {}
+        
+        b1.should_not be(nil)
+        b2.should_not be(nil)
         
-        behaviour_class.find_shared_behaviour("b1").should_not be_nil
-        behaviour_class.find_shared_behaviour("b2").should_not be_nil
+        behaviour_class.find_shared_behaviour("b1").should equal(b1)
+        behaviour_class.find_shared_behaviour("b2").should equal(b2)
       end
 
       it "should be shared when configured as shared" do
-        behaviour = make_shared_behaviour("context", :shared => true) {}
+        behaviour = make_shared_behaviour("behaviour") {}
         behaviour.should be_shared
       end
 
       it "should not be shared when not configured as shared" do
-        @behaviour.should_not be_shared
+        non_shared_behaviour.should_not be_shared
       end
 
       it "should raise if run when shared" do
-        behaviour = make_shared_behaviour("context", :shared => true) {}
-        $spec_ran = false
-        behaviour.it("test") {$spec_ran = true}
+        behaviour = make_shared_behaviour("context") {}
+        $example_ran = false
+        behaviour.it("test") {$example_ran = true}
         lambda { behaviour.run(@formatter) }.should raise_error
-        $spec_ran.should be_false
+        $example_ran.should be_false
       end
 
       it "should contain examples when shared" do
-        shared_behaviour = make_shared_behaviour("shared behaviour", :shared => true) {}
+        shared_behaviour = make_shared_behaviour("shared behaviour") {}
         shared_behaviour.it("shared example") {}
         shared_behaviour.number_of_examples.should == 1
       end
 
       it "should complain when adding a second shared behaviour with the same description" do
-        make_shared_behaviour("shared behaviour", :shared => true) {}
-        lambda { make_shared_behaviour("shared behaviour", :shared => true) {} }.should raise_error(ArgumentError)
+        make_shared_behaviour("shared behaviour") {}
+        lambda { make_shared_behaviour("shared behaviour") {} }.should raise_error(ArgumentError)
       end
 
       it "should NOT complain when adding a the same shared behaviour again (i.e. file gets reloaded)" do
-        behaviour = behaviour_class.new("shared behaviour", :shared => true) {}
+        behaviour = behaviour_class.new("shared behaviour") {}
         behaviour_class.add_shared_behaviour(behaviour)
         behaviour_class.add_shared_behaviour(behaviour)
       end
 
       it "should add examples to current behaviour when calling it_should_behave_like" do
-        shared_behaviour = make_shared_behaviour("shared behaviour", :shared => true) {}
+        shared_behaviour = make_shared_behaviour("shared behaviour") {}
         shared_behaviour.it("shared example") {}
         shared_behaviour.it("shared example 2") {}
 
@@ -90,7 +97,7 @@ module Spec
 
       it "should run shared examples" do
         shared_example_ran = false
-        shared_behaviour = make_shared_behaviour("shared behaviour", :shared => true) {}
+        shared_behaviour = make_shared_behaviour("shared behaviour") {}
         shared_behaviour.it("shared example") { shared_example_ran = true }
 
         example_ran = false
@@ -105,7 +112,7 @@ module Spec
       it "should run setup and teardown from shared behaviour" do
         shared_setup_ran = false
         shared_teardown_ran = false
-        shared_behaviour = make_shared_behaviour("shared behaviour", :shared => true) {}
+        shared_behaviour = make_shared_behaviour("shared behaviour") {}
         shared_behaviour.before { shared_setup_ran = true }
         shared_behaviour.after { shared_teardown_ran = true }
         shared_behaviour.it("shared example") { shared_example_ran = true }
@@ -123,7 +130,7 @@ module Spec
       it "should run before(:all) and after(:all) only once from shared behaviour" do
         shared_before_all_run_count = 0
         shared_after_all_run_count = 0
-        shared_behaviour = make_shared_behaviour("shared behaviour", :shared => true) {}
+        shared_behaviour = make_shared_behaviour("shared behaviour") {}
         shared_behaviour.before(:all) { shared_before_all_run_count += 1}
         shared_behaviour.after(:all) { shared_after_all_run_count += 1}
         shared_behaviour.it("shared example") { shared_example_ran = true }
@@ -139,10 +146,10 @@ module Spec
       end
 
       it "should include modules, included into shared behaviour, into current behaviour" do
-        @formatter.should_receive(:add_behaviour).with :any_args
-        @formatter.should_receive(:example_finished).twice.with :any_args
+        @formatter.should_receive(:add_behaviour).with(any_args)
+        @formatter.should_receive(:example_finished).twice.with(any_args)
 
-        shared_behaviour = make_shared_behaviour("shared behaviour", :shared => true) {}
+        shared_behaviour = make_shared_behaviour("shared behaviour") {}
         shared_behaviour.it("shared example") { shared_example_ran = true }
 
         mod1_method_called = false
@@ -174,7 +181,7 @@ module Spec
       end
       
       it "should make methods defined in the shared behaviour available in consuming behaviour" do
-        shared_behaviour = make_shared_behaviour("shared behaviour xyz", :shared => true) do
+        shared_behaviour = make_shared_behaviour("shared behaviour xyz") do
           def a_shared_helper_method
             "this got defined in a shared behaviour"
           end
@@ -190,7 +197,7 @@ module Spec
       end
 
       it "should error if told to inherit from a class" do
-        shared_behaviour = make_shared_behaviour("shared behaviour", :shared => true) {}
+        shared_behaviour = make_shared_behaviour("shared behaviour") {}
         shared_behaviour.it("shared example") { shared_example_ran = true }
         lambda { shared_behaviour.inherit Object }.should raise_error(ArgumentError)
       end

data/spec/spec/matchers/mock_constraint_matchers_spec.rb

@@ -0,0 +1,24 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+describe "The anything() mock argument constraint matcher" do
+  specify { anything.should == Object.new }
+  specify { anything.should == Class }
+  specify { anything.should == 1 }
+  specify { anything.should == "a string" }
+  specify { anything.should == :a_symbol }
+end
+
+describe "The boolean() mock argument constraint matcher" do
+  specify { boolean.should == true }
+  specify { boolean.should == false }
+  specify { boolean.should_not == Object.new }
+  specify { boolean.should_not == Class }
+  specify { boolean.should_not == 1 }
+  specify { boolean.should_not == "a string" }
+  specify { boolean.should_not == :a_symbol }
+end
+
+describe "The an_instance_of() mock argument constraint matcher" do
+  # NOTE - this is implemented as a predicate_matcher - see behaviour.rb
+  specify { an_instance_of(String).should == "string"  }
+end

data/spec/spec/mocks/failing_mock_argument_constraints_spec.rb

@@ -2,42 +2,42 @@ require File.dirname(__FILE__) + '/../../spec_helper.rb'
 
 module Spec
   module Mocks
-    describe "FailingMockArgumentConstraints" do
-      before do
+    describe "failing MockArgumentConstraints" do
+      before(:each) do
         @mock = mock("test mock")
         @reporter = Mock.new("reporter", :null_object => true)
       end
       
-      after do
+      after(:each) do
         @mock.rspec_reset
       end
-      
-      it "should reject goose when expecting a duck" do
-        @mock.should_receive(:random_call).with(DuckTypeArgConstraint.new(:abs, :div))
-        lambda { @mock.random_call("I don't respond to :abs or :div") }.should raise_error(MockExpectationError)
-      end
-      
+
       it "should reject non boolean" do
-        @mock.should_receive(:random_call).with(:boolean)
+        @mock.should_receive(:random_call).with(boolean())
         lambda do
           @mock.random_call("false")
         end.should raise_error(MockExpectationError)
       end
-      
+
       it "should reject non numeric" do
-        @mock.should_receive(:random_call).with(:numeric)
+        @mock.should_receive(:random_call).with(an_instance_of(Numeric))
         lambda do
           @mock.random_call("1")
         end.should raise_error(MockExpectationError)
       end
       
       it "should reject non string" do
-        @mock.should_receive(:random_call).with(:string)
+        @mock.should_receive(:random_call).with(an_instance_of(String))
         lambda do
           @mock.random_call(123)
         end.should raise_error(MockExpectationError)
       end
       
+      it "should reject goose when expecting a duck" do
+        @mock.should_receive(:random_call).with(duck_type(:abs, :div))
+        lambda { @mock.random_call("I don't respond to :abs or :div") }.should raise_error(MockExpectationError)
+      end
+
       it "should fail if regexp does not match submitted string" do
         @mock.should_receive(:random_call).with(/bcd/)
         lambda { @mock.random_call("abc") }.should raise_error(MockExpectationError)
@@ -68,6 +68,47 @@ module Spec
           @mock.msg(37)
         end.should raise_error(MockExpectationError, "Mock 'test mock' expected :msg with (equal 3) but received it with (37)")
       end
+      
+      it "should fail no_args with one arg" do
+        lambda do
+          @mock.should_receive(:msg).with(no_args)
+          @mock.msg(37)
+        end.should raise_error(MockExpectationError, "Mock 'test mock' expected :msg with (no args) but received it with (37)")
+      end
+    end
+      
+    describe "failing deprecated MockArgumentConstraints" do
+      before(:each) do
+        @mock = mock("test mock")
+        @reporter = Mock.new("reporter", :null_object => true)
+      end
+
+      after(:each) do
+        @mock.rspec_reset
+      end
+
+      it "should reject non boolean" do
+        @mock.should_receive(:random_call).with(:boolean)
+        lambda do
+          @mock.random_call("false")
+        end.should raise_error(MockExpectationError)
+      end
+      
+      it "should reject non numeric" do
+        @mock.should_receive(:random_call).with(:numeric)
+        lambda do
+          @mock.random_call("1")
+        end.should raise_error(MockExpectationError)
+      end
+      
+      it "should reject non string" do
+        @mock.should_receive(:random_call).with(:string)
+        lambda do
+          @mock.random_call(123)
+        end.should raise_error(MockExpectationError)
+      end
+      
+
     end
   end
 end

data/spec/spec/mocks/mock_spec.rb

@@ -180,7 +180,7 @@ module Spec
       end
       
       it "should ignore args on any args" do
-        @mock.should_receive(:something).at_least(:once).with(:any_args)
+        @mock.should_receive(:something).at_least(:once).with(any_args)
         @mock.something
         @mock.something 1
         @mock.something "a", 2
@@ -189,7 +189,7 @@ module Spec
       end
       
       it "should fail on no args if any args received" do
-        @mock.should_receive(:something).with(:no_args)
+        @mock.should_receive(:something).with(no_args())
         begin
           @mock.something 1
         rescue MockExpectationError => e
@@ -207,7 +207,7 @@ module Spec
       end
 
       it "should yield 0 args to blocks that take a variable number of arguments" do
-        @mock.should_receive(:yield_back).with(:no_args).once.and_yield
+        @mock.should_receive(:yield_back).with(no_args()).once.and_yield
         a = nil
         @mock.yield_back {|*a|}
         a.should == []
@@ -215,7 +215,7 @@ module Spec
       end
 
       it "should yield one arg to blocks that take a variable number of arguments" do
-        @mock.should_receive(:yield_back).with(:no_args).once.and_yield(99)
+        @mock.should_receive(:yield_back).with(no_args()).once.and_yield(99)
         a = nil
         @mock.yield_back {|*a|}
         a.should == [99]
@@ -223,7 +223,7 @@ module Spec
       end
 
       it "should yield many args to blocks that take a variable number of arguments" do
-        @mock.should_receive(:yield_back).with(:no_args).once.and_yield(99, 27, "go")
+        @mock.should_receive(:yield_back).with(no_args()).once.and_yield(99, 27, "go")
         a = nil
         @mock.yield_back {|*a|}
         a.should == [99, 27, "go"]
@@ -231,7 +231,7 @@ module Spec
       end
 
       it "should yield single value" do
-        @mock.should_receive(:yield_back).with(:no_args).once.and_yield(99)
+        @mock.should_receive(:yield_back).with(no_args()).once.and_yield(99)
         a = nil
         @mock.yield_back {|a|}
         a.should == 99
@@ -239,7 +239,7 @@ module Spec
       end
 
       it "should yield two values" do
-        @mock.should_receive(:yield_back).with(:no_args).once.and_yield('wha', 'zup')
+        @mock.should_receive(:yield_back).with(no_args()).once.and_yield('wha', 'zup')
         a, b = nil
         @mock.yield_back {|a,b|}
         a.should == 'wha'
@@ -248,7 +248,7 @@ module Spec
       end
 
       it "should fail when calling yielding method with wrong arity" do
-        @mock.should_receive(:yield_back).with(:no_args).once.and_yield('wha', 'zup')
+        @mock.should_receive(:yield_back).with(no_args()).once.and_yield('wha', 'zup')
           begin
           @mock.yield_back {|a|}
         rescue MockExpectationError => e
@@ -257,7 +257,7 @@ module Spec
       end
 
       it "should fail when calling yielding method without block" do
-        @mock.should_receive(:yield_back).with(:no_args).once.and_yield('wha', 'zup')
+        @mock.should_receive(:yield_back).with(no_args()).once.and_yield('wha', 'zup')
         begin
           @mock.yield_back
         rescue MockExpectationError => e
@@ -266,7 +266,7 @@ module Spec
       end
       
       it "should be able to mock send" do
-        @mock.should_receive(:send).with(:any_args)
+        @mock.should_receive(:send).with(any_args)
         @mock.send 'hi'
         @mock.rspec_verify
       end

data/spec/spec/mocks/passing_mock_argument_constraints_spec.rb

@@ -2,7 +2,7 @@ require File.dirname(__FILE__) + '/../../spec_helper.rb'
 
 module Spec
   module Mocks
-    describe "a mock, in handling arguments" do
+    describe "mock argument constraints", :shared => true do
       before(:each) do
         @mock = Mock.new("test mock")
       end
@@ -10,6 +10,10 @@ module Spec
       after(:each) do
         @mock.rspec_verify
       end
+    end
+    
+    describe Methods, "handling argument constraints with DEPRECATED symbols" do
+      it_should_behave_like "mock argument constraints"
 
       it "should accept true as boolean" do
         @mock.should_receive(:random_call).with(:boolean)
@@ -36,26 +40,78 @@ module Spec
         @mock.random_call("a", "whatever", "c")
       end
 
+      it "should match string" do
+        @mock.should_receive(:random_call).with(:string)
+        @mock.random_call("a string")
+      end
+      
+      it "should match no args against any_args" do
+        @mock.should_receive(:random_call).with(:any_args)
+        @mock.random_call("a string")
+      end
+    end
+
+    describe Methods, "handling argument constraints" do
+      it_should_behave_like "mock argument constraints"
+
+      it "should accept true as boolean()" do
+        @mock.should_receive(:random_call).with(boolean())
+        @mock.random_call(true)
+      end
+
+      it "should accept false as boolean()" do
+        @mock.should_receive(:random_call).with(boolean())
+        @mock.random_call(false)
+      end
+
+      it "should accept fixnum as an_instance_of(Numeric)" do
+        @mock.should_receive(:random_call).with(an_instance_of(Numeric))
+        @mock.random_call(1)
+      end
+
+      it "should accept float as an_instance_of(Numeric)" do
+        @mock.should_receive(:random_call).with(an_instance_of(Numeric))
+        @mock.random_call(1.5)
+      end
+
+      it "should accept string as anything()" do
+        @mock.should_receive(:random_call).with("a", anything(), "c")
+        @mock.random_call("a", "whatever", "c")
+      end
+
       it "should match duck type with one method" do
-        @mock.should_receive(:random_call).with(DuckTypeArgConstraint.new(:length))
+        @mock.should_receive(:random_call).with(duck_type(:length))
         @mock.random_call([])
       end
 
       it "should match duck type with two methods" do
-        @mock.should_receive(:random_call).with(DuckTypeArgConstraint.new(:abs, :div))
+        @mock.should_receive(:random_call).with(duck_type(:abs, :div))
         @mock.random_call(1)
       end
+      
+      it "should match no args against any_args()" do
+        @mock.should_receive(:random_call).with(any_args)
+        @mock.random_call()
+      end
+      
+      it "should match one arg against any_args()" do
+        @mock.should_receive(:random_call).with(any_args)
+        @mock.random_call("a string")
+      end
+      
+      it "should match no args against no_args()" do
+        @mock.should_receive(:random_call).with(no_args)
+        @mock.random_call()
+      end
+    end
+    
+    describe Methods, "handling non-constraint arguments" do
 
-      it "should match non special symbol" do
+      it "should match non special symbol (can be removed when deprecated symbols are removed)" do
         @mock.should_receive(:random_call).with(:some_symbol)
         @mock.random_call(:some_symbol)
       end
 
-      it "should match string" do
-        @mock.should_receive(:random_call).with(:string)
-        @mock.random_call("a string")
-      end
-
       it "should match string against regexp" do
         @mock.should_receive(:random_call).with(/bcd/)
         @mock.random_call("abcde")

data/spec/spec/runner/options_spec.rb

@@ -113,7 +113,7 @@ module Spec
 
       it "sets Expectations differ when differ_class is set" do
         @options.differ_class = Spec::Expectations::Differs::Default
-        Spec::Expectations.should_receive(:differ=).with(:anything).and_return do |arg|
+        Spec::Expectations.should_receive(:differ=).with(anything()).and_return do |arg|
           arg.class.should == Spec::Expectations::Differs::Default
         end
         @options.create_behaviour_runner

data/spec/spec/runner/reporter_spec.rb

@@ -30,7 +30,7 @@ module Spec
         @formatter.should_receive(:example_started).exactly(3).times
         @formatter.should_receive(:example_passed).exactly(3).times
         @formatter.should_receive(:start_dump)
-        @formatter.should_receive(:dump_summary).with(:anything, 3, 0, 0)
+        @formatter.should_receive(:dump_summary).with(anything(), 3, 0, 0)
         @reporter.add_behaviour("behaviour")
         @reporter.example_started("spec 1")
         @reporter.example_finished("spec 1")
@@ -51,7 +51,7 @@ module Spec
         @formatter.should_receive(:example_failed).with("example", 2, failure)
         @formatter.should_receive(:dump_failure).exactly(2).times
         @formatter.should_receive(:start_dump)
-        @formatter.should_receive(:dump_summary).with(:anything, 4, 2, 0)
+        @formatter.should_receive(:dump_summary).with(anything(), 4, 2, 0)
         @backtrace_tweaker.should_receive(:tweak_backtrace).twice
         @reporter.add_behaviour("behaviour")
         @reporter.example_finished("example")
@@ -64,7 +64,7 @@ module Spec
 
       it "should push stats to formatter even with no data" do
         @formatter.should_receive(:start_dump)
-        @formatter.should_receive(:dump_summary).with(:anything, 0, 0, 0)
+        @formatter.should_receive(:dump_summary).with(anything(), 0, 0, 0)
         @reporter.dump
       end
       
@@ -98,7 +98,7 @@ module Spec
       it "should account for passing example in stats" do
         @formatter.should_receive(:example_passed)
         @formatter.should_receive(:start_dump)
-        @formatter.should_receive(:dump_summary).with(:anything, 1, 0, 0)
+        @formatter.should_receive(:dump_summary).with(anything(), 1, 0, 0)
         @reporter.example_finished("example")
         @reporter.dump
       end
@@ -123,8 +123,8 @@ module Spec
         @formatter.should_receive(:add_behaviour)
         @formatter.should_receive(:example_failed).with("example", 1, failure)
         @formatter.should_receive(:start_dump)
-        @formatter.should_receive(:dump_failure).with(1, :anything)
-        @formatter.should_receive(:dump_summary).with(:anything, 1, 1, 0)
+        @formatter.should_receive(:dump_failure).with(1, anything())
+        @formatter.should_receive(:dump_summary).with(anything(), 1, 1, 0)
         @reporter.add_behaviour("behaviour")
         @reporter.example_finished("example", RuntimeError.new)
         @reporter.dump
@@ -144,7 +144,7 @@ module Spec
       it "should account for not implemented example in stats" do
         @formatter.should_receive(:example_not_implemented)
         @formatter.should_receive(:start_dump)
-        @formatter.should_receive(:dump_summary).with(:anything, 1, 0, 1)
+        @formatter.should_receive(:dump_summary).with(anything(), 1, 0, 1)
         @reporter.example_finished("example", nil, nil, true)
         @reporter.dump
       end

data/spec/spec_helper.rb

@@ -6,6 +6,7 @@ lib_path = File.expand_path("#{dir}/../lib")
 $LOAD_PATH.unshift lib_path unless $LOAD_PATH.include?(lib_path)
 
 require 'spec'
+require 'spec/mocks'
 require 'hpricot'
 spec_classes_path = File.expand_path("#{dir}/../spec/spec/spec_classes")
 require spec_classes_path unless $LOAD_PATH.include?(spec_classes_path)

metadata

@@ -3,9 +3,9 @@ rubygems_version: 0.9.2
 specification_version: 1
 name: rspec
 version: !ruby/object:Gem::Version 
-  version: 1.0.3
-date: 2007-05-25 00:00:00 -05:00
-summary: RSpec-1.0.3 (r2035) - BDD for Ruby http://rspec.rubyforge.org/
+  version: 1.0.4
+date: 2007-05-29 00:00:00 -04:00
+summary: RSpec-1.0.4 (r2054) - BDD for Ruby http://rspec.rubyforge.org/
 require_paths: 
 - lib
 email: rspec-devel@rubyforge.org
@@ -142,6 +142,7 @@ files:
 - spec/spec/matchers/include_spec.rb
 - spec/spec/matchers/match_spec.rb
 - spec/spec/matchers/matcher_methods_spec.rb
+- spec/spec/matchers/mock_constraint_matchers_spec.rb
 - spec/spec/matchers/operator_matcher_spec.rb
 - spec/spec/matchers/raise_error_spec.rb
 - spec/spec/matchers/respond_to_spec.rb