rspec-core 3.0.0.beta2 → 3.0.0.rc1

data/spec/rspec/core/shared_example_group_spec.rb

@@ -1,114 +0,0 @@
-require 'spec_helper'
-require 'rspec/support/spec/in_sub_process'
-
-module RandomTopLevelModule
-  def self.setup!
-    RSpec.shared_examples_for("top level in module") {}
-  end
-end
-
-module RSpec::Core
-  RSpec.describe SharedExampleGroup do
-    include RSpec::Support::InSubProcess
-
-    ExampleModule = Module.new
-    ExampleClass = Class.new
-
-    it 'does not add a bunch of private methods to Module' do
-      seg_methods = RSpec::Core::SharedExampleGroup.private_instance_methods
-      expect(Module.private_methods & seg_methods).to eq([])
-    end
-
-    module SharedExampleGroup
-      RSpec.describe Registry do
-        it "can safely be reset when there aren't any shared groups" do
-          expect { Registry.new.clear }.to_not raise_error
-        end
-      end
-    end
-
-    before(:all) do
-      # this is a work around as SharedExampleGroup is not world safe
-      RandomTopLevelModule.setup!
-    end
-
-    %w[share_examples_for shared_examples_for shared_examples shared_context].each do |shared_method_name|
-      describe shared_method_name do
-        let(:group) { ExampleGroup.describe('example group') }
-
-        define_method :define_shared_group do |*args, &block|
-          group.send(shared_method_name, *args, &block)
-        end
-
-        it "is exposed to the global namespace when expose_dsl_globally is enabled" do
-          in_sub_process do
-            RSpec.configuration.expose_dsl_globally = true
-            expect(Kernel).to respond_to(shared_method_name)
-          end
-        end
-
-        it "is not exposed to the global namespace when monkey patching is disabled" do
-          expect(Kernel).to_not respond_to(shared_method_name)
-        end
-
-        it "displays a warning when adding a second shared example group with the same name" do
-          group.send(shared_method_name, 'some shared group') {}
-          original_declaration = [__FILE__, __LINE__ - 1].join(':')
-
-          warning = nil
-          allow(::Kernel).to receive(:warn) { |msg| warning = msg }
-
-          group.send(shared_method_name, 'some shared group') {}
-          second_declaration = [__FILE__, __LINE__ - 1].join(':')
-          expect(warning).to include('some shared group', original_declaration, second_declaration)
-          expect(warning).to_not include 'Called from'
-        end
-
-        it 'works with top level defined examples in modules' do
-          expect(RSpec::configuration.reporter).to_not receive(:deprecation)
-          ExampleGroup.describe('example group') { include_context 'top level in module' }
-        end
-
-        ["name", :name, ExampleModule, ExampleClass].each do |object|
-          type = object.class.name.downcase
-          context "given a #{type}" do
-            it "captures the given #{type} and block in the collection of shared example groups" do
-              implementation = lambda {}
-              define_shared_group(object, &implementation)
-              expect(SharedExampleGroup.registry.shared_example_groups[group][object]).to eq implementation
-            end
-          end
-        end
-
-        context "given a hash" do
-          it "delegates include on configuration" do
-            implementation = Proc.new { def bar; 'bar'; end }
-            define_shared_group(:foo => :bar, &implementation)
-            a = RSpec.configuration.include_or_extend_modules.first
-            expect(a[0]).to eq(:include)
-            expect(Class.new.send(:include, a[1]).new.bar).to eq('bar')
-            expect(a[2]).to eq(:foo => :bar)
-          end
-        end
-
-        context "given a string and a hash" do
-          it "captures the given string and block in the World's collection of shared example groups" do
-            implementation = lambda {}
-            define_shared_group("name", :foo => :bar, &implementation)
-            expect(SharedExampleGroup.registry.shared_example_groups[group]["name"]).to eq implementation
-          end
-
-          it "delegates include on configuration" do
-            implementation = Proc.new { def bar; 'bar'; end }
-            define_shared_group("name", :foo => :bar, &implementation)
-            a = RSpec.configuration.include_or_extend_modules.first
-            expect(a[0]).to eq(:include)
-            expect(Class.new.send(:include, a[1]).new.bar).to eq('bar')
-            expect(a[2]).to eq(:foo => :bar)
-          end
-        end
-      end
-    end
-  end
-end
-

data/spec/rspec/core/warnings_spec.rb

@@ -1,29 +0,0 @@
-require "spec_helper"
-
-RSpec.describe "rspec warnings and deprecations" do
-
-  describe "#deprecate" do
-    it "passes the hash to the reporter" do
-      expect(RSpec.configuration.reporter).to receive(:deprecation).with(hash_including :deprecated => "deprecated_method", :replacement => "replacement")
-      RSpec.deprecate("deprecated_method", :replacement => "replacement")
-    end
-
-    it "adds the call site" do
-      expect_deprecation_with_call_site(__FILE__, __LINE__ + 1)
-      RSpec.deprecate("deprecated_method")
-    end
-
-    it "doesn't override a passed call site" do
-      expect_deprecation_with_call_site("some_file.rb", 17)
-      RSpec.deprecate("deprecated_method", :call_site => "/some_file.rb:17")
-    end
-  end
-
-  describe "#warn_deprecation" do
-    it "puts message in a hash" do
-      expect(RSpec.configuration.reporter).to receive(:deprecation).with(hash_including :message => "this is the message")
-      RSpec.warn_deprecation("this is the message")
-    end
-  end
-
-end

data/spec/rspec/core/world_spec.rb

@@ -1,142 +0,0 @@
-require 'spec_helper'
-
-class Bar; end
-class Foo; end
-
-module RSpec::Core
-
-  RSpec.describe RSpec::Core::World do
-    let(:configuration) { RSpec::Core::Configuration.new }
-    let(:world) { RSpec::Core::World.new(configuration) }
-
-    describe '#reset' do
-      it 'clears #example_groups' do
-        world.example_groups << :example_group
-        world.reset
-        expect(world.example_groups).to be_empty
-      end
-    end
-
-    describe "#example_groups" do
-      it "contains all registered example groups" do
-        group = RSpec::Core::ExampleGroup.describe("group"){}
-        world.register(group)
-        expect(world.example_groups).to include(group)
-      end
-    end
-
-    describe "#preceding_declaration_line (again)" do
-      let(:group) do
-        RSpec::Core::ExampleGroup.describe("group") do
-
-          example("example") {}
-
-        end
-      end
-
-      let(:second_group) do
-        RSpec::Core::ExampleGroup.describe("second_group") do
-
-          example("second_example") {}
-
-        end
-      end
-
-      let(:group_declaration_line) { group.metadata[:example_group][:line_number] }
-      let(:example_declaration_line) { group_declaration_line + 2 }
-
-      context "with one example" do
-        before { world.register(group) }
-
-        it "returns nil if no example or group precedes the line" do
-          expect(world.preceding_declaration_line(group_declaration_line - 1)).to be_nil
-        end
-
-        it "returns the argument line number if a group starts on that line" do
-          expect(world.preceding_declaration_line(group_declaration_line)).to eq(group_declaration_line)
-        end
-
-        it "returns the argument line number if an example starts on that line" do
-          expect(world.preceding_declaration_line(example_declaration_line)).to eq(example_declaration_line)
-        end
-
-        it "returns line number of a group that immediately precedes the argument line" do
-          expect(world.preceding_declaration_line(group_declaration_line + 1)).to eq(group_declaration_line)
-        end
-
-        it "returns line number of an example that immediately precedes the argument line" do
-          expect(world.preceding_declaration_line(example_declaration_line + 1)).to eq(example_declaration_line)
-        end
-      end
-
-      context "with two exaples and the second example is registre first" do
-        let(:second_group_declaration_line) { second_group.metadata[:example_group][:line_number] }
-
-        before do
-          world.register(second_group)
-          world.register(group)
-        end
-
-        it 'return line number of group if a group start on that line' do
-          expect(world.preceding_declaration_line(second_group_declaration_line)).to eq(second_group_declaration_line)
-        end
-      end
-    end
-
-    describe "#announce_filters" do
-      let(:reporter) { double('reporter').as_null_object }
-      before { allow(world).to receive(:reporter) { reporter } }
-
-      context "with no examples" do
-        before { allow(world).to receive(:example_count) { 0 } }
-
-        context "with no filters" do
-          it "announces" do
-            expect(reporter).to receive(:message).
-              with("No examples found.")
-            world.announce_filters
-          end
-        end
-
-        context "with an inclusion filter" do
-          it "announces" do
-            configuration.filter_run_including :foo => 'bar'
-            expect(reporter).to receive(:message).
-              with(/All examples were filtered out/)
-            world.announce_filters
-          end
-        end
-
-        context "with an inclusion filter and run_all_when_everything_filtered" do
-          it "announces" do
-            allow(configuration).to receive(:run_all_when_everything_filtered?) { true }
-            configuration.filter_run_including :foo => 'bar'
-            expect(reporter).to receive(:message).
-              with(/All examples were filtered out/)
-            world.announce_filters
-          end
-        end
-
-        context "with an exclusion filter" do
-          it "announces" do
-            configuration.filter_run_excluding :foo => 'bar'
-            expect(reporter).to receive(:message).
-              with(/All examples were filtered out/)
-            world.announce_filters
-          end
-        end
-      end
-
-      context "with examples" do
-        before { allow(world).to receive(:example_count) { 1 } }
-
-        context "with no filters" do
-          it "does not announce" do
-            expect(reporter).not_to receive(:message)
-            world.announce_filters
-          end
-        end
-      end
-    end
-  end
-end

data/spec/rspec/core_spec.rb

@@ -1,91 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe RSpec do
-  describe "::configuration" do
-    it "returns the same object every time" do
-      expect(RSpec.configuration).to equal(RSpec.configuration)
-    end
-  end
-
-  describe "::configuration=" do
-    it "sets the configuration object" do
-      configuration = RSpec::Core::Configuration.new
-
-      RSpec.configuration = configuration
-
-      expect(RSpec.configuration).to equal(configuration)
-    end
-  end
-
-  describe "::configure" do
-    it "yields the current configuration" do
-      RSpec.configure do |config|
-        expect(config).to equal(RSpec::configuration)
-      end
-    end
-  end
-
-  describe "::world" do
-    it "returns the same object every time" do
-      expect(RSpec.world).to equal(RSpec.world)
-    end
-  end
-
-  describe "::world=" do
-    it "sets the world object" do
-      world = RSpec::Core::World.new
-
-      RSpec.world = world
-
-      expect(RSpec.world).to equal(world)
-    end
-  end
-
-  describe ".current_example" do
-    it "sets the example being executed" do
-      group = RSpec::Core::ExampleGroup.describe("an example group")
-      example = group.example("an example")
-
-      RSpec.current_example = example
-      expect(RSpec.current_example).to be(example)
-    end
-  end
-
-  describe "::reset" do
-    it "resets the configuration and world objects" do
-      config_before_reset = RSpec.configuration
-      world_before_reset  = RSpec.world
-
-      RSpec.reset
-
-      expect(RSpec.configuration).not_to equal(config_before_reset)
-      expect(RSpec.world).not_to equal(world_before_reset)
-    end
-  end
-
-  describe "::Core.path_to_executable" do
-    it 'returns the absolute location of the exe/rspec file' do
-      expect(File.exist? RSpec::Core.path_to_executable).to be_truthy
-      expect(File.executable? RSpec::Core.path_to_executable).to be_truthy
-    end
-  end
-
-  # This is hard to test :(. Best way I could come up with was starting
-  # fresh ruby process w/o this stuff already loaded.
-  it "loads mocks and expectations when the constants are referenced", :slow do
-    code = "$LOAD_PATH.replace(#{$LOAD_PATH.inspect}); " +
-           'require "rspec"; ' +
-           "puts RSpec::Mocks.name; " +
-           "puts RSpec::Expectations.name"
-
-    result = `ruby -e '#{code}'`.chomp
-    expect(result.split("\n")).to eq(%w[ RSpec::Mocks RSpec::Expectations ])
-  end
-
-  it 'correctly raises an error when an invalid const is referenced' do
-    expect {
-      RSpec::NotAConst
-    }.to raise_error(NameError, /RSpec::NotAConst/)
-  end
-end
-

data/spec/spec_helper.rb

@@ -1,160 +0,0 @@
-require 'rubygems' if RUBY_VERSION.to_f < 1.9
-
-begin
-  require 'spork'
-rescue LoadError
-  module Spork
-    def self.prefork
-      yield
-    end
-
-    def self.each_run
-      yield
-    end
-  end
-end
-
-Spork.prefork do
-  require 'rspec/support/spec'
-
-  module ArubaLoader
-    extend RSpec::Support::WithIsolatedStdErr
-    with_isolated_stderr do
-      require 'aruba/api'
-    end
-  end
-
-  if RUBY_PLATFORM == 'java'
-    # Works around https://jira.codehaus.org/browse/JRUBY-5678
-    require 'fileutils'
-    ENV['TMPDIR'] = File.expand_path('../../tmp', __FILE__)
-    FileUtils.mkdir_p(ENV['TMPDIR'])
-  end
-
-  $rspec_core_without_stderr_monkey_patch = RSpec::Core::Configuration.new
-
-  class RSpec::Core::Configuration
-    def self.new(*args, &block)
-      super.tap do |config|
-        # We detect ruby warnings via $stderr,
-        # so direct our deprecations to $stdout instead.
-        config.deprecation_stream = $stdout
-      end
-    end
-  end
-
-  Dir['./spec/support/**/*.rb'].map {|f| require f}
-
-  class NullObject
-    private
-    def method_missing(method, *args, &block)
-      # ignore
-    end
-  end
-
-  module Sandboxing
-    def self.sandboxed(&block)
-      @orig_config = RSpec.configuration
-      @orig_world  = RSpec.world
-      @orig_example = RSpec.current_example
-      new_config = RSpec::Core::Configuration.new
-      new_config.expose_dsl_globally = false
-      new_world  = RSpec::Core::World.new(new_config)
-      RSpec.configuration = new_config
-      RSpec.world = new_world
-      object = Object.new
-      object.extend(RSpec::Core::SharedExampleGroup)
-
-      (class << RSpec::Core::ExampleGroup; self; end).class_eval do
-        alias_method :orig_run, :run
-        def run(reporter=nil)
-          RSpec.current_example = nil
-          orig_run(reporter || NullObject.new)
-        end
-      end
-
-      RSpec::Mocks.with_temporary_scope do
-        object.instance_eval(&block)
-      end
-    ensure
-      (class << RSpec::Core::ExampleGroup; self; end).class_eval do
-        remove_method :run
-        alias_method :run, :orig_run
-        remove_method :orig_run
-      end
-
-      RSpec.configuration = @orig_config
-      RSpec.world = @orig_world
-      RSpec.current_example = @orig_example
-    end
-  end
-
-  def in_editor?
-    ENV.has_key?('TM_MODE') || ENV.has_key?('EMACS') || ENV.has_key?('VIM')
-  end
-
-  module EnvHelpers
-    def with_env_vars(vars)
-      original = ENV.to_hash
-      vars.each { |k, v| ENV[k] = v }
-
-      begin
-        yield
-      ensure
-        ENV.replace(original)
-      end
-    end
-
-    def without_env_vars(*vars)
-      original = ENV.to_hash
-      vars.each { |k| ENV.delete(k) }
-
-      begin
-        yield
-      ensure
-        ENV.replace(original)
-      end
-    end
-  end
-
-  RSpec.configure do |c|
-    # structural
-    c.alias_it_behaves_like_to 'it_has_behavior'
-    c.around {|example| Sandboxing.sandboxed { example.run }}
-    c.include(RSpecHelpers)
-    c.include Aruba::Api, :example_group => {
-      :file_path => /spec\/command_line/
-    }
-
-    c.expect_with :rspec do |expectations|
-      expectations.syntax = :expect
-    end
-
-    c.mock_with :rspec do |mocks|
-      mocks.syntax = :expect
-    end
-
-    # runtime options
-    c.color = !in_editor?
-    c.include EnvHelpers
-    c.filter_run_excluding :ruby => lambda {|version|
-      case version.to_s
-      when "!jruby"
-        RUBY_ENGINE == "jruby"
-      when /^> (.*)/
-        !(RUBY_VERSION.to_s > $1)
-      else
-        !(RUBY_VERSION.to_s =~ /^#{version.to_s}/)
-      end
-    }
-
-    c.after(:suite) do
-      if $stderr.has_output?
-        raise "Ruby warnings were emitted:\n\n#{$stderr.output}"
-      end
-    end
-  end
-end
-
-Spork.each_run do
-end