rspec-core 3.0.0.beta1 → 3.0.0.beta2

data/spec/rspec/core/formatters/snippet_extractor_spec.rb

@@ -4,7 +4,7 @@ require 'rspec/core/formatters/snippet_extractor'
 module RSpec
   module Core
     module Formatters
-      describe SnippetExtractor do
+      RSpec.describe SnippetExtractor do
         it "falls back on a default message when it doesn't understand a line" do
           expect(RSpec::Core::Formatters::SnippetExtractor.new.snippet_for("blech")).to eq(["# Couldn't get snippet for blech", 1])
         end

data/spec/rspec/core/formatters_spec.rb

@@ -0,0 +1,120 @@
+require 'spec_helper'
+
+module RSpec::Core::Formatters
+  describe Loader do
+
+    describe "#add(formatter)" do
+      let(:loader) { Loader.new reporter }
+      let(:output)     { StringIO.new }
+      let(:path)       { File.join(Dir.tmpdir, 'output.txt') }
+      let(:reporter)   { double "reporter", :register_listener => nil }
+
+      it "adds to the list of formatters" do
+        loader.add :documentation, output
+        expect(loader.formatters.first).to be_an_instance_of(DocumentationFormatter)
+      end
+
+      it "finds a formatter by name (w/ Symbol)" do
+        loader.add :documentation, output
+        expect(loader.formatters.first).to be_an_instance_of(DocumentationFormatter)
+      end
+
+      it "finds a formatter by name (w/ String)" do
+        loader.add 'documentation', output
+        expect(loader.formatters.first).to be_an_instance_of(DocumentationFormatter)
+      end
+
+      it "finds a formatter by class" do
+        formatter_class = Class.new(BaseTextFormatter)
+        Loader.formatters[formatter_class] = []
+        loader.add formatter_class, output
+        expect(loader.formatters.first).to be_an_instance_of(formatter_class)
+      end
+
+      it "finds a formatter by class name" do
+        stub_const("CustomFormatter", Class.new(BaseFormatter))
+        Loader.formatters[CustomFormatter] = []
+        loader.add "CustomFormatter", output
+        expect(loader.formatters.first).to be_an_instance_of(CustomFormatter)
+      end
+
+      it "handles formatters that dont implement notifications" do
+        formatter_class = Struct.new(:output)
+        loader.add formatter_class, output
+        expect(loader.formatters.first).to be_an_instance_of(RSpec::Core::Formatters::LegacyFormatter)
+      end
+
+      context "when a legacy formatter is added" do
+        formatter_class = Struct.new(:output)
+
+        it "issues a deprecation" do
+          expect_warn_deprecation_with_call_site(__FILE__, __LINE__ + 2,
+            /The #{formatter_class} formatter uses the deprecated formatter interface/)
+          loader.add formatter_class, output
+        end
+
+        it "does not mistakenly add in the progress formatter" do
+          # When we issue a deprecation warning it triggers `setup_defaults`,
+          # which adds the progress formatter if it thinks no formatter has been
+          # added yet.
+          allow(RSpec).to receive(:warn_deprecation) do
+            loader.setup_default(StringIO.new, StringIO.new)
+          end
+
+          loader.add formatter_class, output
+
+          expect(loader.formatters.grep(RSpec::Core::Formatters::ProgressFormatter)).to eq([])
+        end
+      end
+
+      it "finds a formatter by class fully qualified name" do
+        stub_const("RSpec::CustomFormatter", (Class.new(BaseFormatter)))
+        Loader.formatters[RSpec::CustomFormatter] = []
+        loader.add "RSpec::CustomFormatter", output
+        expect(loader.formatters.first).to be_an_instance_of(RSpec::CustomFormatter)
+      end
+
+      it "requires a formatter file based on its fully qualified name" do
+        expect(loader).to receive(:require).with('rspec/custom_formatter') do
+          stub_const("RSpec::CustomFormatter", (Class.new(BaseFormatter)))
+          Loader.formatters[RSpec::CustomFormatter] = []
+        end
+        loader.add "RSpec::CustomFormatter", output
+        expect(loader.formatters.first).to be_an_instance_of(RSpec::CustomFormatter)
+      end
+
+      it "raises NameError if class is unresolvable" do
+        expect(loader).to receive(:require).with('rspec/custom_formatter3')
+        expect { loader.add "RSpec::CustomFormatter3", output }.to raise_error(NameError)
+      end
+
+      it "raises ArgumentError if formatter is unknown" do
+        expect { loader.add :progresss, output }.to raise_error(ArgumentError)
+      end
+
+      context "with a 2nd arg defining the output" do
+        it "creates a file at that path and sets it as the output" do
+          loader.add('doc', path)
+          expect(loader.formatters.first.output).to be_a(File)
+          expect(loader.formatters.first.output.path).to eq(path)
+        end
+      end
+
+      context "when a duplicate formatter exists" do
+        before { loader.add :documentation, output }
+
+        it "doesn't add the formatter for the same output target" do
+          expect {
+            loader.add :documentation, output
+          }.not_to change { loader.formatters.length }
+        end
+
+        it "adds the formatter for different output targets" do
+          expect {
+            loader.add :documentation, path
+          }.to change { loader.formatters.length }
+        end
+      end
+    end
+  end
+end

data/spec/rspec/core/hooks_filtering_spec.rb

@@ -1,7 +1,7 @@
 require "spec_helper"
 
 module RSpec::Core
-  describe "config block hook filtering" do
+  RSpec.describe "config block hook filtering" do
     describe "unfiltered hooks" do
       it "is run" do
         filters = []

data/spec/rspec/core/hooks_spec.rb

@@ -1,7 +1,7 @@
 require "spec_helper"
 
 module RSpec::Core
-  describe Hooks do
+  RSpec.describe Hooks do
     class HooksHost
       include Hooks
 
@@ -69,7 +69,7 @@ module RSpec::Core
 
             expect { |b|
               instance.send(type, scope, &b)
-              instance.run_hook(type, scope)
+              instance.hooks.run(type, scope)
             }.not_to yield_control
           end
         end
@@ -279,5 +279,16 @@ module RSpec::Core
         expect(messages).to eq ["hook 1", "hook 2", "example"]
       end
     end
+
+    it "only defines methods that are intended to be part of RSpec's public API (+ `hooks`)" do
+      expect(Hooks.private_instance_methods).to eq([])
+
+      expect(Hooks.instance_methods.map(&:to_sym)).to match_array([
+        :before, :after, :around,
+        :append_before, :append_after,
+        :prepend_before, :prepend_after,
+        :hooks
+      ])
+    end
   end
 end

data/spec/rspec/core/memoized_helpers_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 module RSpec::Core
-  describe MemoizedHelpers do
+  RSpec.describe MemoizedHelpers do
     before(:each) { RSpec.configuration.configure_expectation_framework }
 
     def subject_value_for(describe_arg, &block)
@@ -73,7 +73,7 @@ module RSpec::Core
           it "is evaluated once per example" do
             group = ExampleGroup.describe(Array)
             group.before do
-              Object.should_receive(:this_question?).once.and_return(falsy_value)
+              expect(Object).to receive(:this_question?).once.and_return(falsy_value)
             end
             group.subject do
               Object.this_question?
@@ -298,7 +298,16 @@ module RSpec::Core
           it { should_not be_not_ok }
         end
 
-        expect(group.run).to be_truthy
+        expect(group.run).to be true
+      end
+
+      it 'supports a new expect-based syntax' do
+        group = ExampleGroup.describe([1, 2, 3]) do
+          it { is_expected.to be_an Array }
+          it { is_expected.not_to include 4 }
+        end
+
+        expect(group.run).to be true
       end
     end
 
@@ -316,7 +325,7 @@ module RSpec::Core
     end
   end
 
-  describe "#let" do
+  RSpec.describe "#let" do
     let(:counter) do
       Class.new do
         def initialize
@@ -434,7 +443,7 @@ module RSpec::Core
     end
   end
 
-  describe "#let!" do
+  RSpec.describe "#let!" do
     subject { [1,2,3] }
     let!(:popped) { subject.pop }
 
@@ -447,7 +456,7 @@ module RSpec::Core
     end
   end
 
-  describe 'using subject in before and let blocks' do
+  RSpec.describe 'using subject in before and let blocks' do
     shared_examples_for 'a subject' do
       let(:subject_id_in_let) { subject.object_id }
       before { @subject_id_in_before = subject.object_id }
@@ -456,7 +465,7 @@ module RSpec::Core
         expect(subject_id_in_let).to eq(@subject_id_in_before)
       end
 
-      it { should eq(subject) }
+      it { is_expected.to eq(subject) }
     end
 
     describe Object do
@@ -476,7 +485,7 @@ module RSpec::Core
     end
   end
 
-  describe 'Module#define_method' do
+  RSpec.describe 'Module#define_method' do
     it 'is still a private method' do
       a_module = Module.new
       expect { a_module.define_method(:name) { "implementation" } }.to raise_error NoMethodError

data/spec/rspec/core/metadata_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 module RSpec
   module Core
-    describe Metadata do
+    RSpec.describe Metadata do
 
       describe '.relative_path' do
         let(:here) { File.expand_path(".") }
@@ -50,7 +50,7 @@ module RSpec
         let(:next_example_metadata) { group_metadata.for_example('next_example', :caller => ["foo_spec.rb:#{example_line_number + 2}"]) }
         let(:world) { World.new }
 
-        before { RSpec.stub(:world) { world } }
+        before { allow(RSpec).to receive(:world) { world } }
 
         shared_examples_for "matching by line number" do
           let(:preceeding_declaration_lines) {{
@@ -61,7 +61,7 @@ module RSpec
             (example_metadata[:line_number] + 2) => example_metadata[:line_number] + 2,
           }}
           before do
-            world.should_receive(:preceding_declaration_line).at_least(:once).and_return do |v|
+            expect(world).to receive(:preceding_declaration_line).at_least(:once) do |v|
               preceeding_declaration_lines[v]
             end
           end

data/spec/rspec/core/option_parser_spec.rb

@@ -1,53 +1,60 @@
 require "spec_helper"
 
 module RSpec::Core
-  describe OptionParser do
+  RSpec.describe OptionParser do
     let(:output_file){ mock File }
 
     before do
-      RSpec.stub(:deprecate)
-      File.stub(:open).with("foo.txt",'w') { (output_file) }
+      allow(RSpec).to receive(:deprecate)
+      allow(File).to receive(:open).with("foo.txt",'w') { (output_file) }
     end
 
     it "does not parse empty args" do
       parser = Parser.new
-      OptionParser.should_not_receive(:new)
-      parser.parse!([])
+      expect(OptionParser).not_to receive(:new)
+      parser.parse([])
     end
 
     it "proposes you to use --help and returns an error on incorrect argument" do
       parser = Parser.new
       option = "--my_wrong_arg"
 
-      parser.should_receive(:abort) do |msg|
+      expect(parser).to receive(:abort) do |msg|
         expect(msg).to include('use --help', option)
       end
 
-      parser.parse!([option])
+      parser.parse([option])
     end
 
-    describe "--formatter" do
-      it "is deprecated" do
-        RSpec.should_receive(:deprecate)
-        Parser.parse!(%w[--formatter doc])
-      end
+    {
+      '--init'         => ['-i','--I'],
+      '--default-path' => ['-d'],
+      '--dry-run'      => ['-d'],
+      '--drb-port'     => ['-d'],
+    }.each do |long, shorts|
+      shorts.each do |option|
+        it "won't parse #{option} as a shorthand for #{long}" do
+          parser = Parser.new
+
+          expect(parser).to receive(:abort) do |msg|
+            expect(msg).to include('use --help', option)
+          end
 
-      it "gets converted to --format" do
-        options = Parser.parse!(%w[--formatter doc])
-        expect(options[:formatters].first).to eq(["doc"])
+          parser.parse([option])
+        end
       end
     end
 
     describe "--default_path" do
       it "gets converted to --default-path" do
-        options = Parser.parse!(%w[--default_path foo])
+        options = Parser.parse(%w[--default_path foo])
         expect(options[:default_path]).to eq "foo"
       end
     end
 
     describe "--line_number" do
       it "gets converted to --line-number" do
-        options = Parser.parse!(%w[--line_number 3])
+        options = Parser.parse(%w[--line_number 3])
         expect(options[:line_numbers]).to eq ["3"]
       end
     end
@@ -55,7 +62,7 @@ module RSpec::Core
 
     describe "--default-path" do
       it "sets the default path where RSpec looks for examples" do
-        options = Parser.parse!(%w[--default-path foo])
+        options = Parser.parse(%w[--default-path foo])
         expect(options[:default_path]).to eq "foo"
       end
     end
@@ -63,7 +70,7 @@ module RSpec::Core
     %w[--line-number -l].each do |option|
       describe option do
         it "sets the line number of an example to run" do
-          options = Parser.parse!([option, "3"])
+          options = Parser.parse([option, "3"])
           expect(options[:line_numbers]).to eq ["3"]
         end
       end
@@ -72,7 +79,7 @@ module RSpec::Core
     %w[--format -f].each do |option|
       describe option do
         it "defines the formatter" do
-          options = Parser.parse!([option, 'doc'])
+          options = Parser.parse([option, 'doc'])
           expect(options[:formatters].first).to eq(["doc"])
         end
       end
@@ -80,7 +87,7 @@ module RSpec::Core
 
     %w[--out -o].each do |option|
       describe option do
-        let(:options) { Parser.parse!([option, 'out.txt']) }
+        let(:options) { Parser.parse([option, 'out.txt']) }
 
         it "sets the output stream for the formatter" do
           expect(options[:formatters].last).to eq(['progress', 'out.txt'])
@@ -89,7 +96,7 @@ module RSpec::Core
         context "with multiple formatters" do
           context "after last formatter" do
             it "sets the output stream for the last formatter" do
-              options = Parser.parse!(['-f', 'progress', '-f', 'doc', option, 'out.txt'])
+              options = Parser.parse(['-f', 'progress', '-f', 'doc', option, 'out.txt'])
               expect(options[:formatters][0]).to eq(['progress'])
               expect(options[:formatters][1]).to eq(['doc', 'out.txt'])
             end
@@ -97,7 +104,7 @@ module RSpec::Core
 
           context "after first formatter" do
             it "sets the output stream for the first formatter" do
-              options = Parser.parse!(['-f', 'progress', option, 'out.txt', '-f', 'doc'])
+              options = Parser.parse(['-f', 'progress', option, 'out.txt', '-f', 'doc'])
               expect(options[:formatters][0]).to eq(['progress', 'out.txt'])
               expect(options[:formatters][1]).to eq(['doc'])
             end
@@ -109,7 +116,7 @@ module RSpec::Core
     %w[--example -e].each do |option|
       describe option do
         it "escapes the arg" do
-          options = Parser.parse!([option, "this (and that)"])
+          options = Parser.parse([option, "this (and that)"])
           expect(options[:full_description].length).to eq(1)
           expect("this (and that)").to match(options[:full_description].first)
         end
@@ -119,7 +126,7 @@ module RSpec::Core
     %w[--pattern -P].each do |option|
       describe option do
         it "sets the filename pattern" do
-          options = Parser.parse!([option, 'spec/**/*.spec'])
+          options = Parser.parse([option, 'spec/**/*.spec'])
           expect(options[:pattern]).to eq('spec/**/*.spec')
         end
       end
@@ -129,69 +136,69 @@ module RSpec::Core
       describe option do
         context "without ~" do
           it "treats no value as true" do
-            options = Parser.parse!([option, 'foo'])
+            options = Parser.parse([option, 'foo'])
             expect(options[:inclusion_filter]).to eq(:foo => true)
           end
 
           it "treats 'true' as true" do
-            options = Parser.parse!([option, 'foo:true'])
+            options = Parser.parse([option, 'foo:true'])
             expect(options[:inclusion_filter]).to eq(:foo => true)
           end
 
           it "treats 'nil' as nil" do
-            options = Parser.parse!([option, 'foo:nil'])
+            options = Parser.parse([option, 'foo:nil'])
             expect(options[:inclusion_filter]).to eq(:foo => nil)
           end
 
           it "treats 'false' as false" do
-            options = Parser.parse!([option, 'foo:false'])
+            options = Parser.parse([option, 'foo:false'])
             expect(options[:inclusion_filter]).to eq(:foo => false)
           end
 
           it "merges muliple invocations" do
-            options = Parser.parse!([option, 'foo:false', option, 'bar:true', option, 'foo:true'])
+            options = Parser.parse([option, 'foo:false', option, 'bar:true', option, 'foo:true'])
             expect(options[:inclusion_filter]).to eq(:foo => true, :bar => true)
           end
 
           it "treats 'any_string' as 'any_string'" do
-            options = Parser.parse!([option, 'foo:any_string'])
+            options = Parser.parse([option, 'foo:any_string'])
             expect(options[:inclusion_filter]).to eq(:foo => 'any_string')
           end
 
           it "treats ':any_sym' as :any_sym" do
-            options = Parser.parse!([option, 'foo::any_sym'])
+            options = Parser.parse([option, 'foo::any_sym'])
             expect(options[:inclusion_filter]).to eq(:foo => :any_sym)
           end
 
           it "treats '42' as 42" do
-            options = Parser.parse!([option, 'foo:42'])
+            options = Parser.parse([option, 'foo:42'])
             expect(options[:inclusion_filter]).to eq(:foo => 42)
           end
 
           it "treats '3.146' as 3.146" do
-            options = Parser.parse!([option, 'foo:3.146'])
+            options = Parser.parse([option, 'foo:3.146'])
             expect(options[:inclusion_filter]).to eq(:foo => 3.146)
           end
         end
 
         context "with ~" do
           it "treats no value as true" do
-            options = Parser.parse!([option, '~foo'])
+            options = Parser.parse([option, '~foo'])
             expect(options[:exclusion_filter]).to eq(:foo => true)
           end
 
           it "treats 'true' as true" do
-            options = Parser.parse!([option, '~foo:true'])
+            options = Parser.parse([option, '~foo:true'])
             expect(options[:exclusion_filter]).to eq(:foo => true)
           end
 
           it "treats 'nil' as nil" do
-            options = Parser.parse!([option, '~foo:nil'])
+            options = Parser.parse([option, '~foo:nil'])
             expect(options[:exclusion_filter]).to eq(:foo => nil)
           end
 
           it "treats 'false' as false" do
-            options = Parser.parse!([option, '~foo:false'])
+            options = Parser.parse([option, '~foo:false'])
             expect(options[:exclusion_filter]).to eq(:foo => false)
           end
         end
@@ -200,13 +207,13 @@ module RSpec::Core
 
     describe "--order" do
       it "is nil by default" do
-        expect(Parser.parse!([])[:order]).to be_nil
+        expect(Parser.parse([])[:order]).to be_nil
       end
 
       %w[rand random].each do |option|
         context "with #{option}" do
           it "defines the order as random" do
-            options = Parser.parse!(['--order', option])
+            options = Parser.parse(['--order', option])
             expect(options[:order]).to eq(option)
           end
         end
@@ -215,38 +222,38 @@ module RSpec::Core
 
     describe "--seed" do
       it "sets the order to rand:SEED" do
-        options = Parser.parse!(%w[--seed 123])
+        options = Parser.parse(%w[--seed 123])
         expect(options[:order]).to eq("rand:123")
       end
     end
 
     describe '--profile' do
       it 'sets profile_examples to true by default' do
-        options = Parser.parse!(%w[--profile])
+        options = Parser.parse(%w[--profile])
         expect(options[:profile_examples]).to eq true
       end
 
       it 'sets profile_examples to supplied int' do
-        options = Parser.parse!(%w[--profile 10])
+        options = Parser.parse(%w[--profile 10])
         expect(options[:profile_examples]).to eq 10
       end
 
       it 'sets profile_examples to true when accidentally combined with path' do
         allow_warning
-        options = Parser.parse!(%w[--profile some/path])
+        options = Parser.parse(%w[--profile some/path])
         expect(options[:profile_examples]).to eq true
       end
 
       it 'warns when accidentally combined with path' do
         expect_warning_without_call_site "Non integer specified as profile count"
-        options = Parser.parse!(%w[--profile some/path])
+        options = Parser.parse(%w[--profile some/path])
         expect(options[:profile_examples]).to eq true
       end
     end
 
     describe '--warning' do
       it 'enables warnings' do
-        options = Parser.parse!(%w[--warnings])
+        options = Parser.parse(%w[--warnings])
         expect(options[:warnings]).to eq true
       end
     end