opal-connect-rspec 0.5.0

data/rspec-expectations/spec/rspec/matchers/legacy_spec.rb

@@ -0,0 +1,104 @@
+module RSpec
+  module Matchers
+    RSpec.describe "Legacy matchers" do
+      it 'still provides a `LegacyMacherAdapter` constant because 3.0 was released with ' +
+         'it and it would be a SemVer violation to remove it before 4.0' do
+        expect(Expectations::LegacyMacherAdapter).to be(Expectations::LegacyMatcherAdapter)
+      end
+
+      shared_examples "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/rspec-expectations/spec/rspec/matchers_spec.rb

@@ -0,0 +1,108 @@
+main = self
+RSpec.describe RSpec::Matchers do
+  include ::RSpec::Support::InSubProcess
+
+  describe ".configuration" do
+    it 'returns a memoized configuration instance' do
+      expect(RSpec::Matchers.configuration).to be_a(RSpec::Expectations::Configuration)
+      expect(RSpec::Matchers.configuration).to be(RSpec::Matchers.configuration)
+    end
+  end
+
+  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 `4.zero?` to return true, got false")
+      end
+    end
+  end
+end
+
+module RSpec
+  module Matchers
+    RSpec.describe ".is_a_matcher?" do
+      it 'does not match BasicObject', :if => RUBY_VERSION.to_f > 1.8 do
+        expect(RSpec::Matchers.is_a_matcher?(BasicObject.new)).to eq(false)
+      end
+
+      it 'is registered with RSpec::Support' do
+        expect(RSpec::Support.is_a_matcher?(be_even)).to eq(true)
+      end
+
+      it 'does not match a multi-element array' do
+        # our original implementation regsitered the matcher definition as
+        # `&RSpec::Matchers.method(:is_a_matcher?)`, which has a bug
+        # on 1.8.7:
+        #
+        # irb(main):001:0> def foo(x); end
+        # => nil
+        # irb(main):002:0> method(:foo).call([1, 2, 3])
+        # => nil
+        # irb(main):003:0> method(:foo).to_proc.call([1, 2, 3])
+        # ArgumentError: wrong number of arguments (3 for 1)
+        #   from (irb):1:in `foo'
+        #   from (irb):1:in `to_proc'
+        #   from (irb):3:in `call'
+        #
+        # This spec guards against a regression for that case.
+        expect(RSpec::Support.is_a_matcher?([1, 2, 3])).to eq(false)
+      end
+    end
+
+    RSpec.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 "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", :slow 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/rspec-expectations/spec/spec_helper.rb

@@ -0,0 +1,94 @@
+require 'rspec/support/spec'
+
+RSpec::Support::Spec.setup_simplecov do
+  minimum_coverage 97
+end
+
+Dir['./spec/support/**/*'].each do |f|
+  require f.sub(%r{\./spec/}, '')
+end
+
+module FormattingSupport
+  def dedent(string)
+    string.gsub(/^\s+\|/, '').chomp
+  end
+end
+
+RSpec::configure do |config|
+  config.color = true
+  config.order = :random
+
+  config.include FormattingSupport
+
+  config.expect_with :rspec do |expectations|
+    $default_expectation_syntax = expectations.syntax
+    expectations.syntax = :expect
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  config.disable_monkey_patching!
+end
+
+RSpec.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(:context) do
+    RSpec::Matchers.configuration.syntax = orig_syntax
+  end
+end
+
+RSpec.shared_context "with the default expectation syntax" do
+  orig_syntax = nil
+
+  before(:context) do
+    orig_syntax = RSpec::Matchers.configuration.syntax
+    RSpec::Matchers.configuration.reset_syntaxes_to_default
+  end
+
+  after(:context) do
+    RSpec::Matchers.configuration.syntax = orig_syntax
+  end
+
+end
+
+RSpec.shared_context "with #should exclusively enabled", :uses_only_should do
+  orig_syntax = nil
+
+  before(:context) do
+    orig_syntax = RSpec::Matchers.configuration.syntax
+    RSpec::Matchers.configuration.syntax = :should
+  end
+
+  after(:context) do
+    RSpec::Matchers.configuration.syntax = orig_syntax
+  end
+end
+
+RSpec.shared_context "isolate include_chain_clauses_in_custom_matcher_descriptions" do
+  around do |ex|
+    orig = RSpec::Expectations.configuration.include_chain_clauses_in_custom_matcher_descriptions?
+    ex.run
+    RSpec::Expectations.configuration.include_chain_clauses_in_custom_matcher_descriptions = orig
+  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/rspec-expectations/spec/support/matchers.rb

@@ -0,0 +1,54 @@
+RSpec::Matchers.define :include_method do |expected|
+  match do |actual|
+    actual.map { |m| m.to_s }.include?(expected.to_s)
+  end
+end
+
+RSpec::Matchers.define :custom_include do |*args|
+  match { |actual| expect(actual).to include(*args) }
+end
+
+RSpec::Matchers.define :be_a_clone_of do |expected|
+  match do |actual|
+    !actual.equal?(expected) &&
+        actual.class.equal?(expected.class) &&
+        state_of(actual) == state_of(expected)
+  end
+
+  def state_of(object)
+    ivar_names = object.instance_variables
+    Hash[ ivar_names.map { |n| [n, object.instance_variable_get(n)] } ]
+  end
+end
+
+RSpec::Matchers.define :have_string_length do |expected|
+  match do |actual|
+    @actual = actual
+    string_length == expected
+  end
+
+  def string_length
+    @string_length ||= @actual.length
+  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)
+      if String === message
+        regexp = /#{Regexp.escape(message)}/
+      else
+        regexp = message
+      end
+      raise_error(RSpec::Expectations::ExpectationNotMetError, regexp)
+    end
+  end
+end

data/rspec-expectations/spec/support/shared_examples.rb

@@ -0,0 +1,101 @@
+RSpec.shared_examples "an RSpec matcher" do |options|
+  let(:valid_value)   { options.fetch(:valid_value) }
+  let(:invalid_value) { options.fetch(:invalid_value) }
+
+  # Note: do not use `matcher` in 2 expectation expressions in a single
+  # example here. In some cases (such as `change { }.to(2)`), it will fail
+  # because using it a second time will apply `x += 2` twice, changing
+  # the value to 4.
+
+  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
+    supports_block_expectations
+    match do |actual|
+      actual.call if Proc === actual
+      true
+    end
+  end
+
+  matcher :always_fails do
+    supports_block_expectations
+    match do |actual|
+      actual.call if Proc === actual
+      false
+    end
+  end
+
+  it 'allows additional matchers to be chained off it using `and`' do
+    expect(valid_value).to matcher.and always_passes
+  end
+
+  it 'can be chained off of an existing matcher using `and`' do
+    expect(valid_value).to always_passes.and matcher
+  end
+
+  it 'allows additional matchers to be chained off it using `or`' do
+    expect(valid_value).to matcher.or always_fails
+  end
+
+  it 'can be chained off of an existing matcher using `or`' do
+    expect(valid_value).to always_fails.or matcher
+  end
+
+  it 'implements the full matcher protocol' do
+    expect(matcher).to respond_to(
+      :matches?,
+      :failure_message,
+      :description,
+      :supports_block_expectations?,
+      :expects_call_stack_jump?
+    )
+
+    # We do not require failure_message_when_negated and does_not_match?
+    # Because some matchers purposefully do not support negation.
+  end
+
+  it 'fails gracefully when given a value if it is a block matcher' do
+    if matcher.supports_block_expectations?
+      expect {
+        expect(3).to matcher
+      }.to fail_with(/was not( given)? a block/)
+
+      unless options[:disallows_negation]
+        expect {
+          expect(3).not_to matcher
+        }.to fail_with(/was not( given)? a block/)
+      end
+    end
+  end
+
+  it 'can be used in a composed matcher expression' do
+    expect([valid_value, invalid_value]).to include(matcher)
+
+    expect {
+      expect([invalid_value]).to include(matcher)
+    }.to fail_matching("include (#{matcher.description})")
+  end
+
+  it 'can match negatively properly' do
+    unless options[:disallows_negation]
+      expect(invalid_value).not_to matcher
+
+      expect {
+        expect(valid_value).not_to matcher
+      }.to fail
+    end
+  end
+end
+