rspec 1.0.8 → 1.1.0

data/spec/spec/dsl/shared_behaviour_spec.rb

@@ -1,252 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-module Spec
-  module DSL
-    describe Behaviour, ", with :shared => true" do
-      
-      before(:each) do
-        @formatter = Spec::Mocks::Mock.new("formatter", :null_object => true)
-        @behaviour = behaviour_class.new("behaviour") {}
-      end
-
-      after(:each) do
-        @formatter.rspec_verify
-        @behaviour_class = nil
-        $shared_behaviours.clear unless $shared_behaviours.nil?
-      end
-
-      def behaviour_class
-        unless @behaviour_class
-          @behaviour_class = Behaviour.dup
-          # dup copies the class instance vars
-          @behaviour_class.instance_variable_set(:@shared_behaviours, nil)
-        end
-        @behaviour_class
-      end
-
-      def make_shared_behaviour(name, opts=nil, &block)
-        behaviour = behaviour_class.new(name, :shared => true, &block)
-        behaviour_class.add_shared_behaviour(behaviour)
-        behaviour
-      end
-      
-      def non_shared_behaviour()
-        @non_shared_behaviour ||= behaviour_class.new("behaviour") {}
-      end
-
-      it "should accept an optional options hash" do
-        lambda { behaviour_class.new("context") {} }.should_not raise_error(Exception)
-        lambda { behaviour_class.new("context", :shared => true) {} }.should_not raise_error(Exception)
-      end
-
-      it "should return all shared behaviours" do
-        b1 = make_shared_behaviour("b1", :shared => true) {}
-        b2 = make_shared_behaviour("b2", :shared => true) {}
-        
-        b1.should_not be(nil)
-        b2.should_not be(nil)
-        
-        behaviour_class.find_shared_behaviour("b1").should equal(b1)
-        behaviour_class.find_shared_behaviour("b2").should equal(b2)
-      end
-
-      it "should be shared when configured as shared" do
-        behaviour = make_shared_behaviour("behaviour") {}
-        behaviour.should be_shared
-      end
-
-      it "should not be shared when not configured as shared" do
-        non_shared_behaviour.should_not be_shared
-      end
-
-      it "should raise if run when shared" do
-        behaviour = make_shared_behaviour("context") {}
-        $example_ran = false
-        behaviour.it("test") {$example_ran = true}
-        lambda { behaviour.run(@formatter) }.should raise_error
-        $example_ran.should be_false
-      end
-
-      it "should contain examples when shared" do
-        shared_behaviour = make_shared_behaviour("shared behaviour") {}
-        shared_behaviour.it("shared example") {}
-        shared_behaviour.number_of_examples.should == 1
-      end
-
-      it "should complain when adding a second shared behaviour with the same description" do
-        describe "shared behaviour", :shared => true do
-        end
-        lambda do
-          describe "shared behaviour", :shared => true do
-          end
-        end.should raise_error(ArgumentError)
-      end
-
-      it "should NOT complain when adding the same shared behaviour instance again" do
-        shared_behaviour = behaviour_class.new("shared behaviour", :shared => true) {}
-        behaviour_class.add_shared_behaviour(shared_behaviour)
-        behaviour_class.add_shared_behaviour(shared_behaviour)
-      end
-
-      it "should NOT complain when adding the same shared behaviour again (i.e. file gets reloaded)" do
-        lambda do 
-          2.times do 
-            describe "shared behaviour which gets loaded twice", :shared => true do
-            end 
-          end
-        end.should_not raise_error(ArgumentError)
-      end
-      
-      it "should NOT complain when adding the same shared behaviour in same file with different absolute path" do
-        shared_behaviour_1 = behaviour_class.new("shared behaviour", :shared => true) {}
-        shared_behaviour_2 = behaviour_class.new("shared behaviour", :shared => true) {}
-
-        shared_behaviour_1.description[:spec_path] = "/my/spec/a/../shared.rb"
-        shared_behaviour_2.description[:spec_path] = "/my/spec/b/../shared.rb"
-
-        behaviour_class.add_shared_behaviour(shared_behaviour_1)
-        behaviour_class.add_shared_behaviour(shared_behaviour_2)
-      end
-        
-      it "should complain when adding a different shared behaviour with the same name in a different file with the same basename" do
-        shared_behaviour_1 = behaviour_class.new("shared behaviour", :shared => true) {}
-        shared_behaviour_2 = behaviour_class.new("shared behaviour", :shared => true) {}
-
-        shared_behaviour_1.description[:spec_path] = "/my/spec/a/shared.rb"
-        shared_behaviour_2.description[:spec_path] = "/my/spec/b/shared.rb"
-
-        behaviour_class.add_shared_behaviour(shared_behaviour_1)
-        lambda do
-          behaviour_class.add_shared_behaviour(shared_behaviour_2)
-        end.should raise_error(ArgumentError, /already exists/)
-      end
-        
-      it "should add examples to current behaviour when calling it_should_behave_like" do
-        shared_behaviour = make_shared_behaviour("shared behaviour") {}
-        shared_behaviour.it("shared example") {}
-        shared_behaviour.it("shared example 2") {}
-
-        @behaviour.it("example") {}
-        @behaviour.number_of_examples.should == 1
-        @behaviour.it_should_behave_like("shared behaviour")
-        @behaviour.number_of_examples.should == 3
-      end
-
-      it "should run shared examples" do
-        shared_example_ran = false
-        shared_behaviour = make_shared_behaviour("shared behaviour") {}
-        shared_behaviour.it("shared example") { shared_example_ran = true }
-
-        example_ran = false
-
-        @behaviour.it_should_behave_like("shared behaviour")
-        @behaviour.it("example") {example_ran = true}
-        @behaviour.run(@formatter)
-        example_ran.should be_true
-        shared_example_ran.should be_true
-      end
-
-      it "should run setup and teardown from shared behaviour" do
-        shared_setup_ran = false
-        shared_teardown_ran = false
-        shared_behaviour = make_shared_behaviour("shared behaviour") {}
-        shared_behaviour.before { shared_setup_ran = true }
-        shared_behaviour.after { shared_teardown_ran = true }
-        shared_behaviour.it("shared example") { shared_example_ran = true }
-
-        example_ran = false
-
-        @behaviour.it_should_behave_like("shared behaviour")
-        @behaviour.it("example") {example_ran = true}
-        @behaviour.run(@formatter)
-        example_ran.should be_true
-        shared_setup_ran.should be_true
-        shared_teardown_ran.should be_true
-      end
-
-      it "should run before(:all) and after(:all) only once from shared behaviour" do
-        shared_before_all_run_count = 0
-        shared_after_all_run_count = 0
-        shared_behaviour = make_shared_behaviour("shared behaviour") {}
-        shared_behaviour.before(:all) { shared_before_all_run_count += 1}
-        shared_behaviour.after(:all) { shared_after_all_run_count += 1}
-        shared_behaviour.it("shared example") { shared_example_ran = true }
-
-        example_ran = false
-
-        @behaviour.it_should_behave_like("shared behaviour")
-        @behaviour.it("example") {example_ran = true}
-        @behaviour.run(@formatter)
-        example_ran.should be_true
-        shared_before_all_run_count.should == 1
-        shared_after_all_run_count.should == 1
-      end
-
-      it "should include modules, included into shared behaviour, into current behaviour" do
-        @formatter.should_receive(:add_behaviour).with(any_args)
-        @formatter.should_receive(:example_finished).twice.with(any_args)
-
-        shared_behaviour = make_shared_behaviour("shared behaviour") {}
-        shared_behaviour.it("shared example") { shared_example_ran = true }
-
-        mod1_method_called = false
-        mod1 = Module.new do
-          define_method :mod1_method do
-            mod1_method_called = true
-          end
-        end
-
-        mod2_method_called = false
-        mod2 = Module.new do
-          define_method :mod2_method do
-            mod2_method_called = true
-          end
-        end
-
-        shared_behaviour.include mod2
-
-        @behaviour.it_should_behave_like("shared behaviour")
-        @behaviour.include mod1
-
-        @behaviour.it("test") do
-          mod1_method
-          mod2_method
-        end
-        @behaviour.run(@formatter)
-        mod1_method_called.should be_true
-        mod2_method_called.should be_true
-      end
-      
-      it "should make methods defined in the shared behaviour available in consuming behaviour" do
-        shared_behaviour = make_shared_behaviour("shared behaviour xyz") do
-          def a_shared_helper_method
-            "this got defined in a shared behaviour"
-          end
-        end
-        @behaviour.it_should_behave_like("shared behaviour xyz")
-        success = false
-        @behaviour.it("should access a_shared_helper_method") do
-          a_shared_helper_method
-          success = true
-        end
-        @behaviour.run(@formatter)
-        success.should be_true
-      end
-
-      it "should error if told to inherit from a class" do
-        shared_behaviour = make_shared_behaviour("shared behaviour") {}
-        shared_behaviour.it("shared example") { shared_example_ran = true }
-        lambda { shared_behaviour.inherit Object }.should raise_error(ArgumentError)
-      end
-      
-      it "should raise when named shared behaviour can not be found" do
-        begin
-          @behaviour.it_should_behave_like("non-existent shared behaviour")
-          violated
-        rescue => e
-          e.message.should == "Shared Behaviour 'non-existent shared behaviour' can not be found"
-        end
-      end
-    end
-  end
-end

data/spec/spec/runner/behaviour_runner_spec.rb

@@ -1,229 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-module Spec
-  module Runner
-    describe BehaviourRunner, "#add_behaviour affecting passed in behaviour" do
-      before do
-        @err = StringIO.new('')
-        @out = StringIO.new('')
-        @options = Options.new(@err,@out)
-        @runner = BehaviourRunner.new(@options)
-        class << @runner
-          attr_reader :behaviours
-        end
-
-        @behaviour = ::Spec::DSL::Behaviour.new("A Behaviour") do
-          it "runs 1" do
-          end
-          it "runs 2" do
-          end
-        end
-      end
-      
-      it "removes examples not selected from Behaviour when options.examples is set" do
-        @options.examples << "A Behaviour runs 1"
-
-        @behaviour.number_of_examples.should == 2
-
-        @runner.add_behaviour @behaviour
-        @behaviour.number_of_examples.should == 1
-        @behaviour.examples.first.send(:description).should == "runs 1"
-      end
-
-      it "keeps all examples when options.examples is nil" do
-        @options.examples = nil
-        @behaviour.number_of_examples.should == 2
-
-        @runner.add_behaviour @behaviour
-        @behaviour.number_of_examples.should == 2
-        @behaviour.examples.collect {|example| example.send(:description) }.should == ['runs 1', 'runs 2']
-      end
-
-      it "keeps all examples when options.examples is empty" do
-        @options.examples = []
-        @behaviour.number_of_examples.should == 2
-
-        @runner.add_behaviour @behaviour
-        @behaviour.number_of_examples.should == 2
-        @behaviour.examples.collect {|example| example.send(:description) }.should == ['runs 1', 'runs 2']
-      end
-    end
-
-    describe BehaviourRunner, "#add_behaviour affecting behaviours" do
-      before do
-        @err = StringIO.new('')
-        @out = StringIO.new('')
-        @options = Options.new(@err,@out)
-        @runner = BehaviourRunner.new(@options)
-        class << @runner
-          attr_reader :behaviours
-        end
-      end
-
-      it "adds behaviour when behaviour has examples and is not shared" do
-        @behaviour = ::Spec::DSL::Behaviour.new("A Behaviour") do
-          it "uses this behaviour" do
-          end
-        end
-
-        @behaviour.should_not be_shared
-        @behaviour.number_of_examples.should be > 0
-        @runner.add_behaviour @behaviour
-
-        @runner.behaviours.length.should == 1
-      end
-
-      it "does not add the behaviour when number_of_examples is 0" do
-        @behaviour = ::Spec::DSL::Behaviour.new("A Behaviour") do
-        end
-        @behaviour.number_of_examples.should == 0
-        @runner.add_behaviour @behaviour
-
-        @runner.behaviours.should be_empty
-      end
-
-      it "does not add the behaviour when behaviour is shared" do
-        @behaviour = ::Spec::DSL::Behaviour.new("A Behaviour", :shared => true) do
-          it "does not use this behaviour" do
-          end
-        end
-        @behaviour.should be_shared
-        @runner.add_behaviour @behaviour
-
-        @runner.behaviours.should be_empty
-      end
-    end
-
-    describe BehaviourRunner do
-      before do
-        @err = StringIO.new('')
-        @out = StringIO.new('')
-        @options = Options.new(@err,@out)
-      end
-
-      it "should only run behaviours with at least one example" do
-        desired_behaviour = mock("desired behaviour")
-        desired_behaviour.should_receive(:run)
-        desired_behaviour.should_receive(:retain_examples_matching!)
-        desired_behaviour.should_receive(:number_of_examples).twice.and_return(1)
-        desired_behaviour.should_receive(:shared?).and_return(false)
-        desired_behaviour.should_receive(:set_sequence_numbers).with(0, anything)
-
-        other_behaviour = mock("other behaviour")
-        other_behaviour.should_receive(:run).never
-        other_behaviour.should_receive(:retain_examples_matching!)
-        other_behaviour.should_receive(:number_of_examples).and_return(0)
-
-        reporter = mock("reporter")
-        @options.reporter = reporter
-        @options.examples = ["desired behaviour legal spec"]
-
-        runner = Spec::Runner::BehaviourRunner.new(@options)
-        runner.add_behaviour(desired_behaviour)
-        runner.add_behaviour(other_behaviour)
-        reporter.should_receive(:start)
-        reporter.should_receive(:end)
-        reporter.should_receive(:dump)
-        runner.run([], false)
-      end
-
-      it "should dump even if Interrupt exception is occurred" do
-        behaviour = Spec::DSL::Behaviour.new("behaviour") do
-          it "no error" do
-          end
-
-          it "should interrupt" do
-            raise Interrupt
-          end
-        end
-        
-        reporter = mock("reporter")
-        reporter.should_receive(:start)
-        reporter.should_receive(:add_behaviour)
-        reporter.should_receive(:example_started).twice
-        reporter.should_receive(:example_finished).twice
-        reporter.should_receive(:rspec_verify)
-        reporter.should_receive(:rspec_reset)
-        reporter.should_receive(:end)
-        reporter.should_receive(:dump)
-
-        @options.reporter = reporter
-        runner = Spec::Runner::BehaviourRunner.new(@options)
-        runner.add_behaviour(behaviour)
-        runner.run([], false)
-      end
-
-      it "should heckle when options have heckle_runner" do
-        behaviour = mock("behaviour", :null_object => true)
-        behaviour.should_receive(:number_of_examples).twice.and_return(1)
-        behaviour.should_receive(:run).and_return(0)
-        behaviour.should_receive(:shared?).and_return(false)
-
-        reporter = mock("reporter")
-        reporter.should_receive(:start).with(1)
-        reporter.should_receive(:end)
-        reporter.should_receive(:dump).and_return(0)
-
-        heckle_runner = mock("heckle_runner")
-        heckle_runner.should_receive(:heckle_with)
-
-        @options.reporter = reporter
-        @options.heckle_runner = heckle_runner
-
-        runner = Spec::Runner::BehaviourRunner.new(@options)
-        runner.add_behaviour(behaviour)
-        runner.run([], false)
-      end
-
-      it "should run examples backwards if options.reverse is true" do
-        @options.reverse = true
-
-        reporter = mock("reporter")
-        reporter.should_receive(:start).with(3)
-        reporter.should_receive(:end)
-        reporter.should_receive(:dump).and_return(0)
-        @options.reporter = reporter
-
-        runner = Spec::Runner::BehaviourRunner.new(@options)
-        b1 = mock("b1")
-        b1.should_receive(:number_of_examples).twice.and_return(1)
-        b1.should_receive(:shared?).and_return(false)
-        b1.should_receive(:set_sequence_numbers).with(12, true).and_return(18)
-
-        b2 = mock("b2")
-        b2.should_receive(:number_of_examples).twice.and_return(2)
-        b2.should_receive(:shared?).and_return(false)
-        b2.should_receive(:set_sequence_numbers).with(0, true).and_return(12)
-        b2.should_receive(:run) do
-          b1.should_receive(:run)
-        end
-
-        runner.add_behaviour(b1)
-        runner.add_behaviour(b2)
-    
-        runner.run([], false)
-      end
-      
-      it "should yield global configuration" do
-        Spec::Runner.configure do |config|
-          config.should equal(Spec::Runner.configuration)
-        end
-      end
-
-      it "should pass its Description to the reporter" do
-        behaviour = Spec::DSL::Behaviour.new("behaviour") do
-          it "should" do
-          end
-        end
-        
-        reporter = mock("reporter", :null_object => true)
-        reporter.should_receive(:add_behaviour).with(an_instance_of(Spec::DSL::Description))
-
-        @options.reporter = reporter
-        runner = Spec::Runner::BehaviourRunner.new(@options)
-        runner.add_behaviour(behaviour)
-        runner.run([], false)
-      end
-    end
-  end
-end