rspec-expectations 2.10.0 → 2.11.0

data/lib/rspec/matchers/built_in/start_and_end_with.rb

@@ -1,9 +1,7 @@
 module RSpec
   module Matchers
     module BuiltIn
-      class StartAndEndWith
-        include BaseMatcher
-
+      class StartAndEndWith < BaseMatcher
         def initialize(*expected)
           @expected = expected.length == 1 ? expected.first : expected
         end

data/lib/rspec/matchers/built_in/yield.rb

@@ -64,9 +64,7 @@ module RSpec
         end
       end
 
-      class YieldControl
-        include BaseMatcher
-
+      class YieldControl < BaseMatcher
         def matches?(block)
           probe = YieldProbe.probe(block)
           probe.yielded_once?(:yield_control)
@@ -81,8 +79,7 @@ module RSpec
         end
       end
 
-      class YieldWithNoArgs
-        include BaseMatcher
+      class YieldWithNoArgs < BaseMatcher
 
         def matches?(block)
           @probe = YieldProbe.probe(block)

data/lib/rspec/matchers/configuration.rb

@@ -0,0 +1,66 @@
+require 'rspec/expectations/syntax'
+
+module RSpec
+  module Matchers
+    # Provides configuration options for rspec-expectations.
+    class Configuration
+      # Configures the supported syntax.
+      # @param [Array<Symbol>, Symbol] values the syntaxes to enable
+      # @example
+      #   RSpec.configure do |rspec|
+      #     rspec.expect_with :rspec do |c|
+      #       c.syntax = :should
+      #       # or
+      #       c.syntax = :expect
+      #       # or
+      #       c.syntax = [:should, :expect]
+      #     end
+      #   end
+      def syntax=(values)
+        if Array(values).include?(:expect)
+          Expectations::Syntax.enable_expect
+        else
+          Expectations::Syntax.disable_expect
+        end
+
+        if Array(values).include?(:should)
+          Expectations::Syntax.enable_should
+        else
+          Expectations::Syntax.disable_should
+        end
+      end
+
+      # The list of configured syntaxes.
+      # @return [Array<Symbol>] the list of configured syntaxes.
+      def syntax
+        syntaxes = []
+        syntaxes << :should if Expectations::Syntax.should_enabled?
+        syntaxes << :expect if Expectations::Syntax.expect_enabled?
+        syntaxes
+      end
+
+      # Adds `should` and `should_not` to the given classes
+      # or modules. This can be used to ensure `should` works
+      # properly on things like proxy objects (particular
+      # `Delegator`-subclassed objects on 1.8).
+      #
+      # @param [Array<Module>] modules the list of classes or modules
+      #   to add `should` and `should_not` to.
+      def add_should_and_should_not_to(*modules)
+        modules.each do |mod|
+          Expectations::Syntax.enable_should(mod)
+        end
+      end
+    end
+
+    # The configuration object
+    # @return [RSpec::Matchers::Configuration] the configuration object
+    def self.configuration
+      @configuration ||= Configuration.new
+    end
+
+    # set default syntax
+    configuration.syntax = [:expect, :should]
+  end
+end
+

data/spec/rspec/expectations/expectation_target_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+module RSpec
+  module Expectations
+    # so our examples below can set expectations about the target
+    ExpectationTarget.send(:attr_reader, :target)
+
+    describe ExpectationTarget do
+      context 'when constructed via #expect' do
+        it 'constructs a new instance targetting the given argument' do
+          expect(7).target.should eq(7)
+        end
+
+        it 'constructs a new instance targetting the given block' do
+          block = lambda {}
+          expect(&block).target.should be(block)
+        end
+
+        it 'raises an ArgumentError when given an argument and a block' do
+          lambda { expect(7) { } }.should raise_error(ArgumentError)
+        end
+
+        it 'raises an ArgumentError when given neither an argument nor a block' do
+          lambda { expect }.should raise_error(ArgumentError)
+        end
+
+        it 'can be passed nil' do
+          expect(nil).target.should be_nil
+        end
+
+        it 'passes a valid positive expectation' do
+          expect(5).to eq(5)
+        end
+
+        it 'passes a valid negative expectation' do
+          expect(5).to_not eq(4)
+          expect(5).not_to eq(4)
+        end
+
+        it 'fails an invalid positive expectation' do
+          lambda { expect(5).to eq(4) }.should fail_with(/expected: 4.*got: 5/m)
+        end
+
+        it 'fails an invalid negative expectation' do
+          message = /expected 5 not to be a kind of Fixnum/
+          lambda { expect(5).to_not be_a(Fixnum) }.should fail_with(message)
+          lambda { expect(5).not_to be_a(Fixnum) }.should fail_with(message)
+        end
+
+        it 'does not support operator matchers from #to' do
+          expect {
+            expect(3).to == 3
+          }.to raise_error(ArgumentError)
+        end
+
+        it 'does not support operator matchers from #not_to' do
+          expect {
+            expect(3).not_to == 4
+          }.to raise_error(ArgumentError)
+        end
+      end
+    end
+  end
+end
+

data/spec/rspec/expectations/extensions/kernel_spec.rb

@@ -20,6 +20,28 @@ describe Object, "#should" do
       @target.should @matcher
     }.should fail_with("the failure message")
   end
+
+  context "on interpretters that have BasicObject", :if => defined?(BasicObject) do
+    let(:proxy_class) do
+      Class.new(BasicObject) do
+        def initialize(target)
+          @target = target
+        end
+
+        def proxied?
+          true
+        end
+
+        def method_missing(name, *args)
+          @target.send(name, *args)
+        end
+      end
+    end
+
+    it 'works properly on BasicObject-subclassed proxy objects' do
+      proxy_class.new(Object.new).should be_proxied
+    end
+  end
 end
 
 describe Object, "#should_not" do

data/spec/rspec/matchers/base_matcher_spec.rb

@@ -2,9 +2,7 @@ module RSpec::Matchers::BuiltIn
   describe BaseMatcher do
     describe "#match_unless_raises" do
       let(:matcher) do
-        Class.new do
-          include BaseMatcher
-        end.new
+        Class.new(BaseMatcher).new
       end
 
       it "returns true if there are no errors" do
@@ -41,12 +39,16 @@ module RSpec::Matchers::BuiltIn
 
     describe "#==" do
       it "responds the same way as matches?" do
-        matcher = Class.new do
-          include BaseMatcher
+        matcher = Class.new(BaseMatcher) do
+          def initialize(expected)
+            @expected = expected
+          end
+
           def matches?(actual)
-            actual == expected
+            (@actual = actual) == @expected
           end
         end
+
         matcher.new(3).matches?(3).should be_true
         matcher.new(3).should eq(3)
 

data/spec/rspec/matchers/be_spec.rb

@@ -237,7 +237,7 @@ describe "should be_true" do
   it "fails when actual equal?(false)" do
     lambda {
       false.should be_true
-    }.should fail_with("expected false to be true")
+    }.should fail_with("expected: true value\n     got: false")
   end
 end
 
@@ -253,7 +253,7 @@ describe "should be_false" do
   it "fails when actual equal?(true)" do
     lambda {
       true.should be_false
-    }.should fail_with("expected true to be false")
+    }.should fail_with("expected: false value\n     got: true")
   end
 end
 

data/spec/rspec/matchers/be_within_spec.rb

@@ -57,7 +57,15 @@ module RSpec
 
       it "raises an error if no expected value is given" do
         matcher = be_within(0.5)
-        expect { matcher.matches?(5.1) }.to raise_error(ArgumentError, /must set an expected value using #of/)
+        expect { matcher.matches?(5.1) }.to raise_error(
+          ArgumentError, /must set an expected value using #of/
+        )
+      end
+
+      it "raises an error if the actual value is not of a Numeric type" do
+        expect { be_within(0.1).of(0).matches?(nil) }.to raise_error(
+          ArgumentError, /The actual value \(nil\) must be of a `Numeric` type/
+        )
       end
     end
   end

data/spec/rspec/matchers/configuration_spec.rb

@@ -0,0 +1,160 @@
+require 'spec_helper'
+require 'delegate'
+
+module RSpec
+  module Matchers
+    describe ".configuration" do
+      it 'returns a memoized configuration instance' do
+        RSpec::Matchers.configuration.should be_a(RSpec::Matchers::Configuration)
+        RSpec::Matchers.configuration.should be(RSpec::Matchers.configuration)
+      end
+
+      context 'on an interpreter that does not provide BasicObject', :unless => defined?(::BasicObject) do
+        before { RSpec::Expectations::Syntax.disable_should(Delegator) }
+
+        let(:klass) do
+          Class.new(SimpleDelegator) do
+            def delegated?; true; end
+          end
+        end
+
+        let(:instance) { klass.new(Object.new) }
+
+        it 'provides a means to manually add it Delegator' do
+          instance.should_not respond_to(:delegated?) # because #should is being delegated...
+          RSpec::Matchers.configuration.add_should_and_should_not_to Delegator
+          instance.should respond_to(:delegated?) # now it should work!
+        end
+      end
+    end
+
+    shared_examples_for "configuring the expectation syntax" do
+      # We want a sandboxed method that ensures that we wind up with
+      # both syntaxes properly enabled when the example ends.
+      #
+      # On platforms that fork, using a sub process is the easiest,
+      # most robust way to achieve that.
+      #
+      # On jRuby we just re-enable both syntaxes at the end of the example;
+      # however, this is a generally inferior approach because it depends on
+      # the code-under-test working properly; if it doesn't work properly,
+      # it could leave things in a "broken" state where tons of other examples fail.
+      if RUBY_PLATFORM == "java"
+        def sandboxed
+          yield
+        ensure
+          configure_syntax([:should, :expect])
+        end
+      else
+        include InSubProcess
+        alias sandboxed in_sub_process
+      end
+
+      it 'is configured to :should and :expect by default' do
+        configured_syntax.should eq([:should, :expect])
+
+        3.should eq(3)
+        3.should_not eq(4)
+        expect(3).to eq(3)
+      end
+
+      it 'can limit the syntax to :should' do
+        sandboxed do
+          configure_syntax :should
+          configured_syntax.should eq([:should])
+
+          3.should eq(3)
+          3.should_not eq(4)
+          lambda { expect(6).to eq(6) }.should raise_error(NameError)
+        end
+      end
+
+      it 'is a no-op when configured to :should twice' do
+        sandboxed do
+          ::Kernel.stub(:method_added).and_raise("no methods should be added here")
+
+          configure_syntax :should
+          configure_syntax :should
+        end
+      end
+
+      it 'can limit the syntax to :expect' do
+        sandboxed do
+          configure_syntax :expect
+          expect(configured_syntax).to eq([:expect])
+
+          expect(3).to eq(3)
+          expect { 3.should eq(3) }.to raise_error(NameError)
+          expect { 3.should_not eq(3) }.to raise_error(NameError)
+        end
+      end
+
+      it 'is a no-op when configured to :expect twice' do
+        sandboxed do
+          RSpec::Matchers.stub(:method_added).and_raise("no methods should be added here")
+
+          configure_syntax :expect
+          configure_syntax :expect
+        end
+      end
+
+      it 'can re-enable the :should syntax' do
+        sandboxed do
+          configure_syntax :expect
+          configure_syntax [:should, :expect]
+          configured_syntax.should eq([:should, :expect])
+
+          3.should eq(3)
+          3.should_not eq(4)
+          expect(3).to eq(3)
+        end
+      end
+
+      it 'can re-enable the :expect syntax' do
+        sandboxed do
+          configure_syntax :should
+          configure_syntax [:should, :expect]
+          configured_syntax.should eq([:should, :expect])
+
+          3.should eq(3)
+          3.should_not eq(4)
+          expect(3).to eq(3)
+        end
+      end
+    end
+
+    describe "configuring rspec-expectations directly" do
+      it_behaves_like "configuring the expectation syntax" do
+        def configure_syntax(syntax)
+          RSpec::Matchers.configuration.syntax = syntax
+        end
+
+        def configured_syntax
+          RSpec::Matchers.configuration.syntax
+        end
+      end
+    end
+
+    describe "configuring using the rspec-core config API" do
+      it_behaves_like "configuring the expectation syntax" do
+        def configure_syntax(syntax)
+          RSpec.configure do |rspec|
+            rspec.expect_with :rspec do |c|
+              c.syntax = syntax
+            end
+          end
+        end
+
+        def configured_syntax
+          RSpec.configure do |rspec|
+            rspec.expect_with :rspec do |c|
+              return c.syntax
+            end
+          end
+        end
+      end
+    end
+
+  end
+end
+

data/spec/rspec/matchers/eq_spec.rb

@@ -14,23 +14,35 @@ module RSpec
       it "does not match when actual != expected" do
         1.should_not eq(2)
       end
-      
+
+      it "compares by sending == to actual (not expected)" do
+        called = false
+        actual = Class.new do
+          define_method :== do |other|
+            called = true
+          end
+        end.new
+
+        actual.should eq :anything # to trigger the matches? method
+        called.should be_true
+      end
+
       it "describes itself" do
         matcher = eq(1)
         matcher.matches?(1)
-        matcher.description.should == "eq 1"
+        matcher.description.should eq "eq 1"
       end
       
       it "provides message, expected and actual on #failure_message" do
         matcher = eq("1")
         matcher.matches?(1)
-        matcher.failure_message_for_should.should == "\nexpected: \"1\"\n     got: 1\n\n(compared using ==)\n"
+        matcher.failure_message_for_should.should eq "\nexpected: \"1\"\n     got: 1\n\n(compared using ==)\n"
       end
       
       it "provides message, expected and actual on #negative_failure_message" do
         matcher = eq(1)
         matcher.matches?(1)
-        matcher.failure_message_for_should_not.should == "\nexpected: value != 1\n     got: 1\n\n(compared using ==)\n"
+        matcher.failure_message_for_should_not.should eq "\nexpected: value != 1\n     got: 1\n\n(compared using ==)\n"
       end
     end
   end