typo 5.1.3 → 5.1.98

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
@@ -22,10 +29,9 @@ module Spec
             
       it "should_not_receive should mock out the method" do
         @object.should_not_receive(:fuhbar)
-        @object.fuhbar
         lambda do
-          @object.rspec_verify
-        end.should raise_error(Spec::Mocks::MockExpectationError)
+          @object.fuhbar
+        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
@@ -67,17 +73,18 @@ module Spec
       
       it "should_not_receive should also take a String argument" do
         @object.should_not_receive('foobar')
-        @object.foobar
         lambda do
-          @object.rspec_verify
+          @object.foobar   
         end.should raise_error(Spec::Mocks::MockExpectationError)
       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
     
@@ -102,5 +109,41 @@ module Spec
         lambda { o.stub!(:bar) }.should_not raise_error(NoMethodError)
       end
     end
+
+    describe "Method visibility when using partial mocks" do
+      class MockableClass
+        def public_method
+          private_method
+          protected_method
+        end
+        protected
+        def protected_method; end
+        private
+        def private_method; end
+      end
+
+      before(:each) do
+        @object = MockableClass.new
+      end
+
+      it 'should keep public methods public' do
+        @object.should_receive(:public_method)
+        @object.public_methods.should include('public_method')
+        @object.public_method
+      end
+
+      it 'should keep private methods private' do
+        @object.should_receive(:private_method)
+        @object.private_methods.should include('private_method')
+        @object.public_method
+      end
+
+      it 'should keep protected methods protected' do
+        @object.should_receive(:protected_method)
+        @object.protected_methods.should include('protected_method')
+        @object.public_method
+      end
+
+    end
   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"
 
@@ -109,10 +65,35 @@ module Spec
         @mock.should_receive(:random_call).with(no_args)
         @mock.random_call()
       end
+      
+      it "should match hash with hash_including same hash" do
+        @mock.should_receive(:random_call).with(hash_including(:a => 1))
+        @mock.random_call(:a => 1)
+      end
+        
+    end
+
+    describe Methods, "handling block constraints" do
+      it_should_behave_like "mock argument constraints"
+      
+      it "should match arguments against RSpec expectations" do
+        @mock.should_receive(:random_call).with {|arg1, arg2, arr, *rest|
+          arg1.should == 5
+          arg2.should have_at_least(3).characters
+          arg2.should have_at_most(10).characters
+          arr.map {|i| i * 2}.should == [2,4,6]
+          rest.should == [:fee, "fi", 4]
+        }
+        @mock.random_call 5, "hello", [1,2,3], :fee, "fi", 4
+      end
     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)
@@ -144,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/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/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'
-        Spec::Runner::CommandLine.run(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)
-
-        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

data/vendor/plugins/rspec/spec/spec/runner/drb_command_line_spec.rb

@@ -15,18 +15,22 @@ module Spec
       end    
     end
 
-    class DrbCommandLineSpec < ::Spec::Example::ExampleGroup
-      describe DrbCommandLine, "with local server"
+    describe "with local server" do
 
       class CommandLineForSpec
         def self.run(argv, stderr, stdout)
-          exit Spec::Runner::CommandLine.run(OptionParser.parse(argv, stderr, stdout))
+          orig_options = Spec::Runner.options
+          tmp_options = OptionParser.parse(argv, stderr, stdout)
+          Spec::Runner.use tmp_options
+          Spec::Runner::CommandLine.run(tmp_options)
+        ensure
+          Spec::Runner.use orig_options
         end
       end
       
       unless Config::CONFIG['ruby_install_name'] == 'jruby'
         before(:all) do
-          DRb.start_service("druby://localhost:8989", CommandLineForSpec)
+          DRb.start_service("druby://127.0.0.1:8989", CommandLineForSpec)
           @@drb_example_file_counter = 0
         end
 
@@ -45,7 +49,7 @@ module Spec
 
         it "should run against local server" do
           out = run_spec_via_druby(['--version'])
-          out.should =~ /RSpec/n
+          out.should =~ /rspec \d+\.\d+\.\d+.*/n
         end
 
         it "should output green colorized text when running with --colour option" do
@@ -86,7 +90,8 @@ module Spec
           out.rewind; out.read
         end
       end
-
+      
     end
+
   end
 end