opal-rspec 0.4.3 → 0.5.0.beta1

data/rspec-support/spec/rspec/support/method_signature_verifier_spec.rb

@@ -0,0 +1,357 @@
+require 'rspec/support'
+require 'rspec/support/method_signature_verifier'
+
+module RSpec
+  module Support
+    describe 'verifying methods' do
+      let(:signature) { MethodSignature.new(test_method) }
+
+      def valid_non_kw_args?(arity)
+        described_class.new(signature, [nil] * arity).valid?
+      end
+
+      def valid?(*args)
+        described_class.new(signature, args).valid?
+      end
+
+      def error_description
+        described_class.new(signature, []).error_message[/Expected (.*),/, 1]
+      end
+
+      def error_for(*args)
+        described_class.new(signature, args).error_message
+      end
+
+      def signature_description
+        signature.description
+      end
+
+      shared_context 'a method verifier' do
+        describe 'with a method with arguments' do
+          def arity_two(x, y); end
+
+          let(:test_method) { method(:arity_two) }
+
+          it 'covers only the exact arity' do
+            expect(valid_non_kw_args?(1)).to eq(false)
+            expect(valid_non_kw_args?(2)).to eq(true)
+            expect(valid_non_kw_args?(3)).to eq(false)
+          end
+
+          it "allows matchers to be passed as arguments" do
+            expect(valid?(anything, anything)).to eq(true)
+          end
+
+          it 'does not treat a last-arg hash as kw args' do
+            expect(valid?(1, {})).to eq(true)
+          end
+
+          it 'describes the arity precisely' do
+            expect(error_description).to eq("2")
+          end
+
+          it 'mentions only the arity in the description' do
+            expect(signature_description).to eq("arity of 2")
+          end
+        end
+
+        describe 'a method with splat arguments' do
+          def arity_splat(_, *); end
+
+          let(:test_method) { method(:arity_splat) }
+
+          it 'covers a range from the lower bound upwards' do
+            expect(valid_non_kw_args?(0)).to eq(false)
+            expect(valid_non_kw_args?(1)).to eq(true)
+            expect(valid_non_kw_args?(2)).to eq(true)
+            expect(valid_non_kw_args?(3)).to eq(true)
+          end
+
+          it 'describes the arity with no upper bound' do
+            expect(error_description).to eq("1 or more")
+          end
+
+          it 'mentions only the arity in the description' do
+            expect(signature_description).to eq("arity of 1 or more")
+          end
+        end
+
+        describe 'a method with optional arguments' do
+          def arity_optional(x, y, z = 1); end
+
+          let(:test_method) { method(:arity_optional) }
+
+          it 'covers a range from min to max possible arguments' do
+            expect(valid_non_kw_args?(1)).to eq(false)
+            expect(valid_non_kw_args?(2)).to eq(true)
+            expect(valid_non_kw_args?(3)).to eq(true)
+
+            if RubyFeatures.optional_and_splat_args_supported?
+              expect(valid_non_kw_args?(4)).to eq(false)
+            else
+              expect(valid_non_kw_args?(4)).to eq(true)
+            end
+          end
+
+          if RubyFeatures.optional_and_splat_args_supported?
+            it 'describes the arity as a range' do
+              expect(error_description).to eq("2 to 3")
+            end
+          else
+            it 'describes the arity with no upper bound' do
+              expect(error_description).to eq("2 or more")
+            end
+          end
+        end
+
+        if RubyFeatures.kw_args_supported?
+          describe 'a method with optional keyword arguments' do
+            eval <<-RUBY
+              def arity_kw(x, y:1, z:2); end
+            RUBY
+
+            let(:test_method) { method(:arity_kw) }
+
+            it 'does not require any of the arguments' do
+              expect(valid?(nil)).to eq(true)
+              expect(valid?(nil, nil)).to eq(false)
+            end
+
+            it 'does not allow an invalid keyword arguments' do
+              expect(valid?(nil, :a => 1)).to eq(false)
+            end
+
+            it 'mentions the invalid keyword args in the error', :pending => RUBY_ENGINE == 'jruby' do
+              expect(error_for(nil, :a => 0, :b => 1)).to \
+                eq("Invalid keyword arguments provided: a, b")
+            end
+
+            it 'describes invalid arity precisely' do
+              expect(error_for()).to \
+                eq("Wrong number of arguments. Expected 1, got 0.")
+            end
+
+            it 'does not blow up when given a BasicObject as the last arg' do
+              expect(valid?(BasicObject.new)).to eq(true)
+            end
+
+            it 'does not mutate the provided args array' do
+              args = [nil, { :y => 1 }]
+              described_class.new(signature, args).valid?
+              expect(args).to eq([nil, { :y => 1 }])
+            end
+
+            it 'mentions the arity and optional kw args in the description', :pending => RUBY_ENGINE == 'jruby' do
+              expect(signature_description).to eq("arity of 1 and optional keyword args (:y, :z)")
+            end
+          end
+        end
+
+        if RubyFeatures.required_kw_args_supported?
+          describe 'a method with required keyword arguments' do
+            eval <<-RUBY
+              def arity_required_kw(x, y:, z:, a: 'default'); end
+            RUBY
+
+            let(:test_method) { method(:arity_required_kw) }
+
+            it 'returns false unless all required keywords args are present' do
+              expect(valid?(nil, :a => 0, :y => 1, :z => 2)).to eq(true)
+              expect(valid?(nil, :a => 0, :y => 1)).to eq(false)
+              expect(valid?(nil, nil, :a => 0, :y => 1, :z => 2)).to eq(false)
+              expect(valid?(nil, nil)).to eq(false)
+            end
+
+            it 'mentions the missing required keyword args in the error' do
+              expect(error_for(nil, :a => 0)).to \
+                eq("Missing required keyword arguments: y, z")
+            end
+
+            it 'is described precisely when arity is wrong' do
+              expect(error_for(nil, nil, :z => 0, :y => 1)).to \
+                eq("Wrong number of arguments. Expected 1, got 2.")
+            end
+
+            it 'mentions the arity, optional kw args and required kw args in the description' do
+              expect(signature_description).to \
+                eq("arity of 1 and optional keyword args (:a) and required keyword args (:y, :z)")
+            end
+          end
+
+          describe 'a method with required keyword arguments and a splat' do
+            eval <<-RUBY
+              def arity_required_kw_splat(w, *x, y:, z:, a: 'default'); end
+            RUBY
+
+            let(:test_method) { method(:arity_required_kw_splat) }
+
+            it 'returns false unless all required keywords args are present' do
+              expect(valid?(nil, :a => 0, :y => 1, :z => 2)).to eq(true)
+              expect(valid?(nil, :a => 0, :y => 1)).to eq(false)
+              expect(valid?(nil, nil, :a => 0, :y => 1, :z => 2)).to eq(true)
+              expect(valid?(nil, nil, nil)).to eq(false)
+              expect(valid?).to eq(false)
+            end
+
+            it 'mentions missing required keyword args in the error' do
+              expect(error_for(nil, :y => 1)).to \
+                eq("Missing required keyword arguments: z")
+            end
+
+            it 'mentions the arity, optional kw args and required kw args in the description' do
+              expect(signature_description).to \
+                eq("arity of 1 or more and optional keyword args (:a) and required keyword args (:y, :z)")
+            end
+          end
+
+          describe 'a method with required keyword arguments and a keyword arg splat' do
+            eval <<-RUBY
+              def arity_kw_arg_splat(x:, **rest); end
+            RUBY
+
+            let(:test_method) { method(:arity_kw_arg_splat) }
+
+            it 'allows extra undeclared keyword args' do
+              expect(valid?(:x => 1)).to eq(true)
+              expect(valid?(:x => 1, :y => 2)).to eq(true)
+            end
+
+            it 'mentions missing required keyword args in the error' do
+              expect(error_for(:y => 1)).to \
+                eq("Missing required keyword arguments: x")
+            end
+
+            it 'mentions the required kw args and keyword splat in the description' do
+              expect(signature_description).to \
+                eq("required keyword args (:x) and any additional keyword args")
+            end
+          end
+
+          describe 'a method with a required arg and a keyword arg splat' do
+            eval <<-RUBY
+              def arity_kw_arg_splat(x, **rest); end
+            RUBY
+
+            let(:test_method) { method(:arity_kw_arg_splat) }
+
+            it 'allows a single arg and any number of keyword args' do
+              expect(valid?(nil)).to eq(true)
+              expect(valid?(nil, :x => 1)).to eq(true)
+              expect(valid?(nil, :x => 1, :y => 2)).to eq(true)
+              expect(valid?(:x => 1)).to eq(true)
+
+              expect(valid?).to eq(false)
+              expect(valid?(nil, nil)).to eq(false)
+              expect(valid?(nil, nil, :x => 1)).to eq(false)
+            end
+
+            it 'describes the arity precisely' do
+              expect(error_for()).to \
+                eq("Wrong number of arguments. Expected 1, got 0.")
+            end
+
+            it 'mentions the required kw args and keyword splat in the description' do
+              expect(signature_description).to \
+                eq("arity of 1 and any additional keyword args")
+            end
+          end
+        end
+
+        describe 'a method with a block' do
+          def arity_block(_, &block); end
+
+          let(:test_method) { method(:arity_block) }
+
+          it 'does not count the block as a parameter' do
+            expect(valid_non_kw_args?(1)).to eq(true)
+            expect(valid_non_kw_args?(2)).to eq(false)
+          end
+
+          it 'describes the arity precisely' do
+            expect(error_description).to eq("1")
+          end
+        end
+      end
+
+      let(:fake_matcher) { Object.new }
+      let(:fake_matcher_def) { lambda {|x| fake_matcher == x }}
+
+      before do
+        RSpec::Support.register_matcher_definition(&fake_matcher_def)
+      end
+
+      after do
+        RSpec::Support.deregister_matcher_definition(&fake_matcher_def)
+      end
+
+
+      describe StrictSignatureVerifier do
+        it_behaves_like 'a method verifier'
+
+        if RubyFeatures.kw_args_supported?
+          describe 'providing a matcher for optional keyword arguments' do
+            eval <<-RUBY
+              def arity_kw(x, y:1); end
+            RUBY
+
+            let(:test_method) { method(:arity_kw) }
+
+            it 'is not allowed' do
+              expect(valid?(nil, fake_matcher)).to eq(false)
+            end
+          end
+        end
+
+        if RubyFeatures.required_kw_args_supported?
+          describe 'providing a matcher for required keyword arguments' do
+            eval <<-RUBY
+              def arity_kw_required(x, y:); end
+            RUBY
+
+            let(:test_method) { method(:arity_kw_required) }
+
+            it 'is not allowed' do
+              expect(valid?(nil, fake_matcher)).to eq(false)
+            end
+          end
+        end
+      end
+
+      describe LooseSignatureVerifier do
+        it_behaves_like 'a method verifier'
+
+        if RubyFeatures.kw_args_supported?
+          describe 'for optional keyword arguments' do
+            eval <<-RUBY
+              def arity_kw(x, y:1, z:2); end
+            RUBY
+
+            let(:test_method) { method(:arity_kw) }
+
+            it 'allows a matcher' do
+              expect(valid?(nil, fake_matcher)).to eq(true)
+            end
+
+            it 'allows a matcher only for positional arguments' do
+              expect(valid?(fake_matcher)).to eq(true)
+            end
+          end
+        end
+
+        if RubyFeatures.required_kw_args_supported?
+          describe 'providing a matcher for required keyword arguments' do
+            eval <<-RUBY
+              def arity_kw_required(x, y:); end
+            RUBY
+
+            let(:test_method) { method(:arity_kw_required) }
+
+            it 'is allowed' do
+              expect(valid?(nil, fake_matcher)).to eq(true)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/rspec-support/spec/rspec/support/os_spec.rb

@@ -0,0 +1,36 @@
+require 'rspec/support/os'
+
+module RSpec
+  module Support
+    describe OS do
+
+      describe ".windows?" do
+        %w[cygwin mswin mingw bccwin wince emx].each do |fragment|
+          it "returns true when host os is #{fragment}" do
+            stub_const("RbConfig::CONFIG", 'host_os' => fragment)
+            expect(OS).to be_windows
+          end
+        end
+
+        %w[darwin linux].each do |fragment|
+          it "returns false when host os is #{fragment}" do
+            stub_const("RbConfig::CONFIG", 'host_os' => fragment)
+            expect(OS).to_not be_windows
+          end
+        end
+      end
+
+      describe ".windows_file_path?" do
+        it "returns true when the file alt seperator is a colon" do
+          stub_const("File::ALT_SEPARATOR", "\\") unless OS.windows?
+          expect(OS).to be_windows_file_path
+        end
+
+        it "returns false when file alt seperator is not present" do
+          stub_const("File::ALT_SEPARATOR", nil) if OS.windows?
+          expect(OS).to_not be_windows_file_path
+        end
+      end
+    end
+  end
+end

data/rspec-support/spec/rspec/support/recursive_const_methods_spec.rb

@@ -0,0 +1,49 @@
+require 'rspec/support/recursive_const_methods'
+
+module RSpec
+  module Support
+    describe RecursiveConstMethods do
+      include described_class
+
+      module Foo
+        class Parent
+          UNDETECTED = 'Not seen when looking up constants in Bar'
+        end
+
+        class Bar < Parent
+          VAL = 10
+        end
+      end
+
+      describe '#recursive_const_defined?' do
+        it 'finds constants' do
+          const, _name = recursive_const_defined?('::RSpec::Support::Foo::Bar::VAL')
+
+          expect(const).to eq(10)
+        end
+
+        it 'returns the fully qualified name of the constant' do
+          _const, name = recursive_const_defined?('::RSpec::Support::Foo::Bar::VAL')
+
+          expect(name).to eq('RSpec::Support::Foo::Bar::VAL')
+        end
+
+        it 'does not find constants in ancestors' do
+          expect(recursive_const_defined?('::RSpec::Support::Foo::Bar::UNDETECTED')).to be_falsy
+        end
+      end
+
+      describe '#recursive_const_get' do
+        it 'gets constants' do
+          expect(recursive_const_get('::RSpec::Support::Foo::Bar::VAL')).to eq(10)
+        end
+
+        it 'does not get constants in ancestors' do
+          expect do
+            recursive_const_get('::RSpec::Support::Foo::Bar::UNDETECTED')
+          end.to raise_error(NameError)
+        end
+      end
+    end
+  end
+end

data/rspec-support/spec/rspec/support/spec/in_sub_process_spec.rb

@@ -0,0 +1,36 @@
+require 'rspec/support/spec/in_sub_process'
+
+describe 'isolating code to a sub process' do
+  include RSpec::Support::InSubProcess
+
+  it 'isolates the block from the main process' do
+    in_sub_process do
+      module NotIsolated
+      end
+      expect(defined? NotIsolated).to eq "constant"
+    end
+    expect(defined? NotIsolated).to be_nil
+  end
+
+  if Process.respond_to?(:fork) && !(RUBY_PLATFORM == 'java' && RUBY_VERSION == '1.8.7')
+
+    it 'captures and reraises errors to the main process' do
+      expect {
+        in_sub_process { raise "An Internal Error" }
+      }.to raise_error "An Internal Error"
+    end
+
+    it 'captures and reraises test failures' do
+      expect {
+        in_sub_process { expect(true).to be false }
+      }.to raise_error(/expected false/)
+    end
+
+  else
+
+    it 'pends the block' do
+      expect { in_sub_process { true } }.to raise_error(/This spec requires forking to work properly/)
+    end
+
+  end
+end

data/rspec-support/spec/rspec/support/spec/prevent_load_time_warnings_spec.rb

@@ -0,0 +1,10 @@
+require 'rspec/support/spec/prevent_load_time_warnings'
+
+RSpec.describe RSpec::Support::WarningsPrevention do
+  include described_class
+
+  it 'finds all the files for the named lib and extracts the portion to require' do
+    files = files_to_require_for("rspec-support")
+    expect(files).to include("rspec/support", "rspec/support/spec/prevent_load_time_warnings")
+  end
+end

data/rspec-support/spec/rspec/support/spec/shell_out_spec.rb

@@ -0,0 +1,44 @@
+require 'rspec/support/spec/shell_out'
+
+RSpec.describe RSpec::Support::ShellOut, :slow do
+  include described_class
+
+  it 'shells out and returns stdout and stderr' do
+    stdout, stderr, _ = shell_out("ruby", "-e", "$stdout.print 'yes'; $stderr.print 'no'")
+    expect(stdout).to eq("yes")
+    expect(stderr).to eq("no")
+  end
+
+  it 'returns the exit status as the third argument' do
+    _, _, good_status = shell_out("ruby", "-e", '3 + 3')
+    expect(good_status.exitstatus).to eq(0)
+
+    unless RUBY_VERSION.to_f < 1.9 # except 1.8...
+      _, _, bad_status = shell_out("ruby", "-e", 'boom')
+      expect(bad_status.exitstatus).to eq(1)
+    end
+  end
+
+  it 'can shell out to ruby with the current load path' do
+    out, err, status = run_ruby_with_current_load_path('puts $LOAD_PATH.sort.join("\n")')
+    expect(err).to eq("")
+    expect(out).to include(*$LOAD_PATH.first(10))
+    expect(status.exitstatus).to eq(0)
+  end
+
+  it 'passes along the provided ruby flags' do
+    out, err, status = run_ruby_with_current_load_path('puts "version"', '-v')
+    expect(out).to include('version', RUBY_DESCRIPTION)
+    expect(err).to eq('')
+    expect(status.exitstatus).to eq(0)
+  end
+
+  it 'filters out the annoying output issued by `ruby -w` when the GC ENV vars are set' do
+    with_env 'RUBY_GC_HEAP_FREE_SLOTS' => '10001', 'RUBY_GC_MALLOC_LIMIT' => '16777217', 'RUBY_FREE_MIN' => '10001' do
+      out, err, status = run_ruby_with_current_load_path('', '-w')
+      expect(out).to eq('')
+      expect(err).to eq('')
+      expect(status.exitstatus).to eq(0)
+    end
+  end
+end

data/rspec-support/spec/rspec/support/spec/stderr_splitter_spec.rb

@@ -0,0 +1,60 @@
+require 'rspec/support/spec/stderr_splitter'
+
+describe 'RSpec::Support::StdErrSplitter' do
+
+  let(:splitter) { RSpec::Support::StdErrSplitter.new stderr }
+  let(:stderr)   { STDERR }
+
+  before do
+    allow(stderr).to receive(:write)
+  end
+
+  around do |example|
+    original = $stderr
+    $stderr = splitter
+
+    example.run
+
+    $stderr = original
+  end
+
+  it 'conforms to the stderr interface' do
+    expect(splitter).to respond_to(*stderr.methods)
+  end
+
+  it 'acknowledges its own interface' do
+    expect(splitter).to respond_to :==, :write, :has_output?, :reset!, :verify_example!, :output
+  end
+
+  it 'behaves like stderr' do
+    splitter.write 'a warning'
+    expect(stderr).to have_received(:write)
+  end
+
+  it 'pretends to be stderr' do
+    expect(splitter).to eq stderr
+  end
+
+  it 'tracks when output to' do
+    splitter.write 'a warning'
+    expect(splitter).to have_output
+  end
+
+  it 'will ignore examples without a warning' do
+    splitter.verify_example! self
+  end
+
+  it 'will ignore examples after a reset a warning' do
+    warn 'a warning'
+    splitter.reset!
+    splitter.verify_example! self
+  end
+
+  unless defined?(RUBY_ENGINE) && RUBY_ENGINE == 'rbx'
+    it 'will fail an example which generates a warning' do
+      true unless @undefined
+      expect { splitter.verify_example! self }.to raise_error(/Warnings were generated:/)
+    end
+  end
+
+end

data/rspec-support/spec/rspec/support/spec/with_isolated_std_err_spec.rb

@@ -0,0 +1,21 @@
+require 'rspec/support/spec'
+
+describe 'isolating a spec from the stderr splitter' do
+  include RSpec::Support::WithIsolatedStdErr
+
+  it 'allows a spec to output a warning' do
+    with_isolated_stderr do
+      $stderr.puts "Imma gonna warn you"
+    end
+  end
+
+  it 'resets $stderr to its original value even if an error is raised' do
+    orig_stderr = $stderr
+
+    expect {
+      with_isolated_stderr { raise "boom" }
+    }.to raise_error("boom")
+
+    expect($stderr).to be(orig_stderr)
+  end
+end

data/rspec-support/spec/rspec/support/version_checker_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+require 'rspec/support/version_checker'
+
+module RSpec::Support
+  describe VersionChecker do
+    def check_version(*args)
+      VersionChecker.new(*args).check_version!
+    end
+
+    it 'raises an error if the major version is too low' do
+      expect { check_version('some_gem', '0.7.3', '1.0.0') }.to raise_error(LibraryVersionTooLowError)
+    end
+
+    it 'raises an error if the minor version is too low' do
+      expect { check_version('some_gem', '1.0.99', '1.1.3') }.to raise_error(LibraryVersionTooLowError)
+    end
+
+    it 'raises an error if the patch version is too low' do
+      expect { check_version('some_gem', '1.0.8', '1.0.10') }.to raise_error(LibraryVersionTooLowError)
+    end
+
+    it 'does not raise an error when the version is above the min version' do
+      check_version('some_gem', '2.0.0', '1.0.0')
+      check_version('some_gem', '1.2.0', '1.1.0')
+      check_version('some_gem', '1.1.3', '1.1.1')
+      check_version('some_gem', '1.1.3', '1.1.3')
+    end
+  end
+end