rspec-core 2.99.0 → 3.0.0

data/spec/rspec/core/runner_spec.rb

@@ -1,82 +0,0 @@
-require 'spec_helper'
-require 'rspec/core/drb_command_line'
-
-module RSpec::Core
-  describe Runner do
-    describe 'at_exit' do
-      it 'sets an at_exit hook if none is already set' do
-        RSpec::Core::Runner.stub(:installed_at_exit?).and_return(false)
-        RSpec::Core::Runner.stub(:running_in_drb?).and_return(false)
-        RSpec::Core::Runner.stub(:at_exit_hook_disabled?).and_return(false)
-        RSpec::Core::Runner.stub(:run).and_return(-1)
-        RSpec::Core::Runner.should_receive(:at_exit)
-        RSpec::Core::Runner.autorun
-      end
-
-      it 'does not set the at_exit hook if it is already set' do
-        RSpec::Core::Runner.stub(:installed_at_exit?).and_return(true)
-        RSpec::Core::Runner.stub(:running_in_drb?).and_return(false)
-        RSpec::Core::Runner.stub(:at_exit_hook_disabled?).and_return(false)
-        RSpec::Core::Runner.should_receive(:at_exit).never
-        RSpec::Core::Runner.autorun
-      end
-    end
-
-    describe "#run" do
-      let(:err) { StringIO.new }
-      let(:out) { StringIO.new }
-
-      it "tells RSpec to reset" do
-        RSpec.configuration.stub(:files_to_run => [])
-        RSpec.should_receive(:reset)
-        RSpec::Core::Runner.run([], err, out)
-      end
-
-      context "with --drb or -X" do
-
-        before(:each) do
-          @options = RSpec::Core::ConfigurationOptions.new(%w[--drb --drb-port 8181 --color])
-          RSpec::Core::ConfigurationOptions.stub(:new) { @options }
-        end
-
-        def run_specs
-          RSpec::Core::Runner.run(%w[ --drb ], err, out)
-        end
-
-        context 'and a DRb server is running' do
-          it "builds a DRbCommandLine and runs the specs" do
-            drb_proxy = double(RSpec::Core::DRbCommandLine, :run => true)
-            drb_proxy.should_receive(:run).with(err, out)
-
-            RSpec::Core::DRbCommandLine.should_receive(:new).and_return(drb_proxy)
-
-            run_specs
-          end
-        end
-
-        context 'and a DRb server is not running' do
-          before(:each) do
-            RSpec::Core::DRbCommandLine.should_receive(:new).and_raise(DRb::DRbConnError)
-          end
-
-          it "outputs a message" do
-            RSpec.configuration.stub(:files_to_run) { [] }
-            err.should_receive(:puts).with(
-              "No DRb server is running. Running in local process instead ..."
-            )
-            run_specs
-          end
-
-          it "builds a Runner and runs the specs" do
-            process_proxy = double(RSpec::Core::Runner, :run => 0)
-            process_proxy.should_receive(:run).with(err, out)
-
-            RSpec::Core::Runner.should_receive(:new).and_return(process_proxy)
-
-            run_specs
-          end
-        end
-      end
-    end
-  end
-end

data/spec/rspec/core/shared_context_spec.rb

@@ -1,114 +0,0 @@
-require "spec_helper"
-
-describe RSpec::SharedContext do
-  it "is accessible as RSpec::Core::SharedContext" do
-    RSpec::Core::SharedContext
-  end
-
-  it "is accessible as RSpec::SharedContext" do
-    RSpec::SharedContext
-  end
-
-  it "supports before and after hooks" do
-    before_all_hook = false
-    before_each_hook = false
-    after_each_hook = false
-    after_all_hook = false
-    shared = Module.new do
-      extend RSpec::SharedContext
-      before(:all) { before_all_hook = true }
-      before(:each) { before_each_hook = true }
-      after(:each)  { after_each_hook = true }
-      after(:all)  { after_all_hook = true }
-    end
-    group = RSpec::Core::ExampleGroup.describe do
-      include shared
-      example { }
-    end
-
-    group.run
-
-    expect(before_all_hook).to be_truthy
-    expect(before_each_hook).to be_truthy
-    expect(after_each_hook).to be_truthy
-    expect(after_all_hook).to be_truthy
-  end
-
-  it "runs the before each hooks in configuration before those of the shared context" do
-    ordered_hooks = []
-    RSpec.configure do |c|
-      c.before(:each) { ordered_hooks << "config" }
-    end
-
-    shared_context("before each stuff", :example => :before_each_hook_order) do
-      before(:each) { ordered_hooks << "shared_context"}
-    end
-
-    group = RSpec::Core::ExampleGroup.describe "group", :example => :before_each_hook_order do
-      before(:each) { ordered_hooks << "example_group" }
-      example {}
-    end
-
-    group.run
-
-    expect(ordered_hooks).to be == ["config", "shared_context", "example_group"]
-  end
-
-  it "supports let" do
-    shared = Module.new do
-      extend RSpec::SharedContext
-      let(:foo) { 'foo' }
-    end
-    group = RSpec::Core::ExampleGroup.describe do
-      include shared
-    end
-
-    expect(group.new.foo).to eq('foo')
-  end
-
-  it 'supports explicit subjects' do
-    shared = Module.new do
-      extend RSpec::SharedContext
-      subject { 17 }
-    end
-
-    group = RSpec::Core::ExampleGroup.describe do
-      include shared
-    end
-
-    expect(group.new.subject).to eq(17)
-  end
-
-  it 'supports `its` with an implicit subject' do
-    shared = Module.new do
-      extend RSpec::SharedContext
-      its(:size) { should eq 0 }
-    end
-
-    group = RSpec::Core::ExampleGroup.describe(Array) do
-      include shared
-    end
-
-    group.run
-    expect(group.children.first.examples.first.execution_result).to include(:status => "passed")
-  end
-
-  %w[describe context].each do |method_name|
-    it "supports nested example groups using #{method_name}" do
-      shared = Module.new do
-        extend RSpec::SharedContext
-        send(method_name, "nested using describe") do
-          example {}
-        end
-      end
-      group = RSpec::Core::ExampleGroup.describe do
-        include shared
-      end
-
-      group.run
-
-      expect(group.children.length).to eq(1)
-      expect(group.children.first.examples.length).to eq(1)
-    end
-  end
-end

data/spec/rspec/core/shared_example_group/collection_spec.rb

@@ -1,70 +0,0 @@
-require 'spec_helper'
-
-module RSpec::Core::SharedExampleGroup
-  describe Collection do
-
-    # this represents:
-    #
-    # shared_examples "top level group"
-    #
-    # context do
-    #   shared_examples "nested level one"
-    # end
-    #
-    # context do
-    #   shared_examples "nested level two"
-    # end
-    #
-    let(:examples) do
-      Hash.new { |hash,k| hash[k] = Hash.new }.tap do |hash|
-        hash["main"]     = { "top level group"  => example_1 }
-        hash["nested 1"] = { "nested level one" => example_2 }
-        hash["nested 2"] = { "nested level two" => example_3 }
-      end
-    end
-    (1..3).each { |num| let("example_#{num}") { double "example #{num}" } }
-
-    context 'setup with one source, which is the top level' do
-
-      let(:collection) { Collection.new ['main'], examples }
-
-      it 'fetches examples from the top level' do
-        expect(collection['top level group']).to eq example_1
-      end
-
-      it 'fetches examples across the nested context' do
-        RSpec.stub(:warn_deprecation)
-        expect(collection['nested level two']).to eq example_3
-      end
-
-      it 'warns about deprecation when you fetch across nested contexts' do
-        RSpec.should_receive(:warn_deprecation)
-        collection['nested level two']
-      end
-    end
-
-    context 'setup with multiple sources' do
-
-      let(:collection) { Collection.new ['main','nested 1'], examples }
-
-      it 'fetches examples from the context' do
-        expect(collection['nested level one']).to eq example_2
-      end
-
-      it 'fetches examples from main' do
-        expect(collection['top level group']).to eq example_1
-      end
-
-      it 'fetches examples across the nested context' do
-        RSpec.stub(:warn_deprecation)
-        expect(collection['nested level two']).to eq example_3
-      end
-
-      it 'warns about deprecation when you fetch across nested contexts' do
-        RSpec.should_receive(:warn_deprecation)
-        collection['nested level two']
-      end
-
-    end
-  end
-end

data/spec/rspec/core/shared_example_group_spec.rb

@@ -1,138 +0,0 @@
-require 'spec_helper'
-
-module RandomTopLevelModule
-  def self.setup!
-    shared_examples_for("top level in module") {}
-  end
-end
-
-module RSpec::Core
-  describe SharedExampleGroup do
-
-    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
-      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
-        if shared_method_name == "share_examples_for"
-          before { allow_deprecation }
-
-          it 'is deprecated when called from within an example group' do
-            expect_deprecation_with_call_site(__FILE__, __LINE__ + 2, /share_examples_for/)
-            ExampleGroup.describe("example group") do
-              send(shared_method_name, "group") { }
-            end
-          end
-
-          it 'is deprecated when called from the top level' do
-            expect_deprecation_with_call_site(__FILE__, __LINE__ + 2, /share_examples_for/)
-            Module.new do
-              send(shared_method_name, "group") { }
-            end
-          end
-        end
-
-        it "is exposed to the global namespace" do
-          expect(Kernel).to respond_to(shared_method_name)
-        end
-
-        it "displays a warning when adding a second shared example group with the same name" do
-          group = ExampleGroup.describe('example group')
-          group.send(shared_method_name, 'some shared group') {}
-          original_declaration = [__FILE__, __LINE__ - 1].join(':')
-
-          warning = nil
-          Kernel.stub(: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)
-        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 {}
-              send(shared_method_name, object, &implementation)
-              expect(SharedExampleGroup.registry.shared_example_groups[self][object]).to eq implementation
-            end
-          end
-        end
-
-        context "given a hash" do
-          it "delegates extend on configuration" do
-            implementation = Proc.new { def bar; 'bar'; end }
-            send(shared_method_name, :foo => :bar, &implementation)
-            a = RSpec.configuration.include_or_extend_modules.first
-            expect(a[0]).to eq(:extend)
-            expect(Class.new.extend(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 {}
-            send(shared_method_name, "name", :foo => :bar, &implementation)
-            expect(SharedExampleGroup.registry.shared_example_groups[self]["name"]).to eq implementation
-          end
-
-          it "delegates extend on configuration" do
-            implementation = Proc.new { def bar; 'bar'; end }
-            send(shared_method_name, "name", :foo => :bar, &implementation)
-            a = RSpec.configuration.include_or_extend_modules.first
-            expect(a[0]).to eq(:extend)
-            expect(Class.new.extend(a[1]).new.bar).to eq('bar')
-            expect(a[2]).to eq(:foo => :bar)
-          end
-        end
-      end
-    end
-
-    describe "#share_as" do
-      before { allow(RSpec).to receive(:deprecate) }
-
-      it "is exposed to the global namespace" do
-        expect(Kernel).to respond_to("share_as")
-      end
-
-      it "adds examples to current example_group using include", :compat => 'rspec-1.2' do
-        share_as('Cornucopia') do
-          it "is plentiful" do
-            expect(5).to eq(4)
-          end
-        end
-        group = ExampleGroup.describe('group') { include Cornucopia }
-        phantom_group = group.children.first
-        expect(phantom_group.description).to eql("")
-        expect(phantom_group.metadata[:shared_group_name]).to eql('Cornucopia')
-        expect(phantom_group.examples.length).to eq(1)
-        expect(phantom_group.examples.first.metadata[:description]).to eq("is plentiful")
-      end
-    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
-
-  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 { world.stub(:reporter) { reporter } }
-
-      context "with no examples" do
-        before { world.stub(:example_count) { 0 } }
-
-        context "with no filters" do
-          it "announces" do
-            reporter.should_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'
-            reporter.should_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
-            configuration.stub(:run_all_when_everything_filtered?) { true }
-            configuration.filter_run_including :foo => 'bar'
-            reporter.should_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'
-            reporter.should_receive(:message).
-              with(/All examples were filtered out/)
-            world.announce_filters
-          end
-        end
-      end
-
-      context "with examples" do
-        before { world.stub(:example_count) { 1 } }
-
-        context "with no filters" do
-          it "does not announce" do
-            reporter.should_not_receive(:message)
-            world.announce_filters
-          end
-        end
-      end
-    end
-  end
-end

data/spec/rspec/core_spec.rb

@@ -1,108 +0,0 @@
-require 'spec_helper'
-
-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(RSpec::Core.path_to_executable).to eq File.expand_path('../../../exe/rspec',__FILE__)
-    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" 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
-
-  describe "::Core::PendingExampleFixedError" do
-    before { allow_deprecation }
-
-    it 'is an alternate reference to RSpec::Core::Pending::PendingExampleFixedError' do
-      expect(::RSpec::Core::PendingExampleFixedError).to be(::RSpec::Core::Pending::PendingExampleFixedError)
-    end
-
-    it 'prints a deprecation warning' do
-      expect_deprecation_with_call_site(__FILE__, __LINE__ + 1, /PendingExampleFixedError/)
-      ::RSpec::Core::PendingExampleFixedError
-    end
-
-    specify 'the const_missing hook allows other undefined consts to raise errors as normal' do
-      expect {
-        ::RSpec::Core::SomeUndefinedConst
-      }.to raise_error(NameError, /RSpec::Core::SomeUndefinedConst/)
-    end
-  end
-end