rspec 0.7.5.1 → 0.8.0

data/spec/spec/runner/spec_matcher_spec.rb

@@ -0,0 +1,107 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+module Spec
+  module Runner
+    module SpecMatcherSpecHelper
+      class MatchDescription
+        def initialize(description)
+          @description = description
+        end
+        
+        def matches?(matcher)
+          matcher.matches?(@description)
+        end
+        
+        def failure_message
+          "expected matcher.matches?(#{@description.inspect}) to return true, got false"
+        end
+        
+        def negative_failure_message
+          "expected matcher.matches?(#{@description.inspect}) to return false, got true"
+        end
+      end
+      def match_description(description)
+        MatchDescription.new(description)
+      end
+    end
+        
+    context "SpecMatcher" do
+      include SpecMatcherSpecHelper
+      
+      specify "should match correct context and spec" do
+        matcher=SpecMatcher.new("context", "spec")
+        matcher.should match_description("context spec")
+      end
+      
+      specify "should not match wrong spec" do
+        matcher=SpecMatcher.new("context", "other spec")
+        matcher.should_not match_description("context spec")
+      end
+      
+      specify "should not match wrong context" do
+        matcher=SpecMatcher.new("other context", "spec")
+        matcher.should_not match_description("context spec")
+      end
+      
+      specify "should match spec only" do
+        matcher=SpecMatcher.new("context", "spec")
+        matcher.should match_description("spec")
+      end
+      
+      specify "should match context only" do
+        matcher=SpecMatcher.new("context", "spec")
+        matcher.should match_description("context")
+      end
+      
+      specify "should escape regexp chars" do
+        matcher=SpecMatcher.new("(con|text)", "[spec]")
+        matcher.should_not match_description("con p")
+      end
+      
+      # specify "should match context only" do
+      #   matcher=SpecMatcher.new("context", "a context")
+      #   matcher.should match_description("a context")
+      # end
+      # 
+      # specify "should match spec only" do
+      #   matcher=SpecMatcher.new("with a spec", "a context")
+      #   matcher.should match_description("with a spec")
+      # end
+      
+      # specify "should match with regexp reserved (characters) in the spec" do
+      #   matcher=SpecMatcher.new("with ([#]) a spec", "a context")
+      #   matcher.should match_description("a context")
+      #   matcher.should match_description("with ([#]) a spec")
+      #   matcher.should match_description("a context with ([#]) a spec")
+      # end
+      # 
+      # specify "should match with regexp reserved (characters) in the context" do
+      #   matcher=SpecMatcher.new("with a spec", "a ([#]) context")
+      #   matcher.should match_description("a ([#]) context with a spec")
+      #   matcher.should match_description("a ([#]) context with a spec")
+      #   matcher.should match_description("a ([#]) context with a spec")
+      # end
+      
+      # specify "should not match wrong spec only" do
+      #   matcher=SpecMatcher.new("with another spec", "a context")
+      #   matcher.should_not match_description("with a spec")
+      # end
+      # 
+      # specify "should not match wrong context" do
+      #   matcher=SpecMatcher.new("another context with a spec", "a context")
+      #   matcher.should_not match_description("with a spec")
+      # end
+      # 
+      # specify "should not match wrong context only" do
+      #   matcher=SpecMatcher.new("another context", "a context")
+      #   matcher.should_not match_description("with a spec")
+      # end
+      # 
+      # specify "should not match wrong spec" do
+      #   matcher=SpecMatcher.new("a context with another spec", "a context")
+      #   matcher.should_not match_description("with a spec")
+      # end
+      
+    end
+  end
+end

data/spec/spec/runner/spec_name_generation_spec.rb

@@ -0,0 +1,102 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+module Spec
+  module Runner
+    module SpecNameSpecHelper
+      def run_spec
+        @spec.run(reporter, nil, nil, nil, ::Spec::Runner::ExecutionContext.new(nil))
+      end
+      
+      def reporter
+        @reporter ||= mock("reporter")
+      end
+      
+      def spec_class
+        @spec_class ||= generate_spec_class
+      end
+      
+      def generate_spec_class
+        callback_container = Callback::CallbackContainer.new
+        spec_class = Specification.dup
+        spec_class.stub!(:callbacks).and_return {callback_container}
+        spec_class
+      end
+    end
+    
+    # context "Specification with given name" do
+    #   include SpecNameSpecHelper
+    #   setup do
+    #     @spec = spec_class.new("given name")
+    #   end
+    #   
+    #   specify "should start spec with given name" do
+    #     reporter.stub!(:spec_finished)
+    #     reporter.should_receive(:spec_started).with("given name")
+    #     run_spec
+    #   end
+    #   
+    #   specify "should finish spec with given name" do
+    #     reporter.stub!(:spec_started)
+    #     reporter.should_receive(:spec_finished).with("given name", :anything, :anything)
+    #     run_spec
+    #   end
+    # end
+    # 
+    # context "Specification with given name and error" do
+    #   include SpecNameSpecHelper
+    #   setup do
+    #     @spec = spec_class.new("given name") { raise }
+    #   end
+    #   
+    #   specify "should start spec with given name" do
+    #     reporter.stub!(:spec_finished)
+    #     reporter.should_receive(:spec_started).with("given name")
+    #     run_spec
+    #   end
+    #   
+    #   specify "should finish spec with given name" do
+    #     reporter.stub!(:spec_started)
+    #     reporter.should_receive(:spec_finished).with("given name", :anything, :anything)
+    #     run_spec
+    #   end
+    # end
+    
+    context "Specification with generated name" do
+      include SpecNameSpecHelper
+      setup do
+        @spec = spec_class.new(:__generate_description) { 5.should == 5 }
+      end
+      
+      # specify "should start spec with given name" do
+      #   reporter.stub!(:spec_finished)
+      #   reporter.should_receive(:spec_started).with("NAME NOT GENERATED")
+      #   run_spec
+      # end
+      
+      specify "should finish spec with given name" do
+        reporter.stub!(:spec_started)
+        reporter.should_receive(:spec_finished).with("should == 5", :anything, :anything)
+        run_spec
+      end
+    end
+    
+    # context "Specification with generated name and error" do
+    #   include SpecNameSpecHelper
+    #   setup do
+    #     @spec = spec_class.new(:__generate_description) { raise }
+    #   end
+    #   
+    #   specify "should start spec with given name" do
+    #     reporter.stub!(:spec_finished)
+    #     reporter.should_receive(:spec_started).with("NAME NOT GENERATED")
+    #     run_spec
+    #   end
+    #   
+    #   specify "should finish spec with given name" do
+    #     reporter.stub!(:spec_started)
+    #     reporter.should_receive(:spec_finished).with("NAME NOT GENERATED", :anything, :anything)
+    #     run_spec
+    #   end
+    # end
+  end
+end

data/spec/spec/runner/spec_parser_spec.rb

@@ -0,0 +1,37 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+context "c" do
+
+  specify "1" do
+  end
+
+  specify "2" do
+  end
+
+end
+
+context "SpecParser" do
+  setup do
+    @p = Spec::Runner::SpecParser.new
+  end
+
+  specify "should find spec name at same line" do
+    @p.spec_name_for(File.open(__FILE__), 5).should_eql "c 1"
+  end
+
+  specify "should find spec name at end of spec line" do
+    @p.spec_name_for(File.open(__FILE__), 6).should_eql "c 1"
+  end
+
+  specify "should find context name above all specs" do
+    @p.spec_name_for(File.open(__FILE__), 4).should_eql "c"
+  end
+
+#  specify "should find context name between specs" do
+#    @p.spec_name_for(File.open(__FILE__), 7).should_eql "c"
+#  end
+
+  specify "should find nothing outside a context" do
+    @p.spec_name_for(File.open(__FILE__), 2).should_be_nil
+  end
+end

data/spec/spec/runner/specification_class_spec.rb

@@ -0,0 +1,72 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+module Spec
+  module Runner
+    context "A Specification class" do
+      setup do
+        @reporter = mock("reporter")
+        callback_container = Callback::CallbackContainer.new
+        @specification = Specification.dup
+        @specification.stub!(:callbacks).and_return {callback_container}
+      end
+
+      specify "should have a before_setup callback for all specs" do
+        @reporter.stub!(:spec_started)
+        @reporter.stub!(:spec_finished)
+
+        before_setup_called = false
+        @specification.before_setup {before_setup_called = true}
+
+        spec = @specification.new("spec") {}
+        spec.run(@reporter, nil, nil, nil, ::Spec::Runner::ExecutionContext.new(nil))
+
+        before_setup_called.should == true
+      end
+
+      specify "should have before_setup callback add errors to spec run" do
+        error=Exception.new
+        @specification.before_setup do
+          raise(error)
+        end
+        spec=@specification.new("spec") {}
+        @reporter.should_receive(:spec_started).with("spec")
+        @reporter.should_receive(:spec_finished).with("spec", error, "setup")
+        spec.run(@reporter, nil, nil, nil, ::Spec::Runner::ExecutionContext.new(nil))
+      end
+
+      specify "should report exceptions in spec" do
+        error = Exception.new
+        spec=@specification.new("spec") do
+          raise(error)
+        end
+        @reporter.should_receive(:spec_started).with("spec")
+        @reporter.should_receive(:spec_finished).with("spec", error, "spec")
+        spec.run(@reporter, nil, nil, nil, ::Spec::Runner::ExecutionContext.new(nil))
+      end
+
+      specify "should have an after_teardown callback for all specs" do
+        @reporter.stub!(:spec_started)
+        @reporter.stub!(:spec_finished)
+
+        after_teardown_called = false
+        @specification.after_teardown {after_teardown_called = true}
+
+        spec = @specification.new("spec") {}
+        spec.run(@reporter, nil, nil, nil, ::Spec::Runner::ExecutionContext.new(nil))
+
+        after_teardown_called.should == true
+      end
+
+      specify "should have after_teardown callback add errors to spec run" do
+        error=Exception.new
+        @specification.after_teardown do
+          raise(error)
+        end
+        spec=@specification.new("spec") {}
+        @reporter.should_receive(:spec_started).with("spec")
+        @reporter.should_receive(:spec_finished).with("spec", error, "teardown")
+        spec.run(@reporter, nil, nil, nil, ::Spec::Runner::ExecutionContext.new(nil))
+      end
+    end
+  end
+end

data/spec/spec/runner/specification_instance_spec.rb

@@ -0,0 +1,160 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+module Spec
+  module Runner
+    context "A Specification instance" do
+      setup do
+        @reporter = mock("reporter")
+        Specification.send(:current=, nil)
+      end
+
+      specify "should add itself to reporter when calling run dry" do
+        spec=Specification.new("spec") {}
+        @reporter.should_receive(:spec_started).with("spec")
+        @reporter.should_receive(:spec_finished).with("spec")
+        spec.run(@reporter, nil, nil, true, nil)
+      end
+
+      specify "should add itself to reporter when fails" do
+        error=RuntimeError.new
+        spec=Specification.new("spec") do
+          raise(error)
+        end
+        @reporter.should_receive(:spec_started).with("spec")
+        @reporter.should_receive(:spec_finished).with("spec", error, "spec")
+        spec.run(@reporter, nil, nil, nil, nil)
+      end
+
+      specify "should add itself to reporter when passes" do
+        spec=Specification.new("spec") {}
+        @reporter.should_receive(:spec_started).with("spec")
+        @reporter.should_receive(:spec_finished).with("spec", nil, nil)
+        spec.run(@reporter, nil, nil, nil, nil)
+      end
+
+      specify "should not run spec if setup fails" do
+        spec_ran = false
+        spec=Specification.new("should pass") do
+          spec_ran = true
+        end
+        @reporter.stub!(:spec_started)
+        @reporter.stub!(:spec_finished)
+        setup = proc {raise "Setup error"}
+        spec.run(@reporter, setup, nil, nil, ::Spec::Runner::ExecutionContext.new(nil))
+        spec_ran.should == false
+        @reporter.__verify
+      end
+
+      specify "should run spec in scope of execution context" do
+        spec=Specification.new("should pass") do
+          self.instance_of?(Specification).should == false
+          self.instance_of?(ExecutionContext).should == true
+        end
+        @reporter.should_receive(:spec_started).with("should pass")
+        @reporter.should_receive(:spec_finished).with("should pass", nil, nil)
+        spec.run(@reporter, nil, nil, nil, ::Spec::Runner::ExecutionContext.new(nil))
+        @reporter.__verify
+      end
+
+      specify "should run teardown even when main block fails" do
+        spec=Specification.new("spec") do
+          raise("in body")
+        end
+        teardown=lambda do
+          raise("in teardown")
+        end
+        @reporter.should_receive(:spec_started).with("spec")
+        @reporter.should_receive(:spec_finished) do |spec, error, location|
+          spec.should_eql("spec")
+          location.should_eql("spec")
+          error.message.should_eql("in body")
+        end
+        spec.run(@reporter, nil, teardown, nil, nil)
+      end
+
+      specify "should supply setup as spec name if failure in setup" do
+        spec=Specification.new("spec") {}
+        setup=lambda { raise("in setup") }
+        @reporter.should_receive(:spec_started).with("spec")
+        @reporter.should_receive(:spec_finished) do |name, error, location|
+          name.should_eql("spec")
+          error.message.should_eql("in setup")
+          location.should_eql("setup")
+        end
+        spec.run(@reporter, setup, nil, nil, nil)
+      end
+
+      specify "should supply teardown as failure location if failure in teardown" do
+        spec = Specification.new("spec") {}
+        teardown = lambda { raise("in teardown") }
+        @reporter.should_receive(:spec_started).with("spec")
+        @reporter.should_receive(:spec_finished) do |name, error, location|
+          name.should_eql("spec")
+          error.message.should_eql("in teardown")
+          location.should_eql("teardown")
+        end
+        spec.run(@reporter, nil, teardown, nil, nil)
+      end
+
+      specify "should verify mocks after teardown" do
+        spec=Specification.new("spec") do
+          mock=Spec::Mocks::Mock.new("a mock")
+          mock.should_receive(:poke)
+        end
+        @reporter.should_receive(:spec_started).with("spec")
+        @reporter.should_receive(:spec_finished) do |spec_name, error|
+          spec_name.should_eql("spec")
+          error.message.should_match(/expected :poke with \(any args\) once, but received it 0 times/)
+        end
+        spec.run(@reporter, nil, nil, nil, ::Spec::Runner::ExecutionContext.new(nil))
+      end
+      
+      specify "should accept an options hash following the spec name" do
+        spec = Specification.new("name", :key => 'value')
+      end
+
+      specify "should update the current spec only when running the spec" do
+        @reporter.stub!(:spec_started)
+        @reporter.stub!(:spec_finished)
+
+        spec = Specification.new("spec") do
+          Specification.current.should == spec
+        end
+
+        Specification.current.should_be_nil
+        setup = proc {Specification.current.should == spec}
+        teardown = proc {Specification.current.should == spec}
+        spec.run(@reporter, setup, teardown, nil, ::Spec::Runner::ExecutionContext.new(nil))
+        Specification.current.should_be_nil
+      end
+
+      specify "should notify before_setup callbacks before setup" do
+        spec = Specification.new("spec")
+        @reporter.stub!(:spec_started)
+        @reporter.stub!(:spec_finished)
+
+        mock = mock("setup mock")
+        mock.should_receive(:before_setup).ordered
+        mock.should_receive(:setup).ordered
+
+        spec.before_setup {mock.before_setup}
+        setup = proc {mock.setup}
+        spec.run(@reporter, setup, nil, nil, ::Spec::Runner::ExecutionContext.new(nil))
+      end
+
+      specify "should notify after_teardown callbacks after teardown" do
+        spec = Specification.new("spec")
+        @reporter.stub!(:spec_started)
+        @reporter.stub!(:spec_finished)
+
+        mock = mock("teardown mock")
+        mock.should_receive(:teardown).ordered
+        mock.should_receive(:after_teardown).ordered
+
+        spec.after_teardown {mock.after_teardown}
+        teardown = proc {mock.teardown}
+        spec.run(@reporter, nil, teardown, nil, ::Spec::Runner::ExecutionContext.new(nil))
+      end
+    end
+  end
+end