gem_repackager 0.1.0

data/support/gems/rspec-mocks-2.11.1/spec/rspec/mocks/bug_report_7611_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+module Bug7611
+  describe "A Partial Mock" do
+    class Foo; end
+    class Bar < Foo; end
+
+    it "respects subclasses" do
+      Foo.stub(:new).and_return(Object.new)
+    end
+
+    it "should" do
+      Bar.new.class.should eq Bar
+    end 
+  end
+end

data/support/gems/rspec-mocks-2.11.1/spec/rspec/mocks/bug_report_8165_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe "An object where respond_to? is true and does not have method" do
+  # When should_receive(message) is sent to any object, the Proxy sends
+  # respond_to?(message) to that object to see if the method should be proxied.
+  #
+  # If respond_to? itself is proxied, then when the Proxy sends respond_to?
+  # to the object, the proxy is invoked and responds yes (if so set in the spec).
+  # When the object does NOT actually respond to `message`, an exception is thrown
+  # when trying to proxy it.
+  #
+  # The fix was to keep track of whether `respond_to?` had been proxied and, if
+  # so, call the munged copy of `respond_to?` on the object.
+
+  it "does not raise an exception for Object" do
+    obj = Object.new
+    obj.should_receive(:respond_to?).with(:foobar).and_return(true)
+    obj.should_receive(:foobar).and_return(:baz)
+    obj.respond_to?(:foobar).should be_true
+    obj.foobar.should eq :baz
+  end
+
+  it "does not raise an exception for mock" do
+    obj = double("obj")
+    obj.should_receive(:respond_to?).with(:foobar).and_return(true)
+    obj.should_receive(:foobar).and_return(:baz)
+    obj.respond_to?(:foobar).should be_true
+    obj.foobar.should eq :baz
+  end
+
+end

data/support/gems/rspec-mocks-2.11.1/spec/rspec/mocks/bug_report_830_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+module RSpec
+  module Mocks
+    describe 'Calling a method that catches StandardError' do
+      class Foo
+        def self.foo
+          bar
+        rescue StandardError
+        end
+      end
+
+      it 'still reports mock failures' do
+        Foo.should_not_receive :bar
+        lambda do
+          Foo.foo
+        end.should raise_error(RSpec::Mocks::MockExpectationError)
+      end
+    end
+  end
+end

data/support/gems/rspec-mocks-2.11.1/spec/rspec/mocks/bug_report_957_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+module RSpec
+  module Mocks
+    describe "stubbing a base class class method" do
+      before do
+        @base_class     = Class.new
+        @concrete_class = Class.new(@base_class)
+
+        @base_class.stub(:find).and_return "stubbed_value"
+      end
+
+      it "returns the value for the stub on the base class" do
+        @base_class.find.should eq "stubbed_value"
+      end
+
+      it "returns the value for the descendent class" do
+        @concrete_class.find.should eq "stubbed_value"
+      end
+    end
+  end
+end

data/support/gems/rspec-mocks-2.11.1/spec/rspec/mocks/double_spec.rb

@@ -0,0 +1,12 @@
+require "spec_helper"
+
+describe "double" do
+  it "is an alias for stub and mock" do
+    double().should be_a(RSpec::Mocks::Mock)
+  end
+  
+  it "uses 'Double' in failure messages" do
+    double = double('name')
+    expect {double.foo}.to raise_error(/Double "name" received/)
+  end
+end

data/support/gems/rspec-mocks-2.11.1/spec/rspec/mocks/failing_argument_matchers_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper'
+
+module RSpec
+  module Mocks
+    describe "failing MockArgumentMatchers" do
+      before(:each) do
+        @double = double("double")
+        @reporter = double("reporter").as_null_object
+      end
+      
+      after(:each) do
+        @double.rspec_reset
+      end
+
+      it "rejects non boolean" do
+        @double.should_receive(:random_call).with(boolean())
+        expect do
+          @double.random_call("false")
+        end.to raise_error(RSpec::Mocks::MockExpectationError)
+      end
+
+      it "rejects non numeric" do
+        @double.should_receive(:random_call).with(an_instance_of(Numeric))
+        expect do
+          @double.random_call("1")
+        end.to raise_error(RSpec::Mocks::MockExpectationError)
+      end
+      
+      it "rejects non string" do
+        @double.should_receive(:random_call).with(an_instance_of(String))
+        expect do
+          @double.random_call(123)
+        end.to raise_error(RSpec::Mocks::MockExpectationError)
+      end
+      
+      it "rejects goose when expecting a duck" do
+        @double.should_receive(:random_call).with(duck_type(:abs, :div))
+        expect { @double.random_call("I don't respond to :abs or :div") }.to raise_error(RSpec::Mocks::MockExpectationError)
+      end
+
+      it "fails if regexp does not match submitted string" do
+        @double.should_receive(:random_call).with(/bcd/)
+        expect { @double.random_call("abc") }.to raise_error(RSpec::Mocks::MockExpectationError)
+      end
+      
+      it "fails if regexp does not match submitted regexp" do
+        @double.should_receive(:random_call).with(/bcd/)
+        expect { @double.random_call(/bcde/) }.to raise_error(RSpec::Mocks::MockExpectationError)
+      end
+      
+      it "fails for a hash w/ wrong values" do
+        @double.should_receive(:random_call).with(:a => "b", :c => "d")
+        expect do
+          @double.random_call(:a => "b", :c => "e")
+        end.to raise_error(RSpec::Mocks::MockExpectationError, /Double "double" received :random_call with unexpected arguments\n  expected: \(\{(:a=>\"b\", :c=>\"d\"|:c=>\"d\", :a=>\"b\")\}\)\n       got: \(\{(:a=>\"b\", :c=>\"e\"|:c=>\"e\", :a=>\"b\")\}\)/)
+      end
+      
+      it "fails for a hash w/ wrong keys" do
+        @double.should_receive(:random_call).with(:a => "b", :c => "d")
+        expect do
+          @double.random_call("a" => "b", "c" => "d")
+        end.to raise_error(RSpec::Mocks::MockExpectationError, /Double "double" received :random_call with unexpected arguments\n  expected: \(\{(:a=>\"b\", :c=>\"d\"|:c=>\"d\", :a=>\"b\")\}\)\n       got: \(\{(\"a\"=>\"b\", \"c\"=>\"d\"|\"c\"=>\"d\", \"a\"=>\"b\")\}\)/)
+      end
+      
+      it "matches against a Matcher" do
+        expect do
+          @double.should_receive(:msg).with(equal(3))
+          @double.msg(37)
+        end.to raise_error(RSpec::Mocks::MockExpectationError, "Double \"double\" received :msg with unexpected arguments\n  expected: (equal 3)\n       got: (37)")
+      end
+      
+      it "fails no_args with one arg" do
+        expect do
+          @double.should_receive(:msg).with(no_args)
+          @double.msg(37)
+        end.to raise_error(RSpec::Mocks::MockExpectationError, "Double \"double\" received :msg with unexpected arguments\n  expected: (no args)\n       got: (37)")
+      end
+      
+      it "fails hash_including with missing key" do
+         expect do
+           @double.should_receive(:msg).with(hash_including(:a => 1))
+           @double.msg({})
+         end.to raise_error(RSpec::Mocks::MockExpectationError, "Double \"double\" received :msg with unexpected arguments\n  expected: (hash_including(:a=>1))\n       got: ({})")
+      end
+
+      it "fails with block matchers" do
+        expect do
+          @double.should_receive(:msg).with {|arg| arg.should eq :received }
+          @double.msg :no_msg_for_you
+        end.to raise_error(RSpec::Expectations::ExpectationNotMetError, /expected: :received.*\s*.*got: :no_msg_for_you/)
+      end
+            
+    end
+  end
+end

data/support/gems/rspec-mocks-2.11.1/spec/rspec/mocks/hash_excluding_matcher_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+module RSpec
+  module Mocks
+    module ArgumentMatchers
+      describe HashExcludingMatcher do
+        
+        it "describes itself properly" do
+          HashExcludingMatcher.new(:a => 5).description.should eq "hash_not_including(:a=>5)"
+        end      
+
+        describe "passing" do
+          it "matches a hash without the specified key" do
+            hash_not_including(:c).should eq({:a => 1, :b => 2})
+          end
+          
+          it "matches a hash with the specified key, but different value" do
+            hash_not_including(:b => 3).should eq({:a => 1, :b => 2})
+          end
+                    
+          it "matches a hash without the specified key, given as anything()" do
+            hash_not_including(:c => anything).should eq({:a => 1, :b => 2})
+          end
+
+          it "matches an empty hash" do
+            hash_not_including(:a).should eq({})
+          end
+          
+          it "matches a hash without any of the specified keys" do
+            hash_not_including(:a, :b, :c).should eq({ :d => 7})
+          end
+          
+        end
+        
+        describe "failing" do
+          it "does not match a non-hash" do
+            hash_not_including(:a => 1).should_not == 1
+          end
+          
+          it "does not match a hash with a specified key" do
+            hash_not_including(:b).should_not == {:b => 2}
+          end
+          
+          it "does not match a hash with the specified key/value pair" do
+            hash_not_including(:b => 2).should_not == {:a => 1, :b => 2}
+          end
+          
+          it "does not match a hash with the specified key" do
+            hash_not_including(:a, :b => 3).should_not == {:a => 1, :b => 2}
+          end
+          
+          it "does not match a hash with one of the specified keys" do
+            hash_not_including(:a, :b).should_not == {:b => 2}
+          end
+          
+          it "does not match a hash with some of the specified keys" do
+            hash_not_including(:a, :b, :c).should_not == {:a => 1, :b => 2}
+          end
+          
+          it "does not match a hash with one key/value pair included" do
+            hash_not_including(:a, :b, :c, :d => 7).should_not == { :d => 7}
+          end
+        end
+      end
+    end
+  end
+end

data/support/gems/rspec-mocks-2.11.1/spec/rspec/mocks/hash_including_matcher_spec.rb

@@ -0,0 +1,90 @@
+require 'spec_helper'
+
+module RSpec
+  module Mocks
+    module ArgumentMatchers
+      describe HashIncludingMatcher do
+        
+        it "describes itself properly" do
+          HashIncludingMatcher.new(:a => 1).description.should eq "hash_including(:a=>1)"
+        end      
+
+        describe "passing" do
+          it "matches the same hash" do
+            hash_including(:a => 1).should eq({:a => 1})
+          end
+
+          it "matches a hash with extra stuff" do
+            hash_including(:a => 1).should eq({:a => 1, :b => 2})
+          end
+          
+          describe "when matching against other matchers" do
+            it "matches an int against anything()" do
+              hash_including(:a => anything, :b => 2).should eq({:a => 1, :b => 2})
+            end
+
+            it "matches a string against anything()" do
+              hash_including(:a => anything, :b => 2).should eq({:a => "1", :b => 2})
+            end
+          end
+          
+          describe "when passed only keys or keys mixed with key/value pairs" do
+            it "matches if the key is present" do
+              hash_including(:a).should eq({:a => 1, :b => 2})
+            end
+            
+            it "matches if more keys are present" do
+              hash_including(:a, :b).should eq({:a => 1, :b => 2, :c => 3})
+            end
+
+            it "matches a string against a given key" do
+              hash_including(:a).should eq({:a => "1", :b => 2})
+            end
+
+            it "matches if passed one key and one key/value pair" do
+              hash_including(:a, :b => 2).should eq({:a => 1, :b => 2})
+            end
+            
+            it "matches if passed many keys and one key/value pair" do
+              hash_including(:a, :b, :c => 3).should eq({:a => 1, :b => 2, :c => 3, :d => 4})
+            end
+            
+            it "matches if passed many keys and many key/value pairs" do
+              hash_including(:a, :b, :c => 3, :e => 5).should eq({:a => 1, :b => 2, :c => 3, :d => 4, :e => 5})
+            end
+          end
+        end
+        
+        describe "failing" do
+          it "does not match a non-hash" do
+            hash_including(:a => 1).should_not == 1
+          end
+
+          it "does not match a hash with a missing key" do
+            hash_including(:a => 1).should_not == {:b => 2}
+          end
+          
+          it "does not match a hash with a missing key" do
+            hash_including(:a).should_not == {:b => 2}
+          end
+          
+          it "does not match an empty hash with a given key" do
+            hash_including(:a).should_not == {}
+          end
+          
+          it "does not match a hash with a missing key when one pair is matching" do
+            hash_including(:a, :b => 2).should_not == {:b => 2}
+          end
+          
+          it "does not match a hash with an incorrect value" do
+            hash_including(:a => 1, :b => 2).should_not == {:a => 1, :b => 3}
+          end
+
+          it "does not match when values are nil but keys are different" do
+            hash_including(:a => nil).should_not == {:b => nil}
+          end
+        end
+      end
+    end
+  end
+end

data/support/gems/rspec-mocks-2.11.1/spec/rspec/mocks/mock_ordering_spec.rb

@@ -0,0 +1,103 @@
+require 'spec_helper'
+
+module RSpec
+  module Mocks
+
+    describe "ordering" do
+      before { @double = double("test double") }
+      after  { @double.rspec_reset }
+
+      it "passes when messages are received in order" do
+        @double.should_receive(:one).ordered
+        @double.should_receive(:two).ordered
+        @double.should_receive(:three).ordered
+        @double.one
+        @double.two
+        @double.three
+      end
+
+      it "passes when messages are received in order across objects" do
+        a = double("a")
+        b = double("b")
+        a.should_receive(:one).ordered
+        b.should_receive(:two).ordered
+        a.should_receive(:three).ordered
+        a.one
+        b.two
+        a.three
+      end
+
+      it "fails when messages are received out of order (2nd message 1st)" do
+        @double.should_receive(:one).ordered
+        @double.should_receive(:two).ordered
+        lambda do
+          @double.two
+        end.should raise_error(RSpec::Mocks::MockExpectationError, "Double \"test double\" received :two out of order")
+      end
+
+      it "fails when messages are received out of order (3rd message 1st)" do
+        @double.should_receive(:one).ordered
+        @double.should_receive(:two).ordered
+        @double.should_receive(:three).ordered
+        @double.one
+        lambda do
+          @double.three
+        end.should raise_error(RSpec::Mocks::MockExpectationError, "Double \"test double\" received :three out of order")
+      end
+
+      it "fails when messages are received out of order (3rd message 2nd)" do
+        @double.should_receive(:one).ordered
+        @double.should_receive(:two).ordered
+        @double.should_receive(:three).ordered
+        @double.one
+        lambda do
+          @double.three
+        end.should raise_error(RSpec::Mocks::MockExpectationError, "Double \"test double\" received :three out of order")
+      end
+
+      it "fails when messages are out of order across objects" do
+        a = double("test double")
+        b = double("another test double")
+        a.should_receive(:one).ordered
+        b.should_receive(:two).ordered
+        a.should_receive(:three).ordered
+        a.one
+        lambda do
+          a.three
+        end.should raise_error(RSpec::Mocks::MockExpectationError, "Double \"test double\" received :three out of order")
+        a.rspec_reset
+        b.rspec_reset
+      end
+
+      it "ignores order of non ordered messages" do
+        @double.should_receive(:ignored_0)
+        @double.should_receive(:ordered_1).ordered
+        @double.should_receive(:ignored_1)
+        @double.should_receive(:ordered_2).ordered
+        @double.should_receive(:ignored_2)
+        @double.should_receive(:ignored_3)
+        @double.should_receive(:ordered_3).ordered
+        @double.should_receive(:ignored_4)
+        @double.ignored_3
+        @double.ordered_1
+        @double.ignored_0
+        @double.ordered_2
+        @double.ignored_4
+        @double.ignored_2
+        @double.ordered_3
+        @double.ignored_1
+        @double.rspec_verify
+      end
+
+      it "supports duplicate messages" do
+        @double.should_receive(:a).ordered
+        @double.should_receive(:b).ordered
+        @double.should_receive(:a).ordered
+
+        @double.a
+        @double.b
+        @double.a
+      end
+    end
+  end
+end