resque-pool 0.3.0.beta.2 → 0.3.0

data/vendor/bundle/ruby/1.8/gems/rspec-core-2.9.0/features/hooks/before_and_after_hooks.feature

@@ -0,0 +1,423 @@
+Feature: before and after hooks
+
+  Use `before` and `after` hooks to execute arbitrary code before and/or
+  after the body of an example is run:
+
+      before(:each) # run before each example
+      before(:all)  # run one time only, before all of the examples in a group
+
+      after(:each) # run after each example
+      after(:all)  # run one time only, after all of the examples in a group
+
+  Before and after blocks are called in the following order:
+
+      before suite
+      before all
+      before each
+      after  each
+      after  all
+      after  suite
+
+  `before` and `after` hooks can be defined directly in the example groups they
+  should run in, or in a global RSpec.configure block.
+
+  Scenario: define before(:each) block
+    Given a file named "before_each_spec.rb" with:
+      """
+      require "rspec/expectations"
+
+      class Thing
+        def widgets
+          @widgets ||= []
+        end
+      end
+
+      describe Thing do
+        before(:each) do
+          @thing = Thing.new
+        end
+
+        describe "initialized in before(:each)" do
+          it "has 0 widgets" do
+            @thing.should have(0).widgets
+          end
+
+          it "can get accept new widgets" do
+            @thing.widgets << Object.new
+          end
+
+          it "does not share state across examples" do
+            @thing.should have(0).widgets
+          end
+        end
+      end
+      """
+    When I run `rspec before_each_spec.rb`
+    Then the examples should all pass
+
+  Scenario: define before(:all) block in example group
+    Given a file named "before_all_spec.rb" with:
+      """
+      require "rspec/expectations"
+
+      class Thing
+        def widgets
+          @widgets ||= []
+        end
+      end
+  
+      describe Thing do
+        before(:all) do
+          @thing = Thing.new
+        end
+  
+        describe "initialized in before(:all)" do
+          it "has 0 widgets" do
+            @thing.should have(0).widgets
+          end
+  
+          it "can get accept new widgets" do
+            @thing.widgets << Object.new
+          end
+  
+          it "shares state across examples" do
+            @thing.should have(1).widgets
+          end
+        end
+      end
+      """
+    When I run `rspec before_all_spec.rb`
+    Then the examples should all pass
+
+    When I run `rspec before_all_spec.rb:15`
+    Then the examples should all pass
+
+  Scenario: failure in before(:all) block
+    Given a file named "before_all_spec.rb" with:
+      """
+      describe "an error in before(:all)" do
+        before(:all) do
+          raise "oops"
+        end
+
+        it "fails this example" do
+        end
+
+        it "fails this example, too" do
+        end
+
+        after(:all) do
+          puts "after all ran"
+        end
+
+        describe "nested group" do
+          it "fails this third example" do
+          end
+
+          it "fails this fourth example" do
+          end
+
+          describe "yet another level deep" do
+            it "fails this last example" do
+            end
+          end
+        end
+      end
+      """
+    When I run `rspec before_all_spec.rb --format documentation`
+    Then the output should contain "5 examples, 5 failures"
+    And the output should contain:
+      """
+      an error in before(:all)
+        fails this example (FAILED - 1)
+        fails this example, too (FAILED - 2)
+        nested group
+          fails this third example (FAILED - 3)
+          fails this fourth example (FAILED - 4)
+          yet another level deep
+            fails this last example (FAILED - 5)
+      after all ran
+      """
+
+    When I run `rspec before_all_spec.rb:9 --format documentation`
+    Then the output should contain "1 example, 1 failure"
+    And the output should contain:
+      """
+      an error in before(:all)
+        fails this example, too (FAILED - 1)
+      """
+
+  Scenario: failure in after(:all) block
+    Given a file named "after_all_spec.rb" with:
+      """
+      describe "an error in after(:all)" do
+        after(:all) do
+          raise StandardError.new("Boom!")
+        end
+
+        it "passes this example" do
+        end
+
+        it "passes this example, too" do
+        end
+      end
+      """
+    When I run `rspec after_all_spec.rb`
+    Then the examples should all pass
+    And the output should contain:
+      """
+      An error occurred in an after(:all) hook.
+        StandardError: Boom!
+      """
+
+  Scenario: define before and after blocks in configuration
+    Given a file named "befores_in_configuration_spec.rb" with:
+      """
+      require "rspec/expectations"
+
+      RSpec.configure do |config|
+        config.before(:each) do
+          @before_each = "before each"
+        end
+        config.before(:all) do
+          @before_all = "before all"
+        end
+      end
+  
+      describe "stuff in before blocks" do
+        describe "with :all" do
+          it "should be available in the example" do
+            @before_all.should eq("before all")
+          end
+        end
+        describe "with :each" do
+          it "should be available in the example" do
+            @before_each.should eq("before each")
+          end
+        end
+      end
+      """
+    When I run `rspec befores_in_configuration_spec.rb`
+    Then the examples should all pass
+
+  Scenario: before/after blocks are run in order
+    Given a file named "ensure_block_order_spec.rb" with:
+      """
+      require "rspec/expectations"
+
+      describe "before and after callbacks" do
+        before(:all) do
+          puts "before all"
+        end
+  
+        before(:each) do
+          puts "before each"
+        end
+  
+        after(:each) do
+          puts "after each"
+        end
+  
+        after(:all) do
+          puts "after all"
+        end
+  
+        it "gets run in order" do
+  
+        end
+      end
+      """
+    When I run `rspec ensure_block_order_spec.rb`
+    Then the output should contain:
+      """
+      before all
+      before each
+      after each
+      .after all
+      """
+  
+  Scenario: before/after blocks defined in config are run in order
+    Given a file named "configuration_spec.rb" with:
+      """
+      require "rspec/expectations"
+
+      RSpec.configure do |config|
+        config.before(:suite) do
+          puts "before suite"
+        end
+  
+        config.before(:all) do
+          puts "before all"
+        end
+  
+        config.before(:each) do
+          puts "before each"
+        end
+  
+        config.after(:each) do
+          puts "after each"
+        end
+  
+        config.after(:all) do
+          puts "after all"
+        end
+  
+        config.after(:suite) do
+          puts "after suite"
+        end
+      end
+  
+      describe "ignore" do
+        example "ignore" do
+        end
+      end
+      """
+    When I run `rspec configuration_spec.rb`
+    Then the output should contain:
+      """
+      before suite
+      before all
+      before each
+      after each
+      .after all
+      after suite
+      """
+
+  Scenario: before/after all blocks are run once
+    Given a file named "before_and_after_all_spec.rb" with:
+      """
+      describe "before and after callbacks" do
+        before(:all) do
+          puts "outer before all"
+        end
+  
+        example "in outer group" do
+        end
+
+        after(:all) do
+          puts "outer after all"
+        end
+
+        describe "nested group" do
+          before(:all) do
+            puts "inner before all"
+          end
+          
+          example "in nested group" do
+          end
+
+          after(:all) do
+            puts "inner after all"
+          end
+        end
+
+      end
+      """
+    When I run `rspec before_and_after_all_spec.rb`
+    Then the examples should all pass
+    And the output should contain:
+      """
+      outer before all
+      .inner before all
+      .inner after all
+      outer after all
+      """
+
+    When I run `rspec before_and_after_all_spec.rb:14`
+    Then the examples should all pass
+    And the output should contain:
+      """
+      outer before all
+      inner before all
+      .inner after all
+      outer after all
+      """
+
+    When I run `rspec before_and_after_all_spec.rb:6`
+    Then the examples should all pass
+    And the output should contain:
+      """
+      outer before all
+      .outer after all
+      """
+
+  Scenario: nested examples have access to state set in outer before(:all)
+    Given a file named "before_all_spec.rb" with:
+      """
+      describe "something" do
+        before :all do
+          @value = 123
+        end
+
+        describe "nested" do
+          it "access state set in before(:all)" do
+            @value.should eq(123)
+          end
+
+          describe "nested more deeply" do
+            it "access state set in before(:all)" do
+              @value.should eq(123)
+            end
+          end
+        end
+
+        describe "nested in parallel" do
+          it "access state set in before(:all)" do
+            @value.should eq(123)
+          end
+        end
+      end
+      """
+    When I run `rspec before_all_spec.rb`
+    Then the examples should all pass
+
+  Scenario: before/after all blocks have access to state
+    Given a file named "before_and_after_all_spec.rb" with:
+      """
+      describe "before and after callbacks" do
+        before(:all) do
+          @outer_state = "set in outer before all"
+        end
+
+        example "in outer group" do
+          @outer_state.should eq("set in outer before all")
+        end
+
+        describe "nested group" do
+          before(:all) do
+            @inner_state = "set in inner before all"
+          end
+
+          example "in nested group" do
+            @outer_state.should eq("set in outer before all")
+            @inner_state.should eq("set in inner before all")
+          end
+
+          after(:all) do
+            @inner_state.should eq("set in inner before all")
+          end
+        end
+
+        after(:all) do
+          @outer_state.should eq("set in outer before all")
+        end
+      end
+      """
+    When I run `rspec before_and_after_all_spec.rb`
+    Then the examples should all pass
+
+  Scenario: exception in before(:each) is captured and reported as failure
+    Given a file named "error_in_before_each_spec.rb" with:
+      """
+      describe "error in before(:each)" do
+        before(:each) do
+          raise "this error"
+        end
+
+        it "is reported as failure" do
+        end
+      end
+      """
+    When I run `rspec error_in_before_each_spec.rb`
+    Then the output should contain "1 example, 1 failure"
+    And the output should contain "this error"

data/vendor/bundle/ruby/1.8/gems/rspec-core-2.9.0/features/hooks/filtering.feature

@@ -0,0 +1,234 @@
+Feature: filters
+
+  `before`, `after`, and `around` hooks defined in the block passed to
+  `RSpec.configure` can be constrained to specific examples and/or groups using
+  metadata as a filter.
+
+      RSpec.configure do |c|
+        c.before(:each, :type => :model) do
+        end
+      end
+
+      describe "something", :type => :model do
+      end
+
+  You can specify metadata using only symbols if you set the
+  `treat_symbols_as_metadata_keys_with_true_values` config option to `true`.
+
+  Scenario: filter `before(:each)` hooks using arbitrary metadata
+    Given a file named "filter_before_each_hooks_spec.rb" with:
+      """
+      RSpec.configure do |config|
+        config.before(:each, :foo => :bar) do
+          invoked_hooks << :before_each_foo_bar
+        end
+      end
+
+      describe "a filtered before :each hook" do
+        let(:invoked_hooks) { [] }
+
+        describe "group without matching metadata" do
+          it "does not run the hook" do
+            invoked_hooks.should be_empty
+          end
+
+          it "runs the hook for an example with matching metadata", :foo => :bar do
+            invoked_hooks.should == [:before_each_foo_bar]
+          end
+        end
+
+        describe "group with matching metadata", :foo => :bar do
+          it "runs the hook" do
+            invoked_hooks.should == [:before_each_foo_bar]
+          end
+        end
+      end
+      """
+    When I run `rspec filter_before_each_hooks_spec.rb`
+    Then the examples should all pass
+
+  Scenario: filter `after(:each)` hooks using arbitrary metadata
+    Given a file named "filter_after_each_hooks_spec.rb" with:
+      """
+      RSpec.configure do |config|
+        config.after(:each, :foo => :bar) do
+          raise "boom!"
+        end
+      end
+
+      describe "a filtered after :each hook" do
+        describe "group without matching metadata" do
+          it "does not run the hook" do
+            # should pass
+          end
+
+          it "runs the hook for an example with matching metadata", :foo => :bar do
+            # should fail
+          end
+        end
+
+        describe "group with matching metadata", :foo => :bar do
+          it "runs the hook" do
+            # should fail
+          end
+        end
+      end
+      """
+    When I run `rspec filter_after_each_hooks_spec.rb`
+    Then the output should contain "3 examples, 2 failures"
+
+  Scenario: filter around(:each) hooks using arbitrary metadata
+    Given a file named "filter_around_each_hooks_spec.rb" with:
+      """
+      RSpec.configure do |config|
+        config.around(:each, :foo => :bar) do |example|
+          order << :before_around_each_foo_bar
+          example.run
+          order.should == [:before_around_each_foo_bar, :example]
+        end
+      end
+
+      describe "a filtered around(:each) hook" do
+        let(:order) { [] }
+
+        describe "a group without matching metadata" do
+          it "does not run the hook" do
+            order.should be_empty
+          end
+
+          it "runs the hook for an example with matching metadata", :foo => :bar do
+            order.should == [:before_around_each_foo_bar]
+            order << :example
+          end
+        end
+
+        describe "a group with matching metadata", :foo => :bar do
+          it "runs the hook for an example with matching metadata", :foo => :bar do
+            order.should == [:before_around_each_foo_bar]
+            order << :example
+          end
+        end
+      end
+      """
+    When I run `rspec filter_around_each_hooks_spec.rb`
+    Then the examples should all pass
+
+  Scenario: filter before(:all) hooks using arbitrary metadata
+    Given a file named "filter_before_all_hooks_spec.rb" with:
+      """
+      RSpec.configure do |config|
+        config.before(:all, :foo => :bar) { @hook = :before_all_foo_bar }
+      end
+
+      describe "a filtered before(:all) hook" do
+        describe "a group without matching metadata" do
+          it "does not run the hook" do
+            @hook.should be_nil
+          end
+
+          describe "a nested subgroup with matching metadata", :foo => :bar do
+            it "runs the hook" do
+              @hook.should == :before_all_foo_bar
+            end
+          end
+        end
+
+        describe "a group with matching metadata", :foo => :bar do
+          it "runs the hook" do
+            @hook.should == :before_all_foo_bar
+          end
+
+          describe "a nested subgroup" do
+            it "runs the hook" do
+              @hook.should == :before_all_foo_bar
+            end
+          end
+        end
+      end
+      """
+    When I run `rspec filter_before_all_hooks_spec.rb`
+    Then the examples should all pass
+
+  Scenario: filter after(:all) hooks using arbitrary metadata
+    Given a file named "filter_after_all_hooks_spec.rb" with:
+      """
+      example_msgs = []
+
+      RSpec.configure do |config|
+        config.after(:all, :foo => :bar) do
+          puts "after :all"
+        end
+      end
+
+      describe "a filtered after(:all) hook" do
+        describe "a group without matching metadata" do
+          it "does not run the hook" do
+            puts "unfiltered"
+          end
+        end
+
+        describe "a group with matching metadata", :foo => :bar do
+          it "runs the hook" do
+            puts "filtered 1"
+          end
+        end
+
+        describe "another group without matching metadata" do
+          describe "a nested subgroup with matching metadata", :foo => :bar do
+            it "runs the hook" do
+              puts "filtered 2"
+            end
+          end
+        end
+      end
+      """
+    When I run `rspec filter_after_all_hooks_spec.rb`
+    Then the examples should all pass
+    And the output should contain:
+      """
+      unfiltered
+      .filtered 1
+      .after :all
+      filtered 2
+      .after :all
+      """
+
+  Scenario: Use symbols as metadata
+    Given a file named "less_verbose_metadata_filter.rb" with:
+      """
+      RSpec.configure do |c|
+        c.treat_symbols_as_metadata_keys_with_true_values = true
+        c.before(:each, :before_each) { puts "before each" }
+        c.after(:each,  :after_each) { puts "after each" }
+        c.around(:each, :around_each) do |example|
+          puts "around each (before)"
+          example.run
+          puts "around each (after)"
+        end
+        c.before(:all, :before_all) { puts "before all" }
+        c.after(:all,  :after_all) { puts "after all" }
+      end
+
+      describe "group 1", :before_all, :after_all do
+        it("") { puts "example 1" }
+        it("", :before_each) { puts "example 2" }
+        it("", :after_each) { puts "example 3" }
+        it("", :around_each) { puts "example 4" }
+      end
+      """
+    When I run `rspec less_verbose_metadata_filter.rb`
+    Then the examples should all pass
+    And the output should contain:
+      """
+      before all
+      example 1
+      .before each
+      example 2
+      .example 3
+      after each
+      .around each (before)
+      example 4
+      around each (after)
+      .after all
+      """
+

data/vendor/bundle/ruby/1.8/gems/rspec-core-2.9.0/features/metadata/current_example.feature

@@ -0,0 +1,17 @@
+Feature: current example
+
+  You can reference the example object, and access its metadata, using
+  the `example` method within an example.
+
+  Scenario: access the example object from within an example
+    Given a file named "spec/example_spec.rb" with:
+      """
+      describe "an example" do
+        it "knows itself as example" do
+          example.description.should eq("knows itself as example")
+        end
+      end
+      """
+    When I run `rspec spec/example_spec.rb`
+    Then the example should pass
+

data/vendor/bundle/ruby/1.8/gems/rspec-core-2.9.0/features/metadata/described_class.feature

@@ -0,0 +1,17 @@
+Feature: described class
+
+  If the first argument to the outermost example group is a class, the class is
+  exposed to each example via the described_class() method.
+
+  Scenario: access the described class from the example
+    Given a file named "spec/example_spec.rb" with:
+      """
+      describe Fixnum do
+        it "is available as described_class" do
+          described_class.should eq(Fixnum)
+        end
+      end
+      """
+    When I run `rspec spec/example_spec.rb`
+    Then the example should pass
+