@@ -4,9 +4,10 @@ module Spec class Be #:nodoc: include Spec::Matchers::Pretty - def initialize(*args) + def initialize(*args, &block) @expected = args.empty? ? true : set_expected(args.shift) @args = args + @block = block @comparison_method = nil end @@ -17,13 +18,13 @@ module Spec def run_predicate_on(actual) begin - return @result = actual.__send__(predicate, *@args) + return @result = actual.__send__(predicate, *@args, &@block) rescue NameError => predicate_missing_error "this needs to be here or rcov will not count this branch even though it's executed in a code example" end begin - return @result = actual.__send__(present_tense_predicate, *@args) + return @result = actual.__send__(present_tense_predicate, *@args, &@block) rescue NameError raise predicate_missing_error end @@ -196,8 +197,8 @@ it is a bit confusing. # collection.should be_empty #passes if target.empty? # target.should_not be_empty #passes unless target.empty? # target.should_not be_old_enough(16) #passes unless target.old_enough?(16) - def be(*args) - Matchers::Be.new(*args) + def be(*args, &block) + Matchers::Be.new(*args, &block) end # passes if target.kind_of?(klass) lib/spec/matchers/be.rb @@ -3,12 +3,12 @@ module Spec class Has - def initialize(expected, *args) - @expected, @args = expected, args + def initialize(expected, *args, &block) + @expected, @args, @block = expected, args, block end def matches?(actual) - actual.__send__(predicate(@expected), *@args) + actual.__send__(predicate(@expected), *@args, &@block) end def failure_message_for_should lib/spec/matchers/has.rb @@ -1,8 +1,8 @@ module Spec module Matchers def method_missing(sym, *args, &block) # :nodoc: - return Matchers::Be.new(sym, *args) if sym.to_s =~ /^be_/ - return Matchers::Has.new(sym, *args) if sym.to_s =~ /^have_/ + return Matchers::Be.new(sym, *args, &block) if sym.to_s =~ /^be_/ + return Matchers::Has.new(sym, *args, &block) if sym.to_s =~ /^have_/ super end end lib/spec/matchers/method_missing.rb @@ -117,6 +117,114 @@ 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 true.should be_true spec/spec/matchers/be_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"} spec/spec/matchers/has_spec.rb e45788319aaf2911409ec5905de9decbe2e25b81 Tom Stuart tom@experthuman.com http://github.com/dchelimsky/rspec/commit/c83c3676a8ef8b7de97d88433fe29ef89dcb79f1 c83c3676a8ef8b7de97d88433fe29ef89dcb79f1 2009-11-04T17:05:55-08:00 2009-11-04T07:10:25-08:00 Add block argument support to predicate matchers [#905 state:resolved milestone:'Next Release'] 5d9f73a4d45a9b162e8bdcb3b5f0e6e77f50e9c0 David Chelimsky dchelimsky@gmail.com