rspec-core 2.7.1 → 2.8.0.rc1

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

@@ -16,7 +16,7 @@ module RSpec
 
         let(:generated_html) do
           options = RSpec::Core::ConfigurationOptions.new(
-            %w[spec/rspec/core/resources/formatter_specs.rb --format textmate]
+            %w[spec/rspec/core/resources/formatter_specs.rb --format textmate --order default]
           )
           options.parse_options
           err, out = StringIO.new, StringIO.new

data/spec/rspec/core/metadata_spec.rb

@@ -22,7 +22,6 @@ module RSpec
       end
 
       describe "#filter_applies?" do
-
         let(:parent_group_metadata) { Metadata.new.process('parent group', :caller => ["foo_spec.rb:#{__LINE__}"]) }
         let(:group_metadata) { Metadata.new(parent_group_metadata).process('group', :caller => ["foo_spec.rb:#{__LINE__}"]) }
         let(:example_metadata) { group_metadata.for_example('example', :caller => ["foo_spec.rb:#{__LINE__}"], :if => true) }
@@ -313,13 +312,29 @@ module RSpec
           child.for_example('example', child)[:full_description].should eq("parent child example")
         end
 
+        it "concats nested example group descriptions three deep" do
+          grandparent = Metadata.new
+          grandparent.process('grandparent')
+
+          parent = Metadata.new(grandparent)
+          parent.process('parent')
+
+          child = Metadata.new(parent)
+          child.process('child')
+
+          grandparent[:example_group][:full_description].should eq("grandparent")
+          parent[:example_group][:full_description].should eq("grandparent parent")
+          child[:example_group][:full_description].should eq("grandparent parent child")
+          child.for_example('example', child)[:full_description].should eq("grandparent parent child example")
+        end
+
         %w[# . ::].each do |char|
           context "with a 2nd arg starting with #{char}" do
-          it "removes the space" do
-            m = Metadata.new
-            m.process(Array, "#{char}method")
-            m[:example_group][:full_description].should eq("Array#{char}method")
-          end
+            it "removes the space" do
+              m = Metadata.new
+              m.process(Array, "#{char}method")
+              m[:example_group][:full_description].should eq("Array#{char}method")
+            end
           end
         end
 

data/spec/rspec/core/option_parser_spec.rb

@@ -82,5 +82,79 @@ module RSpec::Core
       end
     end
 
+    %w[--tag -t].each do |option|
+      describe option do
+        context "without ~" do
+          it "treats no value as true" do
+            options = Parser.parse!([option, 'foo'])
+            options[:inclusion_filter].should eq(:foo => true)
+          end
+
+          it "treats 'true' as true" do
+            options = Parser.parse!([option, 'foo:true'])
+            options[:inclusion_filter].should eq(:foo => true)
+          end
+
+          it "treats 'nil' as nil" do
+            options = Parser.parse!([option, 'foo:nil'])
+            options[:inclusion_filter].should eq(:foo => nil)
+          end
+
+          it "treats 'false' as false" do
+            options = Parser.parse!([option, 'foo:false'])
+            options[:inclusion_filter].should eq(:foo => false)
+          end
+
+          it "merges muliple invocations" do
+            options = Parser.parse!([option, 'foo:false', option, 'bar:true', option, 'foo:true'])
+            options[:inclusion_filter].should eq(:foo => true, :bar => true)
+          end
+        end
+
+        context "with ~" do
+          it "treats no value as true" do
+            options = Parser.parse!([option, '~foo'])
+            options[:exclusion_filter].should eq(:foo => true)
+          end
+
+          it "treats 'true' as true" do
+            options = Parser.parse!([option, '~foo:true'])
+            options[:exclusion_filter].should eq(:foo => true)
+          end
+
+          it "treats 'nil' as nil" do
+            options = Parser.parse!([option, '~foo:nil'])
+            options[:exclusion_filter].should eq(:foo => nil)
+          end
+
+          it "treats 'false' as false" do
+            options = Parser.parse!([option, '~foo:false'])
+            options[:exclusion_filter].should eq(:foo => false)
+          end
+        end
+      end
+    end
+
+    describe "--order" do
+      it "is nil by default" do
+        Parser.parse!([])[:order].should 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[:order].should eq(option)
+          end
+        end
+      end
+    end
+
+    describe "--seed" do
+      it "sets the order to rand:SEED" do
+        options = Parser.parse!(%w[--seed 123])
+        options[:order].should eq("rand:123")
+      end
+    end
   end
 end

data/spec/rspec/core/reporter_spec.rb

@@ -10,7 +10,7 @@ module RSpec::Core
       %w[start_dump dump_pending dump_failures dump_summary close].each do |message|
         it "sends #{message} to the formatter(s)" do
           formatter.should_receive(message)
-          reporter.abort
+          reporter.abort(nil)
         end
       end
     end
@@ -82,5 +82,22 @@ module RSpec::Core
         reporter.example_started(example)
       end
     end
+
+    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) {}
+      end
+
+      it "yields itself" do
+        reporter = Reporter.new
+        yielded = nil
+        reporter.report(3) {|r| yielded = r}
+        yielded.should eq(reporter)
+      end
+    end
   end
 end

data/spec/rspec/core/shared_context_spec.rb

@@ -1,30 +1,67 @@
 require "spec_helper"
 
-describe RSpec::Core::SharedContext do
-  describe "hooks" do
-    it "creates a before hook" do
-      before_all_hook = false
-      before_each_hook = false
-      after_each_hook = false
-      after_all_hook = false
+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
+
+    before_all_hook.should be_true
+    before_each_hook.should be_true
+    after_each_hook.should be_true
+    after_all_hook.should be_true
+  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
+
+    group.new.foo.should eq('foo')
+  end
+
+  %w[describe context].each do |method_name|
+    it "supports nested example groups using #{method_name}" do
       shared = Module.new do
-        extend RSpec::Core::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 }
+        extend RSpec::SharedContext
+        send(method_name, "nested using describe") do
+          example {}
+        end
       end
       group = RSpec::Core::ExampleGroup.describe do
         include shared
-        example { }
       end
 
       group.run
 
-      before_all_hook.should be_true
-      before_each_hook.should be_true
-      after_each_hook.should be_true
-      after_all_hook.should be_true
+      group.children.length.should eq(1)
+      group.children.first.examples.length.should eq(1)
     end
   end
 end

data/spec/rspec/core/subject_spec.rb

@@ -152,7 +152,7 @@ module RSpec::Core
         its([:a]) { should eq("Symbol: a") }
         its(['a']) { should eq("String: a") }
         its([:b, 'c', 4]) { should eq("Symbol: b; String: c; Fixnum: 4") }
-        its(:name) { should = "George" }
+        its(:name) { should eq("George") }
         context "when referring to an attribute without the proper array syntax" do
           context "it raises an error" do
             its(:age) do

data/spec/rspec/core/world_spec.rb

@@ -17,138 +17,11 @@ module RSpec::Core
       end
     end
 
-    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
-      }
-      
-      let(:example_groups) { [group1, group2, group3, group4] }
-
-      it "finds no groups when given no search parameters" do
-        world.apply_inclusion_filters([],{}).should eq([])
-      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 eq([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 eq([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 eq([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 eq([group1, group2, group3])
-      end
-
-      it "finds one group when searching for :pending => true" do
-        world.apply_inclusion_filters(example_groups, :pending => true ).should eq([group2])
-      end
-
-      it "finds matching groups when filtering on arbitrary metadata with a number" do
-        world.apply_inclusion_filters(example_groups, :foo => 1 ).should eq([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 eq([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
-      end
-
-      it "finds matching examples when filtering on arbitrary metadata" do
-        world.apply_inclusion_filters(group4.examples, :awesome => true).should eq([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 eq([group4.examples[1], group4.examples[2]])
-      end
-    end
-
-    describe "#apply_exclusion_filters" do
-
-      it "finds nothing if all describes match the exclusion filter" do
-        options = { :network_access => true }
-
-        group1 = ExampleGroup.describe(Bar, "find group-1", options) do
-          it("foo") {}
-          it("bar") {}
-        end
-
-        world.register(group1)
-
-        world.apply_exclusion_filters(group1.examples, :network_access => true).should eq([])
-
-        group2 = ExampleGroup.describe(Bar, "find group-1") do
-          it("foo", :network_access => true) {}
-          it("bar") {}
-        end
-
-        world.register(group2)
-
-        world.apply_exclusion_filters(group2.examples, :network_access => true).should eq([group2.examples.last])
-      end
-
-      it "finds nothing if a regexp matches the exclusion filter" do
-        group = ExampleGroup.describe(Bar, "find group-1", :name => "exclude me with a regex", :another => "foo") do
-          it("foo") {}
-          it("bar") {}
-        end
-        world.register(group)
-        world.apply_exclusion_filters(group.examples, :name => /exclude/).should eq([])
-        world.apply_exclusion_filters(group.examples, :name => /exclude/, :another => "foo").should eq([])
-        world.apply_exclusion_filters(group.examples, :name => /exclude/, :another => "foo", :example_group => {
-          :describes => lambda { |b| b == Bar } } ).should eq([])
-
-        world.apply_exclusion_filters(group.examples, :name => /exclude not/).should eq(group.examples)
-        world.apply_exclusion_filters(group.examples, :name => /exclude/, "another_condition" => "foo").should eq([])
-        world.apply_exclusion_filters(group.examples, :name => /exclude/, "another_condition" => "foo1").should eq([])
-      end
-
-      it "finds all if filters are empty" do
-        group = ExampleGroup.describe(Bar) do
-          example("foo") {}
-          example("bar") {}
-        end
-        world.register(group)
-        world.apply_exclusion_filters(group.examples, {}).should eq(group.examples)
-      end
-    end
-
     describe "#preceding_declaration_line (again)" do
-
       let(:group) do
         RSpec::Core::ExampleGroup.describe("group") do
 
-            example("example") {}
+          example("example") {}
 
         end
       end
@@ -219,9 +92,9 @@ module RSpec::Core
 
         context "with an inclusion filter" do
           it "announces" do
-            configuration.inclusion_filter = { :foo => 'bar' }
+            configuration.filter_run_including :foo => 'bar'
             reporter.should_receive(:message).
-              with("No examples matched #{{ :foo => 'bar' }.inspect}.")
+              with(/All examples were filtered out/)
             world.announce_filters
           end
         end
@@ -229,18 +102,18 @@ module RSpec::Core
         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' }
+            configuration.filter_run_including :foo => 'bar'
             reporter.should_receive(:message).
-              with("No examples matched #{{ :foo => 'bar' }.inspect}. Running all.")
+              with(/All examples were filtered out/)
             world.announce_filters
           end
         end
 
         context "with an exclusion filter" do
           it "announces" do
-            configuration.exclusion_filter = { :foo => 'bar' }
+            configuration.filter_run_excluding :foo => 'bar'
             reporter.should_receive(:message).
-              with("No examples were matched. Perhaps #{{ :foo => 'bar' }.inspect} is excluding everything?")
+              with(/All examples were filtered out/)
             world.announce_filters
           end
         end
@@ -257,59 +130,5 @@ module RSpec::Core
         end
       end
     end
-
-    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 eq({}.inspect)
-        end
-
-        it 'includes other filters' do
-          configuration.exclusion_filter[:foo] = :bar
-          world.exclusion_filter.description.should eq({ :foo => :bar }.inspect)
-        end
-
-        it 'includes an overriden :if filter' do
-          configuration.exclusion_filter[:if] = :custom_filter
-          world.exclusion_filter.description.should eq({ :if => :custom_filter }.inspect)
-        end
-
-        it 'includes an overriden :unless filter' do
-          configuration.exclusion_filter[:unless] = :custom_filter
-          world.exclusion_filter.description.should eq({ :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