rspec 0.8.2 → 0.9.0

data/spec/spec/dsl/composite_proc_builder_spec.rb

@@ -0,0 +1,57 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+module Spec
+  module DSL
+    describe CompositeProcBuilder do
+      before(:each) do
+        @klass = Class.new do
+          attr_reader :an_attribute
+
+          def an_attribute_setter
+            @an_attribute = :the_value
+          end
+        end
+
+        @parent = @klass.new
+        @builder = CompositeProcBuilder.new {}
+      end
+
+      it "calls all of its child procs" do
+        @builder << proc {:proc1}
+        @builder << proc {:proc2}
+        @builder.proc.call.should == [:proc1, :proc2]
+      end
+
+      it "calls block on exceptions" do
+        exception1 = Exception.new("Proc1 Error")
+        exception2 = Exception.new("Proc2 Error")
+        @builder << proc {raise exception1}
+        @builder << proc {raise exception2}
+        @builder << proc {:successful}
+
+        errors = []
+        @builder.proc {|e| errors << e }.call.should == [exception1, exception2, :successful]
+
+        errors.should == [exception1, exception2]
+      end
+
+      it "evals procs in the caller's instance" do
+        the_proc = proc do
+          @an_attribute = :the_value
+        end
+        the_proc.class.should == Proc
+        @builder << the_proc
+        @parent.instance_eval &@builder.proc
+        @parent.an_attribute.should == :the_value
+      end
+
+      it "binds unbound methods to the parent" do
+        unbound_method = @klass.instance_method(:an_attribute_setter)
+        unbound_method.class.should == UnboundMethod
+        @builder << unbound_method
+        @parent.instance_eval &@builder.proc
+        @parent.an_attribute.should == :the_value
+      end
+    end
+  end
+end

data/spec/spec/dsl/configuration_spec.rb

@@ -0,0 +1,43 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+module Spec
+  module DSL
+    describe Configuration do
+      before(:each) do
+        @config = Configuration.new
+        @behaviour = mock("behaviour")
+      end
+
+      it "should default mock framework to rspec" do
+        @config.mock_framework.should =~ /\/plugins\/mock_frameworks\/rspec$/
+      end
+
+      it "should let you set rspec explicitly" do
+        @config.mock_with(:rspec)
+        @config.mock_framework.should =~ /\/plugins\/mock_frameworks\/rspec$/
+      end
+
+      it "should let you set mocha" do
+        @config.mock_with(:mocha)
+        @config.mock_framework.should =~ /\/plugins\/mock_frameworks\/mocha$/
+      end
+
+      it "should let you set flexmock" do
+        @config.mock_with(:flexmock)
+        @config.mock_framework.should =~ /\/plugins\/mock_frameworks\/flexmock$/
+      end
+      
+      it "should let you set an arbitrary adapter module" do
+        adapter = Module.new
+        @config.mock_with(adapter)
+        @config.mock_framework.should == adapter
+      end
+      
+      it "should let you define modules to be included" do
+        mod = Module.new
+        @config.include mod
+        @config.included_modules.should include(mod)
+      end
+    end
+  end
+end

data/spec/spec/dsl/description_spec.rb

@@ -0,0 +1,51 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+module Spec
+  module DSL
+    describe Description, " constructed with a single String" do before(:each) {@description = Description.new("abc")}
+      it "should provide that string as its name" do
+        @description.description.should == "abc"
+      end
+      it "should provide nil as its type" do
+        @description.described_type.should be_nil
+      end
+      it "should respond to []" do
+        @description[:key].should be_nil
+      end
+      it "should respond to []=" do
+        @description[:key] = :value
+        @description[:key].should == :value
+      end
+      it "should return for == when value matches description" do
+        @description.should == "abc"
+      end
+      it "should return for == when value is other description that matches description" do
+        @description.should == Description.new("abc")
+      end
+    end
+    
+    describe Description, " constructed with a Type" do before(:each) {@description = Description.new(Behaviour)}
+      it "should provide a String representation of that type (fully qualified) as its name" do
+        @description.description.should == "Spec::DSL::Behaviour"
+      end
+      it "should provide that type (fully qualified) as its type" do
+        @description.described_type.should == Spec::DSL::Behaviour
+      end
+    end
+    
+    describe Description, " constructed with a Type and a String" do before(:each) {@description = Description.new(Behaviour, " behaving")}
+      it "should include the type and second String in its name" do
+        @description.description.should == "Spec::DSL::Behaviour behaving"
+      end
+      it "should provide that type (fully qualified) as its type" do
+        @description.described_type.should == Spec::DSL::Behaviour
+      end
+    end
+
+    describe Description, " constructed with options" do before(:each) {@description = Description.new(Behaviour, :a => "b")}
+      it "should provide its options" do
+        @description[:a].should == "b"
+      end
+    end
+  end
+end

data/spec/spec/dsl/example_class_spec.rb

@@ -0,0 +1,24 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+module Spec
+  module DSL
+    describe Example, " class" do
+
+      def run(example)
+        example.run(@reporter, nil, nil, nil, Object.new)
+      end
+
+      before do
+        @reporter = stub("reporter", :example_started => nil, :example_finished => nil)
+        @example_class = Example.dup
+      end
+      
+      it "should report errors in example" do
+        error = Exception.new
+        @reporter.should_receive(:example_finished).with("example", error, "example")
+
+        run(@example_class.new("example") {raise(error)})
+      end
+    end
+  end
+end

data/spec/spec/dsl/example_instance_spec.rb

@@ -0,0 +1,140 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+module Spec
+  module DSL
+    describe Example, " instance" do
+      # TODO - this should be
+      #   predicate_matchers :is_a
+      def is_a(error)
+        be_is_a(error)
+      end
+      
+      before do
+        @reporter = stub("reporter", :example_started => nil, :example_finished => nil)
+      end
+      
+      it "should send reporter example_started" do
+        example=Example.new("example") {}
+        @reporter.should_receive(:example_started).with("example")
+        example.run(@reporter, nil, nil, false, nil)
+      end
+
+      it "should report its name for dry run" do
+        example=Example.new("example") {}
+        @reporter.should_receive(:example_finished).with("example")
+        example.run(@reporter, nil, nil, true, nil) #4th arg indicates dry run
+      end
+
+      it "should report success" do
+        example=Example.new("example") {}
+        @reporter.should_receive(:example_finished).with("example", nil, nil)
+        example.run(@reporter, nil, nil, nil, nil)
+      end
+
+      it "should report failure due to failure" do
+        example=Example.new("example") do
+          (2+2).should == 5
+        end
+        @reporter.should_receive(:example_finished).with("example", is_a(Spec::Expectations::ExpectationNotMetError), "example")
+        example.run(@reporter, nil, nil, nil, nil)
+      end
+
+      it "should report failure due to error" do
+        error=RuntimeError.new
+        example=Example.new("example") do
+          raise(error)
+        end
+        @reporter.should_receive(:example_finished).with("example", error, "example")
+        example.run(@reporter, nil, nil, nil, nil)
+      end
+
+      it "should run example in scope of supplied object" do
+        scope_class = Class.new
+        example=Example.new("should pass") do
+          self.instance_of?(Example).should == false
+          self.instance_of?(scope_class).should == true
+        end
+        @reporter.should_receive(:example_finished).with("should pass", nil, nil)
+        example.run(@reporter, nil, nil, nil, scope_class.new)
+      end
+
+      it "should not run example block if before_each fails" do
+        example_ran = false
+        example=Example.new("should pass") {example_ran = true}
+        before_each = lambda {raise "Setup error"}
+        example.run(@reporter, before_each, nil, nil, Object.new)
+        example_ran.should == false
+      end
+
+      it "should run after_each block if before_each fails" do
+        after_each_ran = false
+        example=Example.new("should pass") {}
+        before_each = lambda {raise "Setup error"}
+        after_each = lambda {after_each_ran = true}
+        example.run(@reporter, before_each, after_each, nil, Object.new)
+        after_each_ran.should == true
+      end
+
+      it "should run after_each block when example fails" do
+        example=Example.new("example") do
+          raise("in body")
+        end
+        after_each=lambda do
+          raise("in after_each")
+        end
+        @reporter.should_receive(:example_finished) do |example, error, location|
+          example.should eql("example")
+          location.should eql("example")
+          error.message.should eql("in body")
+        end
+        example.run(@reporter, nil, after_each, nil, nil)
+      end
+
+      it "should report failure location when in before_each" do
+        example=Example.new("example") {}
+        before_each=lambda { raise("in before_each") }
+        @reporter.should_receive(:example_finished) do |name, error, location|
+          name.should eql("example")
+          error.message.should eql("in before_each")
+          location.should eql("before(:each)")
+        end
+        example.run(@reporter, before_each, nil, nil, nil)
+      end
+
+      it "should report failure location when in after_each" do
+        example = Example.new("example") {}
+        after_each = lambda { raise("in after_each") }
+        @reporter.should_receive(:example_finished) do |name, error, location|
+          name.should eql("example")
+          error.message.should eql("in after_each")
+          location.should eql("after(:each)")
+        end
+        example.run(@reporter, nil, after_each, nil, nil)
+      end
+
+      it "should accept an options hash following the example name" do
+        example = Example.new("name", :key => 'value')
+      end
+
+      it "should report NAME NOT GENERATED when told to use generated description but none is generated" do
+        example = Example.new(:__generate_description)
+        @reporter.should_receive(:example_finished).with("NAME NOT GENERATED", :anything, :anything)
+        example.run(@reporter, nil, nil, nil, Object.new)
+      end
+
+      it "should report generated description when told to and it is available" do
+        example = Example.new(:__generate_description) {
+          5.should == 5
+        }
+        @reporter.should_receive(:example_finished).with("should == 5", :anything, :anything)
+        example.run(@reporter, nil, nil, nil, Object.new)
+      end
+
+      it "should unregister description_generated callback (lest a memory leak should build up)" do
+        example = Example.new("something")
+        Spec::Matchers.should_receive(:unregister_description_generated).with(is_a(Proc))
+        example.run(@reporter, nil, nil, nil, Object.new)
+      end
+    end
+  end
+end

data/spec/spec/dsl/example_should_raise_spec.rb

@@ -0,0 +1,137 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+module Spec
+  module DSL
+    describe Example, " declared with {:should_raise => ...}" do
+      before(:each) do
+        @reporter = mock("reporter")
+        @reporter.stub!(:example_started)
+      end
+  
+      def verify_error(error, message=nil)
+        error.should be_an_instance_of(Spec::Expectations::ExpectationNotMetError)
+        unless message.nil?
+          return error.message.should =~ message if Regexp === message
+          return error.message.should == message
+        end
+      end
+
+      it "true} should pass when there is an ExpectationNotMetError" do
+        example = Spec::DSL:: Example.new("example", :should_raise => true) do
+          raise Spec::Expectations::ExpectationNotMetError
+        end
+        @reporter.should_receive(:example_finished) do |description, error|
+          error.should be_nil
+        end
+        example.run(@reporter, nil, nil, nil, nil)
+      end
+
+      it "true} should fail if nothing is raised" do
+        example = Spec::DSL:: Example.new("example", :should_raise => true) {}
+        @reporter.should_receive(:example_finished) do |example_name, error|
+          verify_error(error, /example block expected Exception but nothing was raised/)
+        end
+        example.run(@reporter, nil, nil, nil, nil)
+      end
+
+      it "NameError} should pass when there is a NameError" do
+        example = Spec::DSL:: Example.new("example", :should_raise => NameError) do
+          raise NameError
+        end
+        @reporter.should_receive(:example_finished) do |example_name, error|
+          error.should be_nil
+        end
+        example.run(@reporter, nil, nil, nil, nil)
+      end
+
+      it "NameError} should fail when there is no error" do
+        example = Spec::DSL:: Example.new("example", :should_raise => NameError) do
+          #do nothing
+        end
+        @reporter.should_receive(:example_finished) do |example_name, error|
+          verify_error(error,/example block expected NameError but nothing was raised/)
+        end
+        example.run(@reporter, nil, nil, nil, nil)
+      end
+
+      it "NameError} should fail when there is the wrong error" do
+        example = Spec::DSL:: Example.new("example", :should_raise => NameError) do
+          raise RuntimeError
+        end
+        @reporter.should_receive(:example_finished) do |example_name, error|
+          verify_error(error, /example block expected NameError but raised.+RuntimeError/)
+        end
+        example.run(@reporter, nil, nil, nil, nil)
+      end
+
+      it "[NameError]} should pass when there is a NameError" do
+        example = Spec::DSL:: Example.new("spec", :should_raise => [NameError]) do
+          raise NameError
+        end
+        @reporter.should_receive(:example_finished) do |description, error|
+          error.should be_nil
+        end
+        example.run(@reporter, nil, nil, nil, nil)
+      end
+
+      it "[NameError]} should fail when there is no error" do
+        example = Spec::DSL:: Example.new("spec", :should_raise => [NameError]) do
+        end
+        @reporter.should_receive(:example_finished) do |description, error|
+          verify_error(error, /example block expected NameError but nothing was raised/)
+        end
+        example.run(@reporter, nil, nil, nil, nil)
+      end
+
+      it "[NameError]} should fail when there is the wrong error" do
+        example = Spec::DSL:: Example.new("spec", :should_raise => [NameError]) do
+          raise RuntimeError
+        end
+        @reporter.should_receive(:example_finished) do |description, error|
+          verify_error(error, /example block expected NameError but raised.+RuntimeError/)
+        end
+        example.run(@reporter, nil, nil, nil, nil)
+      end
+
+      it "[NameError, 'message'} should pass when there is a NameError with the right message" do
+        example = Spec::DSL:: Example.new("spec", :should_raise => [NameError, 'expected']) do
+          raise NameError, 'expected'
+        end
+        @reporter.should_receive(:example_finished) do |description, error|
+          error.should be_nil
+        end
+        example.run(@reporter, nil, nil, nil, nil)
+      end
+
+      it "[NameError, 'message'} should pass when there is a NameError with a message matching a regex" do
+        example = Spec::DSL:: Example.new("spec", :should_raise => [NameError, /xpec/]) do
+          raise NameError, 'expected'
+        end
+        @reporter.should_receive(:example_finished) do |description, error|
+          error.should be_nil
+        end
+        example.run(@reporter, nil, nil, nil, nil)
+      end
+
+      it "[NameError, 'message'} should fail when there is a NameError with the wrong message" do
+        example = Spec::DSL:: Example.new("spec", :should_raise => [NameError, 'expected']) do
+          raise NameError, 'wrong message'
+        end
+        @reporter.should_receive(:example_finished) do |description, error|
+          verify_error(error, /example block expected #<NameError: expected> but raised #<NameError: wrong message>/)
+        end
+        example.run(@reporter, nil, nil, nil, nil)
+      end
+
+      it "[NameError, 'message'} should fail when there is a NameError with a message not matching regexp" do
+        example = Spec::DSL:: Example.new("spec", :should_raise => [NameError, /exp/]) do
+          raise NameError, 'wrong message'
+        end
+        @reporter.should_receive(:example_finished) do |description, error|
+          verify_error(error, /example block expected #<NameError: \(\?-mix:exp\)> but raised #<NameError: wrong message>/)
+        end
+        example.run(@reporter, nil, nil, nil, nil)
+      end
+    end
+  end
+end