rspec-expectations 2.0.0.beta.22 → 2.6.0

data/spec/rspec/matchers/include_spec.rb

@@ -1,88 +1,341 @@
 require 'spec_helper'
 
 describe "should include(expected)" do
-  it "passes if target includes expected" do
-    [1,2,3].should include(3)
-    "abc".should include("a")
-  end
-  
-  it 'passes if target is a Hash and has the expected as a key' do
-    {:key => 'value'}.should include(:key)
-  end
-
-  it "fails 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\"")
-    lambda {
-      {:key => 'value'}.should include(:other)
-    }.should fail_with(%Q|expected {:key=>"value"} to include :other|)
+  context "for a string target" do
+    it "passes if target includes expected" do
+      "abc".should include("a")
+    end
+
+    it "fails if target does not include expected" do
+      lambda {
+        "abc".should include("d")
+      }.should fail_with("expected \"abc\" to include \"d\"")
+    end
+  end
+
+  context "for an array target" do
+    it "passes if target includes expected" do
+      [1,2,3].should include(3)
+    end
+
+    it "fails if target does not include expected" do
+      lambda {
+        [1,2,3].should include(4)
+      }.should fail_with("expected [1, 2, 3] to include 4")
+    end
+  end
+
+  context "for a hash target" do
+    it 'passes if target has the expected as a key' do
+      {:key => 'value'}.should include(:key)
+    end
+
+    it "fails if target does not include expected" do
+      lambda {
+        {:key => 'value'}.should include(:other)
+      }.should fail_matching(%Q|expected {:key=>"value"} to include :other|)
+    end
   end
 end
 
 describe "should include(with, multiple, args)" do
-  it "passes if target includes all items" do
-    [1,2,3].should include(1,2,3)
-  end
-  
-  it 'passes if target is a Hash including all items as keys' do
-    {:key => 'value', :other => 'value'}.should include(:key, :other)
+  context "for a string target" do
+    it "passes if target includes all items" do
+      "a string".should include("str", "a")
+    end
+
+    it "fails if target does not include any one of the items" do
+      lambda {
+        "a string".should include("str", "a", "foo")
+      }.should fail_with(%Q{expected "a string" to include "str", "a", and "foo"})
+    end
   end
 
-  it "fails if target does not include any one of the items" do
-    lambda {
-      [1,2,3].should include(1,2,4)
-    }.should fail_with("expected [1, 2, 3] to include 1, 2, and 4")
+  context "for an array target" do
+    it "passes if target includes all items" do
+      [1,2,3].should include(1,2,3)
+    end
+
+    it "fails if target does not include any one of the items" do
+      lambda {
+        [1,2,3].should include(1,2,4)
+      }.should fail_with("expected [1, 2, 3] to include 1, 2, and 4")
+    end
   end
-  
-  it 'passes if target is a Hash missing any item as a key' do
-    lambda {
-      {:key => 'value'}.should include(:key, :other)
-    }.should fail_with(%Q|expected {:key=>"value"} to include :key and :other|)
+
+  context "for a hash target" do
+    it 'passes if target includes all items as keys' do
+      {:key => 'value', :other => 'value'}.should include(:key, :other)
+    end
+
+    it 'fails if target is missing any item as a key' do
+      lambda {
+        {:key => 'value'}.should include(:key, :other)
+      }.should fail_matching(%Q|expected {:key=>"value"} to include :key and :other|)
+    end
   end
 end
 
 describe "should_not include(expected)" do
-  it "passes if target does not include expected" do
-    [1,2,3].should_not include(4)
-    "abc".should_not include("d")
-  end
-  
-  it 'passes if target is a Hash and does not have the expected as a key' do
-    {:other => 'value'}.should_not include(:key)
-  end
-
-  it "fails 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\"")
-    lambda {
-      {:key => 'value'}.should_not include(:key)
-    }.should fail_with(%Q|expected {:key=>"value"} not to include :key|)
+  context "for a string target" do
+    it "passes if target does not include expected" do
+      "abc".should_not include("d")
+    end
+
+    it "fails if target includes expected" do
+      lambda {
+        "abc".should_not include("c")
+      }.should fail_with("expected \"abc\" not to include \"c\"")
+    end
+  end
+
+  context "for an array target" do
+    it "passes if target does not include expected" do
+      [1,2,3].should_not include(4)
+    end
+
+    it "fails if target includes expected" do
+      lambda {
+        [1,2,3].should_not include(3)
+      }.should fail_with("expected [1, 2, 3] not to include 3")
+    end
+  end
+
+  context "for a hash target" do
+    it 'passes if target does not have the expected as a key' do
+      {:other => 'value'}.should_not include(:key)
+    end
+
+    it "fails if target includes expected key" do
+      lambda {
+        {:key => 'value'}.should_not include(:key)
+      }.should fail_matching(%Q|expected {:key=>"value"} not to include :key|)
+    end
+  end
+
+end
+
+describe "should_not include(with, multiple, args)" do
+  context "for a string target" do
+    it "passes if the target does not include any of the expected" do
+      "abc".should_not include("d", "e", "f")
+    end
+
+    it "fails if the target includes all of the expected" do
+      expect {
+        "abc".should_not include("c", "a")
+      }.to fail_with(%q{expected "abc" not to include "c" and "a"})
+    end
+
+    it "fails if the target includes some (but not all) of the expected" do
+      expect {
+        "abc".should_not include("d", "a")
+      }.to fail_with(%q{expected "abc" not to include "d" and "a"})
+    end
+  end
+
+  context "for a hash target" do
+    it "passes if it does not include any of the expected keys" do
+      { :a => 1, :b => 2 }.should_not include(:c, :d)
+    end
+
+    it "fails if the target includes all of the expected keys" do
+      expect {
+        { :a => 1, :b => 2 }.should_not include(:a, :b)
+      }.to fail_matching(%Q|expected #{{:a=>1, :b=>2}.inspect} not to include :a and :b|)
+    end
+
+    it "fails if the target includes some (but not all) of the expected keys" do
+      expect {
+        { :a => 1, :b => 2 }.should_not include(:d, :b)
+      }.to fail_matching(%Q|expected #{{:a=>1, :b=>2}.inspect} not to include :d and :b|)
+    end
+  end
+
+  context "for an array target" do
+    it "passes if the target does not include any of the expected" do
+      [1, 2, 3].should_not include(4, 5, 6)
+    end
+
+    it "fails if the target includes all of the expected" do
+      expect {
+        [1, 2, 3].should_not include(3, 1)
+      }.to fail_with(%q{expected [1, 2, 3] not to include 3 and 1})
+    end
+
+    it "fails if the target includes some (but not all) of the expected" do
+      expect {
+        [1, 2, 3].should_not include(4, 1)
+      }.to fail_with(%q{expected [1, 2, 3] not to include 4 and 1})
+    end
   end
 end
 
 describe "should include(:key => value)" do
-  it "passes if target is a Hash and includes the key/value pair" do
-    {:key => 'value'}.should include(:key => 'value')
+  context 'for a hash target' do
+    it "passes if target includes the key/value pair" do
+      {:key => 'value'}.should include(:key => 'value')
+    end
+
+    it "passes if target includes the key/value pair among others" do
+      {:key => 'value', :other => 'different'}.should include(:key => 'value')
+    end
+
+    it "fails if target has a different value for key" do
+      lambda {
+        {:key => 'different'}.should include(:key => 'value')
+      }.should fail_matching(%Q|expected {:key=>"different"} to include {:key=>"value"}|)
+    end
+
+    it "fails if target has a different key" do
+      lambda {
+        {:other => 'value'}.should include(:key => 'value')
+      }.should fail_matching(%Q|expected {:other=>"value"} to include {:key=>"value"}|)
+    end
   end
-  it "passes if target is a Hash and includes the key/value pair among others" do
-    {:key => 'value', :other => 'different'}.should include(:key => 'value')
+
+  context 'for a non-hash target' do
+    it "fails if the target does not contain the given hash" do
+      lambda {
+        ['a', 'b'].should include(:key => 'value')
+      }.should fail_matching(%q|expected ["a", "b"] to include {:key=>"value"}|)
+    end
+
+    it "passes if the target contains the given hash" do
+      ['a', { :key => 'value' } ].should include(:key => 'value')
+    end
   end
-  it "fails 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
+
+describe "should_not include(:key => value)" do
+  context 'for a hash target' do
+    it "fails if target includes the key/value pair" do
+      lambda {
+        {:key => 'value'}.should_not include(:key => 'value')
+      }.should fail_matching(%Q|expected {:key=>"value"} not to include {:key=>"value"}|)
+    end
+
+    it "fails if target includes the key/value pair among others" do
+      lambda {
+        {:key => 'value', :other => 'different'}.should_not include(:key => 'value')
+      }.should fail_matching(%Q|expected #{{:key=>"value", :other=>"different"}.inspect} not to include {:key=>"value"}|)
+    end
+
+    it "passes if target has a different value for key" do
+      {:key => 'different'}.should_not include(:key => 'value')
+    end
+
+    it "passes if target has a different key" do
+      {:other => 'value'}.should_not include(:key => 'value')
+    end
   end
-  it "fails 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"}|)
+
+  context "for a non-hash target" do
+    it "passes if the target does not contain the given hash" do
+      ['a', 'b'].should_not include(:key => 'value')
+    end
+
+    it "fails if the target contains the given hash" do
+      lambda {
+        ['a', { :key => 'value' } ].should_not include(:key => 'value')
+      }.should fail_matching(%Q|expected ["a", {:key=>"value"}] not to include {:key=>"value"}|)
+    end
+  end
+end
+
+describe "should include(:key1 => value1, :key2 => value2)" do
+  context 'for a hash target' do
+    it "passes if target includes the key/value pairs" do
+      {:a => 1, :b => 2}.should include(:b => 2, :a => 1)
+    end
+
+    it "passes if target includes the key/value pairs among others" do
+      {:a => 1, :c => 3, :b => 2}.should include(:b => 2, :a => 1)
+    end
+
+    it "fails if target has a different value for one of the keys" do
+      lambda {
+        {:a => 1, :b => 2}.should include(:a => 2, :b => 2)
+      }.should fail_matching(%Q|expected #{{:a=>1, :b=>2}.inspect} to include #{{:a=>2, :b=>2}.inspect}|)
+    end
+
+    it "fails if target has a different value for both of the keys" do
+      lambda {
+        {:a => 1, :b => 1}.should include(:a => 2, :b => 2)
+      }.should fail_matching(%Q|expected #{{:a=>1, :b=>1}.inspect} to include #{{:a=>2, :b=>2}.inspect}|)
+    end
+
+    it "fails if target lacks one of the keys" do
+      lambda {
+        {:a => 1, :b => 1}.should include(:a => 1, :c => 1)
+      }.should fail_matching(%Q|expected #{{:a=>1, :b=>1}.inspect} to include #{{:a=>1, :c=>1}.inspect}|)
+    end
+
+    it "fails if target lacks both of the keys" do
+      lambda {
+        {:a => 1, :b => 1}.should include(:c => 1, :d => 1)
+      }.should fail_matching(%Q|expected #{{:a=>1, :b=>1}.inspect} to include #{{:c=>1, :d=>1}.inspect}|)
+    end
+  end
+
+  context 'for a non-hash target' do
+    it "fails if the target does not contain the given hash" do
+      lambda {
+        ['a', 'b'].should include(:a => 1, :b => 1)
+      }.should fail_matching(%Q|expected ["a", "b"] to include #{{:a=>1, :b=>1}.inspect}|)
+    end
+
+    it "passes if the target contains the given hash" do
+      ['a', { :a => 1, :b => 2 } ].should include(:a => 1, :b => 2)
+    end
+  end
+end
+
+describe "should_not include(:key1 => value1, :key2 => value2)" do
+  context 'for a hash target' do
+    it "fails if target includes the key/value pairs" do
+      lambda {
+        {:a => 1, :b => 2}.should_not include(:a => 1, :b => 2)
+      }.should fail_matching(%Q|expected #{{:a=>1, :b=>2}.inspect} not to include #{{:a=>1, :b=>2}.inspect}|)
+    end
+
+    it "fails if target includes the key/value pairs among others" do
+      hash = {:a => 1, :b => 2, :c => 3}
+      lambda {
+        hash.should_not include(:a => 1, :b => 2)
+      }.should fail_matching(%Q|expected #{hash.inspect} not to include #{{:a=>1, :b=>2}.inspect}|)
+    end
+
+    it "fails if target has a different value for one of the keys" do
+      lambda {
+        {:a => 1, :b => 2}.should_not include(:a => 2, :b => 2)
+      }.should fail_matching(%Q|expected #{{:a=>1, :b=>2}.inspect} not to include #{{:a=>2, :b=>2}.inspect}|)
+    end
+
+    it "passes if target has a different value for both of the keys" do
+      {:a => 1, :b => 1}.should_not include(:a => 2, :b => 2)
+    end
+
+    it "fails if target lacks one of the keys" do
+      lambda {
+        {:a => 1, :b => 1}.should_not include(:a => 1, :c => 1)
+      }.should fail_matching(%Q|expected #{{:a=>1, :b=>1}.inspect} not to include #{{:a=>1, :c=>1}.inspect}|)
+    end
+
+    it "passes if target lacks both of the keys" do
+      {:a => 1, :b => 1}.should_not include(:c => 1, :d => 1)
+    end
+  end
+
+  context 'for a non-hash target' do
+    it "passes if the target does not contain the given hash" do
+      ['a', 'b'].should_not include(:a => 1, :b => 1)
+    end
+
+    it "fails if the target contains the given hash" do
+      lambda {
+        ['a', { :a => 1, :b => 2 } ].should_not include(:a => 1, :b => 2)
+      }.should fail_matching(%Q|expected #{["a", {:a=>1, :b=>2}].inspect} not to include #{{:a=>1, :b=>2}.inspect}|)
+    end
   end
 end

data/spec/rspec/matchers/matcher_spec.rb

@@ -1,10 +1,56 @@
 require 'spec_helper'
 
 class UnexpectedError < StandardError; end
+module MatcherHelperModule
+  def self.included(base)
+    base.module_eval do
+      def included_method; end
+    end
+  end
+
+  def self.extended(base)
+    base.instance_eval do
+      def extended_method; end
+    end
+  end
+
+  def greeting
+    "Hello, World"
+  end
+end
 
 module RSpec
   module Matchers
     describe Matcher do
+      context "with an included module" do
+        let(:matcher) do
+          RSpec::Matchers::Matcher.new(:be_a_greeting) do
+            include MatcherHelperModule
+            match { |actual| actual == greeting }
+          end
+        end
+
+        it "has access to the module's methods" do
+          matcher.matches?("Hello, World")
+        end
+
+        it "runs the module's included hook" do
+          matcher.should respond_to(:included_method)
+        end
+
+        it "does not run the module's extended hook" do
+          matcher.should_not respond_to(:extended_method)
+        end
+
+        it 'allows multiple modules to be included at once' do
+          m = RSpec::Matchers::Matcher.new(:multiple_modules) do
+            include Enumerable, Comparable
+          end
+          m.should be_a(Enumerable)
+          m.should be_a(Comparable)
+        end
+      end
+
       context "without overrides" do
         before(:each) do
           @matcher = RSpec::Matchers::Matcher.new(:be_a_multiple_of, 3) do |multiple|
@@ -29,6 +75,43 @@ module RSpec
         end
       end
 
+      context "with separate match logic for should and should not" do
+        let(:matcher) do
+          RSpec::Matchers::Matcher.new(:to_be_composed_of, 7, 11) do |a, b|
+            match_for_should do |actual|
+              actual == a * b
+            end
+
+            match_for_should_not do |actual|
+              actual == a + b
+            end
+          end
+        end
+
+        it "invokes the match_for_should block for #matches?" do
+          matcher.matches?(77).should be_true
+          matcher.matches?(18).should be_false
+        end
+
+        it "invokes the match_for_should_not block for #does_not_match?" do
+          matcher.does_not_match?(77).should be_false
+          matcher.does_not_match?(18).should be_true
+        end
+
+        it "provides a default failure message for #should_not" do
+          matcher.does_not_match?(77)
+          matcher.failure_message_for_should_not.should == "expected 77 not to to be composed of 7 and 11"
+        end
+      end
+
+      it "allows helper methods to be defined with #define_method to have access to matcher parameters" do
+        matcher = RSpec::Matchers::Matcher.new(:name, 3, 4) do |a, b|
+          define_method(:sum) { a + b }
+        end
+
+        matcher.sum.should == 7
+      end
+
       it "is not diffable by default" do
         matcher = RSpec::Matchers::Matcher.new(:name) {}
         matcher.should_not be_diffable
@@ -297,6 +380,14 @@ module RSpec
         matcher.expecting('value').matches?('other value').should be_false
       end
 
+      it "prevents name collisions on chainable methods from different matchers" do
+        m1 = RSpec::Matchers::Matcher.new(:m1) { chain(:foo) { raise "foo in m1" } }
+        m2 = RSpec::Matchers::Matcher.new(:m2) { chain(:foo) { raise "foo in m2" } }
+
+        expect { m1.foo }.to raise_error("foo in m1")
+        expect { m2.foo }.to raise_error("foo in m2")
+      end
+
       context "defined using the dsl" do
         def a_method_in_the_example
           "method defined in the example"

data/spec/rspec/matchers/matchers_spec.rb

@@ -1,2 +1,31 @@
 require 'spec_helper'
 
+module RSpec
+  describe Matchers do
+
+    let(:sample_matchers) do
+      [:be,
+       :be_close,
+       :be_instance_of,
+       :be_kind_of]
+    end
+
+    context "once required" do
+      it "includes itself in Test::Unit::TestCase" do
+        test_unit_case = Test::Unit::TestCase.allocate
+        sample_matchers.each do |sample_matcher|
+            test_unit_case.should respond_to(sample_matcher)
+        end
+      end
+
+      it "includes itself in MiniTest::Unit::TestCase", :if => defined?(MiniTest) do
+        minitest_case = MiniTest::Unit::TestCase.allocate
+        sample_matchers.each do |sample_matcher|
+            minitest_case.should respond_to(sample_matcher)
+        end
+      end
+
+    end
+
+  end
+end

data/spec/rspec/matchers/method_missing_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+shared_examples_for "a well-behaved method_missing hook" do
+  it "raises a NoMethodError (and not SystemStackError) for an undefined method" do
+    expect { subject.some_undefined_method }.to raise_error(NoMethodError)
+  end
+end
+
+describe "RSpec::Matchers method_missing hook" do
+  subject { self }
+  it_behaves_like "a well-behaved method_missing hook"
+
+  context 'when invoked in a Test::Unit::TestCase' do
+    subject { Test::Unit::TestCase.allocate }
+    it_behaves_like "a well-behaved method_missing hook"
+  end
+
+  context 'when invoked in a MiniTest::Unit::TestCase', :if => defined?(MiniTest) do
+    subject { MiniTest::Unit::TestCase.allocate }
+    it_behaves_like "a well-behaved method_missing hook"
+  end
+end
+