opal-rspec 0.6.2 → 0.7.0.rc.1

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

@@ -1,104 +0,0 @@
-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

@@ -1,108 +0,0 @@
-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

@@ -1,94 +0,0 @@
-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

@@ -1,54 +0,0 @@
-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

@@ -1,101 +0,0 @@
-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
-