rspec 1.0.0 → 1.3.1

data/spec/spec/matchers/match_array_spec.rb

@@ -0,0 +1,115 @@
+require 'spec_helper'
+
+class UnsortableObject
+  def initialize(id)
+    @id = id
+  end
+
+  def inspect
+    @id.to_s
+  end
+
+  def ==(other)
+    false
+  end
+end
+
+describe "array.should =~ other_array" do
+  it "should pass if target contains all items" do
+    [1,2,3].should =~ [1,2,3]
+  end
+
+  it "should pass if target contains all items out of order" do
+    [1,3,2].should =~ [1,2,3]
+  end
+
+  it "should fail if target includes extra items" do
+    lambda {
+      [1,2,3,4].should =~ [1,2,3]
+    }.should fail_with(<<-MESSAGE)
+expected collection contained:  [1, 2, 3]
+actual collection contained:    [1, 2, 3, 4]
+the extra elements were:        [4]
+MESSAGE
+  end
+
+  it "should fail if target is missing items" do
+    lambda {
+      [1,2].should =~ [1,2,3]
+    }.should fail_with(<<-MESSAGE)
+expected collection contained:  [1, 2, 3]
+actual collection contained:    [1, 2]
+the missing elements were:      [3]
+MESSAGE
+  end
+
+  it "should fail if target is missing items and has extra items" do
+
+    lambda {
+      [1,2,4].should =~ [1,2,3]
+    }.should fail_with(<<-MESSAGE)
+expected collection contained:  [1, 2, 3]
+actual collection contained:    [1, 2, 4]
+the missing elements were:      [3]
+the extra elements were:        [4]
+MESSAGE
+  end
+
+  it "should sort items in the error message if they all respond to <=>" do
+    lambda {
+      [6,2,1,5].should =~ [4,1,2,3]
+    }.should fail_with(<<-MESSAGE)
+expected collection contained:  [1, 2, 3, 4]
+actual collection contained:    [1, 2, 5, 6]
+the missing elements were:      [3, 4]
+the extra elements were:        [5, 6]
+MESSAGE
+  end
+
+  it "should not sort items in the error message if they don't all respond to <=>" do
+    with_ruby 1.8 do
+      lambda {
+        [UnsortableObject.new(2), UnsortableObject.new(1)].should =~ [UnsortableObject.new(4), UnsortableObject.new(3)]
+      }.should fail_with(<<-MESSAGE)
+expected collection contained:  [4, 3]
+actual collection contained:    [2, 1]
+the missing elements were:      [4, 3]
+the extra elements were:        [2, 1]
+MESSAGE
+    end
+  end
+
+  it "should accurately report extra elements when there are duplicates" do
+    lambda {
+      [1,1,1,5].should =~ [1,5]
+    }.should fail_with(<<-MESSAGE)
+expected collection contained:  [1, 5]
+actual collection contained:    [1, 1, 1, 5]
+the extra elements were:        [1, 1]
+MESSAGE
+  end
+
+  it "should accurately report missing elements when there are duplicates" do
+    lambda {
+      [1,5].should =~ [1,1,5]
+    }.should fail_with(<<-MESSAGE)
+expected collection contained:  [1, 1, 5]
+actual collection contained:    [1, 5]
+the missing elements were:      [1]
+MESSAGE
+  end
+
+  it "should work with subclasses of Array" do
+    class SuperArray < Array; end
+    SuperArray.new([1,2,3]).should =~ SuperArray.new([3,2,1])
+  end
+
+end
+
+describe "should_not =~ [:with, :multiple, :args]" do
+  it "should not be supported" do
+    lambda {
+      [1,2,3].should_not =~ [1,2,3]
+    }.should fail_with(/Matcher does not support should_not/)
+  end
+end

data/spec/spec/matchers/match_spec.rb

@@ -1,37 +1,57 @@
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
+require 'spec_helper'
 
 describe "should match(expected)" do
   it "should pass when target (String) matches expected (Regexp)" do
     "string".should match(/tri/)
   end
 
-  it "should fail when target (String) matches expected (Regexp)" do
+  it "should pass when target (String) matches expected (String)" do
+    "string".should match("tri")
+  end
+
+  it "should fail when target (String) does not match expected (Regexp)" do
     lambda {
       "string".should match(/rings/)
     }.should fail
   end
 
+  it "should fail when target (String) does not match expected (String)" do
+    lambda {
+      "string".should match("rings")
+    }.should fail
+  end
+  
   it "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"]
+    matcher.failure_message_for_should.should == "expected \"string\" to match /rings/"
   end
 end
 
 describe "should_not match(expected)" do
-  it "should pass when target (String) matches expected (Regexp)" do
+  it "should pass when target (String) matches does not match (Regexp)" do
     "string".should_not match(/rings/)
   end
 
+  it "should pass when target (String) matches does not match (String)" do
+    "string".should_not match("rings")
+  end
+
   it "should fail when target (String) matches expected (Regexp)" do
     lambda {
       "string".should_not match(/tri/)
     }.should fail
   end
 
+  it "should fail when target (String) matches expected (String)" do
+    lambda {
+      "string".should_not match("tri")
+    }.should fail
+  end
+
   it "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"]
+    matcher.failure_message_for_should_not.should == "expected \"string\" not to match /tri/"
   end
 end

data/spec/spec/matchers/matcher_spec.rb

@@ -0,0 +1,289 @@
+require 'spec_helper'
+
+class UnexpectedError < StandardError; end
+
+module Spec
+  module Matchers
+    describe Matcher do
+      context "without overrides" do
+        before(:each) do
+          @matcher = Spec::Matchers::Matcher.new(:be_a_multiple_of, 3) do |multiple|
+            match do |actual|
+              actual % multiple == 0
+            end
+          end
+        end
+
+        it "provides a default description" do
+          @matcher.description.should == "be a multiple of 3"
+        end
+
+        it "provides a default failure message for #should" do
+          @matcher.matches?(8)
+          @matcher.failure_message_for_should.should == "expected 8 to be a multiple of 3"
+        end
+
+        it "provides a default failure message for #should_not" do
+          @matcher.matches?(9)
+          @matcher.failure_message_for_should_not.should == "expected 9 not to be a multiple of 3"
+        end
+      end
+
+      it "is not diffable by default" do
+        matcher = Spec::Matchers::Matcher.new(:name) {}
+        matcher.should_not be_diffable
+      end
+
+      it "is diffable when told to be" do
+        matcher = Spec::Matchers::Matcher.new(:name) { diffable }
+        matcher.should be_diffable
+      end
+
+      it "provides expected" do
+        matcher = Spec::Matchers::Matcher.new(:name, 'expected string') {}
+        matcher.expected.should == ['expected string']
+      end
+
+      it "provides actual" do
+        matcher = Spec::Matchers::Matcher.new(:name, 'expected string') do
+          match {|actual|}
+        end
+
+        matcher.matches?('actual string')
+
+        matcher.actual.should == 'actual string'
+      end
+
+      context "wrapping another expectation (should == ...)" do
+        it "returns true if the wrapped expectation passes" do
+          matcher = Spec::Matchers::Matcher.new(:name, 'value') do |expected|
+            match do |actual|
+              actual.should == expected
+            end
+          end
+          matcher.matches?('value').should be_true
+        end
+
+        it "returns false if the wrapped expectation fails" do
+          matcher = Spec::Matchers::Matcher.new(:name, 'value') do |expected|
+            match do |actual|
+              actual.should == expected
+            end
+          end
+          matcher.matches?('other value').should be_false
+        end
+      end
+
+      context "with overrides" do
+        before(:each) do
+          @matcher = Spec::Matchers::Matcher.new(:be_boolean, true) do |boolean|
+            match do |actual|
+              actual
+            end
+            description do
+              "be the boolean #{boolean}"
+            end
+            failure_message_for_should do |actual|
+              "expected #{actual} to be the boolean #{boolean}"
+            end
+            failure_message_for_should_not do |actual|
+              "expected #{actual} not to be the boolean #{boolean}"
+            end
+          end
+        end
+
+        it "does not hide result of match block when true" do
+          @matcher.matches?(true).should be_true
+        end
+
+        it "does not hide result of match block when false" do
+          @matcher.matches?(false).should be_false
+        end
+
+        it "overrides the description" do
+          @matcher.description.should == "be the boolean true"
+        end
+
+        it "overrides the failure message for #should" do
+          @matcher.matches?(false)
+          @matcher.failure_message_for_should.should == "expected false to be the boolean true"
+        end
+
+        it "overrides the failure message for #should_not" do
+          @matcher.matches?(true)
+          @matcher.failure_message_for_should_not.should == "expected true not to be the boolean true"
+        end
+      end
+
+      context "#new" do
+        it "passes matches? arg to match block" do
+          matcher = Spec::Matchers::Matcher.new(:ignore) do
+            match do |actual|
+              actual == 5
+            end
+          end
+          matcher.matches?(5).should be_true
+        end
+
+        it "exposes arg submitted through #new to matcher block" do
+          matcher = Spec::Matchers::Matcher.new(:ignore, 4) do |expected|
+            match do |actual|
+              actual > expected
+            end
+          end
+          matcher.matches?(5).should be_true
+        end
+      end
+
+      context "with no args" do
+        before(:each) do
+          @matcher = Spec::Matchers::Matcher.new(:matcher_name) do
+            match do |actual|
+              actual == 5
+            end
+          end
+        end
+
+        it "matches" do
+          @matcher.matches?(5).should be_true
+        end
+
+        it "describes" do
+          @matcher.description.should == "matcher name"
+        end
+      end
+
+      context "with 1 arg" do
+        before(:each) do
+          @matcher = Spec::Matchers::Matcher.new(:matcher_name, 1) do |expected|
+            match do |actual|
+              actual == 5 && expected == 1
+            end
+          end
+        end
+
+        it "matches" do
+          @matcher.matches?(5).should be_true
+        end
+
+        it "describes" do
+          @matcher.description.should == "matcher name 1"
+        end
+      end
+
+      context "with multiple args" do
+        before(:each) do
+          @matcher = Spec::Matchers::Matcher.new(:matcher_name, 1, 2, 3, 4) do |a,b,c,d|
+            match do |sum|
+              a + b + c + d == sum
+            end
+          end
+        end
+
+        it "matches" do
+          @matcher.matches?(10).should be_true
+        end
+
+        it "describes" do
+          @matcher.description.should == "matcher name 1, 2, 3, and 4"
+        end
+      end
+
+      it "supports helper methods" do
+        matcher = Spec::Matchers::Matcher.new(:be_similar_to, [1,2,3]) do |sample|
+          match do |actual|
+            similar?(sample, actual)
+          end
+
+          def similar?(a, b)
+            a.sort == b.sort
+          end
+        end
+
+        matcher.matches?([2,3,1]).should be_true
+      end
+
+      it "supports fluent interface" do
+        matcher = Spec::Matchers::Matcher.new(:first_word) do
+          def second_word
+            self
+          end
+        end
+
+        matcher.second_word.should == matcher
+      end
+
+      it "treats method missing normally for undeclared methods" do
+        matcher = Spec::Matchers::Matcher.new(:ignore) { }
+        expect { matcher.non_existent_method }.to raise_error(NoMethodError)
+      end
+
+      it "has access to other matchers" do
+        matcher = Spec::Matchers::Matcher.new(:ignore, 3) do |expected|
+          match do |actual|
+            extend Spec::Matchers
+            actual.should eql(5 + expected)
+          end
+        end
+
+        matcher.matches?(8).should be_true
+      end
+
+      describe "#match_unless_raises" do
+        context "with a passing assertion" do
+          let(:mod) do
+            Module.new do
+              def assert_equal(a,b)
+                a == b ? nil : (raise UnexpectedError.new("#{a} does not equal #{b}"))
+              end
+            end
+          end
+          let(:matcher) do
+            m = mod
+            Spec::Matchers::Matcher.new :equal, 4 do |expected|
+              extend m
+              match_unless_raises UnexpectedError do
+                assert_equal expected, actual
+              end
+            end
+          end
+          it "passes as you would expect" do
+            matcher.matches?(4).should be_true
+          end
+          it "fails as you would expect" do
+            matcher.matches?(5).should be_false
+          end
+        end
+
+        context "with an unexpected error" do
+          let(:matcher) do
+            Spec::Matchers::Matcher.new :foo, :bar do |expected|
+              match_unless_raises SyntaxError do |actual|
+                raise "unexpected exception"
+              end
+            end
+          end
+
+          it "raises the error" do
+            expect do
+              matcher.matches?(:bar)
+            end.to raise_error("unexpected exception")
+          end
+        end
+
+      end
+
+      it "can define chainable methods" do
+        matcher = Spec::Matchers::Matcher.new(:name) do
+          chain(:expecting) do |expected_value|
+            @expected_value = expected_value
+          end
+          match { |actual| actual == @expected_value }
+        end
+
+        matcher.expecting('value').matches?('value').should be_true
+        matcher.expecting('value').matches?('other value').should be_false
+      end
+    end
+  end
+end

data/spec/spec/matchers/matchers_spec.rb

@@ -0,0 +1,2 @@
+require 'spec_helper'
+

data/spec/spec/matchers/operator_matcher_spec.rb

@@ -1,6 +1,6 @@
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
+require 'spec_helper'
 
-require 'spec/expectations/differs/default'
+require 'spec/runner/differs/default'
 
 describe "should ==" do
   
@@ -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", got "apple" (using ==)], "orange", "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_false
+  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")
+    Spec::Expectations.should_receive(:fail_with).with(%[expected not: == "apple",\n         got:    "apple"], "apple", "apple")
     subject.should_not == "apple"
   end
-
+  
 end
 
 describe "should ===" do
@@ -45,10 +55,10 @@ describe "should ===" do
   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")
+    Spec::Expectations.should_receive(:fail_with).with(%[expected: "orange",\n     got: "apple" (using ===)], "orange", "apple")
     subject.should === "orange"
   end
-
+  
 end
 
 describe "should_not ===" do
@@ -62,7 +72,7 @@ describe "should_not ===" do
   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")
+    Spec::Expectations.should_receive(:fail_with).with(%[expected not: === "apple",\n         got:     "apple"], "apple", "apple")
     subject.should_not === "apple"
   end
 
@@ -79,7 +89,7 @@ describe "should =~" do
   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")
+    Spec::Expectations.should_receive(:fail_with).with(%[expected: /oo/,\n     got: "fu" (using =~)], /oo/, "fu")
     subject.should =~ /oo/
   end
 
@@ -96,7 +106,7 @@ describe "should_not =~" do
   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")
+    Spec::Expectations.should_receive(:fail_with).with(%[expected not: =~ /oo/,\n         got:    "foo"], /oo/, "foo")
     subject.should_not =~ /oo/
   end
 
@@ -109,7 +119,7 @@ describe "should >" do
   end
 
   it "should fail if > fails" do
-    Spec::Expectations.should_receive(:fail_with).with(%[expected > 5, got 4], 5, 4)
+    Spec::Expectations.should_receive(:fail_with).with(%[expected: > 5,\n     got:   4], 5, 4)
     4.should > 5
   end
 
@@ -123,7 +133,7 @@ describe "should >=" do
   end
 
   it "should fail if > fails" do
-    Spec::Expectations.should_receive(:fail_with).with(%[expected >= 5, got 4], 5, 4)
+    Spec::Expectations.should_receive(:fail_with).with(%[expected: >= 5,\n     got:    4], 5, 4)
     4.should >= 5
   end
 
@@ -136,7 +146,7 @@ describe "should <" do
   end
 
   it "should fail if > fails" do
-    Spec::Expectations.should_receive(:fail_with).with(%[expected < 3, got 4], 3, 4)
+    Spec::Expectations.should_receive(:fail_with).with(%[expected: < 3,\n     got:   4], 3, 4)
     4.should < 3
   end
 
@@ -150,9 +160,32 @@ describe "should <=" do
   end
 
   it "should fail if > fails" do
-    Spec::Expectations.should_receive(:fail_with).with(%[expected <= 3, got 4], 3, 4)
+    Spec::Expectations.should_receive(:fail_with).with(%[expected: <= 3,\n     got:    4], 3, 4)
     4.should <= 3
   end
 
 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