rspec 0.8.2 → 0.9.0

data/spec/spec/matchers/respond_to_spec.rb

@@ -1,12 +1,12 @@
 require File.dirname(__FILE__) + '/../../spec_helper.rb'
 
-context "should respond_to(:sym)" do
+describe "should respond_to(:sym)" do
   
-  specify "should pass if target responds to :sym" do
+  it "should pass if target responds to :sym" do
     Object.new.should respond_to(:methods)
   end
   
-  specify "should fail target does not respond to :sym" do
+  it "should fail target does not respond to :sym" do
     lambda {
       Object.new.should respond_to(:some_method)
     }.should fail_with("expected target to respond to :some_method")
@@ -14,17 +14,41 @@ context "should respond_to(:sym)" do
   
 end
 
-context "should_not respond_to(:sym)" do
+describe "should respond_to(message1, message2)" do
   
-  specify "should pass if target does not respond to :sym" do
+  it "should pass if target responds to both messages" do
+    Object.new.should respond_to('methods', 'inspect')
+  end
+  
+  it "should fail target does not respond to first message" do
+    lambda {
+      Object.new.should respond_to('method_one', 'inspect')
+    }.should fail_with('expected target to respond to "method_one"')
+  end
+  
+  it "should fail target does not respond to second message" do
+    lambda {
+      Object.new.should respond_to('inspect', 'method_one')
+    }.should fail_with('expected target to respond to "method_one"')
+  end
+  
+  it "should fail target does not respond to either message" do
+    lambda {
+      Object.new.should respond_to('method_one', 'method_two')
+    }.should fail_with('expected target to respond to "method_one", "method_two"')
+  end
+end
+
+describe "should_not respond_to(:sym)" do
+  
+  it "should pass if target does not respond to :sym" do
     Object.new.should_not respond_to(:some_method)
   end
   
-  specify "should fail target responds to :sym" do
+  it "should fail target responds to :sym" do
     lambda {
       Object.new.should_not respond_to(:methods)
     }.should fail_with("expected target not to respond to :methods")
   end
   
-end
-
+end

data/spec/spec/matchers/satisfy_spec.rb

@@ -1,14 +1,14 @@
 require File.dirname(__FILE__) + '/../../spec_helper.rb'
 
-context "should satisfy { block }" do
-  specify "should pass if block returns true" do
+describe "should satisfy { block }" do
+  it "should pass if block returns true" do
     true.should satisfy { |val| val }
     true.should satisfy do |val|
       val
     end
   end
 
-  specify "should fail if block returns false" do
+  it "should fail if block returns false" do
     lambda {
       false.should satisfy { |val| val }
     }.should fail_with("expected false to satisfy block")
@@ -20,15 +20,15 @@ context "should satisfy { block }" do
   end
 end
 
-context "should_not satisfy { block }" do
-  specify "should pass if block returns false" do
+describe "should_not satisfy { block }" do
+  it "should pass if block returns false" do
     false.should_not satisfy { |val| val }
     false.should_not satisfy do |val|
       val
     end
   end
 
-  specify "should fail if block returns true" do
+  it "should fail if block returns true" do
     lambda {
       true.should_not satisfy { |val| val }
     }.should fail_with("expected true not to satisfy block")

data/spec/spec/matchers/should_===_spec.rb

@@ -0,0 +1,38 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+require 'spec/expectations/differs/default'
+
+describe "should ===" do
+  
+  it "should delegate message to target" do
+    subject = "apple"
+    subject.should_receive(:===).with("apple").and_return(true)
+    subject.should === "apple"
+  end
+  
+  it "should fail when target.===(actual) returns false" do
+    subject = "apple"
+    subject.should_receive(:===).with("orange").and_return(false)
+    Spec::Expectations.should_receive(:fail_with).with(%[expected "orange", got "apple" (using ===)], "orange", "apple")
+    subject.should === "orange"
+  end
+
+end
+
+describe "should_not ===" do
+  
+  it "should delegate message to target" do
+    subject = "orange"
+    subject.should_receive(:===).with("apple").and_return(false)
+    subject.should_not === "apple"
+  end
+  
+  it "should fail when target.===(actual) returns false" do
+    subject = "apple"
+    subject.should_receive(:===).with("apple").and_return(true)
+    Spec::Expectations.should_receive(:fail_with).with(%[expected not === "apple", got "apple"], "apple", "apple")
+    subject.should_not === "apple"
+  end
+
+end
+

data/spec/spec/matchers/should_==_spec.rb

@@ -0,0 +1,37 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+require 'spec/expectations/differs/default'
+
+describe "should ==" do
+  
+  it "should delegate message to target" do
+    subject = "apple"
+    subject.should_receive(:==).with("apple").and_return(true)
+    subject.should == "apple"
+  end
+  
+  it "should fail when target.==(actual) returns false" do
+    subject = "apple"
+    Spec::Expectations.should_receive(:fail_with).with(%[expected "orange", got "apple" (using ==)], "orange", "apple")
+    subject.should == "orange"
+  end
+
+end
+
+describe "should_not ==" do
+  
+  it "should delegate message to target" do
+    subject = "orange"
+    subject.should_receive(:==).with("apple").and_return(false)
+    subject.should_not == "apple"
+  end
+  
+  it "should fail when target.==(actual) returns false" do
+    subject = "apple"
+    Spec::Expectations.should_receive(:fail_with).with(%[expected not == "apple", got "apple"], "apple", "apple")
+    subject.should_not == "apple"
+  end
+
+end
+
+  

data/spec/spec/matchers/should_=~_spec.rb

@@ -0,0 +1,36 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+describe "should =~" do
+  
+  it "should delegate message to target" do
+    subject = "foo"
+    subject.should_receive(:=~).with(/oo/).and_return(true)
+    subject.should =~ /oo/
+  end
+  
+  it "should fail when target.=~(actual) returns false" do
+    subject = "fu"
+    subject.should_receive(:=~).with(/oo/).and_return(false)
+    Spec::Expectations.should_receive(:fail_with).with(%[expected =~ /oo/, got "fu"], /oo/, "fu")
+    subject.should =~ /oo/
+  end
+
+end
+
+describe "should_not =~" do
+  
+  it "should delegate message to target" do
+    subject = "fu"
+    subject.should_receive(:=~).with(/oo/).and_return(false)
+    subject.should_not =~ /oo/
+  end
+  
+  it "should fail when target.=~(actual) returns false" do
+    subject = "foo"
+    subject.should_receive(:=~).with(/oo/).and_return(true)
+    Spec::Expectations.should_receive(:fail_with).with(%[expected not =~ /oo/, got "foo"], /oo/, "foo")
+    subject.should_not =~ /oo/
+  end
+
+end
+

data/spec/spec/matchers/throw_symbol_spec.rb

@@ -1,59 +1,51 @@
 require File.dirname(__FILE__) + '/../../spec_helper.rb'
 
-context "should throw_symbol" do
-  specify "should pass if any Symbol is thrown" do
-    lambda{ throw :sym }.should throw_symbol
-  end
-
-  specify "should fail if no Symbol is thrown" do
-    lambda {
-      lambda { }.should throw_symbol
-    }.should fail_with("expected a Symbol but nothing was thrown")
-  end
-end
-
-context "should_not throw_symbol" do
-  specify "should pass if no Symbol is thrown" do
-    lambda{ }.should_not throw_symbol
-  end
-
-  specify "should fail if any Symbol is thrown" do
-    lambda {
-      lambda { throw :sym }.should_not throw_symbol
-    }.should fail_with("expected no Symbol, got :sym")
-  end
-end
-
-context "should throw_symbol(:sym)" do
-  specify "should pass if correct Symbol is thrown" do
-    lambda{ throw :sym }.should throw_symbol(:sym)
-  end
-
-  specify "should fail if no Symbol is thrown" do
-    lambda {
-      lambda { }.should throw_symbol(:sym)
-    }.should fail_with("expected :sym but nothing was thrown")
-  end
-
-  specify "should fail if wrong Symbol is thrown" do
-    lambda {
-      lambda { throw :wrong_sym }.should throw_symbol(:sym)
-    }.should fail_with("expected :sym, got :wrong_sym")
-  end
-end
-
-context "should_not throw_symbol(:sym)" do
-  specify "should pass if no Symbol is thrown" do
-    lambda { }.should_not throw_symbol(:sym)
-  end
-
-  specify "should pass if other Symbol is thrown" do
-    lambda { throw :wrong_sym }.should_not throw_symbol(:sym)
-  end
-
-  specify "should fail if correct Symbol is thrown" do
-    lambda {
-      lambda{ throw :sym }.should_not throw_symbol(:sym)
-    }.should fail_with("expected :sym not to be thrown")
+module Spec
+  module Matchers
+    describe ThrowSymbol, "(constructed with no Symbol)" do
+      before(:each) { @matcher = ThrowSymbol.new }
+
+      it "should match if any Symbol is thrown" do
+        @matcher.matches?(lambda{ throw :sym }).should be_true
+      end
+      it "should not match if no Symbol is thrown" do
+        @matcher.matches?(lambda{ }).should be_false
+      end
+      it "should provide a failure message" do
+        @matcher.matches?(lambda{})
+        @matcher.failure_message.should == "expected a Symbol but nothing was thrown"
+      end
+      it "should provide a negative failure message" do
+        @matcher.matches?(lambda{ throw :sym})
+        @matcher.negative_failure_message.should == "expected no Symbol, got :sym"
+      end
+    end
+    
+    describe ThrowSymbol, "(constructed with a Symbol)" do
+      before(:each) { @matcher = ThrowSymbol.new(:sym) }
+      
+      it "should match if correct Symbol is thrown" do
+        @matcher.matches?(lambda{ throw :sym }).should be_true
+      end
+      it "should not match no Symbol is thrown" do
+        @matcher.matches?(lambda{ }).should be_false
+      end
+      it "should not match if correct Symbol is thrown" do
+        @matcher.matches?(lambda{ throw :other_sym }).should be_false
+        @matcher.failure_message.should == "expected :sym, got :other_sym"
+      end
+      it "should provide a failure message when no Symbol is thrown" do
+        @matcher.matches?(lambda{})
+        @matcher.failure_message.should == "expected :sym but nothing was thrown"
+      end
+      it "should provide a failure message when wrong Symbol is thrown" do
+        @matcher.matches?(lambda{ throw :other_sym })
+        @matcher.failure_message.should == "expected :sym, got :other_sym"
+      end
+      it "should provide a negative failure message" do
+        @matcher.matches?(lambda{ throw :sym })
+        @matcher.negative_failure_message.should == "expected :sym not to be thrown"
+      end
+    end
   end
 end

data/spec/spec/mocks/any_number_of_times_spec.rb

@@ -1,34 +1,29 @@
 require File.dirname(__FILE__) + '/../../spec_helper.rb'
 
 module Spec
-module Mocks
-context "AnyNumberOfTimes" do
-    setup do
-        @mock = Mock.new("test mock", {
-          :auto_verify => false
-        })
-      
-    end
-    specify "should pass if any number of times method is called many times" do
+  module Mocks
+    
+    describe "AnyNumberOfTimes" do
+      before(:each) do
+        @mock = Mock.new("test mock")
+      end
+
+      it "should pass if any number of times method is called many times" do
         @mock.should_receive(:random_call).any_number_of_times
         (1..10).each do
           @mock.random_call
         end
-        @mock.__verify
-      
-    end
-    specify "should pass if any number of times method is called once" do
+      end
+
+      it "should pass if any number of times method is called once" do
         @mock.should_receive(:random_call).any_number_of_times
         @mock.random_call
-        @mock.__verify
+      end
       
-    end
-    specify "should pass if any number of times method is not called" do
+      it "should pass if any number of times method is not called" do
         @mock.should_receive(:random_call).any_number_of_times
-        @mock.__verify
-      
+      end
     end
-  
-end
-end
+
+  end
 end

data/spec/spec/mocks/argument_expectation_spec.rb

@@ -1,7 +1,7 @@
 require File.dirname(__FILE__) + '/../../spec_helper.rb'
 
-context "An ArgumentExpectation" do
-  specify "should consider an object that responds to #matches? and #description to be a matcher" do
+describe "An ArgumentExpectation" do
+  it "should consider an object that responds to #matches? and #description to be a matcher" do
     argument_expecatation = Spec::Mocks::ArgumentExpectation.new([])
     obj = mock("matcher")
     obj.should_receive(:respond_to?).with(:matches?).and_return(true)
@@ -9,7 +9,7 @@ context "An ArgumentExpectation" do
     argument_expecatation.is_matcher?(obj).should be_true
   end
 
-  specify "should NOT consider an object that only responds to #matches? to be a matcher" do
+  it "should NOT consider an object that only responds to #matches? to be a matcher" do
     argument_expecatation = Spec::Mocks::ArgumentExpectation.new([])
     obj = mock("matcher")
     obj.should_receive(:respond_to?).with(:matches?).and_return(true)

data/spec/spec/mocks/at_least_spec.rb

@@ -2,95 +2,95 @@ require File.dirname(__FILE__) + '/../../spec_helper.rb'
 
 module Spec
   module Mocks
-    context "at_least" do
-      setup do
-        @mock = Mock.new("test mock", :auto_verify => false)
+    describe "at_least" do
+      before(:each) do
+        @mock = Mock.new("test mock")
       end
 
-      specify "should fail if method is never called" do
+      it "should fail if method is never called" do
         @mock.should_receive(:random_call).at_least(4).times
           lambda do
-        @mock.__verify
-        end.should_raise(MockExpectationError)
+        @mock.rspec_verify
+        end.should raise_error(MockExpectationError)
       end
 
-      specify "should fail when called less than n times" do
+      it "should fail when called less than n times" do
         @mock.should_receive(:random_call).at_least(4).times
         @mock.random_call
         @mock.random_call
         @mock.random_call
         lambda do
-          @mock.__verify
-        end.should_raise(MockExpectationError)
+          @mock.rspec_verify
+        end.should raise_error(MockExpectationError)
       end
 
-      specify "should fail when at least once method is never called" do
+      it "should fail when at least once method is never called" do
         @mock.should_receive(:random_call).at_least(:once)
         lambda do
-          @mock.__verify
-        end.should_raise(MockExpectationError)
+          @mock.rspec_verify
+        end.should raise_error(MockExpectationError)
       end
 
-      specify "should fail when at least twice method is called once" do
+      it "should fail when at least twice method is called once" do
         @mock.should_receive(:random_call).at_least(:twice)
         @mock.random_call
         lambda do
-          @mock.__verify
-        end.should_raise(MockExpectationError)
+          @mock.rspec_verify
+        end.should raise_error(MockExpectationError)
       end
 
-      specify "should fail when at least twice method is never called" do
+      it "should fail when at least twice method is never called" do
         @mock.should_receive(:random_call).at_least(:twice)
         lambda do
-          @mock.__verify
-        end.should_raise(MockExpectationError)
+          @mock.rspec_verify
+        end.should raise_error(MockExpectationError)
       end
 
-      specify "should pass when at least n times method is called exactly n times" do
+      it "should pass when at least n times method is called exactly n times" do
         @mock.should_receive(:random_call).at_least(4).times
         @mock.random_call
         @mock.random_call
         @mock.random_call
         @mock.random_call
-        @mock.__verify
+        @mock.rspec_verify
       end
 
-      specify "should pass when at least n times method is called n plus 1 times" do
+      it "should pass when at least n times method is called n plus 1 times" do
         @mock.should_receive(:random_call).at_least(4).times
         @mock.random_call
         @mock.random_call
         @mock.random_call
         @mock.random_call
         @mock.random_call
-        @mock.__verify
+        @mock.rspec_verify
       end
 
-      specify "should pass when at least once method is called once" do
+      it "should pass when at least once method is called once" do
         @mock.should_receive(:random_call).at_least(:once)
         @mock.random_call
-        @mock.__verify
+        @mock.rspec_verify
       end
 
-      specify "should pass when at least once method is called twice" do
+      it "should pass when at least once method is called twice" do
         @mock.should_receive(:random_call).at_least(:once)
         @mock.random_call
         @mock.random_call
-        @mock.__verify
+        @mock.rspec_verify
       end
 
-      specify "should pass when at least twice method is called three times" do
+      it "should pass when at least twice method is called three times" do
         @mock.should_receive(:random_call).at_least(:twice)
         @mock.random_call
         @mock.random_call
         @mock.random_call
-        @mock.__verify
+        @mock.rspec_verify
       end
 
-      specify "should pass when at least twice method is called twice" do
+      it "should pass when at least twice method is called twice" do
         @mock.should_receive(:random_call).at_least(:twice)
         @mock.random_call
         @mock.random_call
-        @mock.__verify
+        @mock.rspec_verify
       end
     end
   end