typo 5.1.3 → 5.1.98

data/vendor/plugins/rspec/spec/spec/interop/test/unit/resources/spec_with_options_hash.rb

@@ -0,0 +1,13 @@
+rspec_lib = File.dirname(__FILE__) + "/../../../../../../lib"
+$:.unshift rspec_lib unless $:.include?(rspec_lib)
+require 'test/unit'
+require 'spec'
+
+describe "options hash" do
+  describe "#options" do
+    it "should expose the options hash" do
+      group = describe("group", :this => 'hash') {}
+      group.options[:this].should == 'hash'
+    end
+  end
+end

data/vendor/plugins/rspec/spec/spec/interop/test/unit/spec_spec.rb

@@ -3,43 +3,50 @@ require File.dirname(__FILE__) + '/test_unit_spec_helper'
 describe "ExampleGroup with test/unit/interop" do
   include TestUnitSpecHelper
   
-  before(:each) do
-    @dir = File.dirname(__FILE__) + "/resources"
+  def resources
+    File.dirname(__FILE__) + "/resources"
   end
   
   describe "with passing examples" do
     it "should output 0 failures" do
-      output = ruby("#{@dir}/spec_that_passes.rb")
+      output = ruby("#{resources}/spec_that_passes.rb")
       output.should include("1 example, 0 failures")
     end
 
     it "should return an exit code of 0" do
-      ruby("#{@dir}/spec_that_passes.rb")
+      ruby("#{resources}/spec_that_passes.rb")
       $?.should == 0
     end
   end
 
   describe "with failing examples" do
     it "should output 1 failure" do
-      output = ruby("#{@dir}/spec_that_fails.rb")
+      output = ruby("#{resources}/spec_that_fails.rb")
       output.should include("1 example, 1 failure")
     end
 
     it "should return an exit code of 256" do
-      ruby("#{@dir}/spec_that_fails.rb")
+      ruby("#{resources}/spec_that_fails.rb")
       $?.should == 256
     end
   end
 
   describe "with example that raises an error" do
     it "should output 1 failure" do
-      output = ruby("#{@dir}/spec_with_errors.rb")
+      output = ruby("#{resources}/spec_with_errors.rb")
       output.should include("1 example, 1 failure")
     end
 
     it "should return an exit code of 256" do
-      ruby("#{@dir}/spec_with_errors.rb")
+      ruby("#{resources}/spec_with_errors.rb")
       $?.should == 256
     end
   end
+  
+  describe "options hash" do
+    it "should be exposed" do
+      output = ruby("#{resources}/spec_with_options_hash.rb")
+      output.should include("1 example, 0 failures")
+    end
+  end
 end

data/vendor/plugins/rspec/spec/spec/interop/test/unit/testcase_spec.rb

@@ -42,4 +42,8 @@ describe "Test::Unit::TestCase" do
       $?.should == 256
     end
   end
+  
+  describe "not yet implemented examples:" do
+    it "this example should be reported as pending (not an error)"
+  end
 end

data/vendor/plugins/rspec/spec/spec/matchers/be_spec.rb

@@ -222,3 +222,27 @@ describe "should be(value)" do
     lambda { 5.should be(6) }.should fail_with("expected 6, got 5")
   end
 end
+
+
+describe "arbitrary predicate with DelegateClass" do
+  it "should access methods defined in the delegating class (LH[#48])" do
+    pending(%{
+      Looks like DelegateClass is delegating #should to the
+      delegate. Not sure how to fix this one. Or if we even should."
+    })
+    require 'delegate'
+    class ArrayDelegate < DelegateClass(Array)
+      def initialize(array)
+        @internal_array = array
+        super(@internal_array)
+      end
+
+      def large?
+        @internal_array.size >= 5
+      end
+    end
+
+    delegate = ArrayDelegate.new([1,2,3,4,5,6])
+    delegate.should be_large
+  end
+end

data/vendor/plugins/rspec/spec/spec/matchers/change_spec.rb

@@ -55,10 +55,9 @@ describe "should change { block }" do
     end.should fail_with("result should have changed, but is still 5")
   end
   
-  it "should warn if passed a block using do/end" do
+  it "should warn if passed a block using do/end instead of {}" do
     lambda do
-      lambda {}.should change do
-      end
+      lambda {}.should change do; end
     end.should raise_error(Spec::Matchers::MatcherError, /block passed to should or should_not/)
   end
 end
@@ -79,10 +78,9 @@ describe "should_not change { block }" do
     end.should fail_with("result should not have changed, but did change from 5 to 6")
   end
   
-  it "should warn if passed a block using do/end" do
+  it "should warn if passed a block using do/end instead of {}" do
     lambda do
-      lambda {}.should_not change do
-      end
+      lambda {}.should_not change do; end
     end.should raise_error(Spec::Matchers::MatcherError, /block passed to should or should_not/)
   end
 end
@@ -317,3 +315,15 @@ describe "should change{ block }.from(old).to(new)" do
     lambda { @instance.some_value = "cat" }.should change{@instance.some_value}.from("string").to("cat")
   end
 end
+
+describe Spec::Matchers::Change do
+  it "should work when the receiver has implemented #send" do
+    @instance = SomethingExpected.new
+    @instance.some_value = "string"
+    def @instance.send(*args); raise "DOH! Library developers shouldn't use #send!" end
+    
+    lambda {
+      lambda { @instance.some_value = "cat" }.should change(@instance, :some_value)
+    }.should_not raise_error
+  end
+end

data/vendor/plugins/rspec/spec/spec/matchers/handler_spec.rb

@@ -48,53 +48,73 @@ end
 
 module Spec
   module Expectations
-    describe ExpectationMatcherHandler, ".handle_matcher" do
-      it "should ask the matcher if it matches" do
-        matcher = mock("matcher")
-        actual = Object.new
-        matcher.should_receive(:matches?).with(actual).and_return(true)
-        ExpectationMatcherHandler.handle_matcher(actual, matcher)
-      end
-      
-      it "should explain when the matcher parameter is not a matcher" do
-        begin
-          nonmatcher = mock("nonmatcher")
+    describe ExpectationMatcherHandler do
+      describe "#handle_matcher" do
+        it "should ask the matcher if it matches" do
+          matcher = mock("matcher")
           actual = Object.new
-          ExpectationMatcherHandler.handle_matcher(actual, nonmatcher)
-        rescue Spec::Expectations::InvalidMatcherError => e
+          matcher.should_receive(:matches?).with(actual).and_return(true)
+          ExpectationMatcherHandler.handle_matcher(actual, matcher)
         end
+      
+        it "should explain when the matcher parameter is not a matcher" do
+          begin
+            nonmatcher = mock("nonmatcher")
+            actual = Object.new
+            ExpectationMatcherHandler.handle_matcher(actual, nonmatcher)
+          rescue Spec::Expectations::InvalidMatcherError => e
+          end
 
-        e.message.should =~ /^Expected a matcher, got /
+          e.message.should =~ /^Expected a matcher, got /
+        end
+        
+        it "should return the match value" do
+          matcher = mock("matcher")
+          actual = Object.new
+          matcher.should_receive(:matches?).with(actual).and_return(:this_value)
+          ExpectationMatcherHandler.handle_matcher(actual, matcher).should == :this_value
+        end
       end
     end
 
-    describe NegativeExpectationMatcherHandler, ".handle_matcher" do
-      it "should explain when matcher does not support should_not" do
-        matcher = mock("matcher")
-        matcher.stub!(:matches?)
-        actual = Object.new
-        lambda {
-          NegativeExpectationMatcherHandler.handle_matcher(actual, matcher)
-        }.should fail_with(/Matcher does not support should_not.\n/)
-      end      
-      
-      it "should ask the matcher if it matches" do
-        matcher = mock("matcher")
-        actual = Object.new
-        matcher.stub!(:negative_failure_message)
-        matcher.should_receive(:matches?).with(actual).and_return(false)
-        NegativeExpectationMatcherHandler.handle_matcher(actual, matcher)
-      end
+    describe NegativeExpectationMatcherHandler do
+      describe "#handle_matcher" do
+        it "should explain when matcher does not support should_not" do
+          matcher = mock("matcher")
+          matcher.stub!(:matches?)
+          actual = Object.new
+          lambda {
+            NegativeExpectationMatcherHandler.handle_matcher(actual, matcher)
+          }.should fail_with(/Matcher does not support should_not.\n/)
+        end      
       
-      it "should explain when the matcher parameter is not a matcher" do
-        begin
-          nonmatcher = mock("nonmatcher")
+        it "should ask the matcher if it matches" do
+          matcher = mock("matcher")
           actual = Object.new
-          NegativeExpectationMatcherHandler.handle_matcher(actual, nonmatcher)
-        rescue Spec::Expectations::InvalidMatcherError => e
+          matcher.stub!(:negative_failure_message)
+          matcher.should_receive(:matches?).with(actual).and_return(false)
+          NegativeExpectationMatcherHandler.handle_matcher(actual, matcher)
+        end
+      
+        it "should explain when the matcher parameter is not a matcher" do
+          begin
+            nonmatcher = mock("nonmatcher")
+            actual = Object.new
+            NegativeExpectationMatcherHandler.handle_matcher(actual, nonmatcher)
+          rescue Spec::Expectations::InvalidMatcherError => e
+          end
+
+          e.message.should =~ /^Expected a matcher, got /
         end
 
-        e.message.should =~ /^Expected a matcher, got /
+        
+        it "should return the match value" do
+          matcher = mock("matcher")
+          actual = Object.new
+          matcher.should_receive(:matches?).with(actual).and_return(false)
+          matcher.stub!(:negative_failure_message).and_return("ignore")
+          NegativeExpectationMatcherHandler.handle_matcher(actual, matcher).should be_false
+        end
       end
     end
     
@@ -124,6 +144,7 @@ module Spec
         }.should fail_with(/Matcher does not support should_not.\n/)
       end
 
+
     end
   end
 end

data/vendor/plugins/rspec/spec/spec/matchers/has_spec.rb

@@ -16,6 +16,14 @@ describe "should have_sym(*args)" do
       Object.new.should have_key(:a)
     }.should raise_error(NoMethodError)
   end
+  
+  it "should reraise an exception thrown in #has_sym?(*args)" do
+    o = Object.new
+    def o.has_sym?(*args)
+      raise "Funky exception"
+    end
+    lambda { o.should have_sym(:foo) }.should raise_error("Funky exception")
+  end
 end
 
 describe "should_not have_sym(*args)" do
@@ -34,4 +42,22 @@ describe "should_not have_sym(*args)" do
       Object.new.should have_key(:a)
     }.should raise_error(NoMethodError)
   end
+  
+  it "should reraise an exception thrown in #has_sym?(*args)" do
+    o = Object.new
+    def o.has_sym?(*args)
+      raise "Funky exception"
+    end
+    lambda { o.should_not have_sym(:foo) }.should raise_error("Funky exception")
+  end
+end
+
+describe Spec::Matchers::Has do
+  it "should work when the target implements #send" do
+    o = {:a => "A"}
+    def o.send(*args); raise "DOH! Library developers shouldn't use #send!" end
+    lambda {
+      o.should have_key(:a)
+    }.should_not raise_error
+  end
 end

data/vendor/plugins/rspec/spec/spec/matchers/have_spec.rb

@@ -47,11 +47,40 @@ describe "should have(n).items" do
   end
 end
 
+describe 'should have(1).item when ActiveSupport::Inflector is defined' do
+  include HaveSpecHelper
+  
+  before(:each) do
+    unless defined?(ActiveSupport::Inflector)
+      @active_support_was_not_defined
+      module ActiveSupport
+        class Inflector
+          def self.pluralize(string)
+            string.to_s + 's'
+          end
+        end
+      end
+    end
+  end
+  
+  it 'should pluralize the collection name' do
+    owner = create_collection_owner_with(1)
+    owner.should have(1).item
+  end
+  
+  after(:each) do
+    if @active_support_was_not_defined
+      Object.send :remove_const, :ActiveSupport
+    end
+  end
+end
+
 describe 'should have(1).item when Inflector is defined' do
   include HaveSpecHelper
   
-  before do
-    unless Object.const_defined?(:Inflector)
+  before(:each) do
+    unless defined?(Inflector)
+      @inflector_was_not_defined
       class Inflector
         def self.pluralize(string)
           string.to_s + 's'
@@ -64,6 +93,12 @@ describe 'should have(1).item when Inflector is defined' do
     owner = create_collection_owner_with(1)
     owner.should have(1).item
   end
+
+  after(:each) do
+    if @inflector_was_not_defined
+      Object.send :remove_const, :Inflector
+    end
+  end
 end
 
 describe "should have(n).items where result responds to items but returns something other than a collection" do
@@ -289,3 +324,71 @@ describe "have(n).things on an object which is not a collection nor contains one
     lambda { Object.new.should have(2).things }.should raise_error(NoMethodError, /undefined method `things' for #<Object:/)
   end
 end
+
+describe Spec::Matchers::Have, "for a collection owner that implements #send" do
+  include HaveSpecHelper
+
+  before(:each) do
+    @collection = Object.new
+    def @collection.floozles; [1,2] end
+    def @collection.send(*args); raise "DOH! Library developers shouldn't use #send!" end
+  end
+  
+  it "should work in the straightforward case" do
+    lambda {
+      @collection.should have(2).floozles
+    }.should_not raise_error
+  end
+
+  it "should work when doing automatic pluralization" do
+    lambda {
+      @collection.should have_at_least(1).floozle
+    }.should_not raise_error
+  end
+
+  it "should blow up when the owner doesn't respond to that method" do
+    lambda {
+      @collection.should have(99).problems
+    }.should raise_error(NoMethodError, /problems/)
+  end
+end
+
+module Spec
+  module Matchers
+    describe Have do
+      it "should have method_missing as private" do
+        Have.private_instance_methods.should include("method_missing")
+      end
+      
+      describe "respond_to?" do
+        before :each do
+          @have = Have.new(:foo)
+          @a_method_which_have_defines = Have.instance_methods.first
+          @a_method_which_object_defines = Object.instance_methods.first
+        end
+        
+        it "should be true for a method which Have defines" do
+          @have.should respond_to(@a_method_which_have_defines)
+        end
+        
+        it "should be true for a method that it's superclass (Object) defines" do
+          @have.should respond_to(@a_method_which_object_defines)
+        end
+        
+        it "should be false for a method which neither Object nor nor Have defines" do
+          @have.should_not respond_to(:foo_bar_baz)
+        end
+        
+        it "should be false if the owner doesn't respond to the method" do
+          have = Have.new(99)
+          have.should_not respond_to(:problems)
+        end
+        
+        it "should be true if the owner responds to the method" do
+          have = Have.new(:a_symbol)
+          have.should respond_to(:to_sym)
+        end
+      end
+    end
+  end
+end

data/vendor/plugins/rspec/spec/spec/matchers/include_spec.rb

@@ -43,3 +43,22 @@ describe "should_not include(expected)" do
     }.should fail_with("expected \"abc\" not to include \"c\"")
   end
 end
+
+describe "should include(:key => value)" do
+  it "should pass if target is a Hash and includes the key/value pair" do
+    {:key => 'value'}.should include(:key => 'value')
+  end
+  it "should pass if target is a Hash and includes the key/value pair among others" do
+    {:key => 'value', :other => 'different'}.should include(:key => 'value')
+  end
+  it "should fail if target is a Hash and has a different value for key" do
+    lambda {
+      {:key => 'different'}.should include(:key => 'value')
+    }.should fail_with(%Q|expected {:key=>"different"} to include {:key=>"value"}|)
+  end
+  it "should fail if target is a Hash and has a different key" do
+    lambda {
+      {:other => 'value'}.should include(:key => 'value')
+    }.should fail_with(%Q|expected {:other=>"value"} to include {:key=>"value"}|)
+  end
+end

data/vendor/plugins/rspec/spec/spec/matchers/operator_matcher_spec.rb

@@ -10,12 +10,17 @@ describe "should ==" do
     subject.should == "apple"
   end
   
+  it "should return true on success" do
+    subject = "apple"
+    (subject.should == "apple").should be_true
+  end
+  
   it "should fail when target.==(actual) returns false" do
     subject = "apple"
     Spec::Expectations.should_receive(:fail_with).with(%[expected: "orange",\n     got: "apple" (using ==)], "orange", "apple")
     subject.should == "orange"
   end
-
+  
 end
 
 describe "should_not ==" do
@@ -26,12 +31,17 @@ describe "should_not ==" do
     subject.should_not == "apple"
   end
   
+  it "should return true on success" do
+    subject = "apple"
+    (subject.should_not == "orange").should be_true
+  end
+
   it "should fail when target.==(actual) returns false" do
     subject = "apple"
     Spec::Expectations.should_receive(:fail_with).with(%[expected not: == "apple",\n         got:    "apple"], "apple", "apple")
     subject.should_not == "apple"
   end
-
+  
 end
 
 describe "should ===" do
@@ -156,3 +166,26 @@ describe "should <=" do
 
 end
 
+describe Spec::Matchers::PositiveOperatorMatcher do
+
+  it "should work when the target has implemented #send" do
+    o = Object.new
+    def o.send(*args); raise "DOH! Library developers shouldn't use #send!" end
+    lambda {
+      o.should == o
+    }.should_not raise_error
+  end
+
+end
+
+describe Spec::Matchers::NegativeOperatorMatcher do
+
+  it "should work when the target has implemented #send" do
+    o = Object.new
+    def o.send(*args); raise "DOH! Library developers shouldn't use #send!" end
+    lambda {
+      o.should_not == :foo
+    }.should_not raise_error
+  end
+
+end

data/vendor/plugins/rspec/spec/spec/matchers/raise_error_spec.rb

@@ -28,6 +28,9 @@ describe "should raise_error(message)" do
   it "should pass if RuntimeError is raised with the right message" do
     lambda {raise 'blah'}.should raise_error('blah')
   end
+  it "should pass if RuntimeError is raised with a matching message" do
+    lambda {raise 'blah'}.should raise_error(/blah/)
+  end
   it "should pass if any other error is raised with the right message" do
     lambda {raise NameError.new('blah')}.should raise_error('blah')
   end
@@ -126,6 +129,127 @@ describe "should raise_error(NamedError, error_message) with String" do
   end
 end
 
+describe "should raise_error(NamedError, error_message) { |err| ... }" do
+  it "should yield exception if named error is raised with same message" do
+    ran = false
+
+    lambda {
+      raise "example message"
+    }.should raise_error(RuntimeError, "example message") { |err|
+      ran = true
+      err.class.should == RuntimeError
+      err.message.should == "example message"
+    }
+
+    ran.should == true
+  end
+
+  it "yielded block should be able to fail on it's own right" do
+    ran, passed = false, false
+
+    lambda {
+      lambda {
+        raise "example message"
+      }.should raise_error(RuntimeError, "example message") { |err|
+        ran = true
+        5.should == 4
+        passed = true
+      }
+    }.should fail_with(/expected: 4/m)
+
+    ran.should == true
+    passed.should == false
+  end
+
+  it "should NOT yield exception if no error was thrown" do
+    ran = false
+
+    lambda {
+      lambda {}.should raise_error(RuntimeError, "example message") { |err|
+        ran = true
+      }
+    }.should fail_with("expected RuntimeError with \"example message\" but nothing was raised")
+
+    ran.should == false
+  end
+
+  it "should not yield exception if error class is not matched" do
+    ran = false
+
+    lambda {
+      lambda {
+        raise "example message"
+      }.should raise_error(SyntaxError, "example message") { |err|
+        ran = true
+      }
+    }.should fail_with("expected SyntaxError with \"example message\", got #<RuntimeError: example message>")
+
+    ran.should == false
+  end
+
+  it "should NOT yield exception if error message is not matched" do
+    ran = false
+
+    lambda {
+      lambda {
+        raise "example message"
+      }.should raise_error(RuntimeError, "different message") { |err|
+        ran = true
+      }
+    }.should fail_with("expected RuntimeError with \"different message\", got #<RuntimeError: example message>")
+
+    ran.should == false
+  end
+end
+
+describe "should_not raise_error(NamedError, error_message) { |err| ... }" do
+  it "should pass if nothing is raised" do
+    ran = false
+
+    lambda {}.should_not raise_error(RuntimeError, "example message") { |err|
+      ran = true
+    }
+
+    ran.should == false
+  end
+
+  it "should pass if a different error is raised" do
+    ran = false
+
+    lambda { raise }.should_not raise_error(NameError, "example message") { |err|
+      ran = true
+    }
+
+    ran.should == false
+  end
+
+  it "should pass if same error is raised with different message" do
+    ran = false
+
+    lambda {
+      raise RuntimeError.new("not the example message")
+    }.should_not raise_error(RuntimeError, "example message") { |err|
+      ran = true
+    }
+
+    ran.should == false
+  end
+
+  it "should fail if named error is raised with same message" do
+    ran = false
+
+    lambda {
+      lambda {
+        raise "example message"
+      }.should_not raise_error(RuntimeError, "example message") { |err|
+        ran = true
+      }
+    }.should fail_with("expected no RuntimeError with \"example message\", got #<RuntimeError: example message>")
+
+    ran.should == false
+  end
+end
+
 describe "should_not raise_error(NamedError, error_message) with String" do
   it "should pass if nothing is raised" do
     lambda {}.should_not raise_error(RuntimeError, "example message")