rspec-core 2.0.0.a2 → 2.0.0.a3

data/spec/rspec/core/example_group_subject_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 def describe_double(describes=Object)
   group = Rspec::Core::ExampleGroup.describe(describes) {}
-  remove_last_describe_from_world
+  remove_last_example_group_from_world
   yield group if block_given?
   group
 end

data/spec/rspec/core/example_spec.rb

@@ -3,13 +3,18 @@ require 'spec_helper'
 describe Rspec::Core::Example, :parent_metadata => 'sample' do
 
   before do
-    behaviour = stub('behaviour', :metadata => { :behaviour => { :name => 'behaviour_name' }})
-    @example = Rspec::Core::Example.new(behaviour, 'description', {}, (lambda {}))
+    example_group = stub('example_group', 
+      :metadata => Rspec::Core::Metadata.new.process(
+        'group description',
+        :caller => ['foo_spec.rb:37']
+      )
+    ).as_null_object 
+    @example = Rspec::Core::Example.new(example_group, 'example description', {}, (lambda {}))
   end
 
   describe "attr readers" do
-    it "should have one for the parent behaviour" do
-      @example.should respond_to(:behaviour)
+    it "should have one for the parent example group" do
+      @example.should respond_to(:example_group)
     end
 
     it "should have one for it's description" do
@@ -26,8 +31,8 @@ describe Rspec::Core::Example, :parent_metadata => 'sample' do
   end
 
   describe '#inspect' do
-    it "should return 'behaviour_name - description'" do
-      @example.inspect.should == 'behaviour_name - description'
+    it "should return 'group description - description'" do
+      @example.inspect.should == 'group description example description'
     end
   end
 
@@ -37,13 +42,19 @@ describe Rspec::Core::Example, :parent_metadata => 'sample' do
     end
   end
 
+  describe '#described_class' do
+    it "returns the class (if any) of the outermost example group" do
+      described_class.should == Rspec::Core::Example
+    end
+  end
+
   describe "accessing metadata within a running example" do
     it "should have a reference to itself when running" do
       running_example.description.should == "should have a reference to itself when running"
     end
 
-    it "should be able to access the behaviours top level metadata as if it were its own" do
-      running_example.behaviour.metadata.should include(:parent_metadata => 'sample')
+    it "should be able to access the example group's top level metadata as if it were its own" do
+      running_example.example_group.metadata.should include(:parent_metadata => 'sample')
       running_example.metadata.should include(:parent_metadata => 'sample')
     end
   end

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

@@ -68,8 +68,8 @@ describe Rspec::Core::Formatters::BaseFormatter do
     @formatter.should have_interface_for(:start).with(1).argument
   end
 
-  it "should have add_behaviour as an interface with one argument" do
-    @formatter.should have_interface_for(:add_behaviour).with(1).argument
+  it "should have add_example_group as an interface with one argument" do
+    @formatter.should have_interface_for(:add_example_group).with(1).argument
   end
 
   it "should have example_finished as an interface with one argument" do

data/spec/rspec/core/metadata_spec.rb

@@ -3,29 +3,41 @@ require 'spec_helper'
 module Rspec
   module Core
     describe Metadata do
-      describe "#generated_name" do
+      describe "[:example_group][:name]" do
         it "generates name for top level example group" do
           m = Metadata.new
           m.process("description", :caller => caller(0))
-          m[:behaviour][:name].should == "description"
+          m[:example_group][:name].should == "description"
         end
 
         it "concats args to describe()" do
           m = Metadata.new
           m.process(String, "with dots", :caller => caller(0))
-          m[:behaviour][:name].should == "String with dots"
+          m[:example_group][:name].should == "String with dots"
         end
 
         it "concats nested names" do
-          m = Metadata.new(:behaviour => {:name => 'parent'})
-          m.process(String, "child", :caller => caller(0))
-          m[:behaviour][:name].should == "parent child"
+          parent = Metadata.new
+          parent.process("parent", :caller => caller(0))
+          m = Metadata.new(parent)
+          m.process("child", :caller => caller(0))
+          m[:example_group][:name].should == "parent child"
         end
 
         it "strips the name" do
           m = Metadata.new
           m.process("  description  \n", :caller => caller(0))
-          m[:behaviour][:name].should == "description"
+          m[:example_group][:name].should == "description"
+        end
+      end
+
+      describe "[:full_description]" do
+        it "concats the example group name and description" do
+          m = Metadata.new
+          m[:example_group][:name] = "group"
+
+          m = m.for_example("example", {})
+          m[:full_description].should == "group example"
         end
       end
 
@@ -38,7 +50,7 @@ module Rspec
             "bar_spec.rb:23",
             "baz"
           ])
-          m[:behaviour][:file_path].should == __FILE__
+          m[:example_group][:file_path].should == __FILE__
         end
       end
 
@@ -51,7 +63,7 @@ module Rspec
             "bar_spec.rb:23",
             "baz"
           ])
-          m[:behaviour][:line_number].should == __LINE__ - 4
+          m[:example_group][:line_number].should == __LINE__ - 4
         end
         it "uses the number after the first : for ruby 1.9" do
           m = Metadata.new
@@ -61,18 +73,22 @@ module Rspec
             "bar_spec.rb:23",
             "baz"
           ])
-          m[:behaviour][:line_number].should == __LINE__ - 4
+          m[:example_group][:line_number].should == __LINE__ - 4
         end
       end
 
       describe "#metadata_for_example" do
-        let(:caller_to_use)      { caller(0) }
-        let(:caller_line_number) { __LINE__ - 1 }
-        let(:metadata)           { Metadata.new.process(:caller => caller_to_use) }
-        let(:mfe)                { metadata.for_example("this description", {:caller => caller_to_use, :arbitrary => :options}) }
+        let(:caller_for_example) { caller(0) }
+        let(:line_number)        { __LINE__ - 1 }
+        let(:metadata)           { Metadata.new.process("group description", :caller => caller(0)) }
+        let(:mfe)                { metadata.for_example("example description", {:caller => caller_for_example, :arbitrary => :options}) }
 
         it "stores the description" do
-          mfe[:description].should == "this description"
+          mfe[:description].should == "example description"
+        end
+
+        it "stores the full_description (group description + example description)" do
+          mfe[:full_description].should == "group description example description"
         end
 
         it "creates an empty execution result" do
@@ -80,7 +96,7 @@ module Rspec
         end
 
         it "stores the caller" do
-          mfe[:caller].should == caller_to_use
+          mfe[:caller].should == caller_for_example
         end
 
         it "extracts file path from caller" do
@@ -88,14 +104,33 @@ module Rspec
         end
 
         it "extracts line number from caller" do
-          mfe[:line_number].should == caller_line_number 
+          mfe[:line_number].should == line_number 
+        end
+
+        it "extracts location from caller" do
+          mfe[:location].should == "#{__FILE__}:#{line_number}"
         end
 
         it "merges arbitrary options" do
           mfe[:arbitrary].should == :options 
         end
+      end
 
+      describe "#apply_condition" do
+        let(:group_metadata) { Metadata.new.process('group', :caller => ["foo_spec.rb:#{__LINE__}"]) }
+        let(:group_line_number) { __LINE__ -1 }
+        let(:example_metadata) { group_metadata.for_example('example', :caller => ["foo_spec.rb:#{__LINE__}"]) }
+        let(:example_line_number) { __LINE__ -1 }
+
+        it "matches when the line_number matches the group" do
+          group_metadata.apply_condition(:line_number, group_line_number).should be_true
+        end
+
+        it "matches when the line_number matches the example" do
+          example_metadata.apply_condition(:line_number, example_line_number).should be_true
+        end
       end
+
     end
   end
 end

data/spec/rspec/core/mocha_spec.rb

@@ -10,15 +10,15 @@ describe "Mocha Regression involving double reporting of errors" do
 
     use_formatter(formatter) do
 
-      isolate_example_group do
-        desc = Rspec::Core::ExampleGroup.describe("my favorite pony") do
+      disconnect_from_world do
+        group = Rspec::Core::ExampleGroup.describe("my favorite pony") do
           example("showing a double fail") do
             foo = "string"
             foo.expects(:something)
           end
         end      
-        desc.examples_to_run.replace(desc.examples)
-        desc.run(formatter)
+        group.examples_to_run.replace(group.examples)
+        group.run(formatter)
       end
 
     end

data/spec/rspec/core/pending_example_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+Rspec::Matchers.define :be_pending do
+  match do |example|
+    example.metadata[:pending]
+  end
+end
+
+describe "an example" do
+  context "with no block" do
+    it "is listed as pending" do
+      group = isolated_example_group do
+        it "has no block" 
+      end
+      group.run(stub('reporter').as_null_object)
+      group.examples.first.should be_pending
+    end
+  end
+end

data/spec/rspec/core/ruby_project_spec.rb

@@ -0,0 +1,24 @@
+module Rspec
+  module Core
+    describe RubyProject do
+
+      describe "#determine_root" do
+
+        context "with ancestor containing spec directory" do
+          it "returns ancestor containing the spec directory" do
+            RubyProject.stub(:ascend_until).and_return('foodir')
+            RubyProject.determine_root.should == 'foodir'
+          end
+        end
+
+        context "without ancestor containing spec directory" do
+          it "returns current working directory" do
+            RubyProject.stub(:find_first_parent_containing).and_return(nil)
+            RubyProject.determine_root.should == '.'
+          end
+        end
+
+      end
+    end
+  end
+end

data/spec/rspec/core/{shared_behaviour_spec.rb → shared_example_group_spec.rb}

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Rspec::Core::SharedBehaviour do
+describe Rspec::Core::SharedExampleGroup do
 
   it "should add the 'share_examples_for' method to the global namespace" do
     Kernel.should respond_to(:share_examples_for)
@@ -14,8 +14,8 @@ describe Rspec::Core::SharedBehaviour do
     Kernel.should respond_to(:share_as)
   end
 
-  it "should raise an ArgumentError when adding a second shared behaviour with the same name" do
-    group = double_describe('example group')
+  it "should raise an ArgumentError when adding a second shared example group with the same name" do
+    group = isolated_example_group('example group')
     group.share_examples_for('really important business value') { }
     lambda do
       group.share_examples_for('really important business value') { }
@@ -24,42 +24,42 @@ describe Rspec::Core::SharedBehaviour do
 
   describe "share_examples_for" do
 
-    it "should capture the given name and block in the Worlds collection of shared behaviours" do
-      Rspec::Core.world.shared_behaviours.should_receive(:[]=).with(:foo, anything)
+    it "should capture the given name and block in the Worlds collection of shared example groups" do
+      Rspec::Core.world.shared_example_groups.should_receive(:[]=).with(:foo, anything)
       share_examples_for(:foo) { }
     end
 
   end
 
-  describe "including shared behaviours using #it_should_behave_like" do
+  describe "including shared example_groups using #it_should_behave_like" do
 
-    def cleanup_shared_behaviours
-      original_shared_behaviours = Rspec::Core.world.shared_behaviours
+    def cleanup_shared_example_groups
+      original_shared_example_groups = Rspec::Core.world.shared_example_groups
       yield if block_given?
-      Rspec::Core.world.shared_behaviours.replace(original_shared_behaviours)
+      Rspec::Core.world.shared_example_groups.replace(original_shared_example_groups)
     end
 
-    it "should module_eval any found shared behaviours" do
-      group = double_describe('fake group')
+    it "should module_eval any found shared example_groups" do
+      group = isolated_example_group('fake group')
       block1 = lambda {}
       block2 = lambda {
         def extra_helper
           'extra_helper'
         end
       }
-      Rspec::Core.world.stub!(:shared_behaviours).and_return({ :a => block1, :shared_behaviour => block2 })
+      Rspec::Core.world.stub!(:shared_example_groups).and_return({ :a => block1, :shared_example_group => block2 })
       group.should_receive(:module_eval).once
-      group.it_should_behave_like :shared_behaviour
+      group.it_should_behave_like :shared_example_group
     end
 
-    it "should make any shared behaviour available at the correct level" do
-      group = double_describe('fake group')
+    it "should make any shared example_group available at the correct level" do
+      group = isolated_example_group('fake group')
       block = lambda {
         def self.class_helper; end
         def extra_helper; end
       }
-      Rspec::Core.world.stub!(:shared_behaviours).and_return({ :shared_behaviour => block })
-      group.it_should_behave_like :shared_behaviour
+      Rspec::Core.world.stub!(:shared_example_groups).and_return({ :shared_example_group => block })
+      group.it_should_behave_like :shared_example_group
       with_ruby(1.8) do
         group.instance_methods.should include('extra_helper')
         group.singleton_methods.should include('class_helper')
@@ -73,9 +73,9 @@ describe Rspec::Core::SharedBehaviour do
     it "should raise when named shared example_group can not be found" 
 
     it "adds examples to current example_group using it_should_behave_like" do
-      cleanup_shared_behaviours do
-        group = double_describe("example_group") do |g|
-          g.it("i was already here") {}
+      cleanup_shared_example_groups do
+        group = isolated_example_group("example_group") do
+          it("i was already here") {}
         end
 
         group.examples.size.should == 1
@@ -92,8 +92,8 @@ describe Rspec::Core::SharedBehaviour do
     end
 
     it "adds examples to from two shared groups" do
-      cleanup_shared_behaviours do
-        group = double_describe("example_group") do |g|
+      cleanup_shared_example_groups do
+        group = isolated_example_group("example_group") do |g|
           g.it("i was already here") {}
         end
 
@@ -116,17 +116,17 @@ describe Rspec::Core::SharedBehaviour do
     end
 
     share_as('Cornucopia') do
-      it "should do foo"
+      it "should do foo" do; end
     end
 
-    it "adds examples to current example_group using include", :compat => 'rspec-1.2' do
-      group = double_describe('group') { include Cornucopia }
-      group.should have(1).example
+    pending "adds examples to current example_group using include", :compat => 'rspec-1.2' do
+      group = isolated_example_group('group') { include Cornucopia }
+      group.examples.length.should == 1
     end
 
     it "adds examples to current example_group using it_should_behave_like with a module" do
-      cleanup_shared_behaviours do
-        group = double_describe("example_group")  {}
+      cleanup_shared_example_groups do
+        group = isolated_example_group("example_group")  {}
 
         shared_foo = group.share_as(:FooShared) do
           it("shared example") {}
@@ -168,13 +168,13 @@ describe Rspec::Core::SharedBehaviour do
       it "should run after(:all) only once from shared example_group", :compat => 'rspec-1.2' 
 
       it "should include modules, included into shared example_group, into current example_group", :compat => 'rspec-1.2' do
-        running_example.behaviour.included_modules.should include(RunningSharedExamplesJustForTesting)
+        running_example.example_group.included_modules.should include(RunningSharedExamplesJustForTesting)
       end
 
       it "should make methods defined in the shared example_group available in consuming example_group", :compat => 'rspec-1.2' do
         # TODO: Consider should have_method(...) simple matcher
-        with_ruby('1.8') { running_example.behaviour.methods.should include('magic') }
-        with_ruby('1.9') { running_example.behaviour.methods.should include(:magic) }
+        with_ruby('1.8') { running_example.example_group.methods.should include('magic') }
+        with_ruby('1.9') { running_example.example_group.methods.should include(:magic) }
       end
 
     end

data/spec/rspec/core/world_spec.rb

@@ -7,14 +7,16 @@ describe Rspec::Core::World do
   
   before do
     @world = Rspec::Core::World.new
-    Rspec::Core.stub!(:world).and_return(@world)
+    Rspec::Core.stub(:world).and_return(@world)
   end
 
-  describe "behaviour groups" do
+  describe "example groups" do
   
-    it "should contain all defined behaviour groups" do
-      behaviour_group = Rspec::Core::ExampleGroup.describe(Bar, 'Empty Behaviour Group') { }
-      @world.behaviours.should include(behaviour_group)       
+    it "should contain all defined example groups" do
+      disconnect_from_world do
+        example_group = Rspec::Core::ExampleGroup.describe(Bar, 'Empty Example Group') { }
+        @world.example_groups.should include(example_group)       
+      end
     end
   
   end
@@ -24,7 +26,7 @@ describe Rspec::Core::World do
     before(:all) do
       options_1 = { :foo => 1, :color => 'blue', :feature => 'reporting' }
       options_2 = { :pending => true, :feature => 'reporting'  }
-      options_3 = { :array => [1,2,3,4], :color => 'blue', :feature => 'weather status' }      
+      options_3 = { :array => [1,2,3,4], :color => 'blue' }      
       @bg1 = Rspec::Core::ExampleGroup.describe(Bar, "find group-1", options_1) { }
       @bg2 = Rspec::Core::ExampleGroup.describe(Bar, "find group-2", options_2) { }
       @bg3 = Rspec::Core::ExampleGroup.describe(Bar, "find group-3", options_3) { }
@@ -35,64 +37,56 @@ describe Rspec::Core::World do
         it("not so awesome", :awesome => false) {}
         it("I also have no options") {}
       end
-      @behaviours = [@bg1, @bg2, @bg3, @bg4]
+      @example_groups = [@bg1, @bg2, @bg3, @bg4]
     end
     
     after(:all) do
-      Rspec::Core.world.behaviours.delete(@bg1)
-      Rspec::Core.world.behaviours.delete(@bg2)
-      Rspec::Core.world.behaviours.delete(@bg3)
-      Rspec::Core.world.behaviours.delete(@bg4)
+      Rspec::Core.world.example_groups.delete(@bg1)
+      Rspec::Core.world.example_groups.delete(@bg2)
+      Rspec::Core.world.example_groups.delete(@bg3)
+      Rspec::Core.world.example_groups.delete(@bg4)
     end
   
-    it "should find awesome examples" do
-      @world.apply_inclusion_filters(@bg4.examples, :awesome => true).should == [@bg4.examples[1], @bg4.examples[2]]
-    end
-    
-    it "should find no groups when given no search parameters" do
+    it "finds no groups when given no search parameters" do
       @world.apply_inclusion_filters([]).should == []
     end
   
-    it "should find three groups when searching for :behaviour_describes => Bar" do
-      @world.apply_inclusion_filters(@behaviours, :behaviour => { :describes => Bar }).should == [@bg1, @bg2, @bg3]
-    end
-    
-    it "should find one group when searching for :description => 'find group-1'" do
-      @world.apply_inclusion_filters(@behaviours, :behaviour => { :description => 'find group-1' }).should == [@bg1]
+    it "finds matching groups when filtering on :describes (described class or module)" do
+      @world.apply_inclusion_filters(@example_groups, :example_group => { :describes => Bar }).should == [@bg1, @bg2, @bg3]
     end
     
-    it "should find two groups when searching for :description => lambda { |v| v.include?('-1') || v.include?('-3') }" do
-      @world.apply_inclusion_filters(@behaviours, :behaviour => { :description => lambda { |v| v.include?('-1') || v.include?('-3') } }).should == [@bg1, @bg3]
+    it "finds matching groups when filtering on :description with text" do
+      @world.apply_inclusion_filters(@example_groups, :example_group => { :description => 'find group-1' }).should == [@bg1]
     end
     
-    it "should find three groups when searching for :description => /find group/" do
-      @world.apply_inclusion_filters(@behaviours, :behaviour => { :description => /find group/ }).should == [@bg1, @bg2, @bg3]
+    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 == [@bg1, @bg3]
     end
     
-    it "should find one group when searching for :foo => 1" do
-      @world.apply_inclusion_filters(@behaviours, :foo => 1 ).should == [@bg1]
+    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 == [@bg1, @bg2, @bg3]
     end
     
-    it "should find one group when searching for :pending => true" do
-      @world.apply_inclusion_filters(@behaviours, :pending => true ).should == [@bg2]
+    it "finds one group when searching for :pending => true" do
+      @world.apply_inclusion_filters(@example_groups, :pending => true ).should == [@bg2]
     end
   
-    it "should find one group when searching for :array => [1,2,3,4]" do
-      @world.apply_inclusion_filters(@behaviours, :array => [1,2,3,4]).should == [@bg3]
+    it "finds matching groups when filtering on arbitrary metadata with a number" do
+      @world.apply_inclusion_filters(@example_groups, :foo => 1 ).should == [@bg1]
+    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 == [@bg3]
     end
   
-    it "should find no group when searching for :array => [4,3,2,1]" do
-      @world.apply_inclusion_filters(@behaviours, :array => [4,3,2,1]).should be_empty
+    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 "should find two groups when searching for :color => 'blue'" do
-      @world.apply_inclusion_filters(@behaviours, :color => 'blue').should == [@bg1, @bg3]
-    end
-  
-    it "should find two groups when searching for :feature => 'reporting' }" do
-      @world.apply_inclusion_filters(@behaviours, :feature => 'reporting').should == [@bg1, @bg2]
+    it "finds matching examples when filtering on arbitrary metadata" do
+      @world.apply_inclusion_filters(@bg4.examples, :awesome => true).should == [@bg4.examples[1], @bg4.examples[2]]
     end
-  
+    
   end
   
   describe "applying exclusion filters" do
@@ -100,65 +94,52 @@ describe Rspec::Core::World do
     it "should find nothing if all describes match the exclusion filter" do
       options = { :network_access => true }      
       
-      isolate_example_group do
-        group1 = Rspec::Core::ExampleGroup.describe(Bar, "find group-1", options) do
-          it("foo") {}
-          it("bar") {}
-        end
-        
-        @world.apply_exclusion_filters(group1.examples, :network_access => true).should == []
+      group1 = isolated_example_group(Bar, "find group-1", options) do
+        it("foo") {}
+        it("bar") {}
       end
       
-      isolate_example_group do
-        group2 = Rspec::Core::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.apply_exclusion_filters(group1.examples, :network_access => true).should == []
+      
+      group2 = isolated_example_group(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]
   
     end
     
     it "should find nothing if a regexp matches the exclusion filter" do
-      isolate_example_group do
-        group = Rspec::Core::ExampleGroup.describe(Bar, "find group-1", :name => "exclude me with a regex", :another => "foo") do
-          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", :behaviour => {
-          :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
+      group = isolated_example_group(Bar, "find group-1", :name => "exclude me with a regex", :another => "foo") do
+        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 => {
+        :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
     end
     
   end
   
-  describe "filtering behaviours" do
+  describe "filtering example groups" do
     
-    before(:all) do
-      @group1 = Rspec::Core::ExampleGroup.describe(Bar, "find these examples") do
+    it "should run matches" do
+      @group1 = isolated_example_group(Bar, "find these examples") do
         it('I have no options',       :color => :red, :awesome => true) {}
         it("I also have no options",  :color => :red, :awesome => true) {}
         it("not so awesome",          :color => :red, :awesome => false) {}
       end
-    end
-    
-    after(:all) do
-      Rspec::Core.world.behaviours.delete(@group1)
-    end
-
-    it "should run matches" do
-      Rspec::Core.world.stub!(:exclusion_filter).and_return({ :awesome => false })
-      Rspec::Core.world.stub!(:filter).and_return({ :color => :red })
-      Rspec::Core.world.stub!(:behaviours).and_return([@group1])
-      filtered_behaviours = @world.filter_behaviours
-      filtered_behaviours.should == [@group1]
+      Rspec::Core.world.stub(:exclusion_filter).and_return({ :awesome => false })
+      Rspec::Core.world.stub(:filter).and_return({ :color => :red })
+      Rspec::Core.world.stub(:example_groups).and_return([@group1])
+      filtered_example_groups = @world.filter_example_groups
+      filtered_example_groups.should == [@group1]
       @group1.examples_to_run.should == @group1.examples[0..1]      
     end