opal-rspec 0.4.3 → 0.5.0.beta1

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
+

data/rspec-mocks/benchmarks/double_creation.rb

@@ -0,0 +1,66 @@
+$LOAD_PATH.unshift(File.expand_path("../../lib", __FILE__))
+
+require 'benchmark'
+require 'rspec/mocks'
+
+n = 1000
+
+puts "#{n} times - ruby #{RUBY_VERSION}"
+puts
+
+Benchmark.bm do |bm|
+  RSpec::Mocks.setup(self)
+
+  (0..9).each do |m|
+    attrs = m.times.inject({}) {|h, x|
+      h["method_#{x}"] = x
+      h
+    }
+
+    bm.report("#{m} attrs") do
+      n.times do
+        double(attrs)
+      end
+    end
+  end
+end
+# $ export OLD_REV=d483e0a893d97c7b8e612e878a9f3562a210df9f
+# $ git checkout $OLD_REV
+# $ ruby benchmarks/double_creation.rb
+# 1000 times - ruby 2.0.0
+#
+#           user     system      total        real
+#    0 attrs  0.010000   0.000000   0.010000 (  0.003686)
+#    1 attrs  0.110000   0.000000   0.110000 (  0.143132)
+#    2 attrs  0.230000   0.010000   0.240000 (  0.311358)
+#    3 attrs  0.400000   0.020000   0.420000 (  0.465994)
+#    4 attrs  0.570000   0.010000   0.580000 (  0.597902)
+#    5 attrs  0.920000   0.010000   0.930000 (  1.060219)
+#    6 attrs  1.350000   0.020000   1.370000 (  1.388386)
+#    7 attrs  1.770000   0.030000   1.800000 (  1.805518)
+#    8 attrs  2.620000   0.030000   2.650000 (  2.681484)
+#    9 attrs  3.320000   0.030000   3.350000 (  3.380757)
+#
+# $ export NEW_REV=13e9d11542a6b60c5dc7ffa4527c98bb255d0a1f
+# $ git checkout $NEW_REV
+# $ ruby benchmarks/double_creation.rb
+# 1000 times - ruby 2.0.0
+#
+#             user     system      total        real
+#    0 attrs  0.010000   0.000000   0.010000 (  0.001544)
+#    1 attrs  0.040000   0.000000   0.040000 (  0.043522)
+#    2 attrs  0.060000   0.000000   0.060000 (  0.081742)
+#    3 attrs  0.090000   0.010000   0.100000 (  0.104526)
+#    4 attrs  0.120000   0.010000   0.130000 (  0.132472)
+#    5 attrs  0.150000   0.010000   0.160000 (  0.162368)
+#    6 attrs  0.190000   0.010000   0.200000 (  0.204610)
+#    7 attrs  0.220000   0.010000   0.230000 (  0.237983)
+#    8 attrs  0.260000   0.010000   0.270000 (  0.281562)
+#    9 attrs  0.310000   0.020000   0.330000 (  0.334489)
+#
+# $ git log $OLD_REV..$NEW_REV --oneline
+# 13e9d11 Remove unused arguments from simple stub interface.
+# 009a697 Extract CallerFilter class to unify caller manipulation.
+# 46c1eb0 Introduce "simple" stub as an optimization over using a normal stub.
+# 4a04b3e Extract constant ArgumentListMatcher::MATCH_ALL.
+# 860d591 Speed up double creation with multiple attributes by caching caller.

data/rspec-mocks/benchmarks/each_value_v_values_each.rb

@@ -0,0 +1,58 @@
+require 'benchmark'
+
+n = 10000
+
+m = 1.upto(1000).reduce({}) {|m, i| m[i] = i; m}
+
+Benchmark.benchmark do |bm|
+  puts "#{n} times - ruby #{RUBY_VERSION}"
+
+  puts
+  puts "each_value"
+
+  3.times do
+    bm.report do
+      n.times do
+        m.each_value {|v|}
+      end
+    end
+  end
+
+  puts
+  puts "values.each"
+
+  3.times do
+    bm.report do
+      n.times do
+        m.values.each{|v|}
+      end
+    end
+  end
+end
+
+# $ ruby benchmarks/values_each_v_each_value.rb
+#  10000 times - ruby 1.9.3
+#
+# each_value
+#    0.720000   0.000000   0.720000 (  0.720237)
+#    0.720000   0.000000   0.720000 (  0.724956)
+#    0.730000   0.000000   0.730000 (  0.730352)
+#
+# values.each
+#    0.910000   0.000000   0.910000 (  0.917496)
+#    0.910000   0.010000   0.920000 (  0.909319)
+#    0.910000   0.000000   0.910000 (  0.911225)
+
+
+# $ ruby benchmarks/values_each_v_each_value.rb
+# 10000 times - ruby 2.0.0
+#
+# each_value
+#    0.730000   0.000000   0.730000 (  0.738443)
+#    0.720000   0.000000   0.720000 (  0.720183)
+#    0.720000   0.000000   0.720000 (  0.720866)
+#
+# values.each
+#    0.940000   0.000000   0.940000 (  0.942597)
+#    0.960000   0.010000   0.970000 (  0.959248)
+#    0.960000   0.000000   0.960000 (  0.959099)

data/rspec-mocks/benchmarks/find_original_method_early.rb

@@ -0,0 +1,64 @@
+$LOAD_PATH.unshift "./lib"
+require 'rspec/mocks'
+require "rspec/mocks/standalone"
+
+=begin
+This benchmark script is for troubleshooting the performance of
+#264. To use it, you have to edit the code in #264 a bit:
+wrap the call in `MethodDouble#initialize` to `find_original_method`
+in a conditional like `if $find_original`.
+
+That allows the code below to compare the perf of stubbing a method
+with the original method being found vs. not.
+=end
+
+require 'benchmark'
+
+n = 10000
+
+Foo = Class.new(Object) do
+  n.times do |i|
+    define_method "meth_#{i}" do
+    end
+  end
+end
+
+Benchmark.bmbm do |bm|
+  puts "#{n} times - ruby #{RUBY_VERSION}"
+
+  perform_report = lambda do |label, find_original, &create_object|
+    dbl = create_object.call
+    $find_original = find_original
+
+    bm.report(label) do
+      n.times do |i|
+        dbl.stub("meth_#{i}")
+      end
+    end
+
+    RSpec::Mocks.space.reset_all
+  end
+
+  perform_report.call("Find original - partial mock", true) { Foo.new }
+  perform_report.call("Don't find original - partial mock", false) { Foo.new }
+  perform_report.call("Find original - test double", true) { double }
+  perform_report.call("Don't find original - test double", false) { double }
+end
+
+=begin
+
+10000 times - ruby 1.9.3
+Rehearsal ----------------------------------------------------------------------
+Don't find original - partial mock   1.050000   0.020000   1.070000 (  1.068561)
+Don't find original - test double    1.190000   0.010000   1.200000 (  1.199815)
+Find original - partial mock         1.270000   0.010000   1.280000 (  1.282944)
+Find original - test double          1.320000   0.020000   1.340000 (  1.336136)
+------------------------------------------------------------- total: 4.890000sec
+
+                                         user     system      total        real
+Don't find original - partial mock   0.990000   0.000000   0.990000 (  1.000959)
+Don't find original - test double    0.930000   0.010000   0.940000 (  0.931871)
+Find original - partial mock         1.040000   0.000000   1.040000 (  1.046354)
+Find original - test double          0.980000   0.010000   0.990000 (  0.983577)
+
+=end