rspec-core 2.99.2 → 3.0.0.beta1

data/spec/rspec/core/random_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+module RSpec
+  module Core
+    describe RandomNumberGenerator do
+      it 'is a random number generator' do
+        random = described_class.new
+
+        expect([Fixnum, Bignum]).to include random.seed.class
+        expect(random.rand).to be_a Float
+
+        rands = []
+        100.times do
+          rands << random.rand
+        end
+
+        expect(rands.uniq.count).to be > 90
+      end
+
+      it 'produces the same results given the same seed' do
+        seed = rand(999)
+
+        random = described_class.new(seed)
+
+        expect(random.seed).to eq seed
+
+        expected = []
+        5.times do
+          expected << random.rand(999)
+        end
+
+        10.times do
+          random = described_class.new(seed)
+
+          expect(random.seed).to eq seed
+
+          actual = []
+          5.times do
+            actual << random.rand(999)
+          end
+
+          expect(actual).to eq expected
+        end
+      end
+    end
+  end
+end

data/spec/rspec/core/reporter_spec.rb

@@ -2,45 +2,25 @@ require "spec_helper"
 
 module RSpec::Core
   describe Reporter do
-    describe "abort" do
-      let(:formatter) { double("formatter") }
-      let(:example)   { double("example") }
-      let(:reporter)  { Reporter.new(formatter) }
-
-      before do
-        allow_deprecation
-      end
-
-      %w[start_dump dump_pending dump_failures dump_summary close].each do |message|
-        it "sends #{message} to the formatter(s) that respond to message" do
-          formatter.should_receive(message)
-          reporter.abort(nil)
-        end
-
-        it "doesnt notify formatters about messages they dont implement" do
-          expect { reporter.abort(nil) }.to_not raise_error
-        end
+    let(:config) { Configuration.new }
 
-        it 'warns of deprecation' do
-          expect_deprecation_with_call_site(__FILE__, __LINE__ + 1)
-          reporter.abort(nil)
-        end
-      end
+    def reporter_for(*formatters)
+      Reporter.new(config, *formatters)
     end
 
-    describe "finish" do
+    describe "abort" do
       let(:formatter) { double("formatter") }
       let(:example)   { double("example") }
-      let(:reporter)  { Reporter.new(formatter) }
+      let(:reporter)  { reporter_for(formatter) }
 
       %w[start_dump dump_pending dump_failures dump_summary close].each do |message|
         it "sends #{message} to the formatter(s) that respond to message" do
-          formatter.should_receive(message)
-          reporter.finish(nil)
+          formatter.as_null_object.should_receive(message)
+          reporter.abort
         end
 
         it "doesnt notify formatters about messages they dont implement" do
-          expect { reporter.finish(nil) }.to_not raise_error
+          expect { reporter.abort }.to_not raise_error
         end
       end
     end
@@ -49,7 +29,7 @@ module RSpec::Core
       it "passes messages to that formatter" do
         formatter = double("formatter", :example_started => nil)
         example = double("example")
-        reporter = Reporter.new(formatter)
+        reporter = reporter_for(formatter)
 
         formatter.should_receive(:example_started).
           with(example)
@@ -60,7 +40,7 @@ module RSpec::Core
       it "passes example_group_started and example_group_finished messages to that formatter in that order" do
         order = []
 
-        formatter = double("formatter")
+        formatter = double("formatter").as_null_object
         formatter.stub(:example_group_started) { |group| order << "Started: #{group.description}" }
         formatter.stub(:example_group_finished) { |group| order << "Finished: #{group.description}" }
 
@@ -72,7 +52,7 @@ module RSpec::Core
           example("ignore") {}
         end
 
-        group.run(Reporter.new(formatter))
+        group.run(reporter_for(formatter))
 
         expect(order).to eq([
            "Started: root",
@@ -87,13 +67,13 @@ module RSpec::Core
 
     context "given an example group with no examples" do
       it "does not pass example_group_started or example_group_finished to formatter" do
-        formatter = double("formatter")
+        formatter = double("formatter").as_null_object
         formatter.should_not_receive(:example_group_started)
         formatter.should_not_receive(:example_group_finished)
 
         group = ExampleGroup.describe("root")
 
-        group.run(Reporter.new(formatter))
+        group.run(reporter_for(formatter))
       end
     end
 
@@ -101,7 +81,7 @@ module RSpec::Core
       it "passes messages to all formatters" do
         formatters = (1..2).map { double("formatter", :example_started => nil) }
         example = double("example")
-        reporter = Reporter.new(*formatters)
+        reporter = reporter_for(*formatters)
 
         formatters.each do |formatter|
           formatter.
@@ -115,15 +95,11 @@ module RSpec::Core
 
     describe "#report" do
       it "supports one arg (count)" do
-        Reporter.new.report(1) {}
-      end
-
-      it "supports two args (count, seed)" do
-        Reporter.new.report(1, 2) {}
+        reporter_for.report(1) {}
       end
 
       it "yields itself" do
-        reporter = Reporter.new
+        reporter = reporter_for
         yielded = nil
         reporter.report(3) {|r| yielded = r}
         expect(yielded).to eq(reporter)
@@ -131,7 +107,7 @@ module RSpec::Core
     end
 
     describe "#register_listener" do
-      let(:reporter) { Reporter.new }
+      let(:reporter) { reporter_for }
       let(:listener) { double("listener", :start => nil) }
 
       before { reporter.register_listener listener, :start }
@@ -148,18 +124,17 @@ module RSpec::Core
 
     describe "timing" do
       it "uses RSpec::Core::Time as to not be affected by changes to time in examples" do
-        formatter = double(:formatter)
+        formatter = double(:formatter).as_null_object
+        reporter = reporter_for formatter
+        reporter.start 1
+        Time.stub(:now => ::Time.utc(2012, 10, 1))
+
         duration = nil
         formatter.stub(:dump_summary) do |dur, _, _, _|
           duration = dur
         end
 
-        reporter = Reporter.new formatter
-        reporter.start 1
-        Time.stub(:now => ::Time.utc(2012, 10, 1))
-
-
-        reporter.finish 1234
+        reporter.finish
         expect(duration).to be < 0.2
       end
     end

data/spec/rspec/core/runner_spec.rb

@@ -22,53 +22,45 @@ module RSpec::Core
       end
     end
 
-    describe "#run" do
-      let(:err) { StringIO.new }
-      let(:out) { StringIO.new }
+    describe "#running_in_drb?" do
+      it "returns true if drb server is started with 127.0.0.1" do
+        allow(::DRb).to receive(:current_server).and_return(double(:uri => "druby://127.0.0.1:0000/"))
 
-      after { RSpec.resets_required = 0 }
-      before { RSpec.resets_required = 0 }
+        expect(RSpec::Core::Runner.running_in_drb?).to be_truthy
+      end
 
-      it "tells RSpec to reset" do
-        RSpec.configuration.stub(:files_to_run => [])
-        RSpec.should_receive(:internal_reset)
-        RSpec::Core::Runner.run([], err, out)
+      it "returns true if drb server is started with localhost" do
+        allow(::DRb).to receive(:current_server).and_return(double(:uri => "druby://localhost:0000/"))
+
+        expect(RSpec::Core::Runner.running_in_drb?).to be_truthy
       end
 
-      it "does not issue a deprecation warning at the end of the first run" do
-        RSpec.configuration.stub(:files_to_run => [])
-        RSpec.should_receive(:internal_reset)
-        allow(RSpec.configuration).to receive(:deprecation_stream).and_return(err)
-        RSpec::Core::Runner.run([], err, out)
-        expect(err.string).to eq("")
+      it "returns true if drb server is started with another local ip address" do
+        allow(::DRb).to receive(:current_server).and_return(double(:uri => "druby://192.168.0.1:0000/"))
+        allow(::IPSocket).to receive(:getaddress).and_return("192.168.0.1")
+
+        expect(RSpec::Core::Runner.running_in_drb?).to be_truthy
       end
 
-      it "issues a deprecation if warn is invoked twice and reset is not called manually" do
-        RSpec.configuration.stub(:files_to_run => [])
-        RSpec::Core::Runner.run([], err, out)
-        RSpec.configuration.stub(:files_to_run => [])
-        allow(RSpec.configuration).to receive(:deprecation_stream).and_return(err)
-        RSpec::Core::Runner.run([], err, out)
-        expect(err.string).to match(/no longer implicitly/)
+      it "returns false if no drb server is running" do
+        ::DRb.stub(:current_server).and_raise(::DRb::DRbServerNotFound)
+
+        expect(RSpec::Core::Runner.running_in_drb?).to be_falsey
       end
+    end
 
-      context "when the user manually invokes reset" do
-        after { RSpec.instance_variable_set(:@reset_called_by_user, false) }
-
-        it "does not issue a deprecation warning" do
-          RSpec.configuration.stub(:files_to_run => [])
-          RSpec::Core::Runner.run([], err, out)
-          RSpec.configuration.stub(:files_to_run => [])
-          RSpec.reset
-          RSpec.configuration.stub(:files_to_run => [])
-          allow(RSpec.configuration).to receive(:deprecation_stream).and_return(err)
-          RSpec::Core::Runner.run([], err, out)
-          expect(err.string).to eq("")
-        end
+    describe "#run" do
+      let(:err) { StringIO.new }
+      let(:out) { StringIO.new }
+
+      it "tells RSpec to reset" do
+        CommandLine.stub(:new => double.as_null_object)
+        RSpec.configuration.stub(:files_to_run => [], :warn => nil)
+        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 }
@@ -102,11 +94,11 @@ module RSpec::Core
             run_specs
           end
 
-          it "builds a Runner and runs the specs" do
-            process_proxy = double(RSpec::Core::Runner, :run => 0)
+          it "builds a CommandLine and runs the specs" do
+            process_proxy = double(RSpec::Core::CommandLine, :run => 0)
             process_proxy.should_receive(:run).with(err, out)
 
-            RSpec::Core::Runner.should_receive(:new).and_return(process_proxy)
+            RSpec::Core::CommandLine.should_receive(:new).and_return(process_proxy)
 
             run_specs
           end

data/spec/rspec/core/shared_context_spec.rb

@@ -34,6 +34,8 @@ describe RSpec::SharedContext do
     expect(after_all_hook).to be_truthy
   end
 
+  include RSpec::Core::SharedExampleGroup::TopLevelDSL
+
   it "runs the before each hooks in configuration before those of the shared context" do
     ordered_hooks = []
     RSpec.configure do |c|
@@ -44,7 +46,7 @@ describe RSpec::SharedContext do
       before(:each) { ordered_hooks << "shared_context"}
     end
 
-    group = RSpec::Core::ExampleGroup.describe "group", :example => :before_each_hook_order do
+    group = RSpec::Core::ExampleGroup.describe :example => :before_each_hook_order do
       before(:each) { ordered_hooks << "example_group" }
       example {}
     end
@@ -79,20 +81,6 @@ describe RSpec::SharedContext do
     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

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

@@ -32,14 +32,8 @@ module RSpec::Core::SharedExampleGroup
         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']
+      it 'wont fetches examples across the nested context' do
+        expect(collection['nested level two']).to eq nil
       end
     end
 
@@ -55,16 +49,9 @@ module RSpec::Core::SharedExampleGroup
         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
+      it 'wont fetch examples across the nested context' do
+        expect(collection['nested level two']).to eq nil
       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

@@ -32,22 +32,10 @@ module RSpec::Core
 
     %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 }
+        let(:group) { ExampleGroup.describe('example group') }
 
-          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
+        define_method :define_shared_group do |*args, &block|
+          group.send(shared_method_name, *args, &block)
         end
 
         it "is exposed to the global namespace" do
@@ -55,16 +43,16 @@ module RSpec::Core
         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 }
+          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
@@ -77,8 +65,8 @@ module RSpec::Core
           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
+              define_shared_group(object, &implementation)
+              expect(SharedExampleGroup.registry.shared_example_groups[group][object]).to eq implementation
             end
           end
         end
@@ -86,7 +74,7 @@ module RSpec::Core
         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)
+            define_shared_group(: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')
@@ -97,13 +85,13 @@ module RSpec::Core
         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
+            define_shared_group("name", :foo => :bar, &implementation)
+            expect(SharedExampleGroup.registry.shared_example_groups[group]["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)
+            define_shared_group("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')
@@ -112,27 +100,6 @@ module RSpec::Core
         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
+