spree 0.5.1 → 0.6.0

data/vendor/plugins/rspec/spec/spec/mocks/nil_expectation_warning_spec.rb

@@ -0,0 +1,53 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+module Spec
+  module Mocks
+
+    describe "an expectation set on nil" do
+      
+      it "should issue a warning with file and line number information" do
+        expected_warning = %r%An expectation of :foo was set on nil. Called from #{__FILE__}:#{__LINE__+3}(:in `block \(2 levels\) in <module:Mocks>')?. Use allow_message_expectations_on_nil to disable warnings.%
+        Kernel.should_receive(:warn).with(expected_warning)
+
+        nil.should_receive(:foo)
+        nil.foo
+      end
+      
+      it "should issue a warning when the expectation is negative" do
+        Kernel.should_receive(:warn)
+
+        nil.should_not_receive(:foo)
+      end
+      
+      it "should not issue a warning when expectations are set to be allowed" do
+        allow_message_expectations_on_nil
+        Kernel.should_not_receive(:warn)
+        
+        nil.should_receive(:foo)
+        nil.should_not_receive(:bar)
+        nil.foo
+      end
+
+    end
+    
+    describe "#allow_message_expectations_on_nil" do
+      
+      it "should not effect subsequent examples" do
+        example_group = Class.new(ExampleGroup)
+        example_group.it("when called in one example that doesn't end up setting an expectation on nil") do
+                        allow_message_expectations_on_nil
+                      end
+        example_group.it("should not effect the next exapmle ran") do
+                        Kernel.should_receive(:warn)
+                        nil.should_receive(:foo)
+                        nil.foo
+                      end
+                              
+        example_group.run(Spec::Runner.options).should be_true
+                  
+      end
+
+    end
+    
+  end
+end

data/vendor/plugins/rspec/spec/spec/mocks/null_object_mock_spec.rb

@@ -36,5 +36,19 @@ module Spec
         @mock.message(:unexpected_arg)
       end
     end
+
+    describe "#null_object?" do
+      it "should default to false" do
+        obj = mock('anything')
+        obj.should_not be_null_object
+      end
+    end
+    
+    describe "#as_null_object" do
+      it "should set the object to null_object" do
+        obj = mock('anything').as_null_object
+        obj.should be_null_object
+      end
+    end
   end
 end

data/vendor/plugins/rspec/spec/spec/mocks/options_hash_spec.rb

@@ -3,42 +3,32 @@ require File.dirname(__FILE__) + '/../../spec_helper.rb'
 module Spec
   module Mocks
     describe "calling :should_receive with an options hash" do
-      it_should_behave_like "sandboxed rspec_options"
-      attr_reader :reporter, :example_group
-      before do
-        @reporter = ::Spec::Runner::Reporter.new(options)
-        @example_group = Class.new(::Spec::Example::ExampleGroup) do
-          plugin_mock_framework
-          describe("Some Examples")
-        end
-        reporter.add_example_group example_group
-      end
-
       it "should report the file and line submitted with :expected_from" do
-        example_definition = example_group.it "spec" do
+        begin
           mock = Spec::Mocks::Mock.new("a mock")
           mock.should_receive(:message, :expected_from => "/path/to/blah.ext:37")
           mock.rspec_verify
+        rescue => e
+        ensure
+          e.backtrace.to_s.should =~ /\/path\/to\/blah.ext:37/m
         end
-        example = example_group.new(example_definition)
-        
-        reporter.should_receive(:example_finished) do |spec, error|
-          error.backtrace.detect {|line| line =~ /\/path\/to\/blah.ext:37/}.should_not be_nil
-        end
-        example.execute(options, {})
       end
 
       it "should use the message supplied with :message" do
-        example_definition = @example_group.it "spec" do
-          mock = Spec::Mocks::Mock.new("a mock")
-          mock.should_receive(:message, :message => "recebi nada")
-          mock.rspec_verify
-        end
-        example = @example_group.new(example_definition)
-        @reporter.should_receive(:example_finished) do |spec, error|
-          error.message.should == "recebi nada"
-        end
-        example.execute(@options, {})
+        lambda {
+          m = Spec::Mocks::Mock.new("a mock")
+          m.should_receive(:message, :message => "recebi nada")
+          m.rspec_verify
+        }.should raise_error("recebi nada")
+      end
+      
+      it "should use the message supplied with :message after a similar stub" do
+        lambda {
+          m = Spec::Mocks::Mock.new("a mock")
+          m.stub!(:message)
+          m.should_receive(:message, :message => "from mock")
+          m.rspec_verify
+        }.should raise_error("from mock")
       end
     end
   end

data/vendor/plugins/rspec/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   
@@ -74,10 +79,12 @@ module Spec
       end
       
       it "should use report nil in the error message" do
+        allow_message_expectations_on_nil
+        
         @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/vendor/plugins/rspec/spec/spec/mocks/passing_mock_argument_constraints_spec.rb

@@ -13,50 +13,6 @@ module Spec
       end
     end
     
-    describe Methods, "handling argument constraints with DEPRECATED symbols" do
-      it_should_behave_like "mock argument constraints"
-
-      it "should accept true as boolean" do
-        @mock.should_receive(:random_call).with(:boolean)
-        @mock.random_call(true)
-      end
-      
-      it "should accept false as boolean" do
-        @mock.should_receive(:random_call).with(:boolean)
-        @mock.random_call(false)
-      end
-
-      it "should accept fixnum as numeric" do
-        @mock.should_receive(:random_call).with(:numeric)
-        @mock.random_call(1)
-      end
-
-      it "should accept float as numeric" do
-        @mock.should_receive(:random_call).with(:numeric)
-        @mock.random_call(1.5)
-      end
-
-      it "should accept string as anything" do
-        @mock.should_receive(:random_call).with("a", :anything, "c")
-        @mock.random_call("a", "whatever", "c")
-      end
-
-      it "should match string" do
-        @mock.should_receive(:random_call).with(:string)
-        @mock.random_call("a string")
-      end
-      
-      it "should match no args against any_args" do
-        @mock.should_receive(:random_call).with(:any_args)
-        @mock.random_call("a string")
-      end
-      
-      it "should match no args against no_args" do
-        @mock.should_receive(:random_call).with(:no_args)
-        @mock.random_call
-      end
-    end
-
     describe Methods, "handling argument constraints" do
       it_should_behave_like "mock argument constraints"
 
@@ -133,7 +89,11 @@ module Spec
     end
     
     describe Methods, "handling non-constraint arguments" do
-
+      
+      before(:each) do
+        @mock = Mock.new("test mock")
+      end
+      
       it "should match non special symbol (can be removed when deprecated symbols are removed)" do
         @mock.should_receive(:random_call).with(:some_symbol)
         @mock.random_call(:some_symbol)
@@ -165,11 +125,6 @@ module Spec
         @mock.should_receive(:random_call).with(:a => "a", :b => "b")
         @mock.random_call(opts)
       end
-      
-      it "should match against a Matcher" do
-        @mock.should_receive(:msg).with(equal(37))
-        @mock.msg(37)
-      end
     end
   end
 end

data/vendor/plugins/rspec/spec/spec/mocks/stub_spec.rb

@@ -14,6 +14,7 @@ module Spec
           end
         end
         @instance = @class.new
+        @stub = Object.new
       end
 
       it "should return expected value when expected message is received" do
@@ -44,6 +45,12 @@ module Spec
           @instance.rspec_verify
         end.should_not raise_error
       end
+
+      it "should handle multiple stubbed methods" do
+        @instance.stub!(:msg1 => 1, :msg2 => 2)
+        @instance.msg1.should == 1
+        @instance.msg2.should == 2
+      end
       
       it "should clear itself when verified" do
         @instance.stub!(:this_should_go).and_return(:blah)

data/vendor/plugins/rspec/spec/spec/mocks/stubbed_message_expectations_spec.rb

@@ -0,0 +1,14 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+module Spec
+  module Mocks
+    describe "Example with stubbed and then called message" do
+      it "should fail if the message is expected and then subsequently not called again" do
+        mock_obj = mock("mock", :msg => nil)
+        mock_obj.msg
+        mock_obj.should_receive(:msg)
+        lambda { mock_obj.rspec_verify }.should raise_error(Spec::Mocks::MockExpectationError)
+      end
+    end
+  end
+end

data/vendor/plugins/rspec/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/vendor/plugins/rspec/spec/spec/runner/command_line_spec.rb

@@ -3,144 +3,138 @@ require File.dirname(__FILE__) + '/../../spec_helper.rb'
 module Spec
   module Runner
     describe CommandLine, ".run" do
-      it_should_behave_like "sandboxed rspec_options"
-      attr_reader :options, :err, :out
-      before do
-        @err = options.error_stream
-        @out = options.output_stream
-      end
-
-      it "should run directory" do
-        file = File.dirname(__FILE__) + '/../../../examples/pure'
-        Spec::Runner::CommandLine.run(OptionParser.parse([file,"-p","**/*.rb"], @err, @out))
+      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
+          @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'
-        Spec::Runner::CommandLine.run(OptionParser.parse([file], @err, @out))
+        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 =~ /2 examples, 1 failure/n
-      end
+          @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'
+        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)
-
-        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
-          end
-          it "should not" do
-            should_not_has_run = true
-          end
+          Spec::Runner::CommandLine.run(OptionParser.parse([], @err, @out))
         end
 
-        options.reporter.should_receive(:add_example_group).with(example_group)
+        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.add_example_group example_group
-        Spec::Runner::CommandLine.run(OptionParser.parse([], @err, @out))
+          options.reporter.should_receive(:add_example_group).with(example_group)
 
-        should_has_run.should be_true
-        should_not_has_run.should be_false
-      end
+          options.add_example_group example_group
+          run_with(options)
 
-      it "sets Spec.run to true" do
-        ::Spec.run = false
-        ::Spec.should_not be_run
-        Spec::Runner::CommandLine.run(OptionParser.parse([], @err, @out))
-        ::Spec.should be_run
+          expected_example_was_run.should be_true
+          unexpected_example_was_run.should be_false
+        end
       end
     end
   end