resque-pool 0.3.0.beta.2 → 0.3.0

data/vendor/bundle/ruby/1.8/gems/rspec-core-2.9.0/spec/rspec/core/rspec_matchers_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+module RSpec::Matchers
+  def __method_with_super
+    super
+  end
+
+  module ModThatIncludesMatchers
+    include RSpec::Matchers
+  end
+
+  RSpec.configure do |c|
+    c.include RSpec::Matchers, :include_rspec_matchers => true
+    c.include ModThatIncludesMatchers, :include_mod_that_includes_rspec_matchers => true
+  end
+
+  describe self do
+    shared_examples_for "a normal module with a method that supers" do
+      it "raises the expected error (and not SystemStackError)" do
+        expect { __method_with_super }.to raise_error(NoMethodError) # there is no __method_with_super in an ancestor
+      end
+    end
+
+    it_behaves_like "a normal module with a method that supers"
+
+    context "when RSpec::Matchers has been included in an example group" do
+      include RSpec::Matchers
+      it_behaves_like "a normal module with a method that supers"
+    end
+
+    context "when a module that includes RSpec::Matchers has been included in an example group" do
+      include RSpec::Matchers::ModThatIncludesMatchers
+      it_behaves_like "a normal module with a method that supers"
+    end
+
+    context "when RSpec::Matchers is included via configuration", :include_rspec_matchers => true do
+      it_behaves_like "a normal module with a method that supers"
+    end
+
+    context "when RSpec::Matchers is included in a module that is included via configuration", :include_mod_that_includes_rspec_matchers => true do
+      it_behaves_like "a normal module with a method that supers"
+    end
+  end
+end
+

data/vendor/bundle/ruby/1.8/gems/rspec-core-2.9.0/spec/rspec/core/ruby_project_spec.rb

@@ -0,0 +1,24 @@
+module RSpec
+  module Core
+    describe RubyProject do
+
+      describe "#determine_root" do
+
+        context "with ancestor containing spec directory" do
+          it "returns ancestor containing the spec directory" do
+            RubyProject.stub(:ascend_until).and_return('foodir')
+            RubyProject.determine_root.should eq("foodir")
+          end
+        end
+
+        context "without ancestor containing spec directory" do
+          it "returns current working directory" do
+            RubyProject.stub(:find_first_parent_containing).and_return(nil)
+            RubyProject.determine_root.should eq(".")
+          end
+        end
+
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/1.8/gems/rspec-core-2.9.0/spec/rspec/core/runner_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+
+module RSpec::Core
+  describe Runner do
+    describe 'at_exit' do
+      it 'sets an at_exit hook if none is already set' do
+        RSpec::Core::Runner.stub(:installed_at_exit?).and_return(false)
+        RSpec::Core::Runner.stub(:running_in_drb?).and_return(false)
+        RSpec::Core::Runner.stub(:at_exit_hook_disabled?).and_return(false)
+        RSpec::Core::Runner.stub(:run).and_return(-1)
+        RSpec::Core::Runner.should_receive(:at_exit)
+        RSpec::Core::Runner.autorun
+      end
+
+      it 'does not set the at_exit hook if it is already set' do
+        RSpec::Core::Runner.stub(:installed_at_exit?).and_return(true)
+        RSpec::Core::Runner.stub(:running_in_drb?).and_return(false)
+        RSpec::Core::Runner.stub(:at_exit_hook_disabled?).and_return(false)
+        RSpec::Core::Runner.should_receive(:at_exit).never
+        RSpec::Core::Runner.autorun
+      end
+    end
+
+    describe "#run" do
+      let(:err) { StringIO.new }
+      let(:out) { StringIO.new }
+
+      it "resets world and configuration" do
+        RSpec.configuration.stub(:files_to_run) { [] }
+        RSpec.configuration.should_receive(:reset)
+        RSpec.world.should_receive(:reset)
+        RSpec::Core::Runner.run([], err, out)
+      end
+
+      context "with --drb or -X" do
+
+        before(:each) do
+          @options = RSpec::Core::ConfigurationOptions.new(%w[--drb --drb-port 8181 --color])
+          RSpec::Core::ConfigurationOptions.stub(:new) { @options }
+        end
+
+        def run_specs
+          RSpec::Core::Runner.run(%w[ --drb ], err, out)
+        end
+
+        context 'and a DRb server is running' do
+          it "builds a DRbCommandLine and runs the specs" do
+            drb_proxy = double(RSpec::Core::DRbCommandLine, :run => true)
+            drb_proxy.should_receive(:run).with(err, out)
+
+            RSpec::Core::DRbCommandLine.should_receive(:new).and_return(drb_proxy)
+
+            run_specs
+          end
+        end
+
+        context 'and a DRb server is not running' do
+          before(:each) do
+            RSpec::Core::DRbCommandLine.should_receive(:new).and_raise(DRb::DRbConnError)
+          end
+
+          it "outputs a message" do
+            RSpec.configuration.stub(:files_to_run) { [] }
+            err.should_receive(:puts).with(
+              "No DRb server is running. Running in local process instead ..."
+            )
+            run_specs
+          end
+
+          it "builds a CommandLine and runs the specs" do
+            process_proxy = double(RSpec::Core::CommandLine, :run => 0)
+            process_proxy.should_receive(:run).with(err, out)
+
+            RSpec::Core::CommandLine.should_receive(:new).and_return(process_proxy)
+
+            run_specs
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/1.8/gems/rspec-core-2.9.0/spec/rspec/core/shared_context_spec.rb

@@ -0,0 +1,67 @@
+require "spec_helper"
+
+describe RSpec::SharedContext do
+  it "is accessible as RSpec::Core::SharedContext" do
+    RSpec::Core::SharedContext
+  end
+
+  it "is accessible as RSpec::SharedContext" do
+    RSpec::SharedContext
+  end
+
+  it "supports before and after hooks" do
+    before_all_hook = false
+    before_each_hook = false
+    after_each_hook = false
+    after_all_hook = false
+    shared = Module.new do
+      extend RSpec::SharedContext
+      before(:all) { before_all_hook = true }
+      before(:each) { before_each_hook = true }
+      after(:each)  { after_each_hook = true }
+      after(:all)  { after_all_hook = true }
+    end
+    group = RSpec::Core::ExampleGroup.describe do
+      include shared
+      example { }
+    end
+
+    group.run
+
+    before_all_hook.should be_true
+    before_each_hook.should be_true
+    after_each_hook.should be_true
+    after_all_hook.should be_true
+  end
+
+  it "supports let" do
+    shared = Module.new do
+      extend RSpec::SharedContext
+      let(:foo) { 'foo' }
+    end
+    group = RSpec::Core::ExampleGroup.describe do
+      include shared
+    end
+
+    group.new.foo.should eq('foo')
+  end
+
+  %w[describe context].each do |method_name|
+    it "supports nested example groups using #{method_name}" do
+      shared = Module.new do
+        extend RSpec::SharedContext
+        send(method_name, "nested using describe") do
+          example {}
+        end
+      end
+      group = RSpec::Core::ExampleGroup.describe do
+        include shared
+      end
+
+      group.run
+
+      group.children.length.should eq(1)
+      group.children.first.examples.length.should eq(1)
+    end
+  end
+end

data/vendor/bundle/ruby/1.8/gems/rspec-core-2.9.0/spec/rspec/core/shared_example_group_spec.rb

@@ -0,0 +1,84 @@
+require 'spec_helper'
+
+module RSpec::Core
+  describe SharedExampleGroup do
+
+    ExampleModule = Module.new
+    ExampleClass = Class.new
+
+    %w[share_examples_for shared_examples_for].each do |method_name|
+      describe method_name do
+        it "is exposed to the global namespace" do
+          Kernel.should respond_to(method_name)
+        end
+
+        it "raises an ArgumentError when adding a second shared example group with the same name" do
+          group = ExampleGroup.describe('example group')
+          group.send(method_name, 'shared group') {}
+          lambda do
+            group.send(method_name, 'shared group') {}
+          end.should raise_error(ArgumentError, "Shared example group 'shared group' already exists")
+        end
+
+        ["name", :name, ExampleModule, ExampleClass].each do |object|
+          type = object.class.name.downcase
+          context "given a #{type}" do
+            it "captures the given #{type} and block in the World's collection of shared example groups" do
+              implementation = lambda {}
+              RSpec.world.shared_example_groups.should_receive(:[]=).with(object, implementation)
+              send(method_name, object, &implementation)
+            end
+          end
+        end
+
+        context "given a hash" do
+          it "delegates extend on configuration" do
+            implementation = Proc.new { def bar; 'bar'; end }
+            send(method_name, :foo => :bar, &implementation)
+            a = RSpec.configuration.include_or_extend_modules.first
+            a[0].should eq(:extend)
+            Class.new.extend(a[1]).new.bar.should eq('bar')
+            a[2].should eq(:foo => :bar)
+          end
+        end
+
+        context "given a string and a hash" do
+          it "captures the given string and block in the World's collection of shared example groups" do
+            implementation = lambda {}
+            RSpec.world.shared_example_groups.should_receive(:[]=).with("name", implementation)
+            send(method_name, "name", :foo => :bar, &implementation)
+          end
+
+          it "delegates extend on configuration" do
+            implementation = Proc.new { def bar; 'bar'; end }
+            send(method_name, "name", :foo => :bar, &implementation)
+            a = RSpec.configuration.include_or_extend_modules.first
+            a[0].should eq(:extend)
+            Class.new.extend(a[1]).new.bar.should eq('bar')
+            a[2].should eq(:foo => :bar)
+          end
+        end
+      end
+    end
+
+    describe "#share_as" do
+      it "is exposed to the global namespace" do
+        Kernel.should respond_to("share_as")
+      end
+
+      it "adds examples to current example_group using include", :compat => 'rspec-1.2' do
+        share_as('Cornucopia') do
+          it "is plentiful" do
+            5.should eq(4)
+          end
+        end
+        group = ExampleGroup.describe('group') { include Cornucopia }
+        phantom_group = group.children.first
+        phantom_group.description.should eql("")
+        phantom_group.metadata[:shared_group_name].should eql('Cornucopia')
+        phantom_group.examples.length.should eq(1)
+        phantom_group.examples.first.metadata[:description].should eq("is plentiful")
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/1.8/gems/rspec-core-2.9.0/spec/rspec/core/subject_spec.rb

@@ -0,0 +1,228 @@
+require 'spec_helper'
+
+module RSpec::Core
+
+  describe Subject do
+    before(:each) { RSpec.configuration.configure_expectation_framework }
+
+    describe "implicit subject" do
+      describe "with a class" do
+        it "returns an instance of the class" do
+          ExampleGroup.describe(Array).subject.call.should eq([])
+        end
+      end
+
+      describe "with a Module" do
+        it "returns the Module" do
+          ExampleGroup.describe(Enumerable).subject.call.should eq(Enumerable)
+        end
+      end
+
+      describe "with a string" do
+        it "return the string" do
+          ExampleGroup.describe("Foo").subject.call.should eq("Foo")
+        end
+      end
+
+      describe "with a number" do
+        it "returns the number" do
+          ExampleGroup.describe(15).subject.call.should eq(15)
+        end
+      end
+
+    end
+
+    describe "explicit subject" do
+      [false, nil].each do |falsy_value|
+        context "with a value of #{falsy_value.inspect}" do
+          it "is evaluated once per example" do
+            group = ExampleGroup.describe(Array)
+            group.before do
+              Object.should_receive(:this_question?).once.and_return(falsy_value)
+            end
+            group.subject do
+              Object.this_question?
+            end
+            group.example do
+              subject
+              subject
+            end
+            group.run.should be_true, "expected subject block to be evaluated only once"
+          end
+        end
+      end
+
+      describe "defined in a top level group" do
+        it "replaces the implicit subject in that group" do
+          group = ExampleGroup.describe(Array)
+          group.subject { [1,2,3] }
+          group.subject.call.should eq([1,2,3])
+        end
+      end
+
+      describe "defined in a top level group" do
+        let(:group) do
+          ExampleGroup.describe do
+            subject{ [4,5,6] }
+          end
+        end
+
+        it "is available in a nested group (subclass)" do
+          nested_group = group.describe("I'm nested!") { }
+          nested_group.subject.call.should eq([4,5,6])
+        end
+
+        it "is available in a doubly nested group (subclass)" do
+          nested_group = group.describe("Nesting level 1") { }
+          doubly_nested_group = nested_group.describe("Nesting level 2") { }
+          doubly_nested_group.subject.call.should eq([4,5,6])
+        end
+      end
+    end
+
+    context "using 'self' as an explicit subject" do
+      it "delegates matcher to the ExampleGroup" do
+        group = ExampleGroup.describe("group") do
+          subject { self }
+          def ok?; true; end
+
+          it { should eq(self) }
+          it { should be_ok }
+        end
+
+        group.run.should be_true
+      end
+    end
+
+    describe "#its" do
+      subject do
+        Class.new do
+          def initialize
+            @call_count = 0
+          end
+
+          def call_count
+            @call_count += 1
+          end
+        end.new
+      end
+
+      context "with a call counter" do
+        its(:call_count) { should eq(1) }
+      end
+
+      context "with nil value" do
+        subject do
+          Class.new do
+            def nil_value
+              nil
+            end
+          end.new
+        end
+        its(:nil_value) { should be_nil }
+      end
+
+      context "with nested attributes" do
+        subject do
+          Class.new do
+            def name
+              "John"
+            end
+          end.new
+        end
+        its("name")            { should eq("John") }
+        its("name.size")       { should eq(4) }
+        its("name.size.class") { should eq(Fixnum) }
+      end
+
+      context "when it responds to #[]" do
+        subject do
+          Class.new do
+            def [](*objects)
+              objects.map do |object|
+                "#{object.class}: #{object.to_s}"
+              end.join("; ")
+            end
+
+            def name
+              "George"
+            end
+          end.new
+        end
+        its([:a]) { should eq("Symbol: a") }
+        its(['a']) { should eq("String: a") }
+        its([:b, 'c', 4]) { should eq("Symbol: b; String: c; Fixnum: 4") }
+        its(:name) { should eq("George") }
+        context "when referring to an attribute without the proper array syntax" do
+          context "it raises an error" do
+            its(:age) do
+              expect do
+                should eq(64)
+              end.to raise_error(NoMethodError)
+            end
+          end
+        end
+      end
+
+      context "when it does not respond to #[]" do
+        subject { Object.new }
+
+        context "it raises an error" do
+          its([:a]) do
+            expect do
+              should eq("Symbol: a")
+            end.to raise_error(NoMethodError)
+          end
+        end
+      end
+
+      context "calling and overriding super" do
+        it "calls to the subject defined in the parent group" do
+          group = ExampleGroup.describe(Array) do
+            subject { [1, 'a'] }
+
+            its(:last) { should eq("a") }
+
+            describe '.first' do
+              def subject; super().first; end
+
+              its(:next) { should eq(2) }
+            end
+          end
+
+          group.run.should be_true
+        end
+      end
+
+      context "with nil subject" do
+        subject do
+          Class.new do
+            def initialize
+              @counter = -1
+            end
+            def nil_if_first_time
+              @counter += 1
+              @counter == 0 ? nil : true
+            end
+          end.new
+        end
+        its(:nil_if_first_time) { should be(nil) }
+      end
+
+      context "with false subject" do
+        subject do
+          Class.new do
+            def initialize
+              @counter = -1
+            end
+            def false_if_first_time
+              @counter += 1
+              @counter > 0
+            end
+          end.new
+        end
+        its(:false_if_first_time) { should be(false) }
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/1.8/gems/rspec-core-2.9.0/spec/rspec/core/world_spec.rb

@@ -0,0 +1,144 @@
+require 'spec_helper'
+
+class Bar; end
+class Foo; end
+
+module RSpec::Core
+
+  describe RSpec::Core::World do
+    let(:configuration) { RSpec::Core::Configuration.new }
+    let(:world) { RSpec::Core::World.new(configuration) }
+
+    describe '#reset' do
+      it 'clears #example_groups and #shared_example_groups' do
+        world.example_groups << :example_group
+        world.shared_example_groups[:shared] = :example_group
+        world.reset
+        world.example_groups.should be_empty
+        world.shared_example_groups.should be_empty
+      end
+    end
+
+    describe "#example_groups" do
+      it "contains all registered example groups" do
+        group = RSpec::Core::ExampleGroup.describe("group"){}
+        world.register(group)
+        world.example_groups.should include(group)
+      end
+    end
+
+    describe "#preceding_declaration_line (again)" do
+      let(:group) do
+        RSpec::Core::ExampleGroup.describe("group") do
+
+          example("example") {}
+
+        end
+      end
+
+      let(:second_group) do
+        RSpec::Core::ExampleGroup.describe("second_group") do
+
+          example("second_example") {}
+
+        end
+      end
+
+      let(:group_declaration_line) { group.metadata[:example_group][:line_number] }
+      let(:example_declaration_line) { group_declaration_line + 2 }
+
+      context "with one example" do
+        before { world.register(group) }
+
+        it "returns nil if no example or group precedes the line" do
+          world.preceding_declaration_line(group_declaration_line - 1).should be_nil
+        end
+
+        it "returns the argument line number if a group starts on that line" do
+          world.preceding_declaration_line(group_declaration_line).should eq(group_declaration_line)
+        end
+
+        it "returns the argument line number if an example starts on that line" do
+          world.preceding_declaration_line(example_declaration_line).should eq(example_declaration_line)
+        end
+
+        it "returns line number of a group that immediately precedes the argument line" do
+          world.preceding_declaration_line(group_declaration_line + 1).should eq(group_declaration_line)
+        end
+
+        it "returns line number of an example that immediately precedes the argument line" do
+          world.preceding_declaration_line(example_declaration_line + 1).should eq(example_declaration_line)
+        end
+      end
+
+      context "with two exaples and the second example is registre first" do
+        let(:second_group_declaration_line) { second_group.metadata[:example_group][:line_number] }
+
+        before do
+          world.register(second_group)
+          world.register(group)
+        end
+
+        it 'return line number of group if a group start on that line' do
+          world.preceding_declaration_line(second_group_declaration_line).should eq(second_group_declaration_line)
+        end
+      end
+    end
+
+    describe "#announce_filters" do
+      let(:reporter) { double('reporter').as_null_object }
+      before { world.stub(:reporter) { reporter } }
+
+      context "with no examples" do
+        before { world.stub(:example_count) { 0 } }
+
+        context "with no filters" do
+          it "announces" do
+            reporter.should_receive(:message).
+              with("No examples found.")
+            world.announce_filters
+          end
+        end
+
+        context "with an inclusion filter" do
+          it "announces" do
+            configuration.filter_run_including :foo => 'bar'
+            reporter.should_receive(:message).
+              with(/All examples were filtered out/)
+            world.announce_filters
+          end
+        end
+
+        context "with an inclusion filter and run_all_when_everything_filtered" do
+          it "announces" do
+            configuration.stub(:run_all_when_everything_filtered?) { true }
+            configuration.filter_run_including :foo => 'bar'
+            reporter.should_receive(:message).
+              with(/All examples were filtered out/)
+            world.announce_filters
+          end
+        end
+
+        context "with an exclusion filter" do
+          it "announces" do
+            configuration.filter_run_excluding :foo => 'bar'
+            reporter.should_receive(:message).
+              with(/All examples were filtered out/)
+            world.announce_filters
+          end
+        end
+      end
+
+      context "with examples" do
+        before { world.stub(:example_count) { 1 } }
+
+        context "with no filters" do
+          it "does not announce" do
+            reporter.should_not_receive(:message)
+            world.announce_filters
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/1.8/gems/rspec-core-2.9.0/spec/rspec/core_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe RSpec::Core do
+
+  describe "#configuration" do
+    it "returns the same object every time" do
+      RSpec.configuration.should equal(RSpec.configuration)
+    end
+  end
+
+  describe "#configure" do
+    it "yields the current configuration" do
+      RSpec.configure do |config|
+        config.should eq(RSpec::configuration)
+      end
+    end
+  end
+
+  describe "#world" do
+    it "returns the RSpec::Core::World instance the current run is using" do
+      RSpec.world.should be_instance_of(RSpec::Core::World)
+    end
+  end
+
+end