rspec-expectations 3.0.0.beta2 → 3.0.0.rc1

data/spec/rspec/matchers/legacy_spec.rb

@@ -1,101 +0,0 @@
-require 'spec_helper'
-
-module RSpec
-  module Matchers
-    describe "Legacy matchers" do
-      shared_examples_for "a matcher written against a legacy protocol" do |matcher_class|
-        matcher = matcher_class.new
-        before { allow_deprecation }
-
-        backwards_compat_matcher = Class.new(matcher_class) do
-          def failure_message; "failure when positive"; end
-          def failure_message_when_negated; "failure when negative"; end
-        end.new
-
-        it 'is still considered to be a matcher' do
-          expect(Matchers.is_a_matcher?(matcher)).to be true
-        end
-
-        context 'when matched positively' do
-          it 'returns the positive expectation failure message' do
-            expect {
-              expect(false).to matcher
-            }.to fail_with("failure when positive")
-          end
-
-          it 'warns about the deprecated protocol' do
-            expect_warn_deprecation_with_call_site(__FILE__, __LINE__ + 1, /legacy\s+RSpec\s+matcher/)
-            expect(true).to matcher
-          end
-
-          it 'does not warn when it also defines the current methods (i.e. to be compatible on multiple RSpec versions)' do
-            expect_no_deprecations
-
-            expect {
-              expect(false).to backwards_compat_matcher
-            }.to fail_with("failure when positive")
-          end
-        end
-
-        context 'when matched negatively' do
-          it 'returns the negative expectation failure message' do
-            expect {
-              expect(true).not_to matcher
-            }.to fail_with("failure when negative")
-          end
-
-          it 'warns about the deprecated protocol' do
-            expect_warn_deprecation_with_call_site(__FILE__, __LINE__ + 1, /legacy\s+RSpec\s+matcher/)
-            expect(false).not_to matcher
-          end
-
-          it 'does not warn when it also defines the current methods (i.e. to be compatible on multiple RSpec versions)' do
-            expect_no_deprecations
-
-            expect {
-              expect(true).not_to backwards_compat_matcher
-            }.to fail_with("failure when negative")
-          end
-
-          def pending_on_rbx
-            return unless defined?(RUBY_ENGINE) && RUBY_ENGINE == 'rbx'
-            pending "intermittently fails on RBX due to https://github.com/rubinius/rubinius/issues/2845"
-          end
-
-          it 'calls `does_not_match?` if it is defined on the matcher' do
-            pending_on_rbx
-
-            called = false
-            with_does_not_match = Class.new(matcher_class) do
-              define_method(:does_not_match?) { |actual| called = true; !actual }
-            end.new
-
-            expect(false).not_to with_does_not_match
-            expect(called).to be true
-          end
-        end
-      end
-
-      context "written using the RSpec 2.x `failure_message_for_should` and `failure_message_for_should_not` protocol" do
-        matcher_class = Class.new do
-          def matches?(actual); actual; end
-          def failure_message_for_should; "failure when positive"; end
-          def failure_message_for_should_not; "failure when negative"; end
-        end
-
-        it_behaves_like "a matcher written against a legacy protocol", matcher_class
-      end
-
-      context "written using the older `failure_message` and `negative_failure_message` protocol" do
-        matcher_class = Class.new do
-          def matches?(actual); actual; end
-          def failure_message; "failure when positive"; end
-          def negative_failure_message; "failure when negative"; end
-        end
-
-        it_behaves_like "a matcher written against a legacy protocol", matcher_class
-      end
-    end
-  end
-end
-

data/spec/rspec/matchers_spec.rb

@@ -1,74 +0,0 @@
-require 'spec_helper'
-
-main = self
-describe RSpec::Matchers do
-  include ::RSpec::Support::InSubProcess
-
-  it 'can be mixed into `main`' do
-    in_sub_process do
-      main.instance_eval do
-        include RSpec::Matchers
-        expect(3).to eq(3)
-        expect(3).to be_odd
-
-        expect {
-          expect(4).to be_zero
-        }.to fail_with("expected zero? to return true, got false")
-      end
-    end
-  end
-end
-
-module RSpec
-  module Matchers
-    describe "built in matchers" do
-      let(:matchers) do
-        BuiltIn.constants.map { |n| BuiltIn.const_get(n) }.select do |m|
-          m.method_defined?(:matches?) && m.method_defined?(:failure_message)
-        end
-      end
-
-      specify "they all have defined #=== so they can be composable" do
-        missing_threequals = matchers.select do |m|
-          m.instance_method(:===).owner == ::Kernel
-        end
-
-        # This spec is merely to make sure we don't forget to make
-        # a built-in matcher implement `===`. It doesn't check the
-        # semantics of that. Use the "an RSpec matcher" shared
-        # example group to actually check the semantics.
-        expect(missing_threequals).to eq([])
-      end
-
-      specify "they all have defined #and and #or so they support compound expectations" do
-        noncompound_matchers = matchers.reject do |m|
-          m.method_defined?(:and) || m.method_defined?(:or)
-        end
-
-        expect(noncompound_matchers).to eq([])
-      end
-
-      shared_examples_for "a well-behaved method_missing hook" do
-        include MinitestIntegration
-
-        it "raises a NoMethodError (and not SystemStackError) for an undefined method" do
-          with_minitest_loaded do
-            expect { subject.some_undefined_method }.to raise_error(NoMethodError)
-          end
-        end
-      end
-
-      describe "RSpec::Matchers method_missing hook" do
-        subject { self }
-
-        it_behaves_like "a well-behaved method_missing hook"
-
-        context 'when invoked in a Minitest::Test' do
-          subject { Minitest::Test.allocate }
-          it_behaves_like "a well-behaved method_missing hook"
-        end
-      end
-    end
-  end
-end
-

data/spec/spec_helper.rb

@@ -1,85 +0,0 @@
-require 'rspec/support/spec'
-
-RSpec::Support::Spec.setup_simplecov do
-  minimum_coverage 97
-end
-
-Dir['./spec/support/**/*'].each {|f| require f}
-
-module FormattingSupport
-  def dedent(string)
-    string.gsub(/^\s+\|/, '').chomp
-  end
-end
-
-RSpec::configure do |config|
-  config.color_enabled = true
-  config.order = :random
-
-  config.include FormattingSupport
-
-  config.expect_with :rspec do |expectations|
-    $default_expectation_syntax = expectations.syntax
-    expectations.syntax = :expect
-  end
-
-  config.mock_with :rspec do |mocks|
-    mocks.syntax = :expect
-  end
-end
-
-shared_context "with #should enabled", :uses_should do
-  orig_syntax = nil
-
-  before(:all) do
-    orig_syntax = RSpec::Matchers.configuration.syntax
-    RSpec::Matchers.configuration.syntax = [:expect, :should]
-  end
-
-  after(:all) do
-    RSpec::Matchers.configuration.syntax = orig_syntax
-  end
-end
-
-shared_context "with the default expectation syntax" do
-  orig_syntax = nil
-
-  before(:all) do
-    orig_syntax = RSpec::Matchers.configuration.syntax
-    RSpec::Matchers.configuration.reset_syntaxes_to_default
-  end
-
-  after(:all) do
-    RSpec::Matchers.configuration.syntax = orig_syntax
-  end
-
-end
-
-shared_context "with #should exclusively enabled", :uses_only_should do
-  orig_syntax = nil
-
-  before(:all) do
-    orig_syntax = RSpec::Matchers.configuration.syntax
-    RSpec::Matchers.configuration.syntax = :should
-  end
-
-  after(:all) do
-    RSpec::Matchers.configuration.syntax = orig_syntax
-  end
-end
-
-require 'rspec/support/spec/in_sub_process'
-module MinitestIntegration
-  include ::RSpec::Support::InSubProcess
-
-  def with_minitest_loaded
-    in_sub_process do
-      with_isolated_stderr do
-        require 'minitest/autorun'
-      end
-
-      require 'rspec/expectations/minitest_integration'
-      yield
-    end
-  end
-end

data/spec/support/matchers.rb

@@ -1,22 +0,0 @@
-RSpec::Matchers.define :include_method do |expected|
-  match do |actual|
-    actual.map { |m| m.to_s }.include?(expected.to_s)
-  end
-end
-
-module RSpec
-  module Matchers
-    def fail
-      raise_error(RSpec::Expectations::ExpectationNotMetError)
-    end
-
-    def fail_with(message)
-      raise_error(RSpec::Expectations::ExpectationNotMetError, message)
-    end
-
-    def fail_matching(message)
-      raise_error(RSpec::Expectations::ExpectationNotMetError, /#{Regexp.escape(message)}/)
-    end
-  end
-end
-

data/spec/support/shared_examples.rb

@@ -1,35 +0,0 @@
-shared_examples_for "an RSpec matcher" do |options|
-  let(:valid_value)   { options.fetch(:valid_value) }
-  let(:invalid_value) { options.fetch(:invalid_value) }
-
-  it 'preserves the symmetric property of `==`' do
-    expect(matcher).to eq(matcher)
-    expect(matcher).not_to eq(valid_value)
-    expect(valid_value).not_to eq(matcher)
-  end
-
-  it 'matches a valid value when using #=== so it can be composed' do
-    expect(matcher).to be === valid_value
-  end
-
-  it 'does not match an invalid value when using #=== so it can be composed' do
-    expect(matcher).not_to be === invalid_value
-  end
-
-  matcher :always_passes do
-    match { true }
-  end
-
-  matcher :always_fails do
-    match { false }
-  end
-
-  it 'supports compound expectations by chaining `and`' do
-    expect(valid_value).to matcher.and always_passes
-  end
-
-  it 'supports compound expectations by chaining `or`' do
-    expect(valid_value).to matcher.or always_fails
-  end
-end
-