opal-rspec 0.6.2 → 0.7.0.rc.1

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

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

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

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

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

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

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

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

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

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

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