rspec 1.2.9 → 1.3.0

data/spec/spec/interop/test/unit/testsuite_adapter_spec.rb

@@ -4,6 +4,6 @@ describe "TestSuiteAdapter" do
   include TestUnitSpecHelper
   it "should pass" do
     dir = File.dirname(__FILE__)
-    run_script "#{dir}/resources/testsuite_adapter_spec_with_test_unit.rb"
+    run_script "'#{dir}/resources/testsuite_adapter_spec_with_test_unit.rb'"
   end
 end

data/spec/spec/matchers/be_spec.rb

@@ -117,27 +117,143 @@ describe "should_not be_predicate(*args)" do
   end
 end
 
+describe "should be_predicate(&block)" do
+  it "should pass when actual returns true for :predicate?(&block)" do
+    actual = mock("actual")
+    delegate = mock("delegate")
+    actual.should_receive(:happy?).and_yield
+    delegate.should_receive(:check_happy).and_return(true)
+    actual.should be_happy { delegate.check_happy }
+  end
+
+  it "should fail when actual returns false for :predicate?(&block)" do
+    actual = mock("actual")
+    delegate = mock("delegate")
+    actual.should_receive(:happy?).and_yield
+    delegate.should_receive(:check_happy).and_return(false)
+    lambda {
+      actual.should be_happy { delegate.check_happy }
+    }.should fail_with("expected happy? to return true, got false")
+  end
+
+  it "should fail when actual does not respond to :predicate?" do
+    delegate = mock("delegate", :check_happy => true)
+    lambda {
+      Object.new.should be_happy { delegate.check_happy }
+    }.should raise_error(NameError)
+  end
+end
+
+describe "should_not be_predicate(&block)" do
+  it "should pass when actual returns false for :predicate?(&block)" do
+    actual = mock("actual")
+    delegate = mock("delegate")
+    actual.should_receive(:happy?).and_yield
+    delegate.should_receive(:check_happy).and_return(false)
+    actual.should_not be_happy { delegate.check_happy }
+  end
+
+  it "should fail when actual returns true for :predicate?(&block)" do
+    actual = mock("actual")
+    delegate = mock("delegate")
+    actual.should_receive(:happy?).and_yield
+    delegate.should_receive(:check_happy).and_return(true)
+    lambda {
+      actual.should_not be_happy { delegate.check_happy }
+    }.should fail_with("expected happy? to return false, got true")
+  end
+
+  it "should fail when actual does not respond to :predicate?" do
+    delegate = mock("delegate", :check_happy => true)
+    lambda {
+      Object.new.should_not be_happy { delegate.check_happy }
+    }.should raise_error(NameError)
+  end
+end
+
+describe "should be_predicate(*args, &block)" do
+  it "should pass when actual returns true for :predicate?(*args, &block)" do
+    actual = mock("actual")
+    delegate = mock("delegate")
+    actual.should_receive(:older_than?).with(3).and_yield(3)
+    delegate.should_receive(:check_older_than).with(3).and_return(true)
+    actual.should be_older_than(3) { |age| delegate.check_older_than(age) }
+  end
+
+  it "should fail when actual returns false for :predicate?(*args, &block)" do
+    actual = mock("actual")
+    delegate = mock("delegate")
+    actual.should_receive(:older_than?).with(3).and_yield(3)
+    delegate.should_receive(:check_older_than).with(3).and_return(false)
+    lambda {
+      actual.should be_older_than(3) { |age| delegate.check_older_than(age) }
+    }.should fail_with("expected older_than?(3) to return true, got false")
+  end
+
+  it "should fail when actual does not respond to :predicate?" do
+    delegate = mock("delegate", :check_older_than => true)
+    lambda {
+      Object.new.should be_older_than(3) { |age| delegate.check_older_than(age) }
+    }.should raise_error(NameError)
+  end
+end
+
+describe "should_not be_predicate(*args, &block)" do
+  it "should pass when actual returns false for :predicate?(*args, &block)" do
+    actual = mock("actual")
+    delegate = mock("delegate")
+    actual.should_receive(:older_than?).with(3).and_yield(3)
+    delegate.should_receive(:check_older_than).with(3).and_return(false)
+    actual.should_not be_older_than(3) { |age| delegate.check_older_than(age) }
+  end
+
+  it "should fail when actual returns true for :predicate?(*args, &block)" do
+    actual = mock("actual")
+    delegate = mock("delegate")
+    actual.should_receive(:older_than?).with(3).and_yield(3)
+    delegate.should_receive(:check_older_than).with(3).and_return(true)
+    lambda {
+      actual.should_not be_older_than(3) { |age| delegate.check_older_than(age) }
+    }.should fail_with("expected older_than?(3) to return false, got true")
+  end
+
+  it "should fail when actual does not respond to :predicate?" do
+    delegate = mock("delegate", :check_older_than => true)
+    lambda {
+      Object.new.should_not be_older_than(3) { |age| delegate.check_older_than(age) }
+    }.should raise_error(NameError)
+  end
+end
+
 describe "should be_true" do
-  it "should pass when actual equal(true)" do
+  it "should pass when actual equal?(true)" do
     true.should be_true
   end
 
-  it "should fail when actual equal(false)" do
+  it "should pass when actual is 1" do
+    1.should be_true
+  end
+
+  it "should fail when actual equal?(false)" do
     lambda {
       false.should be_true
-    }.should fail_with("expected true, got false")
+    }.should fail_with("expected false to be true")
   end
 end
 
 describe "should be_false" do
-  it "should pass when actual equal(false)" do
+  it "should pass when actual equal?(false)" do
     false.should be_false
   end
 
-  it "should fail when actual equal(true)" do
+  it "should pass when actual equal?(nil)" do
+    nil.should be_false
+  end
+
+  it "should fail when actual equal?(true)" do
     lambda {
       true.should be_false
-    }.should fail_with("expected false, got true")
+    }.should fail_with("expected true to be false")
   end
 end
 
@@ -173,6 +289,10 @@ describe "should be <" do
   it "should fail when < operator returns false" do
     lambda { 3.should be < 3 }.should fail_with("expected < 3, got 3")
   end
+
+  it "should describe itself" do
+    be.<(4).description.should == "be < 4"
+  end
 end
 
 describe "should be <=" do
@@ -236,17 +356,32 @@ describe "should_not with operators" do
 end
 
 describe "should be" do
-  it "should pass if actual is true or a set value" do
+  it "should pass if actual is truthy" do
     true.should be
     1.should be
   end
 
   it "should fail if actual is false" do
-    lambda {false.should be}.should fail_with("expected true, got false")
+    lambda {false.should be}.should fail_with("expected false to evaluate to true")
   end
 
   it "should fail if actual is nil" do
-    lambda {nil.should be}.should fail_with("expected true, got nil")
+    lambda {nil.should be}.should fail_with("expected nil to evaluate to true")
+  end
+
+  it "should describe itself" do
+    be.description.should == "be"
+  end
+end
+
+describe "should_not be" do
+  it "should pass if actual is falsy" do
+    false.should_not be
+    nil.should_not be
+  end
+
+  it "should fail on true" do
+    lambda {true.should_not be}.should fail_with("expected true to evaluate to false")
   end
 end
 
@@ -254,9 +389,23 @@ describe "should be(value)" do
   it "should pass if actual.equal?(value)" do
     5.should be(5)
   end
+
   it "should fail if !actual.equal?(value)" do
     lambda { 5.should be(6) }.should fail_with("expected 6, got 5")
   end
+
+  it "should describe itself" do
+    be(5).description.should == "be 5"
+  end
+end
+
+describe "should_not be(value)" do
+  it "should pass if !actual.equal?(value)" do
+    5.should_not be(6)
+  end
+  it "should fail if !actual.equal?(value)" do
+    lambda { 5.should_not be(5) }.should fail_with("expected not 5, got 5")
+  end
 end
 
 describe "'should be' with operator" do
@@ -308,4 +457,4 @@ describe "be_an_instance_of" do
   it "fails when class is higher up hierarchy" do
     5.should_not be_an_instance_of(Numeric)
   end
-end
+end

data/spec/spec/matchers/has_spec.rb

@@ -70,6 +70,115 @@ describe "should_not have_sym(*args)" do
   end
 end
 
+describe "should have_sym(&block)" do
+  it "should pass when actual returns true for :has_sym?(&block)" do
+    actual = mock("actual")
+    delegate = mock("delegate")
+    actual.should_receive(:has_foo?).and_yield
+    delegate.should_receive(:check_has_foo).and_return(true)
+    actual.should have_foo { delegate.check_has_foo }
+  end
+
+  it "should fail when actual returns false for :has_sym?(&block)" do
+    actual = mock("actual")
+    delegate = mock("delegate")
+    actual.should_receive(:has_foo?).and_yield
+    delegate.should_receive(:check_has_foo).and_return(false)
+    lambda {
+      actual.should have_foo { delegate.check_has_foo }
+    }.should fail_with("expected #has_foo?(nil) to return true, got false")
+  end
+
+  it "should fail when actual does not respond to :has_sym?" do
+    delegate = mock("delegate", :check_has_foo => true)
+    lambda {
+      Object.new.should have_foo { delegate.check_has_foo }
+    }.should raise_error(NameError)
+  end
+end
+
+describe "should_not have_sym(&block)" do
+  it "should pass when actual returns false for :has_sym?(&block)" do
+    actual = mock("actual")
+    delegate = mock("delegate")
+    actual.should_receive(:has_foo?).and_yield
+    delegate.should_receive(:check_has_foo).and_return(false)
+    actual.should_not have_foo { delegate.check_has_foo }
+  end
+
+  it "should fail when actual returns true for :has_sym?(&block)" do
+    actual = mock("actual")
+    delegate = mock("delegate")
+    actual.should_receive(:has_foo?).and_yield
+    delegate.should_receive(:check_has_foo).and_return(true)
+    lambda {
+      actual.should_not have_foo { delegate.check_has_foo }
+    }.should fail_with("expected #has_foo?(nil) to return false, got true")
+  end
+
+  it "should fail when actual does not respond to :has_sym?" do
+    delegate = mock("delegate", :check_has_foo => true)
+    lambda {
+      Object.new.should_not have_foo { delegate.check_has_foo }
+    }.should raise_error(NameError)
+  end
+end
+
+describe "should have_sym(*args, &block)" do
+  it "should pass when actual returns true for :has_sym?(*args, &block)" do
+    actual = mock("actual")
+    delegate = mock("delegate")
+    actual.should_receive(:has_foo?).with(:a).and_yield(:a)
+    delegate.should_receive(:check_has_foo).with(:a).and_return(true)
+    actual.should have_foo(:a) { |foo| delegate.check_has_foo(foo) }
+  end
+
+  it "should fail when actual returns false for :has_sym?(*args, &block)" do
+    actual = mock("actual")
+    delegate = mock("delegate")
+    actual.should_receive(:has_foo?).with(:a).and_yield(:a)
+    delegate.should_receive(:check_has_foo).with(:a).and_return(false)
+    lambda {
+      actual.should have_foo(:a) { |foo| delegate.check_has_foo(foo) }
+    }.should fail_with("expected #has_foo?(:a) to return true, got false")
+  end
+
+  it "should fail when actual does not respond to :has_sym?" do
+    delegate = mock("delegate", :check_has_foo => true)
+    lambda {
+      Object.new.should have_foo(:a) { |foo| delegate.check_has_foo(foo) }
+    }.should raise_error(NameError)
+  end
+end
+
+describe "should_not have_sym(*args, &block)" do
+  it "should pass when actual returns false for :has_sym?(*args, &block)" do
+    actual = mock("actual")
+    delegate = mock("delegate")
+    actual.should_receive(:has_foo?).with(:a).and_yield(:a)
+    delegate.should_receive(:check_has_foo).with(:a).and_return(false)
+    actual.should_not have_foo(:a) { |foo| delegate.check_has_foo(foo) }
+  end
+
+  it "should fail when actual returns true for :has_sym?(*args, &block)" do
+    actual = mock("actual")
+    delegate = mock("delegate")
+    actual.should_receive(:has_foo?).with(:a).and_yield(:a)
+    delegate.should_receive(:check_has_foo).with(:a).and_return(true)
+    lambda {
+      actual.should_not have_foo(:a) { |foo| delegate.check_has_foo(foo) }
+    }.should fail_with("expected #has_foo?(:a) to return false, got true")
+  end
+
+  it "should fail when actual does not respond to :has_sym?" do
+    delegate = mock("delegate", :check_has_foo => true)
+    lambda {
+      Object.new.should_not have_foo(:a) { |foo| delegate.check_has_foo(foo) }
+    }.should raise_error(NameError)
+  end
+end
+
+
 describe "has" do
   it "should work when the target implements #send" do
     o = {:a => "A"}

data/spec/spec/matchers/matcher_spec.rb

@@ -1,5 +1,7 @@
 require 'spec_helper'
 
+class UnexpectedError < StandardError; end
+
 module Spec
   module Matchers
     describe Matcher do
@@ -52,6 +54,26 @@ module Spec
         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|
@@ -207,22 +229,61 @@ module Spec
         matcher.matches?(8).should be_true
       end
 
-      it "lets you override the actual() in messages" do
-        matcher = Spec::Matchers::Matcher.new(:be_foo) do
-          match do |actual|
-            @submitted = actual
-            false
+      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
 
-          def actual
-            "replaced"
+        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
 
-        matcher.matches?("foo")
-        matcher.failure_message_for_should.should =~ /replaced/
       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