resque-pool 0.3.0.beta.2 → 0.3.0

data/vendor/bundle/ruby/1.8/gems/rspec-mocks-2.9.0/features/outside_rspec/configuration.feature

@@ -0,0 +1,82 @@
+Feature: configure any test framework to use rspec-mocks
+
+  Test frameworks that want to use rspec-mocks can use
+  RSpec::Mocks::setup(self) to hook into rspec-mocks. Doing so adds the
+  following:
+
+    To the object passed to setup:
+
+      double # creates a test double
+      mock   # creates a test double
+      stub   # creates a test double
+
+    To every object in the system:
+
+      should_receive
+      should_not_receive
+      stub
+      
+  In order to give control to the consuming framework, none of these facilities
+  are added until RSpec::Mocks::setup(self) is called. Simply requiring
+  'rspec/mocks' is not sufficient. 
+
+  NOTICE: the stub() method that is added to the object passed to setup is not
+  the same stub() method that is added to every other object.
+
+  Scenario: RSpec::Mocks::setup(object) adds double, mock, and stub methods to the submitted object
+    Given a file named "foo.rb" with:
+      """
+      require 'rspec/mocks'
+
+      class CodeExample
+        def init
+          RSpec::Mocks::setup(self)
+        end
+      end
+
+      example = CodeExample.new
+      example.init
+
+      puts example.respond_to?(:double)
+      puts example.respond_to?(:mock)
+      puts example.respond_to?(:stub)
+      """
+
+    When I run `ruby foo.rb`
+    Then the output should contain "true"
+    But  the output should not contain "false"
+
+  Scenario: RSpec::Mocks::setup(anything) adds methods to Object
+    Given a file named "foo.rb" with:
+      """
+      require 'rspec/mocks'
+
+      RSpec::Mocks::setup(Object.new)
+
+      obj = Object.new
+
+      puts obj.respond_to?(:should_receive)
+      puts obj.respond_to?(:should_not_receive)
+      puts obj.respond_to?(:stub)
+      """
+
+    When I run `ruby foo.rb`
+    Then the output should contain "true"
+    But  the output should not contain "false"
+
+  Scenario: require "rspec/mocks" does not add methods to Object
+    Given a file named "foo.rb" with:
+      """
+      require 'rspec/mocks'
+
+      obj = Object.new
+
+      puts obj.respond_to?(:should_receive)
+      puts obj.respond_to?(:should_not_receive)
+      puts obj.respond_to?(:stub)
+      """
+
+    When I run `ruby foo.rb`
+    Then the output should contain "false"
+    But  the output should not contain "true"
+

data/vendor/bundle/ruby/1.8/gems/rspec-mocks-2.9.0/features/outside_rspec/standalone.feature

@@ -0,0 +1,32 @@
+Feature: standalone
+
+  require "rspec/mocks/standalone" to expose the mock framework
+  outside the RSpec environment. This is especially useful for
+  exploring rspec-mocks in irb.
+
+  Scenario: method stub outside rspec
+    Given a file named "example.rb" with:
+      """
+      require "rspec/mocks/standalone"
+
+      greeter = double("greeter")
+      greeter.stub(:say_hi) { "Hello!" }
+      puts greeter.say_hi
+      """
+    When I run `ruby example.rb`
+    Then the output should contain "Hello!"
+
+  Scenario: message expectation outside rspec
+    Given a file named "example.rb" with:
+      """
+      require "rspec/mocks/standalone"
+
+      greeter = double("greeter")
+      greeter.should_receive(:say_hi)
+
+      RSpec::Mocks.verify
+      """
+    When I run `ruby example.rb`
+    Then the output should contain "say_hi(any args) (RSpec::Mocks::MockExpectationError)"
+    Then the output should contain "expected: 1 time"
+    Then the output should contain "received: 0 times"

data/vendor/bundle/ruby/1.8/gems/rspec-mocks-2.9.0/features/step_definitions/additional_cli_steps.rb

@@ -0,0 +1,4 @@
+Then /^the example(?:s)? should(?: all)? pass$/ do
+  step %q{the output should contain "0 failures"}
+  step %q{the exit status should be 0}
+end

data/vendor/bundle/ruby/1.8/gems/rspec-mocks-2.9.0/features/support/env.rb

@@ -0,0 +1,6 @@
+require 'aruba/cucumber'
+require 'rspec/expectations'
+
+Before do
+  RUBY_PLATFORM =~ /java/ ? @aruba_timeout_seconds = 60 : @aruba_timeout_seconds = 5
+end

data/vendor/bundle/ruby/1.8/gems/rspec-mocks-2.9.0/lib/rspec/mocks/any_instance/chain.rb

@@ -0,0 +1,158 @@
+module RSpec
+  module Mocks
+    module AnyInstance
+      class Chain
+        class << self
+          private
+
+          # @macro [attach] record
+          #   @method $1(*args, &block)
+          #   Records the `$1` message for playback against an instance that
+          #   invokes a method stubbed or mocked using `any_instance`.
+          #
+          #   @see RSpec::Mocks::MessageExpectation#$1
+          #
+          def record(method_name)
+            class_eval(<<-EOM, __FILE__, __LINE__)
+              def #{method_name}(*args, &block)
+                record(:#{method_name}, *args, &block)
+              end
+            EOM
+          end
+        end
+
+        record :and_return
+        record :and_raise
+        record :and_throw
+        record :and_yield
+        record :with
+        record :once
+        record :twice
+        record :any_number_of_times
+        record :exactly
+        record :times
+        record :never
+        record :at_least
+        record :at_most
+
+        # @private
+        def playback!(instance)
+          messages.inject(instance) do |_instance, message|
+            _instance.__send__(*message.first, &message.last)
+          end
+        end
+
+        # @private
+        def constrained_to_any_of?(*constraints)
+          constraints.any? do |constraint|
+            messages.any? do |message|
+              message.first.first == constraint
+            end
+          end
+        end
+
+        # @private
+        def expectation_fulfilled!
+          @expectation_fulfilled = true
+        end
+
+        private
+
+        def messages
+          @messages ||= []
+        end
+
+        def last_message
+          messages.last.first.first unless messages.empty?
+        end
+
+        def record(rspec_method_name, *args, &block)
+          verify_invocation_order(rspec_method_name, *args, &block)
+          messages << [args.unshift(rspec_method_name), block]
+          self
+        end
+      end
+
+      # @private
+      class ExpectationChain < Chain
+
+        # @private
+        def initialize(*args, &block)
+          record(:should_receive, *args, &block)
+          @expectation_fulfilled = false
+        end
+
+        # @private
+        def expectation_fulfilled?
+          @expectation_fulfilled || constrained_to_any_of?(:never, :any_number_of_times)
+        end
+
+        private
+
+        def verify_invocation_order(rspec_method_name, *args, &block)
+        end
+
+        def invocation_order
+          @invocation_order ||= {
+            :should_receive => [nil],
+            :with => [:should_receive],
+            :and_return => [:with, :should_receive],
+            :and_raise => [:with, :should_receive]
+          }
+        end
+      end
+
+      # @private
+      class StubChain < Chain
+
+        # @private
+        def initialize(*args, &block)
+          record(:stub, *args, &block)
+        end
+
+        # @private
+        def expectation_fulfilled?
+          true
+        end
+
+        private
+
+        def invocation_order
+          @invocation_order ||= {
+            :stub => [nil],
+            :with => [:stub],
+            :and_return => [:with, :stub],
+            :and_raise => [:with, :stub],
+            :and_yield => [:with, :stub]
+          }
+        end
+
+        def verify_invocation_order(rspec_method_name, *args, &block)
+          unless invocation_order[rspec_method_name].include?(last_message)
+            raise(NoMethodError, "Undefined method #{rspec_method_name}")
+          end
+        end
+      end
+
+      # @private
+      class StubChainChain < StubChain
+
+        # @private
+        def initialize(*args, &block)
+          record(:stub_chain, *args, &block)
+        end
+
+        private
+
+        def invocation_order
+          @invocation_order ||= {
+            :stub_chain => [nil],
+            :and_return => [:stub_chain],
+            :and_raise => [:stub_chain],
+            :and_yield => [:stub_chain]
+          }
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/1.8/gems/rspec-mocks-2.9.0/lib/rspec/mocks/any_instance/message_chains.rb

@@ -0,0 +1,60 @@
+module RSpec
+  module Mocks
+    module AnyInstance
+      # @private
+      class MessageChains < Hash
+        def initialize
+          super {|h,k| h[k] = []}
+        end
+
+        # @private
+        def add(method_name, chain)
+          self[method_name] << chain
+          chain
+        end
+
+        # @private
+        def remove_stub_chains_for!(method_name)
+          self[method_name].reject! {|chain| chain.is_a?(StubChain)}
+        end
+
+        # @private
+        def has_expectation?(method_name)
+          self[method_name].find {|chain| chain.is_a?(ExpectationChain)}
+        end
+
+        # @private
+        def all_expectations_fulfilled?
+          all? {|method_name, chains| chains.all? {|chain| chain.expectation_fulfilled?}}
+        end
+
+        # @private
+        def unfulfilled_expectations
+          map do |method_name, chains|
+            method_name.to_s if chains.last.is_a?(ExpectationChain) unless chains.last.expectation_fulfilled?
+          end.compact
+        end
+
+        # @private
+        def received_expected_message!(method_name)
+          self[method_name].each {|chain| chain.expectation_fulfilled!}
+        end
+
+        # @private
+        def playback!(instance, method_name)
+          raise_if_second_instance_to_receive_message(instance)
+          self[method_name].each {|chain| chain.playback!(instance)}
+        end
+
+        private
+
+        def raise_if_second_instance_to_receive_message(instance)
+          @instance_with_expectation ||= instance if instance.is_a?(ExpectationChain)
+          if instance.is_a?(ExpectationChain) && !@instance_with_expectation.equal?(instance)
+            raise RSpec::Mocks::MockExpectationError, "Exactly one instance should have received the following message(s) but didn't: #{unfulfilled_expectations.sort.join(', ')}"
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/1.8/gems/rspec-mocks-2.9.0/lib/rspec/mocks/any_instance/recorder.rb

@@ -0,0 +1,192 @@
+module RSpec
+  module Mocks
+    module AnyInstance
+      # Given a class `TheClass`, `TheClass.any_instance` returns a `Recorder`,
+      # which records stubs and message expectations for later playback on
+      # instances of `TheClass`.
+      #
+      # Further constraints are stored in instances of [Chain](Chain).
+      #
+      # @see AnyInstance
+      # @see Chain
+      class Recorder
+        # @private
+        attr_reader :message_chains
+
+        def initialize(klass)
+          @message_chains = MessageChains.new
+          @observed_methods = []
+          @played_methods = {}
+          @klass = klass
+          @expectation_set = false
+        end
+
+        # Initializes the recording a stub to be played back against any
+        # instance of this object that invokes the submitted method.
+        #
+        # @see Methods#stub
+        def stub(method_name_or_method_map, &block)
+          if method_name_or_method_map.is_a?(Hash)
+            method_name_or_method_map.each do |method_name, return_value|
+              stub(method_name).and_return(return_value)
+            end
+          else
+            observe!(method_name_or_method_map)
+            message_chains.add(method_name_or_method_map, StubChain.new(method_name_or_method_map, &block))
+          end
+        end
+
+        # Initializes the recording a stub chain to be played back against any
+        # instance of this object that invokes the method matching the first
+        # argument.
+        #
+        # @see Methods#stub_chain
+        def stub_chain(*method_names_and_optional_return_values, &block)
+          normalize_chain(*method_names_and_optional_return_values) do |method_name, args|
+            observe!(method_name)
+            message_chains.add(method_name, StubChainChain.new(*args, &block))
+          end
+        end
+
+        # Initializes the recording a message expectation to be played back
+        # against any instance of this object that invokes the submitted
+        # method.
+        #
+        # @see Methods#should_receive
+        def should_receive(method_name, &block)
+          @expectation_set = true
+          observe!(method_name)
+          message_chains.add(method_name, ExpectationChain.new(method_name, &block))
+        end
+
+        # Removes any previously recorded stubs, stub_chains or message
+        # expectations that use `method_name`.
+        #
+        # @see Methods#unstub
+        def unstub(method_name)
+          unless @observed_methods.include?(method_name.to_sym)
+            raise RSpec::Mocks::MockExpectationError, "The method `#{method_name}` was not stubbed or was already unstubbed"
+          end
+          message_chains.remove_stub_chains_for!(method_name)
+          stop_observing!(method_name) unless message_chains.has_expectation?(method_name)
+        end
+
+        # @api private
+        #
+        # Used internally to verify that message expectations have been
+        # fulfilled.
+        def verify
+          if @expectation_set && !message_chains.all_expectations_fulfilled?
+            raise RSpec::Mocks::MockExpectationError, "Exactly one instance should have received the following message(s) but didn't: #{message_chains.unfulfilled_expectations.sort.join(', ')}"
+          end
+        end
+
+        # @private
+        def stub!(*)
+          raise "stub! is not supported on any_instance. Use stub instead."
+        end
+
+        # @private
+        def stop_all_observation!
+          @observed_methods.each {|method_name| restore_method!(method_name)}
+        end
+
+        # @private
+        def playback!(instance, method_name)
+          RSpec::Mocks::space.add(instance)
+          message_chains.playback!(instance, method_name)
+          @played_methods[method_name] = instance
+          received_expected_message!(method_name) if message_chains.has_expectation?(method_name)
+        end
+
+        # @private
+        def instance_that_received(method_name)
+          @played_methods[method_name]
+        end
+
+        private
+
+        def normalize_chain(*args)
+          args.shift.to_s.split('.').map {|s| s.to_sym}.reverse.each {|a| args.unshift a}
+          yield args.first, args
+        end
+
+        def received_expected_message!(method_name)
+          message_chains.received_expected_message!(method_name)
+          restore_method!(method_name)
+          mark_invoked!(method_name)
+        end
+
+        def restore_method!(method_name)
+          if public_protected_or_private_method_defined?(build_alias_method_name(method_name))
+            restore_original_method!(method_name)
+          else
+            remove_dummy_method!(method_name)
+          end
+        end
+
+        def build_alias_method_name(method_name)
+          "__#{method_name}_without_any_instance__"
+        end
+
+        def restore_original_method!(method_name)
+          alias_method_name = build_alias_method_name(method_name)
+          @klass.class_eval do
+            remove_method method_name
+            alias_method  method_name, alias_method_name
+            remove_method alias_method_name
+          end
+        end
+
+        def remove_dummy_method!(method_name)
+          @klass.class_eval do
+            remove_method method_name
+          end
+        end
+
+        def backup_method!(method_name)
+          alias_method_name = build_alias_method_name(method_name)
+          @klass.class_eval do
+            alias_method alias_method_name, method_name
+          end if public_protected_or_private_method_defined?(method_name)
+        end
+
+        def public_protected_or_private_method_defined?(method_name)
+          @klass.method_defined?(method_name) || @klass.private_method_defined?(method_name)
+        end
+
+        def stop_observing!(method_name)
+          restore_method!(method_name)
+          @observed_methods.delete(method_name)
+        end
+
+        def already_observing?(method_name)
+          @observed_methods.include?(method_name)
+        end
+
+        def observe!(method_name)
+          stop_observing!(method_name) if already_observing?(method_name)
+          @observed_methods << method_name
+          backup_method!(method_name)
+          @klass.class_eval(<<-EOM, __FILE__, __LINE__)
+            def #{method_name}(*args, &blk)
+              self.class.__recorder.playback!(self, :#{method_name})
+              self.__send__(:#{method_name}, *args, &blk)
+            end
+          EOM
+        end
+
+        def mark_invoked!(method_name)
+          backup_method!(method_name)
+          @klass.class_eval(<<-EOM, __FILE__, __LINE__)
+            def #{method_name}(*args, &blk)
+              method_name = :#{method_name}
+              invoked_instance = self.class.__recorder.instance_that_received(method_name)
+              raise RSpec::Mocks::MockExpectationError, "The message '#{method_name}' was received by \#{self.inspect} but has already been received by \#{invoked_instance}"
+            end
+          EOM
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/1.8/gems/rspec-mocks-2.9.0/lib/rspec/mocks/any_instance.rb

@@ -0,0 +1,45 @@
+require 'rspec/mocks/any_instance/chain'
+require 'rspec/mocks/any_instance/message_chains'
+require 'rspec/mocks/any_instance/recorder'
+
+module RSpec
+  module Mocks
+    module AnyInstance
+      # Used to set stubs and message expectations on any instance of a given
+      # class. Returns a [Recorder](Recorder), which records messages like
+      # `stub` and `should_receive` for later playback on instances of the
+      # class.
+      #
+      # @example
+      #
+      #     Car.any_instance.should_receive(:go)
+      #     race = Race.new
+      #     race.cars << Car.new
+      #     race.go # assuming this delegates to all of its cars
+      #             # this example would pass
+      #
+      #     Account.any_instance.stub(:balance) { Money.new(:USD, 25) }
+      #     Account.new.balance # => Money.new(:USD, 25))
+      #
+      # @return [Recorder]
+      def any_instance
+        RSpec::Mocks::space.add(self)
+        __recorder
+      end
+      
+      # @private
+      def rspec_verify
+        __recorder.verify
+        super
+      ensure
+        __recorder.stop_all_observation!
+        @__recorder = nil
+      end
+
+      # @private
+      def __recorder
+        @__recorder ||= AnyInstance::Recorder.new(self)
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/1.8/gems/rspec-mocks-2.9.0/lib/rspec/mocks/argument_expectation.rb

@@ -0,0 +1,52 @@
+module RSpec
+  module Mocks
+    # @api private
+    class ArgumentExpectation
+      attr_reader :args
+
+      def initialize(*args, &block)
+        @args = args
+        @block = args.empty? ? block : nil
+        @match_any_args = false
+        @matchers = nil
+
+        case args.first
+        when ArgumentMatchers::AnyArgsMatcher
+          @match_any_args = true
+        when ArgumentMatchers::NoArgsMatcher
+          @matchers = []
+        else
+          @matchers = args.collect {|arg| matcher_for(arg)}
+        end
+      end
+
+      def matcher_for(arg)
+        return ArgumentMatchers::MatcherMatcher.new(arg) if is_matcher?(arg)
+        return ArgumentMatchers::RegexpMatcher.new(arg)  if arg.is_a?(Regexp)
+        return ArgumentMatchers::EqualityProxy.new(arg)
+      end
+
+      def is_matcher?(obj)
+        !obj.null_object? & obj.respond_to?(:matches?) & [:failure_message_for_should, :failure_message].any? { |m| obj.respond_to?(m) }
+      end
+
+      def args_match?(*args)
+        match_any_args? || block_passes?(*args) || matchers_match?(*args)
+      end
+
+      private
+
+      def block_passes?(*args)
+        @block.call(*args) if @block
+      end
+
+      def matchers_match?(*args)
+        @matchers == args
+      end
+
+      def match_any_args?
+        @match_any_args
+      end
+    end
+  end
+end