resque-pool 0.3.0.beta.2 → 0.3.0

data/vendor/bundle/ruby/1.8/gems/rspec-mocks-2.9.0/spec/rspec/mocks/multiple_return_value_spec.rb

@@ -0,0 +1,188 @@
+require 'spec_helper'
+
+module RSpec
+  module Mocks
+    describe "a Mock expectation with multiple return values and no specified count" do
+      before(:each) do
+        @mock = RSpec::Mocks::Mock.new("mock")
+        @return_values = ["1",2,Object.new]
+        @mock.should_receive(:message).and_return(@return_values[0],@return_values[1],@return_values[2])
+      end
+
+      it "returns values in order to consecutive calls" do
+        @mock.message.should eq @return_values[0]
+        @mock.message.should eq @return_values[1]
+        @mock.message.should eq @return_values[2]
+        @mock.rspec_verify
+      end
+
+      it "complains when there are too few calls" do
+        @mock.message.should eq @return_values[0]
+        @mock.message.should eq @return_values[1]
+        expect { @mock.rspec_verify }.to raise_error(
+          RSpec::Mocks::MockExpectationError,
+          %Q|(Mock "mock").message(any args)\n    expected: 3 times\n    received: 2 times|
+        )
+      end
+
+      it "complains when there are too many calls" do
+        @mock.message.should eq @return_values[0]
+        @mock.message.should eq @return_values[1]
+        @mock.message.should eq @return_values[2]
+        @mock.message.should eq @return_values[2]
+        expect { @mock.rspec_verify }.to raise_error(
+          RSpec::Mocks::MockExpectationError,
+          %Q|(Mock "mock").message(any args)\n    expected: 3 times\n    received: 4 times|
+        )
+      end
+
+      it "doesn't complain when there are too many calls but method is stubbed too" do
+        @mock.stub(:message).and_return :stub_result
+        @mock.message.should eq @return_values[0]
+        @mock.message.should eq @return_values[1]
+        @mock.message.should eq @return_values[2]
+        @mock.message.should eq :stub_result
+        expect { @mock.rspec_verify }.to_not raise_error(RSpec::Mocks::MockExpectationError)
+      end
+    end
+
+    describe "a Mock expectation with multiple return values with a specified count equal to the number of values" do
+      before(:each) do
+        @mock = RSpec::Mocks::Mock.new("mock")
+        @return_values = ["1",2,Object.new]
+        @mock.should_receive(:message).exactly(3).times.and_return(@return_values[0],@return_values[1],@return_values[2])
+      end
+
+      it "returns values in order to consecutive calls" do
+        @mock.message.should eq @return_values[0]
+        @mock.message.should eq @return_values[1]
+        @mock.message.should eq @return_values[2]
+        @mock.rspec_verify
+      end
+
+      it "complains when there are too few calls" do
+        @mock.message.should eq @return_values[0]
+        @mock.message.should eq @return_values[1]
+        expect { @mock.rspec_verify }.to raise_error(
+          RSpec::Mocks::MockExpectationError,
+          %Q|(Mock "mock").message(any args)\n    expected: 3 times\n    received: 2 times|
+        )
+      end
+
+      it "complains when there are too many calls" do
+        @mock.message.should eq @return_values[0]
+        @mock.message.should eq @return_values[1]
+        @mock.message.should eq @return_values[2]
+        @mock.message.should eq @return_values[2]
+        expect { @mock.rspec_verify }.to raise_error(
+          RSpec::Mocks::MockExpectationError,
+          %Q|(Mock "mock").message(any args)\n    expected: 3 times\n    received: 4 times|
+        )
+      end
+
+      it "complains when there are too many calls and method is stubbed too" do
+        @mock.stub(:message).and_return :stub_result
+        @mock.message.should eq @return_values[0]
+        @mock.message.should eq @return_values[1]
+        @mock.message.should eq @return_values[2]
+        @mock.message.should eq :stub_result
+        expect { @mock.rspec_verify }.to raise_error(
+          RSpec::Mocks::MockExpectationError,
+          %Q|(Mock "mock").message(any args)\n    expected: 3 times\n    received: 4 times|
+        )
+      end
+    end
+
+    describe "a Mock expectation with multiple return values specifying at_least less than the number of values" do
+      before(:each) do
+        @mock = RSpec::Mocks::Mock.new("mock")
+        @mock.should_receive(:message).at_least(:twice).with(no_args).and_return(11, 22)
+      end
+
+      it "uses the last return value for subsequent calls" do
+        @mock.message.should equal(11)
+        @mock.message.should equal(22)
+        @mock.message.should equal(22)
+        @mock.rspec_verify
+      end
+
+      it "fails when called less than the specified number" do
+        @mock.message.should equal(11)
+        expect { @mock.rspec_verify }.to raise_error(
+          RSpec::Mocks::MockExpectationError,
+          %Q|(Mock "mock").message(no args)\n    expected: 2 times\n    received: 1 time|
+        )
+      end
+
+      context "when method is stubbed too" do
+        before { @mock.stub(:message).and_return :stub_result }
+
+        it "uses the stub return value for subsequent calls" do
+          @mock.message.should equal(11)
+          @mock.message.should equal(22)
+          @mock.message.should equal(:stub_result)
+          @mock.rspec_verify
+        end
+
+        it "fails when called less than the specified number" do
+          @mock.message.should equal(11)
+          expect { @mock.rspec_verify }.to raise_error(
+            RSpec::Mocks::MockExpectationError,
+            %Q|(Mock "mock").message(no args)\n    expected: 2 times\n    received: 1 time|
+          )
+        end
+      end
+
+    end
+
+    describe "a Mock expectation with multiple return values with a specified count larger than the number of values" do
+      before(:each) do
+        @mock = RSpec::Mocks::Mock.new("mock")
+        @mock.should_receive(:message).exactly(3).times.and_return(11, 22)
+      end
+
+      it "uses the last return value for subsequent calls" do
+        @mock.message.should equal(11)
+        @mock.message.should equal(22)
+        @mock.message.should equal(22)
+        @mock.rspec_verify
+      end
+
+      it "fails when called less than the specified number" do
+        @mock.message.should equal(11)
+        expect { @mock.rspec_verify }.to raise_error(
+          RSpec::Mocks::MockExpectationError,
+          %Q|(Mock "mock").message(any args)\n    expected: 3 times\n    received: 1 time|
+        )
+      end
+
+      it "fails when called greater than the specified number" do
+        @mock.message.should equal(11)
+        @mock.message.should equal(22)
+        @mock.message.should equal(22)
+        @mock.message.should equal(22)
+        expect { @mock.rspec_verify }.to raise_error(
+          RSpec::Mocks::MockExpectationError,
+          %Q|(Mock "mock").message(any args)\n    expected: 3 times\n    received: 4 times|
+        )
+      end
+
+      context "when method is stubbed too" do
+        before { @mock.stub(:message).and_return :stub_result }
+
+        it "fails when called greater than the specified number" do
+          @mock.message.should equal(11)
+          @mock.message.should equal(22)
+          @mock.message.should equal(22)
+          @mock.message.should equal(:stub_result)
+          expect { @mock.rspec_verify }.to raise_error(
+            RSpec::Mocks::MockExpectationError,
+            %Q|(Mock "mock").message(any args)\n    expected: 3 times\n    received: 4 times|
+          )
+        end
+
+      end
+    end
+  end
+end
+

data/vendor/bundle/ruby/1.8/gems/rspec-mocks-2.9.0/spec/rspec/mocks/nil_expectation_warning_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+def remove_last_describe_from_world
+  RSpec::world.example_groups.pop
+end
+
+def empty_example_group
+  RSpec::Core::ExampleGroup.describe(Object, 'Empty Behaviour Group') { }
+  remove_last_describe_from_world
+end
+
+module RSpec
+  module Mocks
+
+    describe "an expectation set on nil" do
+      it "issues 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 .+)?. Use allow_message_expectations_on_nil to disable warnings.%
+        Kernel.should_receive(:warn).with(expected_warning)
+
+        nil.should_receive(:foo)
+        nil.foo
+      end
+      
+      it "issues a warning when the expectation is negative" do
+        Kernel.should_receive(:warn)
+
+        nil.should_not_receive(:foo)
+      end
+      
+      it "does 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 "does not effect subsequent examples" do
+        example_group = empty_example_group
+        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
+                  
+      end
+
+    end
+    
+  end
+end

data/vendor/bundle/ruby/1.8/gems/rspec-mocks-2.9.0/spec/rspec/mocks/null_object_mock_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+
+module RSpec
+  module Mocks
+    describe "a double _not_ acting as a null object" do
+      before(:each) do
+        @double = double('non-null object')
+      end
+
+      it "says it does not respond to messages it doesn't understand" do
+        @double.should_not respond_to(:foo)
+      end
+
+      it "says it responds to messages it does understand" do
+        @double.stub(:foo)
+        @double.should respond_to(:foo)
+      end
+    end
+
+    describe "a double acting as a null object" do
+      before(:each) do
+        @double = double('null object').as_null_object
+      end
+
+      it "says it responds to everything" do
+        @double.should respond_to(:any_message_it_gets)
+      end
+
+      it "allows explicit stubs" do
+        @double.stub(:foo) { "bar" }
+        @double.foo.should eq("bar")
+      end
+
+      it "allows explicit expectation" do
+        @double.should_receive(:something)
+        @double.something
+      end
+
+      it "fails verification when explicit exception not met" do
+        lambda do
+          @double.should_receive(:something)
+          @double.rspec_verify
+        end.should raise_error(RSpec::Mocks::MockExpectationError)
+      end
+
+      it "ignores unexpected methods" do
+        @double.random_call("a", "d", "c")
+        @double.rspec_verify
+      end
+
+      it "allows expected message with different args first" do
+        @double.should_receive(:message).with(:expected_arg)
+        @double.message(:unexpected_arg)
+        @double.message(:expected_arg)
+      end
+
+      it "allows expected message with different args second" do
+        @double.should_receive(:message).with(:expected_arg)
+        @double.message(:expected_arg)
+        @double.message(:unexpected_arg)
+      end
+    end
+    
+    describe "#as_null_object" do
+      it "sets the object to null_object" do
+        obj = double('anything').as_null_object
+        obj.should be_null_object
+      end
+    end
+
+    describe "#null_object?" do
+      it "defaults to false" do
+        obj = double('anything')
+        obj.should_not be_null_object
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/1.8/gems/rspec-mocks-2.9.0/spec/rspec/mocks/once_counts_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+module RSpec
+  module Mocks
+    describe "OnceCounts" do
+      before(:each) do
+        @mock = double("test mock")
+      end
+
+      it "once fails when called once with wrong args" do
+        @mock.should_receive(:random_call).once.with("a", "b", "c")
+        lambda do
+          @mock.random_call("d", "e", "f")
+        end.should raise_error(RSpec::Mocks::MockExpectationError)
+        @mock.rspec_reset
+      end
+
+      it "once fails when called twice" do
+        @mock.should_receive(:random_call).once
+        @mock.random_call
+        @mock.random_call
+        lambda do
+          @mock.rspec_verify
+        end.should raise_error(RSpec::Mocks::MockExpectationError)
+      end
+      
+      it "once fails when not called" do
+        @mock.should_receive(:random_call).once
+        lambda do
+          @mock.rspec_verify
+        end.should raise_error(RSpec::Mocks::MockExpectationError)
+      end
+
+      it "once passes when called once" do
+        @mock.should_receive(:random_call).once
+        @mock.random_call
+        @mock.rspec_verify
+      end
+
+      it "once passes when called once with specified args" do
+        @mock.should_receive(:random_call).once.with("a", "b", "c")
+        @mock.random_call("a", "b", "c")
+        @mock.rspec_verify
+      end
+
+      it "once passes when called once with unspecified args" do
+        @mock.should_receive(:random_call).once
+        @mock.random_call("a", "b", "c")
+        @mock.rspec_verify
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/1.8/gems/rspec-mocks-2.9.0/spec/rspec/mocks/options_hash_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+module RSpec
+  module Mocks
+    describe "calling :should_receive with an options hash" do
+      it "reports the file and line submitted with :expected_from" do
+        begin
+          mock = RSpec::Mocks::Mock.new("a mock")
+          mock.should_receive(:message, :expected_from => "/path/to/blah.ext:37")
+          mock.rspec_verify
+        rescue Exception => e
+        ensure
+          e.backtrace.to_s.should =~ /\/path\/to\/blah.ext:37/m
+        end
+      end
+
+      it "uses the message supplied with :message" do
+        lambda {
+          m = RSpec::Mocks::Mock.new("a mock")
+          m.should_receive(:message, :message => "recebi nada")
+          m.rspec_verify
+        }.should raise_error("recebi nada")
+      end
+      
+      it "uses the message supplied with :message after a similar stub" do
+        lambda {
+          m = RSpec::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
+end

data/vendor/bundle/ruby/1.8/gems/rspec-mocks-2.9.0/spec/rspec/mocks/partial_mock_spec.rb

@@ -0,0 +1,156 @@
+require 'spec_helper'
+
+module RSpec
+  module Mocks
+    describe "using a Partial Mock," do
+      before(:each) do
+        @object = Object.new
+      end
+    
+      it "names the class in the failure message" do
+        @object.should_receive(:foo)
+        expect do
+          @object.rspec_verify
+        end.to raise_error(RSpec::Mocks::MockExpectationError, /\(#<Object:.*>\).foo/)
+      end
+    
+      it "names 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(RSpec::Mocks::MockExpectationError, /<Object \(class\)>/)
+      end
+    
+      it "does not conflict with @options in the object" do
+        @object.instance_eval { @options = Object.new }
+        @object.should_receive(:blah)
+        @object.blah
+      end
+            
+      it "should_not_receive mocks out the method" do
+        @object.should_not_receive(:fuhbar)
+        expect {
+          @object.fuhbar
+        }.to raise_error(
+          RSpec::Mocks::MockExpectationError, 
+          /expected\: 0 times\n    received\: 1 time/
+        )
+      end
+    
+      it "should_not_receive returns a negative message expectation" do
+        @object.should_not_receive(:foobar).should be_kind_of(RSpec::Mocks::NegativeMessageExpectation)
+      end
+    
+      it "should_receive mocks out the method" do
+        @object.should_receive(:foobar).with(:test_param).and_return(1)
+        @object.foobar(:test_param).should equal(1)
+      end
+    
+      it "should_receive handles a hash" do
+        @object.should_receive(:foobar).with(:key => "value").and_return(1)
+        @object.foobar(:key => "value").should equal(1)
+      end
+    
+      it "should_receive handles an inner hash" do
+        hash = {:a => {:key => "value"}}
+        @object.should_receive(:foobar).with(:key => "value").and_return(1)
+        @object.foobar(hash[:a]).should equal(1)
+      end
+    
+      it "should_receive returns a message expectation" do
+        @object.should_receive(:foobar).should be_kind_of(RSpec::Mocks::MessageExpectation)
+        @object.foobar
+      end
+    
+      it "should_receive verifies method was called" do
+        @object.should_receive(:foobar).with(:test_param).and_return(1)
+        lambda do
+          @object.rspec_verify
+        end.should raise_error(RSpec::Mocks::MockExpectationError)
+      end
+    
+      it "should_receive also takes a String argument" do
+        @object.should_receive('foobar')
+        @object.foobar
+      end
+      
+      it "should_not_receive also takes a String argument" do
+        @object.should_not_receive('foobar')
+        lambda do
+          @object.foobar   
+        end.should raise_error(RSpec::Mocks::MockExpectationError)
+      end
+      
+      it "uses reports nil in the error message" do
+        allow_message_expectations_on_nil
+        
+        @nil = nil
+        @nil.should_receive(:foobar)
+        expect {
+          @nil.rspec_verify
+        }.to raise_error(
+          RSpec::Mocks::MockExpectationError, 
+          %Q|(nil).foobar(any args)\n    expected: 1 time\n    received: 0 times|
+        )
+      end
+    end
+    
+    describe "Partially mocking an object that defines ==, after another mock has been defined" do
+      before(:each) do
+        stub("existing mock", :foo => :foo)
+      end
+      
+      class PartiallyMockedEquals
+        attr_reader :val
+        def initialize(val)
+          @val = val
+        end
+        
+        def ==(other)
+          @val == other.val
+        end
+      end
+      
+      it "does not raise an error when stubbing the object" do
+        o = PartiallyMockedEquals.new :foo
+        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 'keeps public methods public' do
+        @object.should_receive(:public_method)
+        @object.public_methods.should include_method(:public_method)
+        @object.public_method
+      end
+
+      it 'keeps private methods private' do
+        @object.should_receive(:private_method)
+        @object.private_methods.should include_method(:private_method)
+        @object.public_method
+      end
+
+      it 'keeps protected methods protected' do
+        @object.should_receive(:protected_method)
+        @object.protected_methods.should include_method(:protected_method)
+        @object.public_method
+      end
+
+    end
+  end
+end

data/vendor/bundle/ruby/1.8/gems/rspec-mocks-2.9.0/spec/rspec/mocks/partial_mock_using_mocks_directly_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper'
+
+module RSpec::Mocks
+  describe "PartialMockUsingMocksDirectly" do
+    let(:klass) do
+      Class.new do
+        module MethodMissing
+          remove_method :method_missing rescue nil
+          def method_missing(m, *a, &b)
+            if m == :captured_by_method_missing
+              "response generated by method missing"
+            else
+              super(m, *a, &b)
+            end
+          end
+        end
+
+        extend MethodMissing
+        include MethodMissing
+
+        def existing_method
+          :original_value
+        end
+
+      end
+    end
+
+    let(:obj) { klass.new }
+
+    # See http://rubyforge.org/tracker/index.php?func=detail&aid=10263&group_id=797&atid=3149
+    # specify "should clear expectations on verify" do
+    #     obj.should_receive(:msg)
+    #     obj.msg
+    #     obj.rspec_verify
+    #     lambda do
+    #       obj.msg
+    #     end.should raise_error(NoMethodError)
+    #   
+    # end
+    it "fails when expected message is not received" do
+      obj.should_receive(:msg)
+      lambda do
+        obj.rspec_verify
+      end.should raise_error(RSpec::Mocks::MockExpectationError)
+    end
+
+    it "fails when message is received with incorrect args" do
+      obj.should_receive(:msg).with(:correct_arg)
+      lambda do
+        obj.msg(:incorrect_arg)
+      end.should raise_error(RSpec::Mocks::MockExpectationError)
+      obj.msg(:correct_arg)
+    end
+
+    it "passes when expected message is received" do
+      obj.should_receive(:msg)
+      obj.msg
+      obj.rspec_verify
+    end
+
+    it "passes when message is received with correct args" do
+      obj.should_receive(:msg).with(:correct_arg)
+      obj.msg(:correct_arg)
+      obj.rspec_verify
+    end
+
+    it "restores the original method if it existed" do
+      obj.existing_method.should equal(:original_value)
+      obj.should_receive(:existing_method).and_return(:mock_value)
+      obj.existing_method.should equal(:mock_value)
+      obj.rspec_verify
+      obj.existing_method.should equal(:original_value)
+    end
+
+    context "with an instance method handled by method_missing" do
+      it "restores the original behavior" do
+        obj.captured_by_method_missing.should eq("response generated by method missing")
+        obj.stub(:captured_by_method_missing) { "foo" }
+        obj.captured_by_method_missing.should eq("foo")
+        obj.rspec_reset
+        obj.captured_by_method_missing.should eq("response generated by method missing")
+      end
+    end
+
+    context "with a class method handled by method_missing" do 
+      it "restores the original behavior" do
+        klass.captured_by_method_missing.should eq("response generated by method missing")
+        klass.stub(:captured_by_method_missing) { "foo" }
+        klass.captured_by_method_missing.should eq("foo")
+        klass.rspec_reset
+        klass.captured_by_method_missing.should eq("response generated by method missing")
+      end
+    end
+  end
+end