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/passing_argument_matchers_spec.rb

@@ -0,0 +1,142 @@
+require 'spec_helper'
+
+module RSpec
+  module Mocks
+    describe Methods do
+      before(:each) do
+        @double = double('double')
+        Kernel.stub(:warn)
+      end
+
+      after(:each) do
+        @double.rspec_verify
+      end
+
+      context "handling argument matchers" do
+        it "accepts true as boolean()" do
+          @double.should_receive(:random_call).with(boolean())
+          @double.random_call(true)
+        end
+
+        it "accepts false as boolean()" do
+          @double.should_receive(:random_call).with(boolean())
+          @double.random_call(false)
+        end
+
+        it "accepts fixnum as kind_of(Numeric)" do
+          @double.should_receive(:random_call).with(kind_of(Numeric))
+          @double.random_call(1)
+        end
+
+        it "accepts float as an_instance_of(Numeric)" do
+          @double.should_receive(:random_call).with(kind_of(Numeric))
+          @double.random_call(1.5)
+        end
+
+        it "accepts fixnum as instance_of(Fixnum)" do
+          @double.should_receive(:random_call).with(instance_of(Fixnum))
+          @double.random_call(1)
+        end
+
+        it "does NOT accept fixnum as instance_of(Numeric)" do
+          @double.should_not_receive(:random_call).with(instance_of(Numeric))
+          @double.random_call(1)
+        end
+
+        it "does NOT accept float as instance_of(Numeric)" do
+          @double.should_not_receive(:random_call).with(instance_of(Numeric))
+          @double.random_call(1.5)
+        end
+
+        it "accepts string as anything()" do
+          @double.should_receive(:random_call).with("a", anything(), "c")
+          @double.random_call("a", "whatever", "c")
+        end
+
+        it "matches duck type with one method" do
+          @double.should_receive(:random_call).with(duck_type(:length))
+          @double.random_call([])
+        end
+
+        it "matches duck type with two methods" do
+          @double.should_receive(:random_call).with(duck_type(:abs, :div))
+          @double.random_call(1)
+        end
+
+        it "matches no args against any_args()" do
+          @double.should_receive(:random_call).with(any_args)
+          @double.random_call()
+        end
+
+        it "matches one arg against any_args()" do
+          @double.should_receive(:random_call).with(any_args)
+          @double.random_call("a string")
+        end
+
+        it "matches no args against no_args()" do
+          @double.should_receive(:random_call).with(no_args)
+          @double.random_call()
+        end
+
+        it "matches hash with hash_including same hash" do
+          @double.should_receive(:random_call).with(hash_including(:a => 1))
+          @double.random_call(:a => 1)
+        end
+      end
+
+      context "handling block matchers" do
+        it "matches arguments against RSpec expectations" do
+          @double.should_receive(:random_call).with {|arg1, arg2, arr, *rest|
+            arg1.should eq 5
+            arg2.should have_at_least(3).characters
+            arg2.should have_at_most(10).characters
+            arr.map {|i| i * 2}.should eq [2,4,6]
+            rest.should eq [:fee, "fi", 4]
+          }
+          @double.random_call 5, "hello", [1,2,3], :fee, "fi", 4
+        end
+
+        it "does not eval the block as the return value" do
+          eval_count = 0
+          @double.should_receive(:msg).with {|a| eval_count += 1}
+          @double.msg(:ignore)
+          eval_count.should eq(1)
+        end
+      end
+
+      context "handling non-matcher arguments" do
+        it "matches non special symbol (can be removed when deprecated symbols are removed)" do
+          @double.should_receive(:random_call).with(:some_symbol)
+          @double.random_call(:some_symbol)
+        end
+
+        it "matches string against regexp" do
+          @double.should_receive(:random_call).with(/bcd/)
+          @double.random_call("abcde")
+        end
+
+        it "matches regexp against regexp" do
+          @double.should_receive(:random_call).with(/bcd/)
+          @double.random_call(/bcd/)
+        end
+
+        it "matches against a hash submitted and received by value" do
+          @double.should_receive(:random_call).with(:a => "a", :b => "b")
+          @double.random_call(:a => "a", :b => "b")
+        end
+
+        it "matches against a hash submitted by reference and received by value" do
+          opts = {:a => "a", :b => "b"}
+          @double.should_receive(:random_call).with(opts)
+          @double.random_call(:a => "a", :b => "b")
+        end
+
+        it "matches against a hash submitted by value and received by reference" do
+          opts = {:a => "a", :b => "b"}
+          @double.should_receive(:random_call).with(:a => "a", :b => "b")
+          @double.random_call(opts)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+module RSpec
+  module Mocks
+    describe "PreciseCounts" do
+      before(:each) do
+        @mock = double("test mock")
+      end
+
+      it "fails when exactly n times method is called less than n times" do
+        @mock.should_receive(:random_call).exactly(3).times
+        @mock.random_call
+        @mock.random_call
+        lambda do
+          @mock.rspec_verify
+        end.should raise_error(RSpec::Mocks::MockExpectationError)
+      end
+
+      it "fails when exactly n times method is never called" do
+        @mock.should_receive(:random_call).exactly(3).times
+        lambda do
+          @mock.rspec_verify
+        end.should raise_error(RSpec::Mocks::MockExpectationError)
+      end
+
+      it "passes if exactly n times method is called exactly n times" do
+        @mock.should_receive(:random_call).exactly(3).times
+        @mock.random_call
+        @mock.random_call
+        @mock.random_call
+        @mock.rspec_verify
+      end
+
+      it "returns the value given by a block when the exactly once method is called" do
+        @mock.should_receive(:to_s).exactly(:once) { "testing" }
+        @mock.to_s.should eq "testing"
+        @mock.rspec_verify
+      end
+
+      it "passes multiple calls with different args and counts" do
+        @mock.should_receive(:random_call).twice.with(1)
+        @mock.should_receive(:random_call).once.with(2)
+        @mock.random_call(1)
+        @mock.random_call(2)
+        @mock.random_call(1)
+        @mock.rspec_verify
+      end
+
+      it "passes mutiple calls with different args" do
+        @mock.should_receive(:random_call).once.with(1)
+        @mock.should_receive(:random_call).once.with(2)
+        @mock.random_call(1)
+        @mock.random_call(2)
+        @mock.rspec_verify
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+module RSpec
+  module Mocks
+    describe "a mock" do
+      before(:each) do
+        @mock = double("mock").as_null_object
+      end
+      it "answers false for received_message? when no messages received" do
+        @mock.received_message?(:message).should be_false
+      end
+      it "answers true for received_message? when message received" do
+        @mock.message
+        @mock.received_message?(:message).should be_true
+      end
+      it "answers true for received_message? when message received with correct args" do
+        @mock.message 1,2,3
+        @mock.received_message?(:message, 1,2,3).should be_true
+      end
+      it "answers false for received_message? when message received with incorrect args" do
+        @mock.message 1,2,3
+        @mock.received_message?(:message, 1,2).should be_false
+      end
+    end
+  end
+end

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

@@ -0,0 +1,110 @@
+require 'spec_helper'
+
+module RSpec
+  module Mocks
+    class SerializableStruct < Struct.new(:foo, :bar); end
+
+    class SerializableMockProxy
+      attr_reader :mock_proxy
+
+      def initialize(mock_proxy)
+        @mock_proxy = mock_proxy
+      end
+
+      def ==(other)
+        other.class == self.class && other.mock_proxy == mock_proxy
+      end
+    end
+
+    describe Serialization do
+      def self.with_yaml_loaded(&block)
+        context 'with YAML loaded' do
+          module_eval(&block)
+        end
+      end
+
+      def self.without_yaml_loaded(&block)
+        context 'without YAML loaded' do
+          before(:each) do
+            # We can't really unload yaml, but we can fake it here...
+            @orig_yaml_constant = Object.send(:remove_const, :YAML)
+            Struct.class_eval do
+              alias __old_to_yaml to_yaml
+              undef to_yaml
+            end
+          end
+
+          module_eval(&block)
+
+          after(:each) do
+            Object.const_set(:YAML, @orig_yaml_constant)
+            Struct.class_eval do
+              alias to_yaml __old_to_yaml
+              undef __old_to_yaml
+            end
+          end
+        end
+      end
+
+      subject { RSpec::Mocks::SerializableStruct.new(7, "something") }
+
+      def set_stub
+        subject.stub(:bazz => 5)
+      end
+
+      shared_examples_for 'normal YAML serialization' do
+        it 'serializes to yaml the same with and without stubbing, using #to_yaml' do
+          expect { set_stub }.to_not change { subject.to_yaml }
+        end
+
+        it 'serializes to yaml the same with and without stubbing, using YAML.dump' do
+          expect { set_stub }.to_not change { YAML.dump(subject) }
+        end
+      end
+
+      with_yaml_loaded do
+        compiled_with_psych = begin
+          require 'psych'
+          true
+        rescue LoadError
+          false
+        end
+
+        if compiled_with_psych
+          context 'using Syck as the YAML engine' do
+            before(:each) { YAML::ENGINE.yamler = 'syck' }
+            it_behaves_like 'normal YAML serialization'
+          end
+
+          context 'using Psych as the YAML engine' do
+            before(:each) { YAML::ENGINE.yamler = 'psych' }
+            it_behaves_like 'normal YAML serialization'
+          end
+        else
+          it_behaves_like 'normal YAML serialization'
+        end
+      end
+
+      without_yaml_loaded do
+        it 'does not add #to_yaml to the stubbed object' do
+          subject.should_not respond_to(:to_yaml)
+          set_stub
+          subject.should_not respond_to(:to_yaml)
+        end
+      end
+
+      it 'marshals the same with and without stubbing' do
+        expect { set_stub }.to_not change { Marshal.dump(subject) }
+      end
+
+      describe "an object that has its own mock_proxy instance variable" do
+        subject { RSpec::Mocks::SerializableMockProxy.new(:my_mock_proxy) }
+
+        it 'does not interfere with its marshalling' do
+          marshalled_copy = Marshal.load(Marshal.dump(subject))
+          marshalled_copy.should eq subject
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+module RSpec
+  module Mocks
+
+    describe "only stashing the original method" do
+      let(:klass) do
+        Class.new do
+          def self.foo(arg)
+            :original_value
+          end
+        end
+      end
+      it "keeps the original method intact after multiple expectations are added on the same method" do
+        klass.should_receive(:foo).with(:fizbaz).and_return(:wowwow)
+        klass.should_receive(:foo).with(:bazbar).and_return(:okay)
+
+        klass.foo(:fizbaz)
+        klass.foo(:bazbar)
+        klass.rspec_verify
+
+        klass.rspec_reset
+        klass.foo(:yeah).should equal(:original_value)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,149 @@
+require 'spec_helper'
+
+module RSpec
+  module Mocks
+    describe "A chained method stub" do
+      subject { Object.new }
+
+      context "with one method in chain" do
+        context "using and_return" do
+          it "returns expected value from chaining only one method call" do
+            subject.stub_chain(:msg1).and_return(:return_value)
+            subject.msg1.should equal(:return_value)
+          end
+        end
+
+        context "using a block" do
+          it "returns the correct value" do
+            subject.stub_chain(:msg1) { :return_value }
+            subject.msg1.should equal(:return_value)
+          end
+        end
+
+        context "using a hash" do
+          it "returns the value of the key/value pair" do
+            subject.stub_chain(:msg1 => :return_value)
+            subject.msg1.should equal(:return_value)
+          end
+        end
+      end
+
+      context "with two methods in chain" do
+        context "using and_return" do
+          it "returns expected value from chaining two method calls" do
+            subject.stub_chain(:msg1, :msg2).and_return(:return_value)
+            subject.msg1.msg2.should equal(:return_value)
+          end
+        end
+
+        context "using a block" do
+          it "returns the correct value" do
+            subject.stub_chain(:msg1, :msg2) { :return_value }
+            subject.msg1.msg2.should equal(:return_value)
+          end
+        end
+
+        context "using a hash" do
+          it "returns the value of the key/value pair" do
+            subject.stub_chain(:msg1, :msg2 => :return_value)
+            subject.msg1.msg2.should equal(:return_value)
+          end
+        end
+      end
+
+      context "with four methods in chain" do
+        context "using and_return" do
+          it "returns expected value from chaining two method calls" do
+            subject.stub_chain(:msg1, :msg2, :msg3, :msg4).and_return(:return_value)
+            subject.msg1.msg2.msg3.msg4.should equal(:return_value)
+          end
+        end
+
+        context "using a block" do
+          it "returns the correct value" do
+            subject.stub_chain(:msg1, :msg2, :msg3, :msg4) { :return_value }
+            subject.msg1.msg2.msg3.msg4.should equal(:return_value)
+          end
+        end
+
+        context "using a hash" do
+          it "returns the value of the key/value pair" do
+            subject.stub_chain(:msg1, :msg2, :msg3, :msg4 => :return_value)
+            subject.msg1.msg2.msg3.msg4.should equal(:return_value)
+          end
+        end
+
+        context "using a hash with a string key" do
+          it "returns the value of the key/value pair" do
+            subject.stub_chain("msg1.msg2.msg3.msg4" => :return_value)
+            subject.msg1.msg2.msg3.msg4.should equal(:return_value)
+          end
+        end
+      end
+
+      it "returns expected value from chaining four method calls" do
+        subject.stub_chain(:msg1, :msg2, :msg3, :msg4).and_return(:return_value)
+        subject.msg1.msg2.msg3.msg4.should equal(:return_value)
+      end
+
+      context "with messages shared across multiple chains" do
+        context "using and_return" do
+          context "starting with the same message" do
+            it "returns expected value" do
+              subject.stub_chain(:msg1, :msg2, :msg3).and_return(:first)
+              subject.stub_chain(:msg1, :msg2, :msg4).and_return(:second)
+
+              subject.msg1.msg2.msg3.should equal(:first)
+              subject.msg1.msg2.msg4.should equal(:second)
+            end
+          end
+
+          context "starting with the different messages" do
+            it "returns expected value" do
+              subject.stub_chain(:msg1, :msg2, :msg3).and_return(:first)
+              subject.stub_chain(:msg4, :msg2, :msg3).and_return(:second)
+
+              subject.msg1.msg2.msg3.should equal(:first)
+              subject.msg4.msg2.msg3.should equal(:second)
+            end
+          end
+        end
+
+        context "using => value" do
+          context "starting with the same message" do
+            it "returns expected value", :focus => true do
+              subject.stub_chain(:msg1, :msg2, :msg3 => :first)
+              subject.stub_chain(:msg1, :msg2, :msg4 => :second)
+
+              subject.msg1.msg2.msg3.should equal(:first)
+              subject.msg1.msg2.msg4.should equal(:second)
+            end
+          end
+
+          context "starting with different messages" do
+            it "returns expected value", :focus => true do
+              subject.stub_chain(:msg1, :msg2, :msg3 => :first)
+              subject.stub_chain(:msg4, :msg2, :msg3 => :second)
+
+              subject.msg1.msg2.msg3.should equal(:first)
+              subject.msg4.msg2.msg3.should equal(:second)
+            end
+          end
+        end
+      end
+
+      it "returns expected value when chain is a dot separated string, like stub_chain('msg1.msg2.msg3')" do
+        subject.stub_chain("msg1.msg2.msg3").and_return(:return_value)
+        subject.msg1.msg2.msg3.should equal(:return_value)
+      end
+
+      it "returns expected value from two chains with shared messages at the beginning" do
+        subject.stub_chain(:msg1, :msg2, :msg3, :msg4).and_return(:first)
+        subject.stub_chain(:msg1, :msg2, :msg3, :msg5).and_return(:second)
+
+        subject.msg1.msg2.msg3.msg4.should equal(:first)
+        subject.msg1.msg2.msg3.msg5.should equal(:second)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+require 'spec_helper'
+
+module RSpec
+  module Mocks
+    describe "stub implementation" do
+      describe "with no args" do
+        it "execs the block when called" do
+          obj = stub()
+          obj.stub(:foo) { :bar }
+          obj.foo.should eq :bar
+        end
+      end
+
+      describe "with one arg" do
+        it "execs the block with that arg when called" do
+          obj = stub()
+          obj.stub(:foo) {|given| given}
+          obj.foo(:bar).should eq :bar
+        end
+      end
+
+      describe "with variable args" do
+        it "execs the block when called" do
+          obj = stub()
+          obj.stub(:foo) {|*given| given.first}
+          obj.foo(:bar).should eq :bar
+        end        
+      end
+    end
+
+  
+    describe "unstub implementation" do      
+      it "replaces the stubbed method with the original method" do
+        obj = Object.new
+        def obj.foo; :original; end
+        obj.stub(:foo)
+        obj.unstub(:foo)
+        obj.foo.should eq :original
+      end
+    
+      it "removes all stubs with the supplied method name" do
+        obj = Object.new
+        def obj.foo; :original; end
+        obj.stub(:foo).with(1)
+        obj.stub(:foo).with(2)
+        obj.unstub(:foo)
+        obj.foo.should eq :original
+      end
+    
+      it "does not remove any expectations with the same method name" do
+        obj = Object.new
+        def obj.foo; :original; end
+        obj.should_receive(:foo).with(3).and_return(:three)
+        obj.stub(:foo).with(1)
+        obj.stub(:foo).with(2)
+        obj.unstub(:foo)
+        obj.foo(3).should eq :three
+      end
+    
+      it "raises a MockExpectationError if the method has not been stubbed" do
+        obj = Object.new
+        lambda do
+          obj.unstub(:foo)
+        end.should raise_error(RSpec::Mocks::MockExpectationError)
+      end
+    end
+  end
+end