rspec-core 2.0.0.beta.22 → 2.6.0

data/spec/rspec/core/shared_example_group_spec.rb

@@ -6,7 +6,6 @@ module RSpec::Core
 
     %w[share_examples_for shared_examples_for].each do |method_name|
       describe method_name do
-
         it "is exposed to the global namespace" do
           Kernel.should respond_to(method_name)
         end
@@ -19,32 +18,49 @@ module RSpec::Core
           end.should raise_error(ArgumentError, "Shared example group 'shared group' already exists")
         end
 
-        it "captures the given name and block in the Worlds collection of shared example groups" do
-          implementation = lambda {}
-          RSpec.world.shared_example_groups.should_receive(:[]=).with(:foo, implementation)
-          send(method_name, :foo, &implementation)
+        context "given a string" do
+          it "captures the given string and block in the World's collection of shared example groups" do
+            implementation = lambda {}
+            RSpec.world.shared_example_groups.should_receive(:[]=).with("name", implementation)
+            send(method_name, "name", &implementation)
+          end
         end
 
-      end
-    end
+        context "given a symbol" do
+          it "captures the given symbol and block in the World's collection of shared example groups" do
+            implementation = lambda {}
+            RSpec.world.shared_example_groups.should_receive(:[]=).with(:name, implementation)
+            send(method_name, :name, &implementation)
+          end
+        end
 
-    describe "#share_as" do
-      it "is exposed to the global namespace" do
-        Kernel.should respond_to("share_as")
-      end
+        context "given a hash" do
+          it "delegates extend on configuration" do
+            implementation = Proc.new { def bar; 'bar'; end }
+            send(method_name, :foo => :bar, &implementation)
+            a = RSpec.configuration.include_or_extend_modules.first
+            a[0].should eq(:extend)
+            Class.new.extend(a[1]).new.bar.should eq('bar')
+            a[2].should eq(:foo => :bar)
+          end
+        end
 
-      it "adds examples to current example_group using include", :compat => 'rspec-1.2' do
-        share_as('Cornucopia') do
-          it "is plentiful" do
-            5.should == 4
+        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 {}
+            RSpec.world.shared_example_groups.should_receive(:[]=).with("name", implementation)
+            send(method_name, "name", :foo => :bar, &implementation)
+          end
+
+          it "delegates extend on configuration" do
+            implementation = Proc.new { def bar; 'bar'; end }
+            send(method_name, "name", :foo => :bar, &implementation)
+            a = RSpec.configuration.include_or_extend_modules.first
+            a[0].should eq(:extend)
+            Class.new.extend(a[1]).new.bar.should eq('bar')
+            a[2].should eq(:foo => :bar)
           end
         end
-        group = ExampleGroup.describe('group') { include Cornucopia }
-        phantom_group = group.children.first
-        phantom_group.description.should eql("")
-        phantom_group.metadata[:shared_group_name].should eql('Cornucopia')
-        phantom_group.examples.length.should == 1
-        phantom_group.examples.first.metadata[:description].should == "is plentiful"
       end
     end
 
@@ -97,7 +113,7 @@ module RSpec::Core
           group = ExampleGroup.describe("group") do
             it_should_behave_like "thing", :value1, :value2
           end
-          group.run_all
+          group.run
 
           passed_params.should == { :param1 => :value1, :param2 => :value2 }
         end
@@ -135,7 +151,7 @@ module RSpec::Core
               end
             end
           end
-          group.run_all
+          group.run
 
           scopes[0].should be(scopes[1])
         end
@@ -148,5 +164,25 @@ module RSpec::Core
         end.should raise_error(/Could not find shared example group named/)
       end
     end
+
+    describe "#share_as" do
+      it "is exposed to the global namespace" do
+        Kernel.should 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
+            5.should == 4
+          end
+        end
+        group = ExampleGroup.describe('group') { include Cornucopia }
+        phantom_group = group.children.first
+        phantom_group.description.should eql("")
+        phantom_group.metadata[:shared_group_name].should eql('Cornucopia')
+        phantom_group.examples.length.should == 1
+        phantom_group.examples.first.metadata[:description].should == "is plentiful"
+      end
+    end
   end
 end

data/spec/rspec/core/subject_spec.rb

@@ -3,6 +3,7 @@ require 'spec_helper'
 module RSpec::Core
 
   describe Subject do
+    before(:each) { RSpec.configuration.configure_expectation_framework }
 
     describe "implicit subject" do
       describe "with a class" do
@@ -32,6 +33,25 @@ module RSpec::Core
     end
 
     describe "explicit subject" do
+      [false, nil].each do |falsy_value|
+        context "with a value of #{falsy_value.inspect}" do
+          it "is evaluated once per example" do
+            group = ExampleGroup.describe(Array)
+            group.before do
+              Object.should_receive(:this_question?).once.and_return(falsy_value)
+            end
+            group.subject do
+              Object.this_question?
+            end
+            group.example do
+              subject
+              subject
+            end
+            group.run.should be_true, "expected subject block to be evaluated only once"
+          end
+        end
+      end
+
       describe "defined in a top level group" do
         it "replaces the implicit subject in that group" do
           group = ExampleGroup.describe(Array)
@@ -59,5 +79,121 @@ module RSpec::Core
         end
       end
     end
+
+    context "using 'self' as an explicit subject" do
+      it "delegates matcher to the ExampleGroup" do
+        group = ExampleGroup.describe("group") do
+          subject { self }
+          def ok?; true; end
+
+          it { should eq(self) }
+          it { should be_ok }
+        end
+
+        group.run.should be_true
+      end
+    end
+
+    describe "#its" do
+      subject do
+        Class.new do
+          def initialize
+            @call_count = 0
+          end
+
+          def call_count
+            @call_count += 1
+          end
+        end.new
+      end
+
+      context "with a call counter" do
+        its(:call_count) { should eq(1) }
+      end
+
+      context "with nil value" do
+        subject do
+          Class.new do
+            def nil_value
+              nil
+            end
+          end.new
+        end
+        its(:nil_value) { should be_nil }
+      end
+
+      context "with nested attributes" do
+        subject do
+          Class.new do
+            def name
+              "John"
+            end
+          end.new
+        end
+        its("name")            { should eq("John") }
+        its("name.size")       { should eq(4) }
+        its("name.size.class") { should eq(Fixnum) }
+      end
+
+      context "when it responds to #[]" do
+        subject do
+          Class.new do
+            def [](*objects)
+              objects.map do |object|
+                "#{object.class}: #{object.to_s}"
+              end.join("; ")
+            end
+
+            def name
+              "George"
+            end
+          end.new
+        end
+        its([:a]) { should == 'Symbol: a' }
+        its(['a']) { should == 'String: a' }
+        its([:b, 'c', 4]) { should == 'Symbol: b; String: c; Fixnum: 4' }
+        its(:name) { should = "George" }
+        context "when referring to an attribute without the proper array syntax" do
+          context "it raises an error" do
+            its(:age) do
+              expect do
+                should eq(64)
+              end.to raise_error(NoMethodError)
+            end
+          end
+        end
+      end
+
+      context "when it does not respond to #[]" do
+        subject { Object.new }
+
+        context "it raises an error" do
+          its([:a]) do
+            expect do
+              should == 'Symbol: a'
+            end.to raise_error(NoMethodError)
+          end
+        end
+      end
+
+      context "calling and overriding super" do
+        it "calls to the subject defined in the parent group" do
+          group = ExampleGroup.describe(Array) do
+            subject { [1, 'a'] }
+
+            its(:last) { should == 'a' }
+
+            describe '.first' do
+              def subject; super().first; end
+
+              its(:next) { should == 2 }
+            end
+          end
+
+          group.run.should be_true
+        end
+      end
+
+    end
   end
 end

data/spec/rspec/core/world_spec.rb

@@ -5,83 +5,95 @@ class Foo; end
 
 module RSpec::Core
 
-  describe World do
-
-    before do
-      @world = RSpec.world
-    end
-
-    describe "example_groups" do
-
-      it "should contain all defined example groups" do
-        group = RSpec::Core::ExampleGroup.describe("group") {}
-        @world.example_groups.should include(group)
+  describe RSpec::Core::World do
+    let(:configuration) { RSpec::Core::Configuration.new }
+    let(:world) { RSpec::Core::World.new(configuration) }
+
+    describe "#example_groups" do
+      it "contains all registered example groups" do
+        group = RSpec::Core::ExampleGroup.describe("group"){}
+        world.register(group)
+        world.example_groups.should include(group)
       end
-
     end
 
-    describe "applying inclusion filters" do
-
-      before(:each) do
-        options_1 = { :foo => 1, :color => 'blue', :feature => 'reporting' }
-        options_2 = { :pending => true, :feature => 'reporting'  }
-        options_3 = { :array => [1,2,3,4], :color => 'blue' }
-        @group1 = RSpec::Core::ExampleGroup.describe(Bar, "find group-1", options_1) { }
-        @group2 = RSpec::Core::ExampleGroup.describe(Bar, "find group-2", options_2) { }
-        @group3 = RSpec::Core::ExampleGroup.describe(Bar, "find group-3", options_3) { }
-        @group4 = RSpec::Core::ExampleGroup.describe(Foo, "find these examples") do
+    describe "#apply_inclusion_filters" do
+      let(:group1) { 
+        RSpec::Core::ExampleGroup.describe(Bar, "find group-1", 
+          { :foo => 1, :color => 'blue', :feature => 'reporting' }
+        ) {}
+      }
+
+      let(:group2) {
+        RSpec::Core::ExampleGroup.describe(Bar, "find group-2",
+          { :pending => true, :feature => 'reporting' }
+        ) {}
+      }
+
+      let(:group3) {
+        RSpec::Core::ExampleGroup.describe(Bar, "find group-3", 
+          { :array => [1,2,3,4], :color => 'blue' }
+        ) {}
+      }
+
+      let(:group4) {
+        RSpec::Core::ExampleGroup.describe(Foo, "find these examples") do
           it('I have no options') {}
           it("this is awesome", :awesome => true) {}
           it("this is too", :awesome => true) {}
           it("not so awesome", :awesome => false) {}
           it("I also have no options") {}
         end
-        @example_groups = [@group1, @group2, @group3, @group4]
-      end
+      }
+      
+      let(:example_groups) { [group1, group2, group3, group4] }
 
       it "finds no groups when given no search parameters" do
-        @world.apply_inclusion_filters([]).should == []
+        world.apply_inclusion_filters([]).should == []
       end
 
       it "finds matching groups when filtering on :describes (described class or module)" do
-        @world.apply_inclusion_filters(@example_groups, :example_group => { :describes => Bar }).should == [@group1, @group2, @group3]
+        world.apply_inclusion_filters(example_groups, :example_group => { :describes => Bar }).should == [group1, group2, group3]
       end
 
       it "finds matching groups when filtering on :description with text" do
-        @world.apply_inclusion_filters(@example_groups, :example_group => { :description => 'Bar find group-1' }).should == [@group1]
+        world.apply_inclusion_filters(example_groups, :example_group => { :description => 'Bar find group-1' }).should == [group1]
       end
 
       it "finds matching groups when filtering on :description with a lambda" do
-        @world.apply_inclusion_filters(@example_groups, :example_group => { :description => lambda { |v| v.include?('-1') || v.include?('-3') } }).should == [@group1, @group3]
+        world.apply_inclusion_filters(example_groups, :example_group => { :description => lambda { |v| v.include?('-1') || v.include?('-3') } }).should == [group1, group3]
       end
 
       it "finds matching groups when filtering on :description with a regular expression" do
-        @world.apply_inclusion_filters(@example_groups, :example_group => { :description => /find group/ }).should == [@group1, @group2, @group3]
+        world.apply_inclusion_filters(example_groups, :example_group => { :description => /find group/ }).should == [group1, group2, group3]
       end
 
       it "finds one group when searching for :pending => true" do
-        @world.apply_inclusion_filters(@example_groups, :pending => true ).should == [@group2]
+        world.apply_inclusion_filters(example_groups, :pending => true ).should == [group2]
       end
 
       it "finds matching groups when filtering on arbitrary metadata with a number" do
-        @world.apply_inclusion_filters(@example_groups, :foo => 1 ).should == [@group1]
+        world.apply_inclusion_filters(example_groups, :foo => 1 ).should == [group1]
       end
 
       it "finds matching groups when filtering on arbitrary metadata with an array" do
-        @world.apply_inclusion_filters(@example_groups, :array => [1,2,3,4]).should == [@group3]
+        world.apply_inclusion_filters(example_groups, :array => [1,2,3,4]).should == [group3]
       end
 
       it "finds no groups when filtering on arbitrary metadata with an array but the arrays do not match" do
-        @world.apply_inclusion_filters(@example_groups, :array => [4,3,2,1]).should be_empty
+        world.apply_inclusion_filters(example_groups, :array => [4,3,2,1]).should be_empty
       end
 
       it "finds matching examples when filtering on arbitrary metadata" do
-        @world.apply_inclusion_filters(@group4.examples, :awesome => true).should == [@group4.examples[1], @group4.examples[2]]
+        world.apply_inclusion_filters(group4.examples, :awesome => true).should == [group4.examples[1], group4.examples[2]]
       end
 
+      it "finds matching examples for example that match any of the filters" do
+        world.apply_inclusion_filters(group4.examples, :awesome => true, :something => :else).should == [group4.examples[1], group4.examples[2]]
+      end
     end
 
-    describe "applying exclusion filters" do
+    describe "#apply_exclusion_filters" do
 
       it "finds nothing if all describes match the exclusion filter" do
         options = { :network_access => true }
@@ -91,15 +103,18 @@ module RSpec::Core
           it("bar") {}
         end
 
-        @world.apply_exclusion_filters(group1.examples, :network_access => true).should == []
+        world.register(group1)
+
+        world.apply_exclusion_filters(group1.examples, :network_access => true).should == []
 
         group2 = ExampleGroup.describe(Bar, "find group-1") do
           it("foo", :network_access => true) {}
           it("bar") {}
         end
 
-        @world.apply_exclusion_filters(group2.examples, :network_access => true).should == [group2.examples.last]
+        world.register(group2)
 
+        world.apply_exclusion_filters(group2.examples, :network_access => true).should == [group2.examples.last]
       end
 
       it "finds nothing if a regexp matches the exclusion filter" do
@@ -107,57 +122,185 @@ module RSpec::Core
           it("foo") {}
           it("bar") {}
         end
-        @world.apply_exclusion_filters(group.examples, :name => /exclude/).should == []
-        @world.apply_exclusion_filters(group.examples, :name => /exclude/, :another => "foo").should == []
-        @world.apply_exclusion_filters(group.examples, :name => /exclude/, :another => "foo", :example_group => {
+        world.register(group)
+        world.apply_exclusion_filters(group.examples, :name => /exclude/).should == []
+        world.apply_exclusion_filters(group.examples, :name => /exclude/, :another => "foo").should == []
+        world.apply_exclusion_filters(group.examples, :name => /exclude/, :another => "foo", :example_group => {
           :describes => lambda { |b| b == Bar } } ).should == []
 
-        @world.apply_exclusion_filters(group.examples, :name => /exclude not/).should == group.examples
-        @world.apply_exclusion_filters(group.examples, :name => /exclude/, "another_condition" => "foo").should == group.examples
-        @world.apply_exclusion_filters(group.examples, :name => /exclude/, "another_condition" => "foo1").should == group.examples
+        world.apply_exclusion_filters(group.examples, :name => /exclude not/).should == group.examples
+        world.apply_exclusion_filters(group.examples, :name => /exclude/, "another_condition" => "foo").should == []
+        world.apply_exclusion_filters(group.examples, :name => /exclude/, "another_condition" => "foo1").should == []
       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
 
-    describe "preceding_declaration_line" do
-      before(:each) do
-        @group1_line = 10
-        @group2_line = 20
-        @group2_example1_line = 30
-        @group2_example2_line = 40
+          example("second_example") {}
 
-        @group1 = RSpec::Core::ExampleGroup.describe(Bar, "group-1") { }
-        @group2 = RSpec::Core::ExampleGroup.describe(Bar, "group-2") do
-          it('example 1') {}
-          it("example 2") {}
         end
-        @group1.metadata[:example_group][:line_number] = @group1_line
-        @group2.metadata[:example_group][:line_number] = @group2_line
-        @group2.examples[0].metadata[:line_number] = @group2_example1_line
-        @group2.examples[1].metadata[:line_number] = @group2_example2_line
       end
 
-      it "returns nil if no example or group precedes the line" do
-        @world.preceding_declaration_line(@group1_line-1).should == nil
+      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
+          world.preceding_declaration_line(group_declaration_line - 1).should be_nil
+        end
+
+        it "returns the argument line number if a group starts on that line" do
+          world.preceding_declaration_line(group_declaration_line).should eq(group_declaration_line)
+        end
+
+        it "returns the argument line number if an example starts on that line" do
+          world.preceding_declaration_line(example_declaration_line).should eq(example_declaration_line)
+        end
+
+        it "returns line number of a group that immediately precedes the argument line" do
+          world.preceding_declaration_line(group_declaration_line + 1).should eq(group_declaration_line)
+        end
+
+        it "returns line number of an example that immediately precedes the argument line" do
+          world.preceding_declaration_line(example_declaration_line + 1).should eq(example_declaration_line)
+        end
       end
 
-      it "returns the argument line number if a group starts on that line" do
-        @world.preceding_declaration_line(@group1_line).should == @group1_line
+      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
+          world.preceding_declaration_line(second_group_declaration_line).should 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
 
-      it "returns the argument line number if an example starts on that line" do
-        @world.preceding_declaration_line(@group2_example1_line).should == @group2_example1_line
+        context "with an inclusion filter" do
+          it "announces" do
+            configuration.inclusion_filter = { :foo => 'bar' }
+            reporter.should_receive(:message).
+              with("No examples matched #{{ :foo => 'bar' }.inspect}.")
+            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.inclusion_filter = { :foo => 'bar' }
+            reporter.should_receive(:message).
+              with("No examples matched #{{ :foo => 'bar' }.inspect}. Running all.")
+            world.announce_filters
+          end
+        end
+
+        context "with an exclusion filter" do
+          it "announces" do
+            configuration.exclusion_filter = { :foo => 'bar' }
+            reporter.should_receive(:message).
+              with("No examples were matched. Perhaps #{{ :foo => 'bar' }.inspect} is excluding everything?")
+            world.announce_filters
+          end
+        end
       end
 
-      it "returns line number of a group that immediately precedes the argument line" do
-        @world.preceding_declaration_line(@group2_line+1).should == @group2_line
+      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
 
-      it "returns line number of an example that immediately precedes the argument line" do
-        @world.preceding_declaration_line(@group2_example1_line+1).should == @group2_example1_line
+    describe "#inclusion_filter" do
+      describe "#description" do
+        it 'cleans up the description' do
+          # check the assumptions of this example
+          project_dir = File.expand_path('.')
+          lambda { }.inspect.should include(project_dir)
+          lambda { }.inspect.should include('0x')
+          lambda { }.inspect.should include(' (lambda)') if RUBY_VERSION > '1.9'
+
+          configuration.filter_run :foo => lambda { }
+          world.inclusion_filter.description.should_not include('0x')
+          world.inclusion_filter.description.should_not include(project_dir)
+          world.inclusion_filter.description.should_not include(' (lambda)')
+        end
       end
+    end
+
+    describe "#exclusion_filter" do
+      describe "#description" do
+        it 'returns `{}` when it only contains the default filters' do
+          world.exclusion_filter.description.should == {}.inspect
+        end
+
+        it 'includes other filters' do
+          configuration.exclusion_filter[:foo] = :bar
+          world.exclusion_filter.description.should == { :foo => :bar }.inspect
+        end
 
+        it 'includes an overriden :if filter' do
+          configuration.exclusion_filter[:if] = :custom_filter
+          world.exclusion_filter.description.should == { :if => :custom_filter }.inspect
+        end
+
+        it 'includes an overriden :unless filter' do
+          configuration.exclusion_filter[:unless] = :custom_filter
+          world.exclusion_filter.description.should == { :unless => :custom_filter }.inspect
+        end
+
+        it 'cleans up the description' do
+          # check the assumptions of this example
+          project_dir = File.expand_path('.')
+          lambda { }.inspect.should include(project_dir)
+          lambda { }.inspect.should include('0x')
+          lambda { }.inspect.should include(' (lambda)') if RUBY_VERSION > '1.9'
+
+          configuration.exclusion_filter[:foo] = lambda { }
+          configuration.filter_run_excluding :bar => lambda { }
+          world.exclusion_filter.description.should_not include('0x')
+          world.exclusion_filter.description.should_not include(project_dir)
+          world.exclusion_filter.description.should_not include(' (lambda)')
+        end
+      end
     end
   end
-
 end