resque-pool 0.3.0.beta.2 → 0.3.0

data/vendor/bundle/ruby/1.8/gems/rspec-mocks-2.9.0/features/README.markdown

@@ -0,0 +1,67 @@
+rspec-mocks helps to control the context in a code example by letting you set
+known return values, fake implementations of methods, and even expectations
+that specific messages are received by an object.
+
+You can do these three things on test doubles that rspec-mocks creates for you
+on the fly, or you can do them on objects that are part of your system.
+
+## Messages and Methods
+
+_Message_ and _method_ are metaphors that we use somewhat interchangeably, but
+they are subtly different.  In Object Oriented Programming, objects communicate
+by sending _messages_ to one another. When an object receives a message, it
+invokes a _method_ with the same name as the message.
+
+## Test Doubles
+
+A test double is an object that stands in for another object in your system
+during a code example. Use the `double` method to create one:
+
+    double_account = double("Account")
+
+You can also use the `mock` and `stub` methods to create test doubles, however
+these methods are there for backward compatibility only and will likely be
+deprecated and then removed from future versions.
+
+## Method Stubs
+
+A method stub is an instruction to an object (real or test double) to return a
+known value in response to a message:
+
+    die.stub(:roll) { 3 }
+
+This tells the `die` object to return the value `3` when it receives the `roll`
+message.
+
+## Message Expectations
+
+A message expectation is an expectation that an object should receive a
+specific message during the course of a code example:
+
+    describe Account do
+      context "when closed" do
+        it "logs an 'account closed' message" do
+          logger = double()
+          account = Account.new
+          account.logger = logger
+
+          logger.should_receive(:account_closed).with(account)
+
+          account.close
+        end
+      end
+    end
+
+This example specifies that the `account` object sends the `logger` the
+`account_closed` message (with itself as an argument) when it receives the
+`close` message.
+
+## Issues
+
+The documentation for rspec-mocks is a work in progress. We'll be adding
+Cucumber features over time, and clarifying existing ones.  If you have
+specific features you'd like to see added, find the existing documentation
+incomplete or confusing, or, better yet, wish to write a missing Cucumber
+feature yourself, please [submit an
+issue](http://github.com/rspec/rspec-mocks/issues) or a [pull
+request](http://github.com/rspec/rspec-mocks).

data/vendor/bundle/ruby/1.8/gems/rspec-mocks-2.9.0/features/Scope.md

@@ -0,0 +1,17 @@
+Doubles, stubs, and message expectations are all cleaned out after each
+example. This ensures that each example can be run in isolation, and in any
+order.
+
+### `before(:each)`
+
+It is perfectly fine to set up doubles, stubs, and message expectations in
+a `before(:each)` hook, as that hook is executed in the scope of the example:
+
+    before(:each) do
+      @account = double('account')
+    end
+
+### Do not create doubles, stubs, or message expectations in `before(:all)`
+
+If you do, they'll get cleaned out after the first example, and you will be
+very confused as to what's going on in the second example.

data/vendor/bundle/ruby/1.8/gems/rspec-mocks-2.9.0/features/Upgrade.md

@@ -0,0 +1,22 @@
+## rspec-mocks-2.6
+
+### `any_instance`
+
+Set method stubs and message expectations on any instance of a class:
+
+    class Foo; end
+    Foo.any_instance.stub(:bar) { 'bar' }
+    Foo.new.bar # => 'bar'
+
+## rspec-mocks-2.2
+
+### `require "rspec/mocks/standalone"`
+
+Sets up top-level environment to explore rspec-mocks. Mostly useful in irb:
+
+    $ irb
+    > require 'rspec/mocks/standalone'
+    > foo = double()
+    > foo.stub(:bar) { :baz }
+    > foo.bar
+      => :baz

data/vendor/bundle/ruby/1.8/gems/rspec-mocks-2.9.0/features/argument_matchers/README.md

@@ -0,0 +1,27 @@
+### Introduction
+
+Argument matchers can be used:
+
+* In stubs to constrain the scope of the stubbed method
+
+      obj.stub(:foo).with(:bar) do |arg|
+        #do something for :bar
+      end
+      obj.stub(:foo).with(:baz) do |arg|
+        #do something for :baz
+      end
+
+* In expectations to validate the arguments that should be received in a method call
+
+      #create a double
+      obj = double()
+      
+      #expect a message with given args
+      obj.should_receive(:message).with('an argument')
+
+If more control is needed, one can use a block
+
+    obj.should_receive(:message) do |arg1,  arg2|
+      # set expectations about the args in this block
+      # and optionally set a return value
+    end

data/vendor/bundle/ruby/1.8/gems/rspec-mocks-2.9.0/features/argument_matchers/explicit.feature

@@ -0,0 +1,60 @@
+Feature: explicit arguments
+
+  Allows you to explicitly specify the argument values
+
+  Scenario: explicit arguments
+    Given a file named "stub_explicit_args_spec.rb" with:
+      """
+      describe "stubbed explicit arguments" do
+        it "works on stubs" do
+          object = Object.new
+          object.stub(:foo).with(:this) do |arg|
+            "got this"
+          end
+          object.stub(:foo).with(:that) do |arg|
+            "got that"
+          end
+
+          object.foo(:this).should eq("got this")
+          object.foo(:that).should eq("got that")
+        end
+
+        it "works on doubles and expectations" do
+          object = double('foo')
+          object.should_receive(:bar).with(:foo)
+
+          object.bar(:foo)
+        end
+      end
+      """
+    When I run `rspec stub_explicit_args_spec.rb`
+    Then the output should contain "2 examples, 0 failures"
+
+  Scenario: explicit arguments with multiple arities
+    Given a file named "stub_multiple_explicit_args_spec.rb" with:
+      """
+      describe "stubbed multiple explicit arguments" do
+        it "works on stubs" do
+          object = Object.new
+          object.stub(:foo).with(:this) do |arg|
+            "got this"
+          end
+          object.stub(:foo).with(:this, :that) do |arg1, arg2|
+            "got this and that"
+          end
+
+          object.foo(:this).should eq("got this")
+          object.foo(:this, :that).should eq("got this and that")
+        end
+        
+        it "works on mocks" do
+          object = double('foo')
+          object.should_receive(:foo).with(:this, :that)
+
+          object.foo(:this, :that)
+        end
+      end
+      """
+    When I run `rspec stub_multiple_explicit_args_spec.rb`
+    Then the output should contain "2 examples, 0 failures"
+

data/vendor/bundle/ruby/1.8/gems/rspec-mocks-2.9.0/features/argument_matchers/general_matchers.feature

@@ -0,0 +1,85 @@
+Feature: General matchers
+
+  The `anything`,  `any_args`,  and `no_args` matchers can be used to require the method 
+  to have arguments (or not) without constraining the details of the argument, such as its
+  type,  pattern or value. The `anything` matcher only reflects a single argument, while
+  the `any_args` matcher matches any arity.
+
+  Scenario: anything argument matcher
+    Given a file named "stub_anything_args_spec.rb" with:
+      """
+      describe "stubbed anything() args spec" do
+        it "works" do
+          object = Object.new
+          object.stub(:foo).with(anything) do
+            "anything"
+          end
+
+          object.foo(1).should eq("anything")
+          object.foo(:that).should eq("anything")
+        end
+      end
+      """
+    When I run `rspec stub_anything_args_spec.rb`
+    Then the output should contain "1 example, 0 failures"
+
+  Scenario: any_args argument matcher
+    Given a file named "stub_any_args_spec.rb" with:
+      """
+      describe "stubbed any_args() args spec" do
+        it "works" do
+          object = Object.new
+          object.stub(:foo).with(any_args) do
+            "anything"
+          end
+
+          object.foo(1).should eq("anything")
+          object.foo(:that).should eq("anything")
+          object.foo.should eq("anything")
+        end
+      end
+      """
+    When I run `rspec stub_any_args_spec.rb`
+    Then the output should contain "1 example, 0 failures"
+
+  Scenario: no_args argument matcher
+    Given a file named "stub_no_args_spec.rb" with:
+      """
+      describe "stubbed no_args() args spec" do
+        it "works for no args" do
+          object = Object.new
+          object.stub(:foo).with(no_args) do
+            "nothing"
+          end
+          object.stub(:foo).with(anything) do
+            "something"
+          end
+
+          object.foo(:that).should eq("something")
+          object.foo.should eq("nothing")
+        end
+      end
+      """
+    When I run `rspec stub_no_args_spec.rb`
+    Then the output should contain "1 example, 0 failures"
+
+  Scenario: no_args argument matcher for expectations
+    Given a file named "stub_no_args_expectations_spec.rb" with:
+      """
+      describe "stubbed no_args() args spec for expectations" do
+        it "works for no args" do
+          object = Object.new
+          object.should_receive(:foo).with(no_args)
+
+          object.foo
+        end
+        it "fails for args" do
+          object = Object.new
+          object.should_receive(:foo).with(no_args)
+
+          object.foo(:bar)
+        end
+      end
+      """
+    When I run `rspec stub_no_args_expectations_spec.rb`
+    Then the output should contain "2 examples, 1 failure"

data/vendor/bundle/ruby/1.8/gems/rspec-mocks-2.9.0/features/argument_matchers/type_matchers.feature

@@ -0,0 +1,25 @@
+Feature: stub with argument constraints
+
+  You can further specify the behavior by constraining the type, format and/or number of arguments with the #with() method chained off of #stub()
+  
+  Scenario: an_instance_of argument matcher
+    Given a file named "stub_an_instance_of_args_spec.rb" with:
+      """
+      describe "stubbed an_instance_of() args spec" do
+        it "works" do
+          object = Object.new
+          object.stub(:foo).with(an_instance_of(Symbol)) do
+            "symbol"
+          end
+          object.stub(:foo).with(an_instance_of(String)) do
+            "string"
+          end
+
+          object.foo("bar").should eq("string")
+          object.foo(:that).should eq("symbol")
+        end
+      end
+      """
+    When I run `rspec stub_an_instance_of_args_spec.rb`
+    Then the output should contain "1 example, 0 failures"
+

data/vendor/bundle/ruby/1.8/gems/rspec-mocks-2.9.0/features/message_expectations/README.md

@@ -0,0 +1,58 @@
+### Basics
+
+    # create a double
+    obj = double()
+
+    # expect a message
+    obj.should_receive(:message)
+
+    # specify a return value
+    obj.should_receive(:message) { 'this is the value to return' }
+
+### Argument constraints
+   
+#### Explicit arguments
+
+    obj.should_receive(:message).with('an argument')
+    obj.should_receive(:message).with('more_than', 'one_argument')
+
+#### Argument matchers
+
+    obj.should_receive(:message).with(anything())
+    obj.should_receive(:message).with(an_instance_of(Money))
+    obj.should_receive(:message).with(hash_including(:a => 'b'))
+
+#### Regular expressions
+
+    obj.should_receive(:message).with(/abc/)
+
+### Counts 
+
+    obj.should_receive(:message).once
+    obj.should_receive(:message).twice
+    obj.should_receive(:message).exactly(3).times
+
+    obj.should_receive(:message).at_least(:once)
+    obj.should_receive(:message).at_least(:twice)
+    obj.should_receive(:message).at_least(n).times
+
+    obj.should_receive(:message).at_most(:once)
+    obj.should_receive(:message).at_most(:twice)
+    obj.should_receive(:message).at_most(n).times
+
+### Raising/Throwing
+
+    obj.should_receive(:message) { raise "this error" }
+    obj.should_receive(:message) { throw :this_symbol }
+
+### Ordering
+
+    obj.should_receive(:one).ordered
+    obj.should_receive(:two).ordered
+
+### Arbitrary handling
+
+    obj.should_receive(:message) do |arg1, arg2|
+      # set expectations about the args in this block
+      # and set a return value
+    end

data/vendor/bundle/ruby/1.8/gems/rspec-mocks-2.9.0/features/message_expectations/any_instance.feature

@@ -0,0 +1,21 @@
+Feature: expect a message on any instance of a class
+
+  Use `any_instance.should_receive` to set an expectation that one (and only
+  one) instance of a class receives a message before the example is completed.
+  
+  The spec will fail if no instance receives a message.
+
+  Scenario: expect a message on any instance of a class
+    Given a file named "example_spec.rb" with:
+      """
+      describe "any_instance.should_receive" do
+        it "verifies that one instance of the class receives the message" do
+          Object.any_instance.should_receive(:foo).and_return(:return_value)
+
+          o = Object.new
+          o.foo.should eq(:return_value)
+        end
+      end
+      """
+    When I run `rspec example_spec.rb`
+    Then the examples should all pass

data/vendor/bundle/ruby/1.8/gems/rspec-mocks-2.9.0/features/message_expectations/block_local_expectations.feature.pending

@@ -0,0 +1,55 @@
+Feature: block local expectations
+
+  Background:
+    Given a file named "lib/account.rb" with:
+      """
+      class Account
+        def self.create
+          yield new
+        end
+
+        def opening_balance(amount, currency)
+        end
+      end
+      """
+
+  Scenario: passing example
+    Given a file named "spec/account_spec.rb" with:
+      """
+      require 'account'
+
+      describe "account DSL" do
+        it "it succeeds when the block local receives the given call" do
+          account = double("Account")
+          Account.should_receive(:create).and_yield(account) do |account|
+            account.should_receive(:opening_balance).with(100, :USD)
+          end
+          Account.create do |account|
+            account.opening_balance 100, :USD
+          end
+        end
+      end
+      """
+    When I run `rspec spec/account_spec.rb`
+    Then the output should contain "1 example, 0 failures"
+    
+  Scenario: failing example
+    
+    Given a file named "spec/account_spec.rb" with:
+      """
+      require 'account'
+
+      describe "account DSL" do
+        it "fails when the block local does not receive the expected call" do
+          Account.should_receive(:create).and_yield do |account|
+            account.should_receive(:opening_balance).with(100, :USD)
+          end
+          Account.create do |account|
+            # opening_balance is not called here
+          end
+        end
+      end
+      """
+
+    When I run `rspec spec/account_spec.rb`
+    Then the output should contain "1 example, 1 failure"

data/vendor/bundle/ruby/1.8/gems/rspec-mocks-2.9.0/features/message_expectations/expect_message.feature

@@ -0,0 +1,94 @@
+Feature: expect a message
+
+  Use should_receive() to set an expectation that a receiver should receive a
+  message before the example is completed.
+
+  Scenario: expect a message
+    Given a file named "spec/account_spec.rb" with:
+      """
+      require "account"
+
+      describe Account do
+        context "when closed" do
+          it "logs an account closed message" do
+            logger = double("logger")
+            account = Account.new
+            account.logger = logger
+
+            logger.should_receive(:account_closed)
+
+            account.close
+          end
+        end
+      end
+      """
+    And a file named "lib/account.rb" with:
+      """
+      class Account
+        attr_accessor :logger
+
+        def close
+          logger.account_closed
+        end
+      end
+      """
+    When I run `rspec spec/account_spec.rb`
+    Then the output should contain "1 example, 0 failures"
+
+  Scenario: expect a message with an argument
+    Given a file named "spec/account_spec.rb" with:
+      """
+      require "account"
+
+      describe Account do
+        context "when closed" do
+          it "logs an account closed message" do
+            logger = double("logger")
+            account = Account.new
+            account.logger = logger
+
+            logger.should_receive(:account_closed).with(account)
+
+            account.close
+          end
+        end
+      end
+      """
+    And a file named "lib/account.rb" with:
+      """
+      class Account
+        attr_accessor :logger
+
+        def close
+          logger.account_closed(self)
+        end
+      end
+      """
+    When I run `rspec spec/account_spec.rb`
+    Then the output should contain "1 example, 0 failures"
+
+  Scenario: provide a return value
+    Given a file named "message_expectation_spec.rb" with:
+      """
+      describe "a message expectation" do
+        context "with a return value" do
+          context "specified in a block" do
+            it "returns the specified value" do
+              receiver = double("receiver")
+              receiver.should_receive(:message) { :return_value }
+              receiver.message.should eq(:return_value)
+            end
+          end
+
+          context "specified with and_return" do
+            it "returns the specified value" do
+              receiver = double("receiver")
+              receiver.should_receive(:message).and_return(:return_value)
+              receiver.message.should eq(:return_value)
+            end
+          end
+        end
+      end
+      """
+    When I run `rspec message_expectation_spec.rb`
+    Then the output should contain "2 examples, 0 failures"