rspec-expectations 2.13.0 → 3.0.0

data/spec/rspec/matchers/equal_spec.rb

@@ -1,78 +0,0 @@
-require 'spec_helper'
-module RSpec
-  module Matchers
-    describe "equal" do
-      it_behaves_like "an RSpec matcher", :valid_value => :a, :invalid_value => :b do
-        let(:matcher) { equal(:a) }
-      end
-
-      def inspect_object(o)
-        "#<#{o.class}:#{o.object_id}> => #{o.inspect}"
-      end
-
-      it "matches when actual.equal?(expected)" do
-        expect(1).to equal(1)
-      end
-
-      it "does not match when !actual.equal?(expected)" do
-        expect("1").not_to equal("1")
-      end
-
-      it "describes itself" do
-        matcher = equal(1)
-        matcher.matches?(1)
-        expect(matcher.description).to eq "equal 1"
-      end
-
-      it "suggests the `eq` matcher on failure" do
-        expected, actual = "1", "1"
-        expect {
-          expect(actual).to equal(expected)
-        }.to fail_with <<-MESSAGE
-
-expected #{inspect_object(expected)}
-     got #{inspect_object(actual)}
-
-Compared using equal?, which compares object identity,
-but expected and actual are not the same object. Use
-`expect(actual).to eq(expected)` if you don't care about
-object identity in this example.
-
-MESSAGE
-      end
-
-      context "when using only `should`", :uses_only_should do
-        it "suggests the `eq` matcher on failure" do
-          expected, actual = "1", "1"
-          lambda {
-            actual.should equal(expected)
-          }.should fail_with <<-MESSAGE
-
-expected #{inspect_object(expected)}
-     got #{inspect_object(actual)}
-
-Compared using equal?, which compares object identity,
-but expected and actual are not the same object. Use
-`actual.should eq(expected)` if you don't care about
-object identity in this example.
-
-MESSAGE
-        end
-      end
-
-      it "provides message on #negative_failure_message" do
-        expected = actual = "1"
-        matcher = equal(expected)
-        matcher.matches?(actual)
-        expect(matcher.failure_message_for_should_not).to eq <<-MESSAGE
-
-expected not #{inspect_object(expected)}
-         got #{inspect_object(actual)}
-
-Compared using equal?, which compares object identity.
-
-MESSAGE
-      end
-    end
-  end
-end

data/spec/rspec/matchers/exist_spec.rb

@@ -1,124 +0,0 @@
-require 'spec_helper'
-require 'ostruct'
-
-describe "exist matcher" do
-  it_behaves_like "an RSpec matcher", :valid_value => OpenStruct.new(:exist? => true),
-                                      :invalid_value => OpenStruct.new(:exist? => false) do
-    let(:matcher) { exist }
-  end
-
-  context "when the object does not respond to #exist? or #exists?" do
-    subject { mock }
-
-    [:to, :not_to].each do |expect_method|
-      describe "expect(...).#{expect_method} exist" do
-        it "raises an error" do
-          expect {
-            expect(subject).send(expect_method, exist)
-          }.to raise_error(NoMethodError)
-        end
-      end
-    end
-  end
-
-  [:exist?, :exists?].each do |predicate|
-    context "when the object responds to ##{predicate}" do
-      describe "expect(...).to exist" do
-        it "passes if #{predicate}" do
-          expect(mock(predicate => true)).to exist
-        end
-
-        it "fails if not #{predicate}" do
-          expect {
-            expect(mock(predicate => false)).to exist
-          }.to fail_with(/expected .* to exist/)
-        end
-
-        it 'works when the object overrides `send`' do
-          klass = Struct.new(:message) do
-            def send
-              :message_sent
-            end
-
-            define_method predicate do
-              true
-            end
-          end
-
-          expect(klass.new("msg")).to exist
-        end
-      end
-
-      describe "expect(...).not_to exist" do
-        it "passes if not #{predicate}" do
-          expect(mock(predicate => false)).not_to exist
-        end
-
-        it "fails if #{predicate}" do
-          expect {
-            expect(mock(predicate => true)).not_to exist
-          }.to fail_with(/expected .* not to exist/)
-        end
-      end
-    end
-  end
-
-  context "when the object responds to #exist? and #exists?" do
-    context "when they both return falsey values" do
-      subject { mock(:exist? => false, :exists? => nil) }
-
-      describe "expect(...).not_to exist" do
-        it "passes" do
-          expect(subject).not_to exist
-        end
-      end
-
-      describe "expect(...).to exist" do
-        it "fails" do
-          expect {
-            expect(subject).to exist
-          }.to fail_with(/expected .* to exist/)
-        end
-      end
-    end
-
-    context "when they both return truthy values" do
-      subject { mock(:exist? => true, :exists? => "something true") }
-
-      describe "expect(...).not_to exist" do
-        it "fails" do
-          expect {
-            expect(subject).not_to exist
-          }.to fail_with(/expected .* not to exist/)
-        end
-      end
-
-      describe "expect(...).to exist" do
-        it "passes" do
-          expect(subject).to exist
-        end
-      end
-    end
-
-    context "when they return values with different truthiness" do
-      subject { mock(:exist? => true, :exists? => false) }
-
-      [:to, :not_to].each do |expect_method|
-        describe "expect(...).#{expect_method} exist" do
-          it "raises an error" do
-            expect {
-              expect(subject).send(expect_method, exist)
-            }.to raise_error(/#exist\? and #exists\? returned different values/)
-          end
-        end
-      end
-    end
-  end
-
-  it 'passes any provided arguments to the call to #exist?' do
-    object = mock
-    object.should_receive(:exist?).with(:foo, :bar) { true }
-
-    expect(object).to exist(:foo, :bar)
-  end
-end

data/spec/rspec/matchers/has_spec.rb

@@ -1,122 +0,0 @@
-require 'spec_helper'
-
-describe "expect(...).to have_sym(*args)" do
-  it_behaves_like "an RSpec matcher", :valid_value => { :a => 1 },
-                                      :invalid_value => {} do
-    let(:matcher) { have_key(:a) }
-  end
-
-  it "passes if #has_sym?(*args) returns true" do
-    expect({:a => "A"}).to have_key(:a)
-  end
-
-  it "fails if #has_sym?(*args) returns false" do
-    expect {
-      expect({:b => "B"}).to have_key(:a)
-    }.to fail_with("expected #has_key?(:a) to return true, got false")
-  end
-
-  it 'does not include any args in the failure message if no args were given to the matcher' do
-    o = Object.new
-    def o.has_some_stuff?; false; end
-    expect {
-      expect(o).to have_some_stuff
-    }.to fail_with("expected #has_some_stuff? to return true, got false")
-  end
-
-  it 'includes multiple args in the failure message if multiple args were given to the matcher' do
-    o = Object.new
-    def o.has_some_stuff?(*_); false; end
-    expect {
-      expect(o).to have_some_stuff(:a, 7, "foo")
-    }.to fail_with('expected #has_some_stuff?(:a, 7, "foo") to return true, got false')
-  end
-
-  it "fails if #has_sym?(*args) returns nil" do
-    klass = Class.new do
-      def has_foo?
-      end
-    end
-    expect {
-      expect(klass.new).to have_foo
-    }.to fail_with(/expected #has_foo.* to return true, got false/)
-  end
-
-  it "fails if target does not respond to #has_sym?" do
-    expect {
-      expect(Object.new).to have_key(:a)
-    }.to raise_error(NoMethodError)
-  end
-
-  it "reraises an exception thrown in #has_sym?(*args)" do
-    o = Object.new
-    def o.has_sym?(*args)
-      raise "Funky exception"
-    end
-    expect {
-      expect(o).to have_sym(:foo)
-    }.to raise_error("Funky exception")
-  end
-end
-
-describe "expect(...).not_to have_sym(*args)" do
-  it "passes if #has_sym?(*args) returns false" do
-    expect({:a => "A"}).not_to have_key(:b)
-  end
-
-  it "passes if #has_sym?(*args) returns nil" do
-    klass = Class.new do
-      def has_foo?
-      end
-    end
-    expect(klass.new).not_to have_foo
-  end
-
-  it "fails if #has_sym?(*args) returns true" do
-    expect {
-      expect({:a => "A"}).not_to have_key(:a)
-    }.to fail_with("expected #has_key?(:a) to return false, got true")
-  end
-
-  it "fails if target does not respond to #has_sym?" do
-    expect {
-      expect(Object.new).to have_key(:a)
-    }.to raise_error(NoMethodError)
-  end
-
-  it "reraises an exception thrown in #has_sym?(*args)" do
-    o = Object.new
-    def o.has_sym?(*args)
-      raise "Funky exception"
-    end
-    expect {
-      expect(o).not_to have_sym(:foo)
-    }.to raise_error("Funky exception")
-  end
-
-  it 'does not include any args in the failure message if no args were given to the matcher' do
-    o = Object.new
-    def o.has_some_stuff?; true; end
-    expect {
-      expect(o).not_to have_some_stuff
-    }.to fail_with("expected #has_some_stuff? to return false, got true")
-  end
-
-  it 'includes multiple args in the failure message if multiple args were given to the matcher' do
-    o = Object.new
-    def o.has_some_stuff?(*_); true; end
-    expect {
-      expect(o).not_to have_some_stuff(:a, 7, "foo")
-    }.to fail_with('expected #has_some_stuff?(:a, 7, "foo") to return false, got true')
-  end
-end
-
-describe "has" do
-  it "works when the target implements #send" do
-    o = {:a => "A"}
-    def o.send(*args); raise "DOH! Library developers shouldn't use #send!" end
-    expect {
-      expect(o).to have_key(:a)
-    }.to_not raise_error
-  end
-end