rspec 0.7.5.1 → 0.8.0

data/spec/spec/matchers/include_spec.rb

@@ -0,0 +1,33 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+context "should include(expected)" do
+  specify "should pass if target includes expected" do
+    [1,2,3].should include(3)
+    "abc".should include("a")
+  end
+
+  specify "should fail if target does not include expected" do
+    lambda {
+      [1,2,3].should include(4)
+    }.should fail_with("expected [1, 2, 3] to include 4")
+    lambda {
+      "abc".should include("d")
+    }.should fail_with("expected \"abc\" to include \"d\"")
+  end
+end
+
+context "should_not include(expected)" do
+  specify "should pass if target does not include expected" do
+    [1,2,3].should_not include(4)
+    "abc".should_not include("d")
+  end
+
+  specify "should fail if target includes expected" do
+    lambda {
+      [1,2,3].should_not include(3)
+    }.should fail_with("expected [1, 2, 3] not to include 3")
+    lambda {
+      "abc".should_not include("c")
+    }.should fail_with("expected \"abc\" not to include \"c\"")
+  end
+end

data/spec/spec/matchers/match_spec.rb

@@ -0,0 +1,37 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+context "should match(expected)" do
+  specify "should pass when target (String) matches expected (Regexp)" do
+    "string".should match(/tri/)
+  end
+
+  specify "should fail when target (String) matches expected (Regexp)" do
+    lambda {
+      "string".should match(/rings/)
+    }.should fail
+  end
+
+  specify "should provide message, expected and actual on failure" do
+    matcher = match(/rings/)
+    matcher.matches?("string")
+    matcher.failure_message.should == ["expected \"string\" to match /rings/", /rings/, "string"]
+  end
+end
+
+context "should_not match(expected)" do
+  specify "should pass when target (String) matches expected (Regexp)" do
+    "string".should_not match(/rings/)
+  end
+
+  specify "should fail when target (String) matches expected (Regexp)" do
+    lambda {
+      "string".should_not match(/tri/)
+    }.should fail
+  end
+
+  specify "should provide message, expected and actual on failure" do
+    matcher = match(/tri/)
+    matcher.matches?("string")
+    matcher.negative_failure_message.should == ["expected \"string\" not to match /tri/", /tri/, "string"]
+  end
+end

data/spec/spec/matchers/matcher_methods_spec.rb

@@ -0,0 +1,85 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+module Spec
+  module Matchers
+    
+    context "Spec::Matchers should support" do
+      specify "be_true" do
+        be_true.should be_an_instance_of(Be)
+      end
+      specify "be_false" do
+        be_false.should be_an_instance_of(Be)
+      end
+      specify "be_nil" do
+        be_nil.should be_an_instance_of(Be)
+      end
+      specify "be_arbitrary_predicate" do
+        be_arbitrary_predicate.should be_an_instance_of(Be)
+      end
+      specify "be_close" do
+        be_close(1,2).should be_an_instance_of(BeClose)
+      end
+      specify "change" do
+        change("target", :message).should be_an_instance_of(Change)
+      end
+      specify "eql" do
+        eql(:expected).should be_an_instance_of(Eql)
+      end
+      specify "equal" do
+        equal(:expected).should be_an_instance_of(Equal)
+      end
+      specify "have_x > has_x?" do
+        have_key(:key).should be_an_instance_of(Has)
+      end
+      specify "have" do
+        have(0).should be_an_instance_of(Have)
+      end
+      specify "have_exactly" do
+        have_exactly(0).should be_an_instance_of(Have)
+      end
+      specify "have_at_least" do
+        have_at_least(0).should be_an_instance_of(Have)
+      end
+      specify "have_at_most" do
+        have_at_most(0).should be_an_instance_of(Have)
+      end
+      specify "include" do
+        include(:value).should be_an_instance_of(Include)
+      end
+      specify "match" do
+        match(:value).should be_an_instance_of(Match)
+      end
+      specify "raise_error" do
+        raise_error.should be_an_instance_of(RaiseError)
+        raise_error(NoMethodError).should be_an_instance_of(RaiseError)
+        raise_error(NoMethodError, "message").should be_an_instance_of(RaiseError)
+      end
+      specify "satisfy" do
+        satisfy{}.should be_an_instance_of(Satisfy)
+      end
+      specify "throw_symbol" do
+        throw_symbol.should be_an_instance_of(ThrowSymbol)
+        throw_symbol(:sym).should be_an_instance_of(ThrowSymbol)
+      end
+      specify "respond_to" do
+        respond_to(:sym).should be_an_instance_of(RespondTo)
+      end
+      
+    end
+    
+    context "Spec::Matchers should convert be_xyz to..." do
+      specify "sym passed to Be" do
+        Be.should_receive(:new).with(:be_whatever)
+        be_whatever
+      end
+    end
+    
+    context "Spec::Matchers should convert have_xyz to..." do
+      specify "string passed to Has" do
+        Has.should_receive(:new).with(:have_whatever)
+        have_whatever
+      end
+    end
+
+  end
+end

data/spec/spec/matchers/raise_error_spec.rb

@@ -0,0 +1,147 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+context "should raise_error" do
+  specify "should pass if anything is raised" do
+    lambda {raise}.should raise_error
+  end
+  
+  specify "should fail if nothing is raised" do
+    lambda {
+      lambda {}.should raise_error
+    }.should fail_with("expected Exception but nothing was raised")
+  end
+end
+
+context "should_not raise_error" do
+  specify "should pass if nothing is raised" do
+    lambda {}.should_not raise_error
+  end
+  
+  specify "should fail if anything is raised" do
+    lambda {
+      lambda {raise}.should_not raise_error
+    }.should fail_with("expected no Exception, got RuntimeError")
+  end
+end
+
+context "should raise_error(NamedError)" do
+  specify "should pass if named error is raised" do
+    lambda { non_existent_method }.should raise_error(NameError)
+  end
+  
+  specify "should fail if nothing is raised" do
+    lambda {
+      lambda { }.should raise_error(NameError)
+    }.should fail_with("expected NameError but nothing was raised")
+  end
+  
+  specify "should fail if another error is raised" do
+    lambda {
+      lambda { raise }.should raise_error(NameError)
+    }.should fail_with("expected NameError, got RuntimeError")
+  end
+end
+
+context "should_not raise_error(NamedError)" do
+  specify "should pass if nothing is raised" do
+    lambda { }.should_not raise_error(NameError)
+  end
+  
+  specify "should pass if another error is raised" do
+    lambda { raise }.should_not raise_error(NameError)
+  end
+  
+  specify "should fail if named error is raised" do
+    lambda {
+      lambda { non_existent_method }.should_not raise_error(NameError)
+    }.should fail_with(/expected no NameError, got #<NameError: undefined/)
+  end  
+end
+
+context "should raise_error(NamedError, error_message) with String" do
+  specify "should pass if named error is raised with same message" do
+    lambda { raise "example message" }.should raise_error(RuntimeError, "example message")
+  end
+  
+  specify "should fail if nothing is raised" do
+    lambda {
+      lambda {}.should raise_error(RuntimeError, "example message")
+    }.should fail_with("expected RuntimeError with \"example message\" but nothing was raised")
+  end
+  
+  specify "should fail if incorrect error is raised" do
+    lambda {
+      lambda { raise }.should raise_error(NameError, "example message")
+    }.should fail_with("expected NameError with \"example message\", got RuntimeError")
+  end
+  
+  specify "should fail if correct error is raised with incorrect message" do
+    lambda {
+      lambda { raise RuntimeError.new("not the example message") }.should raise_error(RuntimeError, "example message")
+    }.should fail_with(/expected RuntimeError with \"example message\", got #<RuntimeError: not the example message/)
+  end
+end
+
+context "should_not raise_error(NamedError, error_message) with String" do
+  specify "should pass if nothing is raised" do
+    lambda {}.should_not raise_error(RuntimeError, "example message")
+  end
+  
+  specify "should pass if a different error is raised" do
+    lambda { raise }.should_not raise_error(NameError, "example message")
+  end
+  
+  specify "should pass if same error is raised with different message" do
+    lambda { raise RuntimeError.new("not the example message") }.should_not raise_error(RuntimeError, "example message")
+  end
+  
+  specify "should fail if named error is raised with same message" do
+    lambda {
+      lambda { raise "example message" }.should_not raise_error(RuntimeError, "example message")
+    }.should fail_with("expected no RuntimeError with \"example message\", got #<RuntimeError: example message>")
+  end
+end
+
+context "should raise_error(NamedError, error_message) with Regexp" do
+  specify "should pass if named error is raised with matching message" do
+    lambda { raise "example message" }.should raise_error(RuntimeError, /ample mess/)
+  end
+  
+  specify "should fail if nothing is raised" do
+    lambda {
+      lambda {}.should raise_error(RuntimeError, /ample mess/)
+    }.should fail_with("expected RuntimeError with message matching /ample mess/ but nothing was raised")
+  end
+  
+  specify "should fail if incorrect error is raised" do
+    lambda {
+      lambda { raise }.should raise_error(NameError, /ample mess/)
+    }.should fail_with("expected NameError with message matching /ample mess/, got RuntimeError")
+  end
+  
+  specify "should fail if correct error is raised with incorrect message" do
+    lambda {
+      lambda { raise RuntimeError.new("not the example message") }.should raise_error(RuntimeError, /less than ample mess/)
+    }.should fail_with("expected RuntimeError with message matching /less than ample mess/, got #<RuntimeError: not the example message>")
+  end
+end
+
+context "should_not raise_error(NamedError, error_message) with Regexp" do
+  specify "should pass if nothing is raised" do
+    lambda {}.should_not raise_error(RuntimeError, /ample mess/)
+  end
+  
+  specify "should pass if a different error is raised" do
+    lambda { raise }.should_not raise_error(NameError, /ample mess/)
+  end
+  
+  specify "should pass if same error is raised with non-matching message" do
+    lambda { raise RuntimeError.new("non matching message") }.should_not raise_error(RuntimeError, /ample mess/)
+  end
+  
+  specify "should fail if named error is raised with matching message" do
+    lambda {
+      lambda { raise "example message" }.should_not raise_error(RuntimeError, /ample mess/)
+    }.should fail_with("expected no RuntimeError with message matching /ample mess/, got #<RuntimeError: example message>")
+  end
+end

data/spec/spec/matchers/respond_to_spec.rb

@@ -0,0 +1,30 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+context "should respond_to(:sym)" do
+  
+  specify "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
+    lambda {
+      Object.new.should respond_to(:some_method)
+    }.should fail_with("expected target to respond to :some_method")
+  end
+  
+end
+
+context "should_not respond_to(:sym)" do
+  
+  specify "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
+    lambda {
+      Object.new.should_not respond_to(:methods)
+    }.should fail_with("expected target not to respond to :methods")
+  end
+  
+end
+

data/spec/spec/matchers/satisfy_spec.rb

@@ -0,0 +1,36 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+context "should satisfy { block }" do
+  specify "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
+    lambda {
+      false.should satisfy { |val| val }
+    }.should fail_with("expected false to satisfy block")
+    lambda do
+      false.should satisfy do |val|
+        val
+      end
+    end.should fail_with("expected false to satisfy block")
+  end
+end
+
+context "should_not satisfy { block }" do
+  specify "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
+    lambda {
+      true.should_not satisfy { |val| val }
+    }.should fail_with("expected true not to satisfy block")
+  end
+end

data/spec/spec/matchers/throw_symbol_spec.rb

@@ -0,0 +1,59 @@
+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")
+  end
+end

data/spec/spec/mocks/any_number_of_times_spec.rb

@@ -0,0 +1,34 @@
+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
+        @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
+        @mock.should_receive(:random_call).any_number_of_times
+        @mock.random_call
+        @mock.__verify
+      
+    end
+    specify "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