resque-pool 0.3.0.beta.2 → 0.3.0

data/vendor/bundle/ruby/1.8/gems/rspec-expectations-2.9.1/spec/rspec/expectations/differ_spec.rb

@@ -0,0 +1,153 @@
+require 'spec_helper'
+require 'ostruct'
+
+module RSpec
+  module Expectations
+    describe Differ do
+      let(:differ) { RSpec::Expectations::Differ.new }
+
+      describe '#diff_as_string' do
+        it "outputs unified diff of two strings" do
+          expected="foo\nbar\nzap\nthis\nis\nsoo\nvery\nvery\nequal\ninsert\na\nline\n"
+          actual="foo\nzap\nbar\nthis\nis\nsoo\nvery\nvery\nequal\ninsert\na\nanother\nline\n"
+          expected_diff= <<'EOD'
+
+
+@@ -1,6 +1,6 @@
+ foo
+-zap
+ bar
++zap
+ this
+ is
+ soo
+@@ -9,6 +9,5 @@
+ equal
+ insert
+ a
+-another
+ line
+EOD
+
+          diff = differ.diff_as_string(expected, actual)
+          diff.should eql(expected_diff)
+        end
+      end
+
+      describe '#diff_as_object' do
+        it "outputs unified diff message of two objects" do
+          animal_class = Class.new do
+            def initialize(name, species)
+              @name, @species = name, species
+            end
+
+            def inspect
+              <<-EOA
+<Animal
+  name=#{@name},
+  species=#{@species}
+>
+              EOA
+            end
+          end
+
+          expected = animal_class.new "bob", "giraffe"
+          actual   = animal_class.new "bob", "tortoise"
+
+          expected_diff = <<'EOD'
+
+@@ -1,5 +1,5 @@
+ <Animal
+   name=bob,
+-  species=tortoise
++  species=giraffe
+ >
+EOD
+
+          diff = differ.diff_as_object(expected,actual)
+          diff.should == expected_diff
+        end
+
+        it "outputs a message if the diff is empty" do
+          diff = differ.diff_as_object('foo', 'foo')
+          diff.should eq(
+            "foo.==(foo) returned false even though the diff between " \
+            "foo and foo is empty. Check the implementation of foo.==."
+          )
+        end
+
+        it "outputs unified diff message of two arrays" do
+          expected = [ :foo, 'bar', :baz, 'quux', :metasyntactic, 'variable', :delta, 'charlie', :width, 'quite wide' ]
+          actual   = [ :foo, 'bar', :baz, 'quux', :metasyntactic, 'variable', :delta, 'tango'  , :width, 'very wide'  ]
+
+          expected_diff = <<'EOD'
+
+
+@@ -5,7 +5,7 @@
+  :metasyntactic,
+  "variable",
+  :delta,
+- "tango",
++ "charlie",
+  :width,
+- "very wide"]
++ "quite wide"]
+EOD
+
+          diff = differ.diff_as_object(expected,actual)
+          diff.should == expected_diff
+        end
+
+        it "outputs unified diff message of two hashes" do
+          expected = { :foo => 'bar', :baz => 'quux', :metasyntactic => 'variable', :delta => 'charlie', :width =>'quite wide' }
+          actual   = { :foo => 'bar', :metasyntactic => 'variable', :delta => 'charlotte', :width =>'quite wide' }
+
+          expected_diff = <<'EOD'
+
+@@ -1,4 +1,5 @@
+-:delta => "charlotte",
++:baz => "quux",
++:delta => "charlie",
+ :foo => "bar",
+ :metasyntactic => "variable",
+ :width => "quite wide"
+EOD
+
+          diff = differ.diff_as_object(expected,actual)
+          diff.should == expected_diff
+        end
+
+        it "outputs unified diff of single line strings" do
+          expected = "this is one string"
+          actual   = "this is another string"
+
+          expected_diff = <<'EOD'
+
+@@ -1,2 +1,2 @@
+-"this is another string"
++"this is one string"
+EOD
+
+          diff = differ.diff_as_object(expected,actual)
+          diff.should == expected_diff
+        end
+
+        it "outputs unified diff of multi line strings" do
+          expected = "this is:\n  one string"
+          actual   = "this is:\n  another string"
+
+          expected_diff = <<'EOD'
+
+@@ -1,3 +1,3 @@
+ this is:
+-  another string
++  one string
+EOD
+
+          diff = differ.diff_as_object(expected,actual)
+          diff.should == expected_diff
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/1.8/gems/rspec-expectations-2.9.1/spec/rspec/expectations/extensions/kernel_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe Object, "#should" do
+  before(:each) do
+    @target = "target"
+    @matcher = mock("matcher")
+    @matcher.stub!(:matches?).and_return(true)
+    @matcher.stub!(:failure_message_for_should)
+  end
+  
+  it "accepts and interacts with a matcher" do
+    @matcher.should_receive(:matches?).with(@target).and_return(true)    
+    @target.should @matcher
+  end
+  
+  it "asks for a failure_message_for_should when matches? returns false" do
+    @matcher.should_receive(:matches?).with(@target).and_return(false)
+    @matcher.should_receive(:failure_message_for_should).and_return("the failure message")
+    lambda {
+      @target.should @matcher
+    }.should fail_with("the failure message")
+  end
+end
+
+describe Object, "#should_not" do
+  before(:each) do
+    @target = "target"
+    @matcher = mock("matcher")
+  end
+  
+  it "accepts and interacts with a matcher" do
+    @matcher.should_receive(:matches?).with(@target).and_return(false)
+    @matcher.stub!(:failure_message_for_should_not)
+    
+    @target.should_not @matcher
+  end
+  
+  it "asks for a failure_message_for_should_not when matches? returns true" do
+    @matcher.should_receive(:matches?).with(@target).and_return(true)
+    @matcher.should_receive(:failure_message_for_should_not).and_return("the failure message for should not")
+    lambda {
+      @target.should_not @matcher
+    }.should fail_with("the failure message for should not")
+  end
+end

data/vendor/bundle/ruby/1.8/gems/rspec-expectations-2.9.1/spec/rspec/expectations/fail_with_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+describe RSpec::Expectations, "#fail_with with diff" do
+  let(:differ) { double("differ") }
+
+  before(:each) do
+    RSpec::Expectations.stub(:differ) { differ }
+  end
+
+  it "calls differ if expected/actual are not strings (or numbers or procs)" do
+    differ.should_receive(:diff_as_object).and_return("diff")
+    lambda {
+      RSpec::Expectations.fail_with "the message", Object.new, Object.new
+    }.should fail_with("the message\nDiff:diff")
+  end
+
+  context "with two strings" do
+    context "and actual is multiline" do
+      it "calls differ" do
+        differ.should_receive(:diff_as_string).and_return("diff")
+        lambda {
+          RSpec::Expectations.fail_with "the message", "expected\nthis", "actual"
+        }.should fail_with("the message\nDiff:diff")
+      end
+    end
+
+    context "and expected is multiline" do
+      it "calls differ" do
+        differ.should_receive(:diff_as_string).and_return("diff")
+        lambda {
+          RSpec::Expectations.fail_with "the message", "expected", "actual\nthat"
+        }.should fail_with("the message\nDiff:diff")
+      end
+    end
+
+    context "and both are single line strings" do
+      it "does not call differ" do
+        differ.should_not_receive(:diff_as_string)
+        lambda {
+          RSpec::Expectations.fail_with("the message", "expected", "actual")
+        }.should fail_with("the message")
+      end
+    end
+  end
+
+  it "does not call differ if no expected/actual" do
+    lambda {
+      RSpec::Expectations.fail_with "the message"
+    }.should fail_with("the message")
+  end
+
+  it "does not call differ expected is Numeric" do
+    lambda {
+      RSpec::Expectations.fail_with "the message", 1, "1"
+    }.should fail_with("the message")
+  end
+
+  it "does not call differ when actual is Numeric" do
+    lambda {
+      RSpec::Expectations.fail_with "the message", "1", 1
+    }.should fail_with("the message")
+  end
+
+  it "does not call differ if expected or actual are procs" do
+    lambda {
+      RSpec::Expectations.fail_with "the message", lambda {}, lambda {}
+    }.should fail_with("the message")
+  end
+end
+

data/vendor/bundle/ruby/1.8/gems/rspec-expectations-2.9.1/spec/rspec/expectations/handler_spec.rb

@@ -0,0 +1,206 @@
+require 'spec_helper'
+
+module ExampleExpectations
+  
+  class ArbitraryMatcher
+    def initialize(*args, &block)
+      if args.last.is_a? Hash
+        @expected = args.last[:expected]
+      end
+      @expected = block.call if block
+      @block = block
+    end
+    
+    def matches?(target)
+      @target = target
+      return @expected == target
+    end
+    
+    def with(new_value)
+      @expected = new_value
+      self
+    end
+    
+    def failure_message
+      "expected #{@expected}, got #{@target}"
+    end
+    
+    def negative_failure_message
+      "expected not #{@expected}, got #{@target}"
+    end
+  end
+  
+  class PositiveOnlyMatcher < ArbitraryMatcher
+    undef negative_failure_message rescue nil
+  end
+  
+  def arbitrary_matcher(*args, &block)
+    ArbitraryMatcher.new(*args, &block)
+  end
+  
+  def positive_only_matcher(*args, &block)
+    PositiveOnlyMatcher.new(*args, &block)
+  end
+  
+end
+
+module RSpec
+  module Expectations
+    describe PositiveExpectationHandler do
+      describe "#handle_matcher" do
+        it "asks the matcher if it matches" do
+          matcher = mock("matcher")
+          actual = Object.new
+          matcher.should_receive(:matches?).with(actual).and_return(true)
+          RSpec::Expectations::PositiveExpectationHandler.handle_matcher(actual, matcher)
+        end
+      
+        it "returns the match value" do
+          matcher = mock("matcher")
+          actual = Object.new
+          matcher.should_receive(:matches?).with(actual).and_return(:this_value)
+          RSpec::Expectations::PositiveExpectationHandler.handle_matcher(actual, matcher).should == :this_value
+        end
+        
+        it "calls failure_message_for_should if the matcher implements it" do
+          matcher = mock("matcher", :failure_message_for_should => "message", :matches? => false)
+          actual = Object.new
+          
+          ::RSpec::Expectations.should_receive(:fail_with).with("message")
+          
+          RSpec::Expectations::PositiveExpectationHandler.handle_matcher(actual, matcher)
+        end
+        
+        it "calls fail if matcher.diffable?" do
+          matcher = mock("matcher",
+            :diffable? => true,
+            :failure_message_for_should => "message",
+            :matches? => false,
+            :expected => 1,
+            :actual   => 2
+          )
+          actual = Object.new
+          
+          ::RSpec::Expectations.should_receive(:fail_with).with("message", 1, 2)
+          
+          RSpec::Expectations::PositiveExpectationHandler.handle_matcher(actual, matcher)
+        end
+        
+        it "calls failure_message if the matcher does not implement failure_message_for_should" do
+          matcher = mock("matcher", :failure_message => "message", :matches? => false)
+          actual = Object.new
+          
+          ::RSpec::Expectations.should_receive(:fail_with).with("message")
+          
+          RSpec::Expectations::PositiveExpectationHandler.handle_matcher(actual, matcher)
+          
+        end
+        
+        it "appends the :or message in the options hash passed to should" do
+          matcher = mock("matcher", :failure_message_for_should => "message", :matches? => false)
+          actual = Object.new
+          
+          ::RSpec::Expectations.should_receive(:fail_with).with("custom")
+          
+          RSpec::Expectations::PositiveExpectationHandler.handle_matcher(actual, matcher, "custom")
+        end
+      end
+    end
+
+    describe NegativeExpectationHandler do
+      describe "#handle_matcher" do
+        it "asks the matcher if it doesn't match when the matcher responds to #does_not_match?" do
+          matcher = mock("matcher", :does_not_match? => true, :negative_failure_message => nil)
+          actual = Object.new
+          matcher.should_receive(:does_not_match?).with(actual).and_return(true)
+          RSpec::Expectations::NegativeExpectationHandler.handle_matcher(actual, matcher)
+        end
+
+        it "asks the matcher if it matches when the matcher doesn't respond to #does_not_match?" do
+          matcher = mock("matcher")
+          actual = Object.new
+          matcher.stub!(:negative_failure_message)
+          matcher.should_receive(:matches?).with(actual).and_return(false)
+          RSpec::Expectations::NegativeExpectationHandler.handle_matcher(actual, matcher)
+        end
+      
+        it "returns the match value" do
+          matcher = mock("matcher")
+          actual = Object.new
+          matcher.should_receive(:matches?).with(actual).and_return(false)
+          matcher.stub!(:negative_failure_message).and_return("ignore")
+          RSpec::Expectations::NegativeExpectationHandler.handle_matcher(actual, matcher).should be_false
+        end
+
+        
+        it "calls failure_message_for_should_not if the matcher implements it" do
+          matcher = mock("matcher", :failure_message_for_should_not => "message", :matches? => true)
+          actual = Object.new
+          
+          ::RSpec::Expectations.should_receive(:fail_with).with("message")
+          
+          RSpec::Expectations::NegativeExpectationHandler.handle_matcher(actual, matcher)
+          
+        end
+        
+        it "calls negative_failure_message if the matcher does not implement failure_message_for_should_not" do
+          matcher = mock("matcher", :negative_failure_message => "message", :matches? => true)
+          actual = Object.new
+          
+          ::RSpec::Expectations.should_receive(:fail_with).with("message")
+          
+          RSpec::Expectations::NegativeExpectationHandler.handle_matcher(actual, matcher)
+          
+        end
+
+        
+        it "calls fail if matcher.diffable?" do
+          matcher = mock("matcher",
+            :diffable? => true,
+            :failure_message_for_should_not => "message",
+            :matches? => true,
+            :expected => 1,
+            :actual   => 2
+          )
+          actual = Object.new
+          
+          ::RSpec::Expectations.should_receive(:fail_with).with("message", 1, 2)
+          
+          RSpec::Expectations::NegativeExpectationHandler.handle_matcher(actual, matcher)
+        end
+
+        it "appends the :or message in the options hash passed to should" do
+          matcher = mock("matcher", :failure_message_for_should_not => "message", :matches? => true)
+          actual = Object.new
+          
+          ::RSpec::Expectations.should_receive(:fail_with).with("custom")
+          
+          RSpec::Expectations::NegativeExpectationHandler.handle_matcher(actual, matcher, "custom")
+        end
+
+      end
+    end
+    
+    describe PositiveExpectationHandler do
+      include ExampleExpectations
+      
+      it "handles submitted args" do
+        5.should arbitrary_matcher(:expected => 5)
+        5.should arbitrary_matcher(:expected => "wrong").with(5)
+        lambda { 5.should arbitrary_matcher(:expected => 4) }.should fail_with("expected 4, got 5")
+        lambda { 5.should arbitrary_matcher(:expected => 5).with(4) }.should fail_with("expected 4, got 5")
+        5.should_not arbitrary_matcher(:expected => 4)
+        5.should_not arbitrary_matcher(:expected => 5).with(4)
+        lambda { 5.should_not arbitrary_matcher(:expected => 5) }.should fail_with("expected not 5, got 5")
+        lambda { 5.should_not arbitrary_matcher(:expected => 4).with(5) }.should fail_with("expected not 5, got 5")
+      end
+
+      it "handles the submitted block" do
+        5.should arbitrary_matcher { 5 }
+        5.should arbitrary_matcher(:expected => 4) { 5 }
+        5.should arbitrary_matcher(:expected => 4).with(5) { 3 }
+      end
+  
+    end
+  end
+end

data/vendor/bundle/ruby/1.8/gems/rspec-expectations-2.9.1/spec/rspec/matchers/base_matcher_spec.rb

@@ -0,0 +1,52 @@
+module RSpec::Matchers::BuiltIn
+  describe BaseMatcher do
+    describe "#match_unless_raises" do
+      let(:matcher) do
+        Class.new do
+          include BaseMatcher
+        end.new
+      end
+
+      it "returns true if there are no errors" do
+        matcher.match_unless_raises {}.should be_true
+      end
+
+      it "returns false if there is an error" do
+        matcher.match_unless_raises { raise }.should be_false
+      end
+
+      it "returns false if the submitted error is raised" do
+        matcher.match_unless_raises(RuntimeError){ raise "foo" }.should be_false
+      end
+
+      it "re-raises any error other than the one specified" do
+        expect do
+          matcher.match_unless_raises(ArgumentError){ raise "foo" }
+        end.to raise_error
+      end
+
+      it "stores the rescued exception for use in messages" do
+        matcher.match_unless_raises(RuntimeError){ raise "foo" }
+        matcher.rescued_exception.should be_a(RuntimeError)
+        matcher.rescued_exception.message.should eq("foo")
+      end
+
+    end
+
+    describe "#==" do
+      it "responds the same way as matches?" do
+        matcher = Class.new do
+          include BaseMatcher
+          def matches?(actual)
+            actual == expected
+          end
+        end
+        matcher.new(3).matches?(3).should be_true
+        matcher.new(3).should eq(3)
+
+        matcher.new(3).matches?(4).should be_false
+        matcher.new(3).should_not eq(4)
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/1.8/gems/rspec-expectations-2.9.1/spec/rspec/matchers/be_close_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+module RSpec
+  module Matchers
+    describe "[actual.should] be_close(expected, delta)" do
+      before(:each) do
+        RSpec.stub(:warn)
+      end
+
+      it "delegates to be_within(delta).of(expected)" do
+        should_receive(:be_within).with(0.5).and_return( be_within_matcher = stub )
+        be_within_matcher.should_receive(:of).with(3.0)
+        be_close(3.0, 0.5)
+      end
+
+      it "prints a deprecation warning" do
+        RSpec.should_receive(:warn).with(/please use be_within.*instead/)
+        be_close(3.0, 0.5)
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/1.8/gems/rspec-expectations-2.9.1/spec/rspec/matchers/be_instance_of_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+module RSpec
+  module Matchers
+    [:be_an_instance_of, :be_instance_of].each do |method|
+      describe "actual.should #{method}(expected)" do
+        it "passes if actual is instance of expected class" do
+          5.should send(method, Fixnum)
+        end
+
+        it "fails if actual is instance of subclass of expected class" do
+          lambda { 5.should send(method, Numeric) }.should fail_with(%Q{expected 5 to be an instance of Numeric})
+        end
+
+        it "fails with failure message for should unless actual is instance of expected class" do
+          lambda { "foo".should send(method, Array) }.should fail_with(%Q{expected "foo" to be an instance of Array})
+        end
+
+        it "provides a description" do
+          matcher = be_an_instance_of(Fixnum)
+          matcher.matches?(Numeric)
+          matcher.description.should == "be an instance of Fixnum"
+        end
+      end
+      
+      describe "actual.should_not #{method}(expected)" do
+        
+        it "fails with failure message for should_not if actual is instance of expected class" do
+          lambda { "foo".should_not send(method, String) }.should fail_with(%Q{expected "foo" not to be an instance of String})
+        end
+
+      end
+
+    end
+  end
+end

data/vendor/bundle/ruby/1.8/gems/rspec-expectations-2.9.1/spec/rspec/matchers/be_kind_of_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+module RSpec
+  module Matchers
+    [:be_a_kind_of, :be_kind_of].each do |method|
+      describe "actual.should #{method}(expected)" do
+        it "passes if actual is instance of expected class" do
+          5.should send(method, Fixnum)
+        end
+
+        it "passes if actual is instance of subclass of expected class" do
+          5.should send(method, Numeric)
+        end
+
+        it "fails with failure message for should unless actual is kind of expected class" do
+          lambda { "foo".should send(method, Array) }.should fail_with(%Q{expected "foo" to be a kind of Array})
+        end
+
+        it "provides a description" do
+          matcher = be_a_kind_of(String)
+          matcher.matches?("this")
+          matcher.description.should == "be a kind of String"
+        end
+      end
+      
+      describe "actual.should_not #{method}(expected)" do
+        it "fails with failure message for should_not if actual is kind of expected class" do
+          lambda { "foo".should_not send(method, String) }.should fail_with(%Q{expected "foo" not to be a kind of String})
+        end
+      end
+    end
+  end
+end