@@ -11,16 +11,16 @@ describe Micronaut::World do end describe "behaviour groups" do - + it "should contain all defined behaviour groups" do behaviour_group = Micronaut::Behaviour.describe(Bar, 'Empty Behaviour Group') { } @world.behaviours.should include(behaviour_group) end - + end - - describe "find" do - + + describe "applying inclusion filters" do + before(:all) do options_1 = { :foo => 1, :color => 'blue', :feature => 'reporting' } options_2 = { :pending => true, :feature => 'reporting' } @@ -44,55 +44,124 @@ describe Micronaut::World do Micronaut.world.behaviours.delete(@bg3) Micronaut.world.behaviours.delete(@bg4) end - + it "should find awesome examples" do - @world.find(@bg4.examples, :awesome => true).should == [@bg4.examples[1], @bg4.examples[2]] + @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 - @world.find([]).should == [] + @world.apply_inclusion_filters([]).should == [] end it "should find three groups when searching for :behaviour_describes => Bar" do - @world.find(@behaviours, :behaviour => { :describes => Bar }).should == [@bg1, @bg2, @bg3] + @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.find(@behaviours, :behaviour => { :description => 'find group-1' }).should == [@bg1] + @world.apply_inclusion_filters(@behaviours, :behaviour => { :description => 'find group-1' }).should == [@bg1] end it "should find two groups when searching for :description => lambda { |v| v.include?('-1') || v.include?('-3') }" do - @world.find(@behaviours, :behaviour => { :description => lambda { |v| v.include?('-1') || v.include?('-3') } }).should == [@bg1, @bg3] + @world.apply_inclusion_filters(@behaviours, :behaviour => { :description => lambda { |v| v.include?('-1') || v.include?('-3') } }).should == [@bg1, @bg3] end it "should find three groups when searching for :description => /find group/" do - @world.find(@behaviours, :behaviour => { :description => /find group/ }).should == [@bg1, @bg2, @bg3] + @world.apply_inclusion_filters(@behaviours, :behaviour => { :description => /find group/ }).should == [@bg1, @bg2, @bg3] end it "should find one group when searching for :foo => 1" do - @world.find(@behaviours, :foo => 1 ).should == [@bg1] + @world.apply_inclusion_filters(@behaviours, :foo => 1 ).should == [@bg1] end it "should find one group when searching for :pending => true" do - @world.find(@behaviours, :pending => true ).should == [@bg2] + @world.apply_inclusion_filters(@behaviours, :pending => true ).should == [@bg2] end - + it "should find one group when searching for :array => [1,2,3,4]" do - @world.find(@behaviours, :array => [1,2,3,4]).should == [@bg3] + @world.apply_inclusion_filters(@behaviours, :array => [1,2,3,4]).should == [@bg3] end - + it "should find no group when searching for :array => [4,3,2,1]" do - @world.find(@behaviours, :array => [4,3,2,1]).should be_empty + @world.apply_inclusion_filters(@behaviours, :array => [4,3,2,1]).should be_empty end - + it "should find two groups when searching for :color => 'blue'" do - @world.find(@behaviours, :color => 'blue').should == [@bg1, @bg3] + @world.apply_inclusion_filters(@behaviours, :color => 'blue').should == [@bg1, @bg3] end - + it "should find two groups when searching for :feature => 'reporting' }" do - @world.find(@behaviours, :feature => 'reporting').should == [@bg1, @bg2] + @world.apply_inclusion_filters(@behaviours, :feature => 'reporting').should == [@bg1, @bg2] + end + + end + + describe "applying exclusion filters" do + + it "should find nothing if all describes match the exclusion filter" do + options = { :network_access => true } + + isolate_behaviour do + group1 = Micronaut::Behaviour.describe(Bar, "find group-1", options) do + it("foo") {} + it("bar") {} + end + + @world.apply_exclusion_filters(group1.examples, :network_access => true).should == [] + end + + isolate_behaviour do + group2 = Micronaut::Behaviour.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] + end + + end + + it "should find nothing if a regexp matches the exclusion filter" do + isolate_behaviour do + group = Micronaut::Behaviour.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 + end + end + + end + + describe "filtering behaviours" do + + before(:all) do + @group1 = Micronaut::Behaviour.describe(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 + Micronaut.world.behaviours.delete(@group1) end + it "should run matches" do + Micronaut.world.stubs(:exclusion_filter).returns({ :awesome => false }) + Micronaut.world.stubs(:filter).returns({ :color => :red }) + Micronaut.world.stubs(:behaviours).returns([@group1]) + filtered_behaviours = @world.filter_behaviours + filtered_behaviours.should == [@group1] + @group1.examples_to_run.should == @group1.examples[0..1] + end + end end \ No newline at end of file examples/lib/micronaut/world_example.rb @@ -10,6 +10,8 @@ module Micronaut # Allows you to control what examples are ran by filtering attr_reader :filter + attr_reader :exclusion_filter + # Modules that will be included or extended based on given filters attr_reader :include_or_extend_modules @@ -34,7 +36,7 @@ module Micronaut @before_and_afters = { :before => { :each => [], :all => [] }, :after => { :each => [], :all => [] } } @include_or_extend_modules = [] @formatter_to_use = Micronaut::Formatters::ProgressFormatter - @filter = nil + @filter, @exclusion_filter = nil, nil mock_with nil unless @mock_framework_established end lib/micronaut/configuration.rb @@ -37,11 +37,11 @@ module Micronaut end def pending_examples - @pending_examples ||= ::Micronaut.world.find(examples, :execution_result => { :status => 'pending' }) + @pending_examples ||= ::Micronaut.world.find(examples, :positive, :execution_result => { :status => 'pending' }) end def failed_examples - @failed_examples ||= ::Micronaut.world.find(examples, :execution_result => { :status => 'failed' }) + @failed_examples ||= ::Micronaut.world.find(examples, :positive, :execution_result => { :status => 'failed' }) end # This method is invoked before any examples are run, right after lib/micronaut/formatters/base_formatter.rb @@ -11,12 +11,17 @@ module Micronaut def filter Micronaut.configuration.filter end + + def exclusion_filter + Micronaut.configuration.exclusion_filter + end def behaviours_to_run return @behaviours_to_run if @behaviours_to_run - if filter + if filter || exclusion_filter @behaviours_to_run = filter_behaviours + p @behaviours_to_run if @behaviours_to_run.size == 0 && Micronaut.configuration.run_all_when_everything_filtered? puts "No examples were matched by #{filter.inspect}, running all" # reset the behaviour list to all behaviours, and add back all examples @@ -38,21 +43,38 @@ module Micronaut end def filter_behaviours - behaviours.inject([]) do |list, b| - b.examples_to_run.replace(find(b.examples, filter).uniq) - # Do not add behaviours with 0 examples to run - list << (b.examples_to_run.size == 0 ? nil : b) + behaviours.inject([]) do |list_of_behaviors, _behavior| + examples = _behavior.examples + examples = apply_exclusion_filters(examples, exclusion_filter) if exclusion_filter + examples = apply_inclusion_filters(examples, filter) if filter + examples.uniq! + _behavior.examples_to_run.replace(examples) + if examples.empty? + list_of_behaviors << nil + else + list_of_behaviors << _behavior + end end.compact end - def find(collection, conditions={}) + def find(collection, type_of_filter=:positive, conditions={}) + negative = type_of_filter != :positive + collection.select do |item| - conditions.all? { |filter_on, filter| apply_condition(filter_on, filter, item.metadata) } + # negative conditions.any?, positive conditions.all? ????? + result = conditions.all? do |filter_on, filter| + apply_condition(filter_on, filter, item.metadata) + end + negative ? !result : result end end - def find_behaviours(conditions={}) - find(behaviours, conditions) + def apply_inclusion_filters(collection, conditions={}) + find(collection, :positive, conditions) + end + + def apply_exclusion_filters(collection, conditions={}) + find(collection, :negative, conditions) end def apply_condition(filter_on, filter, metadata) lib/micronaut/world.rb 6c83c03fe94dc836a7c08c6e855cb5f8dbe13bcf a7220683bb449ee56a4096b596c4749d15f2afa9 Chad Humphries chad@spicycode.com http://github.com/spicycode/micronaut/commit/c933e574fbdc1b9c7cf0c96edb39f6d48330b34c c933e574fbdc1b9c7cf0c96edb39f6d48330b34c 2009-05-29T08:01:37-07:00 2009-05-29T08:01:37-07:00 Merge branch 'negative_filters' 3e43a1cba6895c4f4673cbff3627ce2d81b9e759 Chad Humphries chad@spicycode.com