rspec 1.1.8 → 1.1.9

data/spec/spec/extensions/main_spec.rb

@@ -3,7 +3,6 @@ require File.dirname(__FILE__) + '/../../spec_helper.rb'
 module Spec
   module Extensions
     describe Main do
-      include SandboxedOptions
       before(:each) do
         @main = Class.new do; include Main; end
       end
@@ -11,41 +10,42 @@ module Spec
       after(:each) do
         $rspec_story_steps = @original_rspec_story_steps
       end
+      
+      [:describe, :context].each do |method|
+        describe "##{method}" do
+          specify {@main.should respond_to(method)}
 
-      specify {@main.should respond_to(:describe)}
-      specify {@main.should respond_to(:context)}
+          it "should raise when no block is given to #{method}" do
+            lambda { @main.__send__ method, "foo" }.should raise_error(ArgumentError)
+          end
 
-      it "should raise when no block given to describe" do
-        lambda { @main.describe "foo" }.should raise_error(ArgumentError)
-      end
+          it "should raise when no description is given to #{method}" do
+            lambda { @main.__send__ method do; end }.should raise_error(ArgumentError)
+          end
 
-      it "should raise when no description given to describe" do
-        lambda { @main.describe do; end }.should raise_error(ArgumentError)
-      end
-
-      it "should registered ExampleGroups by default" do
-        example_group = @main.describe("The ExampleGroup") do end
-        Spec::Runner.options.example_groups.should include(example_group)
-      end
+          it "should run registered ExampleGroups" do
+            example_group = @main.__send__ method, "The ExampleGroup" do end
+            Spec::Runner.options.example_groups.should include(example_group)
+          end
 
-      it "should not run unregistered ExampleGroups" do
-        example_group = @main.describe("The ExampleGroup") do
-          unregister
+          it "should not run unregistered ExampleGroups" do
+            example_group = @main.__send__ method, "The ExampleGroup" do unregister; end
+            Spec::Runner.options.example_groups.should_not include(example_group)
+          end
         end
-
-        Spec::Runner.options.example_groups.should_not include(example_group)
       end
       
-      it "should create a shared ExampleGroup with share_examples_for" do
-        group = @main.share_examples_for "all things" do end
-        group.should be_an_instance_of(Spec::Example::SharedExampleGroup)
+      describe "#share_examples_for" do
+        it "should create a shared ExampleGroup" do
+          group = @main.share_examples_for "all things" do end
+          group.should be_an_instance_of(Spec::Example::SharedExampleGroup)
+        end
       end
       
       describe "#share_as" do
         before(:each) do
           $share_as_examples_example_module_number ||= 1
           $share_as_examples_example_module_number += 1
-          t = Time.new.to_i
           @group_name = "Group#{$share_as_examples_example_module_number}"
         end
 

data/spec/spec/interop/test/unit/resources/spec_with_options_hash.rb

@@ -0,0 +1,13 @@
+rspec_lib = File.dirname(__FILE__) + "/../../../../../../lib"
+$:.unshift rspec_lib unless $:.include?(rspec_lib)
+require 'test/unit'
+require 'spec'
+
+describe "options hash" do
+  describe "#options" do
+    it "should expose the options hash" do
+      group = describe("group", :this => 'hash') {}
+      group.options[:this].should == 'hash'
+    end
+  end
+end

data/spec/spec/interop/test/unit/spec_spec.rb

@@ -3,43 +3,50 @@ require File.dirname(__FILE__) + '/test_unit_spec_helper'
 describe "ExampleGroup with test/unit/interop" do
   include TestUnitSpecHelper
   
-  before(:each) do
-    @dir = File.dirname(__FILE__) + "/resources"
+  def resources
+    File.dirname(__FILE__) + "/resources"
   end
   
   describe "with passing examples" do
     it "should output 0 failures" do
-      output = ruby("#{@dir}/spec_that_passes.rb")
+      output = ruby("#{resources}/spec_that_passes.rb")
       output.should include("1 example, 0 failures")
     end
 
     it "should return an exit code of 0" do
-      ruby("#{@dir}/spec_that_passes.rb")
+      ruby("#{resources}/spec_that_passes.rb")
       $?.should == 0
     end
   end
 
   describe "with failing examples" do
     it "should output 1 failure" do
-      output = ruby("#{@dir}/spec_that_fails.rb")
+      output = ruby("#{resources}/spec_that_fails.rb")
       output.should include("1 example, 1 failure")
     end
 
     it "should return an exit code of 256" do
-      ruby("#{@dir}/spec_that_fails.rb")
+      ruby("#{resources}/spec_that_fails.rb")
       $?.should == 256
     end
   end
 
   describe "with example that raises an error" do
     it "should output 1 failure" do
-      output = ruby("#{@dir}/spec_with_errors.rb")
+      output = ruby("#{resources}/spec_with_errors.rb")
       output.should include("1 example, 1 failure")
     end
 
     it "should return an exit code of 256" do
-      ruby("#{@dir}/spec_with_errors.rb")
+      ruby("#{resources}/spec_with_errors.rb")
       $?.should == 256
     end
   end
+  
+  describe "options hash" do
+    it "should be exposed" do
+      output = ruby("#{resources}/spec_with_options_hash.rb")
+      output.should include("1 example, 0 failures")
+    end
+  end
 end

data/spec/spec/mocks/mock_spec.rb

@@ -451,11 +451,21 @@ module Spec
       it "should not mess with the stub's yielded values when also mocked" do
         @mock.stub!(:yield_back).and_yield(:stub_value)
         @mock.should_receive(:yield_back).and_yield(:mock_value)
-        @mock.yield_back{|v| v}.should == :mock_value
-        @mock.yield_back{|v| v}.should == :stub_value
+        @mock.yield_back{|v| v.should == :mock_value }
+        @mock.yield_back{|v| v.should == :stub_value }
         @mock.rspec_verify
       end
 
+      it "should yield multiple values after a similar stub" do
+        File.stub!(:open).and_yield(:stub_value)
+        File.should_receive(:open).and_yield(:first_call).and_yield(:second_call)
+        yielded_args = []
+        File.open {|v| yielded_args << v }
+        yielded_args.should == [:first_call, :second_call]
+        File.open {|v| v.should == :stub_value }
+        File.rspec_verify
+      end
+
       it "should assign stub return values" do
         mock = Mock.new('name', :message => :response)
         mock.message.should == :response

data/spec/spec/mocks/nil_expectation_warning_spec.rb

@@ -31,7 +31,6 @@ module Spec
     end
     
     describe "#allow_message_expectations_on_nil" do
-      include SandboxedOptions
       
       it "should not effect subsequent examples" do
         example_group = Class.new(ExampleGroup)

data/spec/spec/mocks/partial_mock_spec.rb

@@ -11,7 +11,14 @@ module Spec
         @object.should_receive(:foo)
         lambda do
           @object.rspec_verify
-        end.should raise_error(Spec::Mocks::MockExpectationError, /Object/)
+        end.should raise_error(Spec::Mocks::MockExpectationError, /<Object:.*> expected/)
+      end
+    
+      it "should name the class in the failure message when expectation is on class" do
+        Object.should_receive(:foo)
+        lambda do
+          Object.rspec_verify
+        end.should raise_error(Spec::Mocks::MockExpectationError, /<Object \(class\)>/)
       end
     
       it "should not conflict with @options in the object" do
@@ -21,11 +28,10 @@ module Spec
       end
             
       it "should_not_receive should mock out the method" do
-        pending("example raises the expected error, yet fails")
         @object.should_not_receive(:fuhbar)
         lambda do
           @object.fuhbar
-        end.should raise_error(MockExpectationError, "Mock 'Object' expected :fuhbar with (no args) 0 times, but received it once")
+        end.should raise_error(MockExpectationError, /<Object:.*> expected :fuhbar with \(no args\) 0 times/)
       end
     
       it "should_not_receive should return a negative message expectation" do
@@ -66,7 +72,6 @@ module Spec
       end
       
       it "should_not_receive should also take a String argument" do
-        pending("example raises the expected error, yet fails")
         @object.should_not_receive('foobar')
         lambda do
           @object.foobar   
@@ -79,7 +84,7 @@ module Spec
         @this_will_resolve_to_nil.should_receive(:foobar)
         lambda do
           @this_will_resolve_to_nil.rspec_verify
-        end.should raise_error(Spec::Mocks::MockExpectationError, /NilClass.*expected :foobar with/)
+        end.should raise_error(Spec::Mocks::MockExpectationError, /nil expected :foobar with/)
       end
     end
     

data/spec/spec/package/bin_spec_spec.rb

@@ -11,4 +11,12 @@ describe "The bin/spec script" do
     output = ruby "-w #{spec_path} --help 2>&1"
     output.should_not =~ /warning/n
   end
+  
+  it "should show the help w/ no args" do
+    pending "Hangs on JRuby" if PLATFORM =~ /java/
+    spec_path = "#{File.dirname(__FILE__)}/../../../bin/spec"
+
+    output = ruby "-w #{spec_path} 2>&1"
+    output.should =~ /^Usage: spec/
+  end
 end

data/spec/spec/runner/command_line_spec.rb

@@ -3,137 +3,138 @@ require File.dirname(__FILE__) + '/../../spec_helper.rb'
 module Spec
   module Runner
     describe CommandLine, ".run" do
-      include SandboxedOptions
-      attr_reader :options, :err, :out
-      before do
-        @err = options.error_stream
-        @out = options.output_stream
-      end
+      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/pure'
-        run_with(OptionParser.parse([file,"-p","**/*.rb"], @err, @out))
+        it "should run directory" do
+          file = File.dirname(__FILE__) + '/../../../examples/pure'
+          run_with(OptionParser.parse([file,"-p","**/*.rb"], @err, @out))
 
-        @out.rewind
-        @out.read.should =~ /\d+ examples, 0 failures, 3 pending/n
-      end
+          @out.rewind
+          @out.read.should =~ /\d+ examples, 0 failures, 3 pending/n
+        end
 
-      it "should run file" do
-        file = File.dirname(__FILE__) + '/../../../failing_examples/predicate_example.rb'
-        run_with(OptionParser.parse([file], @err, @out))
+        it "should run file" do
+          file = File.dirname(__FILE__) + '/../../../failing_examples/predicate_example.rb'
+          run_with(OptionParser.parse([file], @err, @out))
 
-        @out.rewind
-        @out.read.should =~ /2 examples, 1 failure/n
-      end
+          @out.rewind
+          @out.read.should =~ /2 examples, 1 failure/n
+        end
 
-      it "should raise when file does not exist" do
-        file = File.dirname(__FILE__) + '/doesntexist'
+        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
+          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 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 dump even if Interrupt exception is occurred" do
-        example_group = Class.new(::Spec::Example::ExampleGroup) do
-          describe("example_group")
-          it "no error" do
-          end
+        it "should dump even if Interrupt exception is occurred" 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"
+            it "should interrupt" do
+              raise Interrupt, "I'm interrupting"
+            end
           end
-        end
 
-        options = ::Spec::Runner::Options.new(@err, @out)
-        ::Spec::Runner::Options.should_receive(:new).with(@err, @out).and_return(options)
-        options.reporter.should_receive(:dump)
-        options.add_example_group(example_group)
+          options = ::Spec::Runner::Options.new(@err, @out)
+          ::Spec::Runner::Options.should_receive(:new).with(@err, @out).and_return(options)
+          options.reporter.should_receive(:dump)
+          options.add_example_group(example_group)
 
-        Spec::Runner::CommandLine.run(OptionParser.parse([], @err, @out))
-      end
+          Spec::Runner::CommandLine.run(OptionParser.parse([], @err, @out))
+        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
+        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
-        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
+          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)
+          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)
+          options.heckle_runner = heckle_runner
+          options.add_example_group(example_group)
 
-        Spec::Runner::CommandLine.run(OptionParser.parse([], @err, @out))
-        heckle_runner.rspec_verify
-      end
+          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
+        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)
+          b1 = Class.new(Spec::Example::ExampleGroup)
+          b2 = Class.new(Spec::Example::ExampleGroup)
 
-        b2.should_receive(:run).ordered
-        b1.should_receive(:run).ordered
+          b2.should_receive(:run).ordered
+          b1.should_receive(:run).ordered
 
-        options.add_example_group(b1)
-        options.add_example_group(b2)
+          options.add_example_group(b1)
+          options.add_example_group(b2)
 
-        Spec::Runner::CommandLine.run(OptionParser.parse([], @err, @out))
-      end
+          Spec::Runner::CommandLine.run(OptionParser.parse([], @err, @out))
+        end
 
-      it "should pass its ExampleGroup to the reporter" do
-        example_group = Class.new(::Spec::Example::ExampleGroup).describe("example_group") do
-          it "should" do
+        it "should pass its ExampleGroup to the reporter" do
+          example_group = describe("example_group") do
+            it "should" do
+            end
           end
-        end
-        options = ::Spec::Runner::Options.new(@err, @out)
-        options.add_example_group(example_group)
+          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(example_group)
+          ::Spec::Runner::Options.should_receive(:new).with(@err, @out).and_return(options)
+          options.reporter.should_receive(:add_example_group).with(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)
+          Spec::Runner::CommandLine.run(OptionParser.parse([], @err, @out))
+        end
 
-        options.examples << "example_group should"
-        should_has_run = false
-        should_not_has_run = false
-        example_group = Class.new(::Spec::Example::ExampleGroup).describe("example_group") do
-          it "should" do
-            should_has_run = true
+        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
-          it "should not" do
-            should_not_has_run = true
-          end
-        end
 
-        options.reporter.should_receive(:add_example_group).with(example_group)
+          options.reporter.should_receive(:add_example_group).with(example_group)
 
-        options.add_example_group example_group
-        run_with(options)
+          options.add_example_group example_group
+          run_with(options)
 
-        should_has_run.should be_true
-        should_not_has_run.should be_false
+          expected_example_was_run.should be_true
+          unexpected_example_was_run.should be_false
+        end
       end
     end
   end