rspec-expectations 2.0.0.beta.22 → 2.6.0

data/spec/rspec/matchers/operator_matcher_spec.rb

@@ -15,12 +15,38 @@ describe "should ==" do
   
   it "fails when target.==(actual) returns false" do
     subject = "apple"
-    RSpec::Expectations.should_receive(:fail_with).with(%[expected: "orange",\n     got: "apple" (using ==)], "orange", "apple")
+    RSpec::Expectations.should_receive(:fail_with).with(%[expected: "orange"\n     got: "apple" (using ==)], "orange", "apple")
     subject.should == "orange"
   end
   
 end
 
+describe "unsupported operators", :if => RUBY_VERSION.to_f == 1.9 do
+  it "raises an appropriate error for should != expected" do
+    expect {
+      "apple".should != "pear"
+    }.to raise_error(/does not support `should != expected`.  Use `should_not == expected`/)
+  end
+
+  it "raises an appropriate error for should_not != expected" do
+    expect {
+      "apple".should_not != "pear"
+    }.to raise_error(/does not support `should_not != expected`.  Use `should == expected`/)
+  end
+
+  it "raises an appropriate error for should !~ expected" do
+    expect {
+      "apple".should !~ /regex/
+    }.to raise_error(/does not support `should !~ expected`.  Use `should_not =~ expected`/)
+  end
+
+  it "raises an appropriate error for should_not !~ expected" do
+    expect {
+      "apple".should_not !~ /regex/
+    }.to raise_error(/does not support `should_not !~ expected`.  Use `should =~ expected`/)
+  end
+end
+
 describe "should_not ==" do
   
   it "delegates message to target" do
@@ -36,7 +62,7 @@ describe "should_not ==" do
 
   it "fails when target.==(actual) returns false" do
     subject = "apple"
-    RSpec::Expectations.should_receive(:fail_with).with(%[expected not: == "apple",\n         got:    "apple"], "apple", "apple")
+    RSpec::Expectations.should_receive(:fail_with).with(%[expected not: == "apple"\n         got:    "apple"], "apple", "apple")
     subject.should_not == "apple"
   end
   
@@ -53,7 +79,7 @@ describe "should ===" do
   it "fails when target.===(actual) returns false" do
     subject = "apple"
     subject.should_receive(:===).with("orange").and_return(false)
-    RSpec::Expectations.should_receive(:fail_with).with(%[expected: "orange",\n     got: "apple" (using ===)], "orange", "apple")
+    RSpec::Expectations.should_receive(:fail_with).with(%[expected: "orange"\n     got: "apple" (using ===)], "orange", "apple")
     subject.should === "orange"
   end
   
@@ -70,7 +96,7 @@ describe "should_not ===" do
   it "fails when target.===(actual) returns false" do
     subject = "apple"
     subject.should_receive(:===).with("apple").and_return(true)
-    RSpec::Expectations.should_receive(:fail_with).with(%[expected not: === "apple",\n         got:     "apple"], "apple", "apple")
+    RSpec::Expectations.should_receive(:fail_with).with(%[expected not: === "apple"\n         got:     "apple"], "apple", "apple")
     subject.should_not === "apple"
   end
 
@@ -87,7 +113,7 @@ describe "should =~" do
   it "fails when target.=~(actual) returns false" do
     subject = "fu"
     subject.should_receive(:=~).with(/oo/).and_return(false)
-    RSpec::Expectations.should_receive(:fail_with).with(%[expected: /oo/,\n     got: "fu" (using =~)], /oo/, "fu")
+    RSpec::Expectations.should_receive(:fail_with).with(%[expected: /oo/\n     got: "fu" (using =~)], /oo/, "fu")
     subject.should =~ /oo/
   end
 
@@ -104,7 +130,7 @@ describe "should_not =~" do
   it "fails when target.=~(actual) returns false" do
     subject = "foo"
     subject.should_receive(:=~).with(/oo/).and_return(true)
-    RSpec::Expectations.should_receive(:fail_with).with(%[expected not: =~ /oo/,\n         got:    "foo"], /oo/, "foo")
+    RSpec::Expectations.should_receive(:fail_with).with(%[expected not: =~ /oo/\n         got:    "foo"], /oo/, "foo")
     subject.should_not =~ /oo/
   end
 
@@ -117,7 +143,7 @@ describe "should >" do
   end
 
   it "fails if > fails" do
-    RSpec::Expectations.should_receive(:fail_with).with(%[expected: > 5,\n     got:   4], 5, 4)
+    RSpec::Expectations.should_receive(:fail_with).with(%[expected: > 5\n     got:   4], 5, 4)
     4.should > 5
   end
 
@@ -131,7 +157,7 @@ describe "should >=" do
   end
 
   it "fails if > fails" do
-    RSpec::Expectations.should_receive(:fail_with).with(%[expected: >= 5,\n     got:    4], 5, 4)
+    RSpec::Expectations.should_receive(:fail_with).with(%[expected: >= 5\n     got:    4], 5, 4)
     4.should >= 5
   end
 
@@ -144,7 +170,7 @@ describe "should <" do
   end
 
   it "fails if > fails" do
-    RSpec::Expectations.should_receive(:fail_with).with(%[expected: < 3,\n     got:   4], 3, 4)
+    RSpec::Expectations.should_receive(:fail_with).with(%[expected: < 3\n     got:   4], 3, 4)
     4.should < 3
   end
 
@@ -158,7 +184,7 @@ describe "should <=" do
   end
 
   it "fails if > fails" do
-    RSpec::Expectations.should_receive(:fail_with).with(%[expected: <= 3,\n     got:    4], 3, 4)
+    RSpec::Expectations.should_receive(:fail_with).with(%[expected: <= 3\n     got:    4], 3, 4)
     4.should <= 3
   end
 

data/spec/rspec/matchers/respond_to_spec.rb

@@ -20,6 +20,18 @@ describe "should respond_to(:sym).with(1).argument" do
     def obj.foo(arg); end
     obj.should respond_to(:foo).with(1).argument
   end
+
+  it "passes if target responds to any number of arguments" do
+    obj = Object.new
+    def obj.foo(*args); end
+    obj.should respond_to(:foo).with(1).argument
+  end
+
+  it "passes if target responds to one or more arguments" do
+    obj = Object.new
+    def obj.foo(a, *args); end
+    obj.should respond_to(:foo).with(1).argument
+  end
   
   it "fails if target does not respond to :sym" do
     obj = Object.new
@@ -43,6 +55,14 @@ describe "should respond_to(:sym).with(1).argument" do
       obj.should respond_to(:foo).with(1).argument
     }.should fail_with(/expected #<Object.*> to respond to :foo with 1 argument/)
   end
+
+  it "fails if :sym expects 2 or more args" do
+    obj = Object.new
+    def obj.foo(arg, arg2, *args); end
+    lambda {
+      obj.should respond_to(:foo).with(1).argument
+    }.should fail_with(/expected #<Object.*> to respond to :foo with 1 argument/)
+  end
 end
 
 describe "should respond_to(message1, message2)" do
@@ -76,6 +96,24 @@ describe "should respond_to(:sym).with(2).arguments" do
     def obj.foo(a1, a2); end
     obj.should respond_to(:foo).with(2).arguments
   end
+
+  it "passes if target responds to any number of arguments" do
+    obj = Object.new
+    def obj.foo(*args); end
+    obj.should respond_to(:foo).with(2).arguments
+  end
+
+  it "passes if target responds to one or more arguments" do
+    obj = Object.new
+    def obj.foo(a, *args); end
+    obj.should respond_to(:foo).with(2).arguments
+  end
+
+  it "passes if target responds to two or more arguments" do
+    obj = Object.new
+    def obj.foo(a, b, *args); end
+    obj.should respond_to(:foo).with(2).arguments
+  end
   
   it "fails if target does not respond to :sym" do
     obj = Object.new
@@ -92,13 +130,21 @@ describe "should respond_to(:sym).with(2).arguments" do
     }.should fail_with(/expected #<Object.*> to respond to :foo with 2 arguments/)
   end
   
-  it "fails if :sym expects 2 args" do
+  it "fails if :sym expects 1 args" do
     obj = Object.new
     def obj.foo(arg); end
     lambda {
       obj.should respond_to(:foo).with(2).arguments
     }.should fail_with(/expected #<Object.*> to respond to :foo with 2 arguments/)
   end
+
+  it "fails if :sym expects 3 or more args" do
+    obj = Object.new
+    def obj.foo(arg, arg2, arg3, *args); end
+    lambda {
+      obj.should respond_to(:foo).with(2).arguments
+    }.should fail_with(/expected #<Object.*> to respond to :foo with 2 arguments/)
+  end
 end
 
 describe "should_not respond_to(:sym)" do
@@ -114,3 +160,133 @@ describe "should_not respond_to(:sym)" do
   end
   
 end
+
+describe "should_not respond_to(:sym).with(1).argument" do
+  it "fails if target responds to :sym with 1 arg" do
+    obj = Object.new
+    def obj.foo(arg); end
+    lambda {
+      obj.should_not respond_to(:foo).with(1).argument
+    }.should fail_with(/expected #<Object:.*> not to respond to :foo with 1 argument/)
+  end
+
+  it "fails if target responds to :sym with any number of args" do
+    obj = Object.new
+    def obj.foo(*args); end
+    lambda {
+      obj.should_not respond_to(:foo).with(1).argument
+    }.should fail_with(/expected #<Object:.*> not to respond to :foo with 1 argument/)
+  end
+
+  it "fails if target responds to :sym with one or more args" do
+    obj = Object.new
+    def obj.foo(a, *args); end
+    lambda {
+      obj.should_not respond_to(:foo).with(1).argument
+    }.should fail_with(/expected #<Object:.*> not to respond to :foo with 1 argument/)
+  end
+
+  it "passes if target does not respond to :sym" do
+    obj = Object.new
+    obj.should_not respond_to(:some_method).with(1).argument
+  end
+
+  it "passes if :sym expects 0 args" do
+    obj = Object.new
+    def obj.foo; end
+    obj.should_not respond_to(:foo).with(1).argument
+  end
+
+  it "passes if :sym expects 2 args" do
+    obj = Object.new
+    def obj.foo(arg, arg2); end
+    obj.should_not respond_to(:foo).with(1).argument
+  end
+
+  it "passes if :sym expects 2 or more args" do
+    obj = Object.new
+    def obj.foo(arg, arg2, *args); end
+    obj.should_not respond_to(:foo).with(1).argument
+  end
+end
+
+describe "should_not respond_to(message1, message2)" do
+  it "passes if target does not respond to either message1 or message2" do
+    Object.new.should_not respond_to(:some_method, :some_other_method)
+  end
+
+  it "fails if target responds to message1 but not message2" do
+    lambda {
+      Object.new.should_not respond_to(:object_id, :some_method)
+    }.should fail_with(/expected #<Object:.*> not to respond to :object_id/)
+  end
+
+  it "fails if target responds to message2 but not message1" do
+    lambda {
+      Object.new.should_not respond_to(:some_method, :object_id)
+    }.should fail_with(/expected #<Object:.*> not to respond to :object_id/)
+  end
+
+  it "fails if target responds to both message1 and message2" do
+    lambda {
+      Object.new.should_not respond_to(:class, :object_id)
+    }.should fail_with(/expected #<Object:.*> not to respond to :class, :object_id/)
+  end
+end
+
+describe "should_not respond_to(:sym).with(2).arguments" do
+  it "fails if target responds to :sym with 2 args" do
+    obj = Object.new
+    def obj.foo(a1, a2); end
+    lambda {
+      obj.should_not respond_to(:foo).with(2).arguments
+    }.should fail_with(/expected .* not to respond to :foo with 2 arguments/)
+  end
+
+  it "fails if target responds to :sym with any number args" do
+    obj = Object.new
+    def obj.foo(*args); end
+    lambda {
+      obj.should_not respond_to(:foo).with(2).arguments
+    }.should fail_with(/expected .* not to respond to :foo with 2 arguments/)
+  end
+
+  it "fails if target responds to :sym with one or more args" do
+    obj = Object.new
+    def obj.foo(a, *args); end
+    lambda {
+      obj.should_not respond_to(:foo).with(2).arguments
+    }.should fail_with(/expected .* not to respond to :foo with 2 arguments/)
+  end
+
+  it "fails if target responds to :sym with two or more args" do
+    obj = Object.new
+    def obj.foo(a, b, *args); end
+    lambda {
+      obj.should_not respond_to(:foo).with(2).arguments
+    }.should fail_with(/expected .* not to respond to :foo with 2 arguments/)
+  end
+
+  it "passes if target does not respond to :sym" do
+    obj = Object.new
+    obj.should_not respond_to(:some_method).with(2).arguments
+  end
+
+  it "passes if :sym expects 0 args" do
+    obj = Object.new
+    def obj.foo; end
+    obj.should_not respond_to(:foo).with(2).arguments
+  end
+
+  it "passes if :sym expects 2 args" do
+    obj = Object.new
+    def obj.foo(arg); end
+    obj.should_not respond_to(:foo).with(2).arguments
+  end
+
+  it "passes if :sym expects 3 or more args" do
+    obj = Object.new
+    def obj.foo(a, b, c, *arg); end
+    obj.should_not respond_to(:foo).with(2).arguments
+  end
+end

data/spec/rspec/matchers/satisfy_spec.rb

@@ -1,6 +1,10 @@
 require 'spec_helper'
 
 describe "should satisfy { block }" do
+  it "describes itself" do
+    satisfy.description.should eq("satisfy block")
+  end
+
   it "passes if block returns true" do
     true.should satisfy { |val| val }
     true.should satisfy do |val|

data/spec/rspec/matchers/throw_symbol_spec.rb

@@ -17,11 +17,11 @@ module RSpec
         end
         it "provides a failure message" do
           @matcher.matches?(lambda{})
-          @matcher.failure_message_for_should.should == "expected a Symbol but nothing was thrown"
+          @matcher.failure_message_for_should.should == "expected a Symbol to be thrown, got nothing"
         end
         it "provides a negative failure message" do
           @matcher.matches?(lambda{ throw :sym})
-          @matcher.failure_message_for_should_not.should == "expected no Symbol, got :sym"
+          @matcher.failure_message_for_should_not.should == "expected no Symbol to be thrown, got :sym"
         end
       end
           
@@ -42,18 +42,20 @@ module RSpec
         end
         it "provides a failure message when no Symbol is thrown" do
           @matcher.matches?(lambda{})
-          @matcher.failure_message_for_should.should == "expected :sym but nothing was thrown"
+          @matcher.failure_message_for_should.should == "expected :sym to be thrown, got nothing"
         end
         it "provides a failure message when wrong Symbol is thrown" do
           @matcher.matches?(lambda{ throw :other_sym })
-          @matcher.failure_message_for_should.should == "expected :sym, got :other_sym"
+          @matcher.failure_message_for_should.should == "expected :sym to be thrown, got :other_sym"
         end
         it "provides a negative failure message" do
           @matcher.matches?(lambda{ throw :sym })
-          @matcher.failure_message_for_should_not.should == "expected :sym not to be thrown"
+          @matcher.failure_message_for_should_not.should == "expected :sym not to be thrown, got :sym"
         end
         it "only matches NameErrors raised by uncaught throws" do
-          @matcher.matches?(lambda{ sym }).should be_false
+          expect {
+            @matcher.matches?(lambda{ sym }).should be_false
+          }.to raise_error(NameError)
         end
       end
 
@@ -77,18 +79,33 @@ module RSpec
         end
         it "provides a failure message when no Symbol is thrown" do
           @matcher.matches?(lambda{})
-          @matcher.failure_message_for_should.should == %q[expected :sym with "a" but nothing was thrown]
+          @matcher.failure_message_for_should.should == %q[expected :sym with "a" to be thrown, got nothing]
         end
         it "provides a failure message when wrong Symbol is thrown" do
           @matcher.matches?(lambda{ throw :other_sym })
-          @matcher.failure_message_for_should.should == %q[expected :sym with "a", got :other_sym]
+          @matcher.failure_message_for_should.should == %q[expected :sym with "a" to be thrown, got :other_sym]
+        end
+        it "provides a failure message when wrong arg is thrown" do
+          @matcher.matches?(lambda{ throw :sym, "b" })
+          @matcher.failure_message_for_should.should == %q[expected :sym with "a" to be thrown, got :sym with "b"]
+        end
+        it "provides a failure message when no arg is thrown" do
+          @matcher.matches?(lambda{ throw :sym })
+          @matcher.failure_message_for_should.should == %q[expected :sym with "a" to be thrown, got :sym with no argument]
         end
         it "provides a negative failure message" do
           @matcher.matches?(lambda{ throw :sym })
-          @matcher.failure_message_for_should_not.should == %q[expected :sym with "a" not to be thrown]
+          @matcher.failure_message_for_should_not.should == %q[expected :sym with "a" not to be thrown, got :sym with no argument]
         end
         it "only matches NameErrors raised by uncaught throws" do
-          @matcher.matches?(lambda{ sym }).should be_false
+          expect {
+            @matcher.matches?(lambda{ sym }).should be_false
+          }.to raise_error(NameError)
+        end
+        it "raises other errors" do
+          expect {
+            @matcher.matches?(lambda { raise "Boom" })
+          }.to raise_error(/Boom/)
         end
       end
     end

data/spec/spec_helper.rb

@@ -1,5 +1,5 @@
 def add_to_load_path(path, prepend=false)
-  path = File.expand_path("../#{path}", __FILE__)
+  path = File.expand_path("../../#{path}/lib", __FILE__)
   if prepend
     $LOAD_PATH.unshift(path) unless $LOAD_PATH.include?(path)
   else
@@ -7,45 +7,20 @@ def add_to_load_path(path, prepend=false)
   end
 end
 
-add_to_load_path("../lib", :prepend)
-add_to_load_path("../../rspec-core/lib")
-add_to_load_path("../../rspec-mocks/lib")
+require 'test/unit'
 
+add_to_load_path("rspec-expectations", :prepend)
+add_to_load_path("rspec-core")
+add_to_load_path("rspec-mocks")
+
+require 'rspec/expectations'
 require 'rspec/core'
 require 'rspec/mocks'
 
-Dir['./spec/support/**/*'].each do |f|
-  require f
-end
-
-def with_ruby(version)
-  yield if RUBY_PLATFORM =~ Regexp.compile("^#{version}")
-end
-
-module RSpec
-  module Ruby
-    class << self
-      def version
-        RUBY_VERSION
-      end
-    end
-  end
-end
-
-module RSpec  
-  module Matchers
-    def fail
-      raise_error(RSpec::Expectations::ExpectationNotMetError)
-    end
-
-    def fail_with(message)
-      raise_error(RSpec::Expectations::ExpectationNotMetError, message)
-    end
-  end
-end
+Dir['./spec/support/**/*'].each {|f| require f}
 
 RSpec::configure do |config|
-  config.mock_with(:rspec)
-  config.include RSpec::Mocks::Methods
   config.color_enabled = true
+  config.filter_run :focused => true
+  config.run_all_when_everything_filtered = true
 end

data/spec/support/classes.rb

@@ -1,4 +1,4 @@
-# This file contains various classes used by the specs.
+# various classes used by the specs
 module RSpec
   module Expectations
     module Helper

data/spec/support/matchers.rb

@@ -0,0 +1,22 @@
+RSpec::Matchers.define :include_method do |expected|
+  match do |actual|
+    actual.map { |m| m.to_s }.include?(expected.to_s)
+  end
+end
+
+module RSpec
+  module Matchers
+    def fail
+      raise_error(RSpec::Expectations::ExpectationNotMetError)
+    end
+
+    def fail_with(message)
+      raise_error(RSpec::Expectations::ExpectationNotMetError, message)
+    end
+
+    def fail_matching(message)
+      raise_error(RSpec::Expectations::ExpectationNotMetError, /#{Regexp.escape(message)}/)
+    end
+  end
+end
+

data/spec/support/ruby_version.rb

@@ -0,0 +1,10 @@
+module RSpec
+  module Ruby
+    class << self
+      def version
+        RUBY_VERSION
+      end
+    end
+  end
+end
+