rspec-expectations 3.0.0.beta1 → 3.0.0.beta2

data/spec/rspec/matchers/{match_spec.rb → built_in/match_spec.rb}

@@ -28,7 +28,7 @@ describe "expect(...).to match(expected)" do
   it "provides message, expected and actual on failure" do
     matcher = match(/rings/)
     matcher.matches?("string")
-    expect(matcher.failure_message_for_should).to eq "expected \"string\" to match /rings/"
+    expect(matcher.failure_message).to eq "expected \"string\" to match /rings/"
   end
 
   it "provides a diff on failure" do
@@ -43,6 +43,22 @@ describe "expect(...).to match(expected)" do
     expect { expect("foo").to match(/bar/) }.to fail_with(failure_message_that_includes_diff)
   end
 
+  context "when passed a data structure with matchers" do
+    it 'passes when the matchers match' do
+      expect(["food", 1.1]).to match([ a_string_matching(/foo/), a_value_within(0.2).of(1) ])
+    end
+
+    it 'fails when the matchers do not match' do
+      expect {
+        expect(["fod", 1.1]).to match([ a_string_matching(/foo/), a_value_within(0.2).of(1) ])
+      }.to fail_with('expected ["fod", 1.1] to match [(a string matching /foo/), (a value within 0.2 of 1)]')
+    end
+
+    it 'provides a description' do
+      description = match([ a_string_matching(/foo/), a_value_within(0.2).of(1) ]).description
+      expect(description).to eq("match [(a string matching /foo/), (a value within 0.2 of 1)]")
+    end
+  end
 end
 
 describe "expect(...).not_to match(expected)" do
@@ -69,6 +85,18 @@ describe "expect(...).not_to match(expected)" do
   it "provides message, expected and actual on failure" do
     matcher = match(/tri/)
     matcher.matches?("string")
-    expect(matcher.failure_message_for_should_not).to eq "expected \"string\" not to match /tri/"
+    expect(matcher.failure_message_when_negated).to eq "expected \"string\" not to match /tri/"
+  end
+
+  context "when passed a data structure with matchers" do
+    it 'passes when the matchers match' do
+      expect(["food", 1.1]).not_to match([ a_string_matching(/fod/), a_value_within(0.2).of(1) ])
+    end
+
+    it 'fails when the matchers do not match' do
+      expect {
+        expect(["fod", 1.1]).not_to match([ a_string_matching(/fod/), a_value_within(0.2).of(1) ])
+      }.to fail_with('expected ["fod", 1.1] not to match [(a string matching /fod/), (a value within 0.2 of 1)]')
+    end
   end
 end

data/spec/rspec/matchers/{operator_matcher_spec.rb → built_in/operators_spec.rb}

@@ -18,7 +18,7 @@ describe "operator matchers", :uses_should do
   describe "should ==" do
     it "delegates message to target" do
       subject = "apple"
-      subject.should_receive(:==).with("apple").and_return(true)
+      expect(subject).to receive(:==).with("apple").and_return(true)
       subject.should == "apple"
     end
 
@@ -29,7 +29,7 @@ describe "operator matchers", :uses_should do
 
     it "fails when target.==(actual) returns false" do
       subject = "apple"
-      RSpec::Expectations.should_receive(:fail_with).with(%[expected: "orange"\n     got: "apple" (using ==)], "orange", "apple")
+      expect(RSpec::Expectations).to receive(:fail_with).with(%[expected: "orange"\n     got: "apple" (using ==)], "orange", "apple")
       subject.should == "orange"
     end
 
@@ -78,7 +78,7 @@ describe "operator matchers", :uses_should do
   describe "should_not ==" do
     it "delegates message to target" do
       subject = "orange"
-      subject.should_receive(:==).with("apple").and_return(false)
+      expect(subject).to receive(:==).with("apple").and_return(false)
       subject.should_not == "apple"
     end
 
@@ -89,7 +89,7 @@ describe "operator matchers", :uses_should do
 
     it "fails when target.==(actual) returns false" do
       subject = "apple"
-      RSpec::Expectations.should_receive(:fail_with).with(%[expected not: == "apple"\n         got:    "apple"], "apple", "apple")
+      expect(RSpec::Expectations).to receive(:fail_with).with(%[expected not: == "apple"\n         got:    "apple"], "apple", "apple")
       subject.should_not == "apple"
     end
   end
@@ -97,14 +97,14 @@ describe "operator matchers", :uses_should do
   describe "should ===" do
     it "delegates message to target" do
       subject = "apple"
-      subject.should_receive(:===).with("apple").and_return(true)
+      expect(subject).to receive(:===).with("apple").and_return(true)
       subject.should === "apple"
     end
 
     it "fails when target.===(actual) returns false" do
       subject = "apple"
-      subject.should_receive(:===).with("orange").and_return(false)
-      RSpec::Expectations.should_receive(:fail_with).with(%[expected: "orange"\n     got: "apple" (using ===)], "orange", "apple")
+      expect(subject).to receive(:===).with("orange").and_return(false)
+      expect(RSpec::Expectations).to receive(:fail_with).with(%[expected: "orange"\n     got: "apple" (using ===)], "orange", "apple")
       subject.should === "orange"
     end
   end
@@ -112,14 +112,14 @@ describe "operator matchers", :uses_should do
   describe "should_not ===" do
     it "delegates message to target" do
       subject = "orange"
-      subject.should_receive(:===).with("apple").and_return(false)
+      expect(subject).to receive(:===).with("apple").and_return(false)
       subject.should_not === "apple"
     end
 
     it "fails when target.===(actual) returns false" do
       subject = "apple"
-      subject.should_receive(:===).with("apple").and_return(true)
-      RSpec::Expectations.should_receive(:fail_with).with(%[expected not: === "apple"\n         got:     "apple"], "apple", "apple")
+      expect(subject).to receive(:===).with("apple").and_return(true)
+      expect(RSpec::Expectations).to receive(:fail_with).with(%[expected not: === "apple"\n         got:     "apple"], "apple", "apple")
       subject.should_not === "apple"
     end
   end
@@ -127,14 +127,14 @@ describe "operator matchers", :uses_should do
   describe "should =~" do
     it "delegates message to target" do
       subject = "foo"
-      subject.should_receive(:=~).with(/oo/).and_return(true)
+      expect(subject).to receive(:=~).with(/oo/).and_return(true)
       subject.should =~ /oo/
     end
 
     it "fails when target.=~(actual) returns false" do
       subject = "fu"
-      subject.should_receive(:=~).with(/oo/).and_return(false)
-      RSpec::Expectations.should_receive(:fail_with).with(%[expected: /oo/\n     got: "fu" (using =~)], /oo/, "fu")
+      expect(subject).to receive(:=~).with(/oo/).and_return(false)
+      expect(RSpec::Expectations).to receive(:fail_with).with(%[expected: /oo/\n     got: "fu" (using =~)], /oo/, "fu")
       subject.should =~ /oo/
     end
   end
@@ -142,14 +142,14 @@ describe "operator matchers", :uses_should do
   describe "should_not =~" do
     it "delegates message to target" do
       subject = "fu"
-      subject.should_receive(:=~).with(/oo/).and_return(false)
+      expect(subject).to receive(:=~).with(/oo/).and_return(false)
       subject.should_not =~ /oo/
     end
 
     it "fails when target.=~(actual) returns false" do
       subject = "foo"
-      subject.should_receive(:=~).with(/oo/).and_return(true)
-      RSpec::Expectations.should_receive(:fail_with).with(%[expected not: =~ /oo/\n         got:    "foo"], /oo/, "foo")
+      expect(subject).to receive(:=~).with(/oo/).and_return(true)
+      expect(RSpec::Expectations).to receive(:fail_with).with(%[expected not: =~ /oo/\n         got:    "foo"], /oo/, "foo")
       subject.should_not =~ /oo/
     end
   end
@@ -160,7 +160,7 @@ describe "operator matchers", :uses_should do
     end
 
     it "fails if > fails" do
-      RSpec::Expectations.should_receive(:fail_with).with(%[expected: > 5\n     got:   4], 5, 4)
+      expect(RSpec::Expectations).to receive(:fail_with).with(%[expected: > 5\n     got:   4], 5, 4)
       4.should > 5
     end
   end
@@ -175,7 +175,7 @@ describe "operator matchers", :uses_should do
     end
 
     it "fails if > fails" do
-      RSpec::Expectations.should_receive(:fail_with).with(%[expected: >= 5\n     got:    4], 5, 4)
+      expect(RSpec::Expectations).to receive(:fail_with).with(%[expected: >= 5\n     got:    4], 5, 4)
       4.should >= 5
     end
   end
@@ -186,7 +186,7 @@ describe "operator matchers", :uses_should do
     end
 
     it "fails if > fails" do
-      RSpec::Expectations.should_receive(:fail_with).with(%[expected: < 3\n     got:   4], 3, 4)
+      expect(RSpec::Expectations).to receive(:fail_with).with(%[expected: < 3\n     got:   4], 3, 4)
       4.should < 3
     end
   end
@@ -201,7 +201,7 @@ describe "operator matchers", :uses_should do
     end
 
     it "fails if > fails" do
-      RSpec::Expectations.should_receive(:fail_with).with(%[expected: <= 3\n     got:    4], 3, 4)
+      expect(RSpec::Expectations).to receive(:fail_with).with(%[expected: <= 3\n     got:    4], 3, 4)
       4.should <= 3
     end
   end
@@ -211,21 +211,21 @@ describe "operator matchers", :uses_should do
     let(:custom_subklass) { Class.new(custom_klass) }
 
     after {
-      RSpec::Matchers::OperatorMatcher.unregister(custom_klass, "=~")
+      RSpec::Matchers::BuiltIn::OperatorMatcher.unregister(custom_klass, "=~")
     }
 
     it "allows operator matchers to be registered for types" do
-      RSpec::Matchers::OperatorMatcher.register(custom_klass, "=~", RSpec::Matchers::BuiltIn::Match)
-      expect(RSpec::Matchers::OperatorMatcher.get(custom_klass, "=~")).to eq(RSpec::Matchers::BuiltIn::Match)
+      RSpec::Matchers::BuiltIn::OperatorMatcher.register(custom_klass, "=~", RSpec::Matchers::BuiltIn::Match)
+      expect(RSpec::Matchers::BuiltIn::OperatorMatcher.get(custom_klass, "=~")).to eq(RSpec::Matchers::BuiltIn::Match)
     end
 
     it "considers ancestors when finding an operator matcher" do
-      RSpec::Matchers::OperatorMatcher.register(custom_klass, "=~", RSpec::Matchers::BuiltIn::Match)
-      expect(RSpec::Matchers::OperatorMatcher.get(custom_subklass, "=~")).to eq(RSpec::Matchers::BuiltIn::Match)
+      RSpec::Matchers::BuiltIn::OperatorMatcher.register(custom_klass, "=~", RSpec::Matchers::BuiltIn::Match)
+      expect(RSpec::Matchers::BuiltIn::OperatorMatcher.get(custom_subklass, "=~")).to eq(RSpec::Matchers::BuiltIn::Match)
     end
 
     it "returns nil if there is no matcher registered for a type" do
-      expect(RSpec::Matchers::OperatorMatcher.get(custom_klass, "=~")).to be_nil
+      expect(RSpec::Matchers::BuiltIn::OperatorMatcher.get(custom_klass, "=~")).to be_nil
     end
   end
 

data/spec/rspec/matchers/built_in/output_spec.rb

@@ -0,0 +1,165 @@
+require 'spec_helper'
+
+shared_examples_for "output_to_stream" do |stream_name|
+  matcher_method = :"to_#{stream_name}"
+
+  define_method :matcher do |*args|
+    output(args.first).send(matcher_method)
+  end
+
+  it 'is diffable' do
+    expect(matcher).to be_diffable
+  end
+
+  context "expect { ... }.to output.#{matcher_method}" do
+    it "passes if the block outputs to #{stream_name}" do
+      expect { stream.print 'foo' }.to matcher
+    end
+
+    it "fails if the block does not output to #{stream_name}" do
+      expect {
+        expect { }.to matcher
+      }.to fail_with("expected block to output to #{stream_name}, but did not")
+    end
+  end
+
+  context "expect { ... }.not_to output.#{matcher_method}" do
+    it "passes if the block does not output to #{stream_name}" do
+      expect { }.not_to matcher
+    end
+
+    it "fails if the block outputs to #{stream_name}" do
+      expect {
+        expect { stream.print 'foo' }.not_to matcher
+      }.to fail_with("expected block to not output to #{stream_name}, but did")
+    end
+  end
+
+  context "expect { ... }.to output('string').#{matcher_method}" do
+    it "passes if the block outputs that string to #{stream_name}" do
+      expect { stream.print 'foo' }.to matcher("foo")
+    end
+
+    it "fails if the block does not output to #{stream_name}" do
+      expect {
+        expect { }.to matcher('foo')
+      }.to fail_with("expected block to output \"foo\" to #{stream_name}, but output nothing")
+    end
+
+    it "fails if the block outputs a different string to #{stream_name}" do
+      expect {
+        expect { stream.print 'food' }.to matcher('foo')
+      }.to fail_with("expected block to output \"foo\" to #{stream_name}, but output \"food\"")
+    end
+  end
+
+  context "expect { ... }.to_not output('string').#{matcher_method}" do
+    it "passes if the block outputs a different string to #{stream_name}" do
+      expect { stream.print 'food' }.to_not matcher('foo')
+    end
+
+    it "passes if the block does not output to #{stream_name}" do
+      expect { }.to_not matcher('foo')
+    end
+
+    it "fails if the block outputs the same string to #{stream_name}" do
+      expect {
+        expect { stream.print 'foo' }.to_not matcher('foo')
+      }.to fail_with("expected block to not output \"foo\" to #{stream_name}, but did")
+    end
+  end
+
+  context "expect { ... }.to output(/regex/).#{matcher_method}" do
+    it "passes if the block outputs a string to #{stream_name} that matches the regex" do
+      expect { stream.print 'foo' }.to matcher(/foo/)
+    end
+
+    it "fails if the block does not output to #{stream_name}" do
+      expect {
+        expect { }.to matcher(/foo/)
+      }.to fail_matching("expected block to output /foo/ to #{stream_name}, but output nothing\nDiff")
+    end
+
+    it "fails if the block outputs a string to #{stream_name} that does not match" do
+      expect {
+        expect { stream.print 'foo' }.to matcher(/food/)
+      }.to fail_matching("expected block to output /food/ to #{stream_name}, but output \"foo\"\nDiff")
+    end
+  end
+
+  context "expect { ... }.to_not output(/regex/).#{matcher_method}" do
+    it "passes if the block outputs a string to #{stream_name} that does not match the regex" do
+      expect { stream.print 'food' }.to_not matcher(/bar/)
+    end
+
+    it "passes if the block does not output to #{stream_name}" do
+      expect { }.to_not matcher(/foo/)
+    end
+
+    it "fails if the block outputs a string to #{stream_name} that matches the regex" do
+      expect {
+        expect { stream.print 'foo' }.to_not matcher(/foo/)
+      }.to fail_matching("expected block to not output /foo/ to #{stream_name}, but did\nDiff")
+    end
+  end
+
+  context "expect { ... }.to output(matcher).#{matcher_method}" do
+    it "passes if the block outputs a string to #{stream_name} that passes the given matcher" do
+      expect { stream.print 'foo' }.to matcher(a_string_starting_with("f"))
+    end
+
+    it "fails if the block outputs a string to #{stream_name} that does not pass the given matcher" do
+      expect {
+        expect { stream.print 'foo' }.to matcher(a_string_starting_with("b"))
+      }.to fail_matching("expected block to output a string starting with \"b\" to #{stream_name}, but output \"foo\"\nDiff")
+    end
+  end
+
+  context "expect { ... }.to_not output(matcher).#{matcher_method}" do
+    it "passes if the block does not output a string to #{stream_name} that passes the given matcher" do
+      expect { stream.print 'foo' }.to_not matcher(a_string_starting_with("b"))
+    end
+
+    it "fails if the block outputs a string to #{stream_name} that passes the given matcher" do
+      expect {
+        expect { stream.print 'foo' }.to_not matcher(a_string_starting_with("f"))
+      }.to fail_matching("expected block to not output a string starting with \"f\" to #{stream_name}, but did\nDiff")
+    end
+  end
+end
+
+module RSpec
+  module Matchers
+    describe "output.to_stderr matcher" do
+      it_behaves_like("an RSpec matcher", :valid_value => lambda { warn('foo') }, :invalid_value => lambda {}) do
+        let(:matcher) { output.to_stderr }
+      end
+
+      include_examples "output_to_stream", :stderr do
+        let(:stream) { $stderr }
+      end
+    end
+
+    describe "output.to_stdout matcher" do
+      it_behaves_like("an RSpec matcher", :valid_value => lambda { print 'foo' }, :invalid_value => lambda {}) do
+        let(:matcher) { output.to_stdout }
+      end
+
+      include_examples "output_to_stream", :stdout do
+        let(:stream) { $stdout }
+      end
+    end
+
+    describe "output (without `to_stdout` or `to_stderr`)" do
+      it 'raises an error explaining the use is invalid' do
+        expect {
+          expect { stream.print 'foo' }.to output
+        }.to raise_error(/must chain.*to_stdout.*to_stderr/)
+      end
+
+      it 'still provides a description (e.g. when used in a one-liner)' do
+        expect(output("foo").description).to eq('output "foo" to some stream')
+      end
+    end
+  end
+end

data/spec/rspec/matchers/{raise_error_spec.rb → built_in/raise_error_spec.rb}

@@ -90,8 +90,7 @@ describe "expect { ... }.not_to raise_error" do
     it "is invalid" do
       expect {
         expect {"bees"}.not_to raise_error(RuntimeError)
-      }.to raise_error(/`expect { }\.not_to raise_error\(SpecificErrorClass\)` is not valid/)
-
+      }.to raise_error(/`expect \{ \}\.not_to raise_error\(SpecificErrorClass\)` is not valid/)
     end
   end
 
@@ -116,8 +115,8 @@ describe "expect { ... }.not_to raise_error" do
     end
 
     it 'formats the backtrace using the configured backtrace formatter' do
-      RSpec::Matchers.configuration.backtrace_formatter.
-        stub(:format_backtrace).
+      allow(RSpec::Matchers.configuration.backtrace_formatter).
+        to receive(:format_backtrace).
         and_return("formatted-backtrace")
 
       expect {
@@ -168,7 +167,7 @@ describe "expect { ... }.to raise_error.with_message(message)" do
   it "raises an argument error if raise_error itself expects a message" do
     expect {
       expect { }.to raise_error("bees").with_message("sup")
-    }.to raise_error.with_message(/`expect { }\.to raise_error\(message\)\.with_message\(message\)` is not valid/)
+    }.to raise_error.with_message(/`expect \{ \}\.to raise_error\(message\)\.with_message\(message\)` is not valid/)
   end
 
   it "passes if RuntimeError is raised with the right message" do
@@ -200,7 +199,7 @@ describe "expect { ... }.not_to raise_error(message)" do
   it "is invalid" do
     expect {
       expect {raise 'blarg'}.not_to raise_error(/blah/)
-    }.to raise_error(/`expect { }\.not_to raise_error\(message\)` is not valid/)
+    }.to raise_error(/`expect \{ \}\.not_to raise_error\(message\)` is not valid/)
   end
 end
 
@@ -232,7 +231,7 @@ describe "expect { ... }.not_to raise_error(NamedError)" do
   it "is invalid" do
     expect {
       expect { }.not_to raise_error(NameError)
-    }.to raise_error(/`expect { }\.not_to raise_error\(SpecificErrorClass\)` is not valid/)
+    }.to raise_error(/`expect \{ \}\.not_to raise_error\(SpecificErrorClass\)` is not valid/)
   end
 end
 
@@ -264,7 +263,7 @@ describe "expect { ... }.not_to raise_error(NamedError, error_message) with Stri
   it "is invalid" do
     expect {
       expect {}.not_to raise_error(RuntimeError, "example message")
-    }.to raise_error(/`expect { }\.not_to raise_error\(SpecificErrorClass, message\)` is not valid/)
+    }.to raise_error(/`expect \{ \}\.not_to raise_error\(SpecificErrorClass, message\)` is not valid/)
   end
 end
 
@@ -296,7 +295,7 @@ describe "expect { ... }.not_to raise_error(NamedError, error_message) with Rege
   it "is invalid" do
     expect {
       expect {}.not_to raise_error(RuntimeError, /ample mess/)
-    }.to raise_error(/`expect { }\.not_to raise_error\(SpecificErrorClass, message\)` is not valid/)
+    }.to raise_error(/`expect \{ \}\.not_to raise_error\(SpecificErrorClass, message\)` is not valid/)
   end
 end
 
@@ -377,15 +376,86 @@ describe "expect { ... }.not_to raise_error(NamedError, error_message) { |err| .
   it "is invalid" do
     expect {
       expect {}.not_to raise_error(RuntimeError, "example message") { |err| }
-    }.to raise_error(/`expect { }\.not_to raise_error\(SpecificErrorClass, message\)` is not valid/)
+    }.to raise_error(/`expect \{ \}\.not_to raise_error\(SpecificErrorClass, message\)` is not valid/)
   end
 end
 
 describe "misuse of raise_error, with (), not {}" do
   it "fails with warning" do
-    ::Kernel.should_receive(:warn).with(/`raise_error` was called with non-proc object 1\.7/)
+    expect(::Kernel).to receive(:warn).with(/`raise_error` was called with non-proc object 1\.7/)
     expect {
       expect(Math.sqrt(3)).to raise_error
     }.to fail_with(/nothing was raised/)
   end
 end
+
+describe "Composing matchers with `raise_error`" do
+  matcher :an_error_with_attribute do |attr|
+    chain :equal_to do |value|
+      @expected_value = value
+    end
+
+    match do |error|
+      error.__send__(attr) == @expected_value
+    end
+
+    description do
+      super() + " equal to #{@expected_value}"
+    end
+  end
+
+  class FooError < StandardError
+    def foo; :bar; end
+  end
+
+  describe "expect { }.to raise_error(matcher)" do
+    it 'passes when the matcher matches the raised error' do
+      expect { raise FooError }.to raise_error(an_error_with_attribute(:foo).equal_to(:bar))
+    end
+
+    it 'fails with a clear message when the matcher does not match the raised error' do
+      expect {
+        expect { raise FooError }.to raise_error(an_error_with_attribute(:foo).equal_to(3))
+      }.to fail_matching("expected an error with attribute :foo equal to 3, got #<FooError: FooError>")
+    end
+
+    it 'provides a description' do
+      description = raise_error(an_error_with_attribute(:foo).equal_to(3)).description
+      expect(description).to eq("raise an error with attribute :foo equal to 3")
+    end
+  end
+
+  describe "expect { }.to raise_error(ErrorClass, matcher)" do
+    it 'passes when the class and matcher match the raised error' do
+      expect { raise FooError, "food" }.to raise_error(FooError, a_string_including("foo"))
+    end
+
+    it 'fails with a clear message when the matcher does not match the raised error' do
+      expect {
+        expect { raise FooError, "food" }.to raise_error(FooError, a_string_including("bar"))
+      }.to fail_matching('expected FooError with a string including "bar", got #<FooError: food')
+    end
+
+    it 'provides a description' do
+      description = raise_error(FooError, a_string_including("foo")).description
+      expect(description).to eq('raise FooError with a string including "foo"')
+    end
+  end
+
+  describe "expect { }.to raise_error(ErrorClass).with_message(matcher)" do
+    it 'passes when the class and matcher match the raised error' do
+      expect { raise FooError, "food" }.to raise_error(FooError).with_message(a_string_including("foo"))
+    end
+
+    it 'fails with a clear message when the matcher does not match the raised error' do
+      expect {
+        expect { raise FooError, "food" }.to raise_error(FooError).with_message(a_string_including("bar"))
+      }.to fail_matching('expected FooError with a string including "bar", got #<FooError: food')
+    end
+
+    it 'provides a description' do
+      description = raise_error(FooError).with_message(a_string_including("foo")).description
+      expect(description).to eq('raise FooError with a string including "foo"')
+    end
+  end
+end