opal-connect-rspec 0.5.0

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

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

@@ -0,0 +1,66 @@
+require "spec_helper"
+require "rspec/support/warnings"
+require 'rspec/support/spec/shell_out'
+
+describe "rspec warnings and deprecations" do
+  include RSpec::Support::ShellOut
+  let(:warning_object) do
+    Object.new.tap { |o| o.extend(RSpec::Support::Warnings) }
+  end
+
+  it 'works when required in isolation' do
+    out, err, status = run_ruby_with_current_load_path("RSpec.deprecate('foo')", "-rrspec/support/warnings")
+    expect(out).to eq("")
+    expect(err).to start_with("DEPRECATION: foo is deprecated")
+    expect(status.exitstatus).to eq(0)
+  end
+
+  context "when rspec-core is not available" do
+    shared_examples "falling back to Kernel.warn" do |args|
+      let(:method_name) { args.fetch(:method_name) }
+
+      it 'falls back to warning with a plain message' do
+        expect(::Kernel).to receive(:warn).with(/message/)
+        warning_object.send(method_name, 'message')
+      end
+
+      it "handles being passed options" do
+        expect(::Kernel).to receive(:warn).with(/message/)
+        warning_object.send(method_name, "this is the message", :type => :test)
+      end
+    end
+
+    it_behaves_like 'falling back to Kernel.warn', :method_name => :deprecate
+    it_behaves_like 'falling back to Kernel.warn', :method_name => :warn_deprecation
+  end
+
+  shared_examples "warning helper" do |helper|
+    it 'warns with the message text' do
+      expect(::Kernel).to receive(:warn).with(/Message/)
+      warning_object.send(helper, 'Message')
+    end
+
+    it 'sets the calling line' do
+      expect(::Kernel).to receive(:warn).with(/#{__FILE__}:#{__LINE__+1}/)
+      warning_object.send(helper, 'Message')
+    end
+
+    it 'optionally sets the replacement' do
+      expect(::Kernel).to receive(:warn).with(/Use Replacement instead./)
+      warning_object.send(helper, 'Message', :replacement => 'Replacement')
+    end
+  end
+
+  describe "#warning" do
+    it 'prepends WARNING:' do
+      expect(::Kernel).to receive(:warn).with(/WARNING: Message\./)
+      warning_object.warning 'Message'
+    end
+
+    it_should_behave_like 'warning helper', :warning
+  end
+
+  describe "#warn_with message, options" do
+    it_should_behave_like 'warning helper', :warn_with
+  end
+end

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

@@ -0,0 +1,119 @@
+require 'rspec/support'
+require 'rspec/support/spec/prevent_load_time_warnings'
+
+module RSpec
+  describe Support do
+    extend Support::RubyFeatures
+
+    it_behaves_like "a library that issues no warnings when loaded", "rspec-support",
+      # Define methods that some of our rspec/support/spec files use at load time.
+      "module RSpec; def self.configure; end; def self.shared_context(*); end; def self.shared_examples_for(*); end; end",
+      'require "rspec/support"'
+
+    describe '.method_handle_for(object, method_name)' do
+      untampered_class = Class.new do
+        def foo
+          :bar
+        end
+      end
+
+      http_request_class = Struct.new(:method, :uri)
+
+      proxy_class = Struct.new(:original) do
+        undef :=~, :method
+        def method_missing(name, *args, &block)
+          original.__send__(name, *args, &block)
+        end
+      end
+
+      it 'fetches method definitions for vanilla objects' do
+        object = untampered_class.new
+        expect(Support.method_handle_for(object, :foo).call).to eq :bar
+      end
+
+      it 'fetches method definitions for objects with method redefined' do
+        request = http_request_class.new(:get, "http://foo.com/")
+        expect(Support.method_handle_for(request, :uri).call).to eq "http://foo.com/"
+      end
+
+      it 'fetches method definitions for proxy objects' do
+        object = proxy_class.new([])
+        expect(Support.method_handle_for(object, :=~)).to be_a Method
+      end
+
+      it 'fetches method definitions for proxy objects' do
+        object = proxy_class.new([])
+        expect(Support.method_handle_for(object, :=~)).to be_a Method
+      end
+
+      it 'fails with `NameError` when an undefined method is fetched ' +
+         'from an object that has overriden `method` to raise an Exception' do
+        object = double
+        allow(object).to receive(:method).and_raise(Exception)
+        expect {
+          Support.method_handle_for(object, :some_undefined_method)
+        }.to raise_error(NameError)
+      end
+
+      it 'fails with `NameError` when a method is fetched from an object ' +
+         'that has overriden `method` to not return a method' do
+        object = proxy_class.new(double(:method => :baz))
+        expect {
+          Support.method_handle_for(object, :=~)
+        }.to raise_error(NameError)
+      end
+
+      context "for a BasicObject subclass", :if => RUBY_VERSION.to_f > 1.8 do
+        let(:basic_class) do
+          Class.new(BasicObject) do
+            def foo
+              :bar
+            end
+          end
+        end
+
+        let(:basic_class_with_method_override) do
+          Class.new(basic_class) do
+            def method
+              :method
+            end
+          end
+        end
+
+        let(:basic_class_with_kernel) do
+          Class.new(basic_class) do
+            include ::Kernel
+          end
+        end
+
+        let(:basic_class_with_proxying) do
+          Class.new(BasicObject) do
+            def method_missing(name, *args, &block)
+              "foo".__send__(name, *args, &block)
+            end
+          end
+        end
+
+        it 'still works', :if => supports_rebinding_module_methods? do
+          object = basic_class.new
+          expect(Support.method_handle_for(object, :foo).call).to eq :bar
+        end
+
+        it 'works when `method` has been overriden', :if => supports_rebinding_module_methods? do
+          object = basic_class_with_method_override.new
+          expect(Support.method_handle_for(object, :foo).call).to eq :bar
+        end
+
+        it 'allows `method` to be proxied', :unless => supports_rebinding_module_methods? do
+          object = basic_class_with_proxying.new
+          expect(Support.method_handle_for(object, :reverse).call).to eq "oof"
+        end
+
+        it 'still works when Kernel has been mixed in' do
+          object = basic_class_with_kernel.new
+          expect(Support.method_handle_for(object, :foo).call).to eq :bar
+        end
+      end
+    end
+  end
+end