rspec 1.0.0 → 1.3.1

data/spec/spec/runner/command_line_spec.rb

@@ -1,33 +1,162 @@
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-describe "CommandLine" do
-  it "should run directory" do
-    file = File.dirname(__FILE__) + '/../../../examples'
-    err = StringIO.new
-    out = StringIO.new
-    Spec::Runner::CommandLine.run([file], err, out, false, true)
-    
-    out.rewind
-    out.read.should =~ /77 examples, 0 failures/n
-  end
+require 'spec_helper'
 
-  it "should run file" do
-    file = File.dirname(__FILE__) + '/../../../failing_examples/predicate_example.rb'
-    err = StringIO.new
-    out = StringIO.new
-    Spec::Runner::CommandLine.run([file], err, out, false, true)
-    
-    out.rewind
-    out.read.should =~ /2 examples, 1 failure/n
-  end
+module Spec
+  module Runner
+    describe CommandLine, ".run" do
+      with_sandboxed_options do
+        attr_reader :err, :out
+        before do
+          @err = options.error_stream
+          @out = options.output_stream
+        end
+
+        it "should run directory" do
+          file = File.dirname(__FILE__) + '/../../../examples/passing'
+          run_with(OptionParser.parse([file,"-p","**/*_spec.rb,**/*_example.rb"], @err, @out))
+
+          @out.rewind
+          @out.read.should =~ /\d+ examples, 0 failures, 3 pending/n
+        end
+
+        it "should run file" do
+          file = File.dirname(__FILE__) + '/../../../examples/failing/predicate_example.rb'
+          run_with(OptionParser.parse([file], @err, @out))
+
+          @out.rewind
+          @out.read.should =~ /3 examples, 2 failures/n
+        end
+
+        it "should raise when file does not exist" do
+          file = File.dirname(__FILE__) + '/doesntexist'
+
+          lambda {
+            Spec::Runner::CommandLine.run(OptionParser.parse([file], @err, @out))
+          }.should raise_error
+        end
+
+        it "should return true when in --generate-options mode" do
+          # NOTE - this used to say /dev/null but jruby hangs on that for some reason
+          Spec::Runner::CommandLine.run(
+            OptionParser.parse(['--generate-options', '/tmp/foo'], @err, @out)
+          ).should be_true
+        end
+
+        it "should exit if Interrupt exception occurrs during the spec" do
+          example_group = Class.new(::Spec::Example::ExampleGroup) do
+            describe("example_group")
+            it "no error" do
+            end
+
+            it "should interrupt" do
+              raise Interrupt, "I'm interrupting"
+            end
+          end
+
+          options = ::Spec::Runner::Options.new(@err, @out)
+          ::Spec::Runner::Options.should_receive(:new).with(@err, @out).and_return(options)
+          options.add_example_group(example_group)
+
+          expect {
+            Spec::Runner::CommandLine.run(OptionParser.parse([], @err, @out))
+          }.to raise_error(SystemExit)
+        end
+
+        it "should exit if Interrupt exception occurrs during an after(:each)" do
+          example_group = Class.new(::Spec::Example::ExampleGroup) do
+            describe("example_group")
+            it "no error" do
+            end
+
+            after do
+              raise Interrupt, "I'm interrupting"
+            end
+          end
+
+          options = ::Spec::Runner::Options.new(@err, @out)
+          ::Spec::Runner::Options.should_receive(:new).with(@err, @out).and_return(options)
+          options.add_example_group(example_group)
+
+          expect {
+            Spec::Runner::CommandLine.run(OptionParser.parse([], @err, @out))
+          }.to raise_error(SystemExit)
+        end
+
+        it "should heckle when options have heckle_runner" do
+          example_group = Class.new(::Spec::Example::ExampleGroup).describe("example_group") do
+            it "no error" do
+            end
+          end
+          options = ::Spec::Runner::Options.new(@err, @out)
+          ::Spec::Runner::Options.should_receive(:new).with(@err, @out).and_return(options)
+          options.add_example_group example_group
+
+          heckle_runner = mock("heckle_runner")
+          heckle_runner.should_receive(:heckle_with)
+          $rspec_mocks.__send__(:mocks).delete(heckle_runner)
+
+          options.heckle_runner = heckle_runner
+          options.add_example_group(example_group)
+
+          Spec::Runner::CommandLine.run(OptionParser.parse([], @err, @out))
+          heckle_runner.rspec_verify
+        end
+
+        it "should run examples backwards if options.reverse is true" do
+          options = ::Spec::Runner::Options.new(@err, @out)
+          ::Spec::Runner::Options.should_receive(:new).with(@err, @out).and_return(options)
+          options.reverse = true
+
+          b1 = Class.new(Spec::Example::ExampleGroup)
+          b2 = Class.new(Spec::Example::ExampleGroup)
+
+          b2.should_receive(:run).ordered
+          b1.should_receive(:run).ordered
+
+          options.add_example_group(b1)
+          options.add_example_group(b2)
+
+          Spec::Runner::CommandLine.run(OptionParser.parse([], @err, @out))
+        end
+
+        it "should pass its ExampleGroup to the reporter" do
+          example_group = describe("example_group") do
+            it "should" do
+            end
+          end
+          options = ::Spec::Runner::Options.new(@err, @out)
+          options.add_example_group(example_group)
+
+          ::Spec::Runner::Options.should_receive(:new).with(@err, @out).and_return(options)
+          options.reporter.should_receive(:add_example_group).with(Spec::Example::ExampleGroupProxy.new(example_group))
+
+          Spec::Runner::CommandLine.run(OptionParser.parse([], @err, @out))
+        end
+
+        it "runs only selected Examples when options.examples is set" do
+          options = ::Spec::Runner::Options.new(@err, @out)
+          ::Spec::Runner::Options.should_receive(:new).with(@err, @out).and_return(options)
+
+          options.examples << "example group expected example"
+          expected_example_was_run = false
+          unexpected_example_was_run = false
+          example_group = describe("example group") do
+            it "expected example" do
+              expected_example_was_run = true
+            end
+            it "unexpected example" do
+              unexpected_example_was_run = true
+            end
+          end
+
+          options.reporter.should_receive(:add_example_group).with(Spec::Example::ExampleGroupProxy.new(example_group))
 
-  it "should raise when file does not exist" do
-    file = File.dirname(__FILE__) + '/doesntexist'
-    err = StringIO.new
-    out = StringIO.new
+          options.add_example_group example_group
+          run_with(options)
 
-    lambda {
-      Spec::Runner::CommandLine.run([file], err, out, false, true)
-    }.should raise_error
+          expected_example_was_run.should be_true
+          unexpected_example_was_run.should be_false
+        end
+      end
+    end
   end
-end
+end

data/spec/spec/runner/configuration_spec.rb

@@ -0,0 +1,320 @@
+require 'spec_helper'
+
+module Spec
+  module Runner
+    describe Configuration do
+      with_sandboxed_options do
+        with_sandboxed_config do
+          
+          describe "#mock_with" do
+            it "should default mock framework to rspec" do
+              config.mock_framework.should =~ /^spec\/adapters\/mock_frameworks\/rspec$/
+            end
+
+            it "should set rspec mocking explicitly" do
+              config.mock_with(:rspec)
+              config.mock_framework.should =~ /^spec\/adapters\/mock_frameworks\/rspec$/
+            end
+
+            it "should set mocha" do
+              config.mock_with(:mocha)
+              config.mock_framework.should =~ /^spec\/adapters\/mock_frameworks\/mocha$/
+            end
+
+            it "should set flexmock" do
+              config.mock_with(:flexmock)
+              config.mock_framework.should =~ /^spec\/adapters\/mock_frameworks\/flexmock$/
+            end
+
+            it "should set rr" do
+              config.mock_with(:rr)
+              config.mock_framework.should =~ /^spec\/adapters\/mock_frameworks\/rr$/
+            end
+
+            it "should set an arbitrary adapter module" do
+              adapter = Module.new
+              config.mock_with(adapter)
+              config.mock_framework.should == adapter
+            end
+          end
+
+          describe "#include" do
+          
+            before(:each) do
+              @example_group_class = Class.new(::Spec::Example::ExampleGroupDouble) {}
+              Spec::Example::ExampleGroupFactory.register(:foobar, @example_group_class)
+            end
+
+            it "should include the submitted module in ExampleGroup subclasses" do
+              mod = Module.new
+              config.include mod
+              Class.new(@example_group_class).included_modules.should include(mod)
+            end
+
+            it "should scope modules to be included for a specific type" do
+              mod = Module.new
+              config.include mod, :type => :foobar
+              Class.new(@example_group_class).included_modules.should include(mod)
+            end
+
+            it "should not include modules in a type they are not intended for" do
+              mod = Module.new
+              @other_example_group_class = Class.new(::Spec::Example::ExampleGroupDouble)
+              Spec::Example::ExampleGroupFactory.register(:baz, @other_example_group_class)
+
+              config.include mod, :type => :foobar
+
+              Class.new(@other_example_group_class).included_modules.should_not include(mod)
+            end
+            
+            it "accepts an Array of types" do
+              mod = Module.new
+              @other_example_group_class = Class.new(::Spec::Example::ExampleGroupDouble)
+              Spec::Example::ExampleGroupFactory.register(:baz, @other_example_group_class)
+
+              config.include mod, :type => [:foobar, :baz]
+
+              Class.new(@example_group_class).included_modules.should include(mod)
+              Class.new(@other_example_group_class).included_modules.should include(mod)
+            end
+
+          end
+      
+          describe "#extend" do
+        
+            before(:each) do
+              @example_group_class = Class.new(::Spec::Example::ExampleGroupDouble) {}
+              Spec::Example::ExampleGroupFactory.register(:foobar, @example_group_class)
+            end
+
+            it "should extend all groups" do
+              mod = Module.new
+              ExampleGroup.should_receive(:extend).with(mod)
+              Spec::Runner.configuration.extend mod
+            end
+      
+            it "should extend specified groups" do
+              mod = Module.new
+              @example_group_class.should_receive(:extend).with(mod)
+              Spec::Runner.configuration.extend mod, :type => :foobar
+            end
+      
+            it "should not extend non-specified groups" do
+              @other_example_group_class = Class.new(::Spec::Example::ExampleGroupDouble)
+              Spec::Example::ExampleGroupFactory.register(:baz, @other_example_group_class)
+
+              mod = Module.new
+              @other_example_group_class.should_not_receive(:extend)          
+
+              Spec::Runner.configuration.extend mod, :type => :foobar
+            end
+        
+          end
+        end
+      
+        describe "ordering methods: " do
+        
+          before(:each) do
+            @special_example_group = Class.new(::Spec::Example::ExampleGroupDouble).describe("special_example_group")
+            @special_child_example_group = Class.new(@special_example_group).describe("special_child_example_group")
+            @nonspecial_example_group = Class.new(::Spec::Example::ExampleGroupDouble).describe("nonspecial_example_group")
+            Spec::Example::ExampleGroupFactory.register(:special, @special_example_group)
+            Spec::Example::ExampleGroupFactory.register(:special_child, @special_child_example_group)
+            Spec::Example::ExampleGroupFactory.register(:non_special, @nonspecial_example_group)
+            @example_group = @special_child_example_group.describe "Special Example Group"
+            @unselected_example_group = Class.new(@nonspecial_example_group).describe "Non Special Example Group"
+          end
+
+          describe "#prepend_before" do
+            it "prepends the before block on all instances of the passed in type" do
+              order = []
+              config.prepend_before(:all) do
+                order << :prepend__before_all
+              end
+              config.prepend_before(:all, :type => :special) do
+                order << :special_prepend__before_all
+              end
+              config.prepend_before(:all, :type => :special_child) do
+                order << :special_child_prepend__before_all
+              end
+              config.prepend_before(:each) do
+                order << :prepend__before_each
+              end
+              config.prepend_before(:each, :type => :special) do
+                order << :special_prepend__before_each
+              end
+              config.prepend_before(:each, :type => :special_child) do
+                order << :special_child_prepend__before_each
+              end
+              config.prepend_before(:all, :type => :non_special) do
+                order << :special_prepend__before_all
+              end
+              config.prepend_before(:each, :type => :non_special) do
+                order << :special_prepend__before_each
+              end
+              @example_group.it "calls prepend_before" do
+              end
+      
+              @example_group.run(options)
+              order.should == [
+                :prepend__before_all,
+                :special_prepend__before_all,
+                :special_child_prepend__before_all,
+                :prepend__before_each,
+                :special_prepend__before_each,
+                :special_child_prepend__before_each
+              ]
+            end
+          end
+
+          describe "#append_before" do
+
+            it "calls append_before on the type" do
+              order = []
+              config.append_before(:all) do
+                order << :append_before_all
+              end
+              config.append_before(:all, :type => :special) do
+                order << :special_append_before_all
+              end
+              config.append_before(:all, :type => :special_child) do
+                order << :special_child_append_before_all
+              end
+              config.append_before do # default is :each
+                order << :append_before_each
+              end
+              config.append_before(:each, :type => :special) do
+                order << :special_append_before_each
+              end
+              config.append_before(:each, :type => :special_child) do
+                order << :special_child_append_before_each
+              end
+              config.append_before(:all, :type => :non_special) do
+                order << :special_append_before_all
+              end
+              config.append_before(:each, :type => :non_special) do
+                order << :special_append_before_each
+              end
+              @example_group.it "calls append_before" do
+              end
+
+              @example_group.run(options)
+              order.should == [
+                :append_before_all,
+                :special_append_before_all,
+                :special_child_append_before_all,
+                :append_before_each,
+                :special_append_before_each,
+                :special_child_append_before_each
+              ]
+            end
+          end
+
+          describe "#prepend_after" do
+
+            it "prepends the after block on all instances of the passed in type" do
+              order = []
+              config.prepend_after(:all) do
+                order << :prepend__after_all
+              end
+              config.prepend_after(:all, :type => :special) do
+                order << :special_prepend__after_all
+              end
+              config.prepend_after(:all, :type => :special) do
+                order << :special_child_prepend__after_all
+              end
+              config.prepend_after(:each) do
+                order << :prepend__after_each
+              end
+              config.prepend_after(:each, :type => :special) do
+                order << :special_prepend__after_each
+              end
+              config.prepend_after(:each, :type => :special) do
+                order << :special_child_prepend__after_each
+              end
+              config.prepend_after(:all, :type => :non_special) do
+                order << :special_prepend__after_all
+              end
+              config.prepend_after(:each, :type => :non_special) do
+                order << :special_prepend__after_each
+              end
+              @example_group.it "calls prepend_after" do
+              end
+
+              @example_group.run(options)
+              order.should == [
+                :special_child_prepend__after_each,
+                :special_prepend__after_each,
+                :prepend__after_each,
+                :special_child_prepend__after_all,
+                :special_prepend__after_all,
+                :prepend__after_all
+              ]
+            end
+          end
+
+          describe "#append_after" do
+
+            it "calls append_after on the type" do
+              order = []
+              config.append_after(:all) do
+                order << :append__after_all
+              end
+              config.append_after(:all, :type => :special) do
+                order << :special_append__after_all
+              end
+              config.append_after(:all, :type => :special_child) do
+                order << :special_child_append__after_all
+              end
+              config.append_after(:each) do
+                order << :append__after_each
+              end
+              config.append_after(:each, :type => :special) do
+                order << :special_append__after_each
+              end
+              config.append_after(:each, :type => :special_child) do
+                order << :special_child_append__after_each
+              end
+              config.append_after(:all, :type => :non_special) do
+                order << :non_special_append_after_all
+              end
+              config.append_after(:each, :type => :non_special) do
+                order << :non_special_append_after_each
+              end
+              @example_group.it "calls append_after" do
+              end
+
+              @example_group.run(options)
+              order.should == [
+                :special_child_append__after_each,
+                :special_append__after_each,
+                :append__after_each,
+                :special_child_append__after_all,
+                :special_append__after_all,
+                :append__after_all
+              ]
+            end
+
+          end
+
+          describe "#ignore_backtrace_patterns" do
+            it "adds patterns to ignore in backtrace" do
+              config.ignore_backtrace_patterns /custom_pattern/, /shoulda/, /spork/
+              config.ignored_backtrace_patterns.should include(/custom_pattern/)
+              config.ignored_backtrace_patterns.should include(/shoulda/)
+              config.ignored_backtrace_patterns.should include(/spork/)
+            end
+          end
+          
+          describe "#predicate_matchers (DEPRECATED)" do
+            it "is deprecated" do
+              Spec.should_receive(:deprecate)
+              config.predicate_matchers[:foo] = :bar?
+            end
+          end
+
+        end
+      end
+    end
+  end
+end