rspec-core 2.0.0.a1

data/spec/rspec/core/shared_behaviour_spec.rb

@@ -0,0 +1,185 @@
+require 'spec/spec_helper'
+
+describe Rspec::Core::SharedBehaviour do
+
+  it "should add the 'share_examples_for' method to the global namespace" do
+    Kernel.should respond_to(:share_examples_for)
+  end
+
+  it "should add the 'shared_examples_for' method to the global namespace" do
+    Kernel.should respond_to(:shared_examples_for)
+  end
+
+  it "should add the 'share_as' method to the global namespace" 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')
+    group.share_examples_for('really important business value') { }
+    lambda do
+      group.share_examples_for('really important business value') { }
+    end.should raise_error(ArgumentError, "Shared example group 'really important business value' already exists")
+  end
+
+  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.expects(:[]=).with(:foo, anything)
+      share_examples_for(:foo) { }
+    end
+
+  end
+
+  describe "including shared behaviours using #it_should_behave_like" do
+
+    def cleanup_shared_behaviours
+      original_shared_behaviours = Rspec::Core.world.shared_behaviours
+      yield if block_given?
+      Rspec::Core.world.shared_behaviours.replace(original_shared_behaviours)
+    end
+
+    it "should module_eval any found shared behaviours" do
+      group = double_describe('fake group')
+      block1 = lambda {}
+      block2 = lambda {
+        def extra_helper
+          'extra_helper'
+        end
+      }
+      Rspec::Core.world.stubs(:shared_behaviours).returns({ :a => block1, :shared_behaviour => block2 })
+      group.expects(:module_eval).once
+      group.it_should_behave_like :shared_behaviour
+    end
+
+    it "should make any shared behaviour available at the correct level" do
+      group = double_describe('fake group')
+      block = lambda {
+        def self.class_helper; end
+        def extra_helper; end
+      }
+      Rspec::Core.world.stubs(:shared_behaviours).returns({ :shared_behaviour => block })
+      group.it_should_behave_like :shared_behaviour
+      with_ruby(1.8) do
+        group.instance_methods.should include('extra_helper')
+        group.singleton_methods.should include('class_helper')
+      end
+      with_ruby(1.9) do
+        group.instance_methods.should include(:extra_helper)
+        group.singleton_methods.should include(:class_helper)
+      end
+    end
+
+    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") {}
+        end
+
+        group.examples.size.should == 1
+
+        group.share_examples_for('shared example_group') do
+          it("shared example") {}
+          it("shared example 2") {}
+        end
+
+        group.it_should_behave_like("shared example_group")
+
+        group.examples.size.should == 3
+      end
+    end
+
+    it "adds examples to from two shared groups" do
+      cleanup_shared_behaviours do
+        group = double_describe("example_group") do |g|
+          g.it("i was already here") {}
+        end
+
+        group.examples.size.should == 1
+
+        group.share_examples_for('test 2 shared groups') do
+          it("shared example") {}
+          it("shared example 2") {}
+        end
+
+        group.share_examples_for('test 2 shared groups 2') do
+          it("shared example 3") {}
+        end
+
+        group.it_should_behave_like("test 2 shared groups")
+        group.it_should_behave_like("test 2 shared groups 2")
+
+        group.examples.size.should == 4
+      end
+    end
+
+    share_as('Cornucopia') do
+      it "should do foo"
+    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
+    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")  {}
+
+        shared_foo = group.share_as(:FooShared) do
+          it("shared example") {}
+        end
+
+        group.it_should_behave_like(::FooShared) 
+
+        group.examples.size.should == 1
+      end
+    end
+
+    describe "running shared examples" do
+      module RunningSharedExamplesJustForTesting; end
+
+      share_examples_for("it runs shared examples") do
+        include RunningSharedExamplesJustForTesting
+
+        def magic
+          @magic ||= {}
+        end
+
+        before(:each) { magic[:before_each] = 'each' }
+        after(:each)  { magic[:after_each] = 'each' }
+        before(:all)  { magic[:before_all] = 'all' }
+      end
+
+      it_should_behave_like "it runs shared examples"
+
+      it "runs before(:each) from shared example_group", :compat => 'rspec-1.2' do
+        magic[:before_each].should == 'each'
+      end
+
+      it "runs after(:each) from shared example_group", :compat => 'rspec-1.2' 
+
+      it "should run before(:all) only once from shared example_group", :compat => 'rspec-1.2' do
+        magic[:before_all].should == 'all'
+      end
+
+      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)
+      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) }
+      end
+
+    end
+
+  end
+
+
+end

data/spec/rspec/core/world_spec.rb

@@ -0,0 +1,167 @@
+require 'spec/spec_helper'
+
+class Bar; end
+class Foo; end
+
+describe Rspec::Core::World do
+  
+  before do
+    @world = Rspec::Core::World.new
+    Rspec::Core.stubs(:world).returns(@world)
+  end
+
+  describe "behaviour 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)       
+    end
+  
+  end
+  
+  describe "applying inclusion filters" 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' }      
+      @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) { }
+      @bg4 = 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
+      @behaviours = [@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)
+    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
+      @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]
+    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]
+    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]
+    end
+    
+    it "should find one group when searching for :foo => 1" do
+      @world.apply_inclusion_filters(@behaviours, :foo => 1 ).should == [@bg1]
+    end
+    
+    it "should find one group when searching for :pending => true" do
+      @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.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.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.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]
+    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 = 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 == []
+      end
+      
+      isolate_behaviour 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]
+      end
+  
+    end
+    
+    it "should find nothing if a regexp matches the exclusion filter" do
+      isolate_behaviour 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
+      end
+    end
+    
+  end
+  
+  describe "filtering behaviours" do
+    
+    before(:all) do
+      @group1 = Rspec::Core::ExampleGroup.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
+      Rspec::Core.world.behaviours.delete(@group1)
+    end
+
+    it "should run matches" do
+      Rspec::Core.world.stubs(:exclusion_filter).returns({ :awesome => false })
+      Rspec::Core.world.stubs(:filter).returns({ :color => :red })
+      Rspec::Core.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

data/spec/rspec/core_spec.rb

@@ -0,0 +1,35 @@
+require 'spec/spec_helper'
+
+describe Rspec::Core do
+
+  describe "#configuration" do
+    
+    it "should return an instance of Rspec::Core::Configuration" do
+      Rspec::Core.configuration.should be_an_instance_of(Rspec::Core::Configuration)
+    end
+    
+  end
+  
+  describe "#configure" do
+    
+    it "should yield the current configuration" do
+      Rspec::Core.configure do |config|
+        config.should == Rspec::Core.configuration
+      end
+    end
+    
+    it "should be callable without a block" do
+      lambda { Rspec::Core.configure }.should_not raise_error
+    end
+    
+  end
+  
+  describe "#world" do
+    
+    it "should return the Rspec::Core::World instance the current run is using" do
+      Rspec::Core.world.should be_instance_of(Rspec::Core::World)
+    end
+    
+  end
+    
+end

data/spec/ruby_forker.rb

@@ -0,0 +1,13 @@
+require 'rbconfig'
+
+module RubyForker
+  # Forks a ruby interpreter with same type as ourself.
+  # juby will fork jruby, ruby will fork ruby etc.
+  def ruby(args, stderr=nil)
+    config       = ::Config::CONFIG
+    interpreter  = File::join(config['bindir'], config['ruby_install_name']) + config['EXEEXT']
+    cmd = "#{interpreter} #{args}"
+    cmd << " 2> #{stderr}" unless stderr.nil?
+    `#{cmd}`
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,72 @@
+dir = File.dirname(__FILE__)
+lib_path = File.expand_path("#{dir}/../lib")
+$LOAD_PATH.unshift lib_path unless $LOAD_PATH.include?(lib_path)
+
+require 'rubygems'
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '/../../expectations/lib'))
+require 'rspec/expectations'
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '/../../mocks/lib'))
+require 'rspec/mocks'
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'rspec/core'
+
+Rspec::Core::ExampleGroup.send(:include, Rspec::Matchers)
+
+def with_ruby(version)
+  yield if RUBY_PLATFORM =~ Regexp.compile("^#{version}")
+end
+
+require 'rubygems'
+require 'mocha'
+
+require File.expand_path(File.dirname(__FILE__) + "/resources/example_classes")
+
+module Rspec
+  module Core
+    module Matchers
+      def fail
+        raise_error(::Rspec::Expectations::ExpectationNotMetError)
+      end
+
+      def fail_with(message)
+        raise_error(::Rspec::Expectations::ExpectationNotMetError, message)
+      end
+    end
+  end
+end
+
+def remove_last_describe_from_world
+  Rspec::Core.world.behaviours.pop
+end
+
+def isolate_behaviour
+  if block_given?
+    yield
+    Rspec::Core.world.behaviours.pop
+  end
+end
+
+def double_describe(*args)
+  group = Rspec::Core::ExampleGroup.describe(*args) {}
+  remove_last_describe_from_world
+  yield group if block_given?
+  group
+end
+
+def use_formatter(new_formatter)
+  original_formatter = Rspec::Core.configuration.formatter
+  Rspec::Core.configuration.instance_variable_set(:@formatter, new_formatter)
+  yield
+ensure
+  Rspec::Core.configuration.instance_variable_set(:@formatter, original_formatter)
+end
+
+def not_in_editor?
+  !(ENV.has_key?('TM_MODE') || ENV.has_key?('EMACS') || ENV.has_key?('VIM'))
+end
+
+Rspec::Core.configure do |c|
+  c.mock_framework = :mocha
+  c.filter_run :focused => true
+  c.color_enabled = not_in_editor?
+end