gem_repackager 0.1.0

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

@@ -0,0 +1,68 @@
+require 'spec_helper'
+
+module RSpec
+  module Mocks
+    describe "stub implementation" do
+      describe "with no args" do
+        it "execs the block when called" do
+          obj = stub()
+          obj.stub(:foo) { :bar }
+          obj.foo.should eq :bar
+        end
+      end
+
+      describe "with one arg" do
+        it "execs the block with that arg when called" do
+          obj = stub()
+          obj.stub(:foo) {|given| given}
+          obj.foo(:bar).should eq :bar
+        end
+      end
+
+      describe "with variable args" do
+        it "execs the block when called" do
+          obj = stub()
+          obj.stub(:foo) {|*given| given.first}
+          obj.foo(:bar).should eq :bar
+        end        
+      end
+    end
+
+  
+    describe "unstub implementation" do      
+      it "replaces the stubbed method with the original method" do
+        obj = Object.new
+        def obj.foo; :original; end
+        obj.stub(:foo)
+        obj.unstub(:foo)
+        obj.foo.should eq :original
+      end
+    
+      it "removes all stubs with the supplied method name" do
+        obj = Object.new
+        def obj.foo; :original; end
+        obj.stub(:foo).with(1)
+        obj.stub(:foo).with(2)
+        obj.unstub(:foo)
+        obj.foo.should eq :original
+      end
+    
+      it "does not remove any expectations with the same method name" do
+        obj = Object.new
+        def obj.foo; :original; end
+        obj.should_receive(:foo).with(3).and_return(:three)
+        obj.stub(:foo).with(1)
+        obj.stub(:foo).with(2)
+        obj.unstub(:foo)
+        obj.foo(3).should eq :three
+      end
+    
+      it "raises a MockExpectationError if the method has not been stubbed" do
+        obj = Object.new
+        lambda do
+          obj.unstub(:foo)
+        end.should raise_error(RSpec::Mocks::MockExpectationError)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,238 @@
+require 'spec_helper'
+
+module RSpec
+  module Mocks
+    describe "A method stub" do
+      before(:each) do
+        @class = Class.new do
+          class << self
+            def existing_class_method
+              existing_private_class_method
+            end
+
+            private
+            def existing_private_class_method
+              :original_value
+            end
+          end
+
+          def existing_instance_method
+            existing_private_instance_method
+          end
+
+          private
+          def existing_private_instance_method
+            :original_value
+          end
+        end
+        @instance = @class.new
+        @stub = Object.new
+      end
+
+      [:stub!, :stub].each do |method|
+        describe "using #{method}" do
+          it "returns declared value when message is received" do
+            @instance.send(method, :msg).and_return(:return_value)
+            @instance.msg.should equal(:return_value)
+            @instance.rspec_verify
+          end
+        end
+      end
+
+      it "instructs an instance to respond_to the message" do
+        @instance.stub(:msg)
+        @instance.should respond_to(:msg)
+      end
+
+      it "instructs a class object to respond_to the message" do
+        @class.stub(:msg)
+        @class.should respond_to(:msg)
+      end
+
+      it "ignores when expected message is received with no args" do
+        @instance.stub(:msg)
+        @instance.msg
+        expect do
+          @instance.rspec_verify
+        end.not_to raise_error
+      end
+
+      it "ignores when message is received with args" do
+        @instance.stub(:msg)
+        @instance.msg(:an_arg)
+        expect do
+          @instance.rspec_verify
+        end.not_to raise_error
+      end
+
+      it "ignores when expected message is not received" do
+        @instance.stub(:msg)
+        expect do
+          @instance.rspec_verify
+        end.not_to raise_error
+      end
+
+      it "handles multiple stubbed methods" do
+        @instance.stub(:msg1 => 1, :msg2 => 2)
+        @instance.msg1.should eq(1)
+        @instance.msg2.should eq(2)
+      end
+
+      describe "#rspec_reset" do
+        it "removes stubbed methods that didn't exist" do
+          @instance.stub(:non_existent_method)
+          @instance.rspec_reset
+          @instance.should_not respond_to(:non_existent_method)
+        end
+
+        it "restores existing instance methods" do
+          # See bug reports 8302 adn 7805
+          @instance.stub(:existing_instance_method) { :stub_value }
+          @instance.rspec_reset
+          @instance.existing_instance_method.should eq(:original_value)
+        end
+
+        it "restores existing private instance methods" do
+          # See bug reports 8302 adn 7805
+          @instance.stub(:existing_private_instance_method) { :stub_value }
+          @instance.rspec_reset
+          @instance.send(:existing_private_instance_method).should eq(:original_value)
+        end
+
+        it "restores existing class methods" do
+          # See bug reports 8302 adn 7805
+          @class.stub(:existing_class_method) { :stub_value }
+          @class.rspec_reset
+          @class.existing_class_method.should eq(:original_value)
+        end
+
+        it "restores existing private class methods" do
+          # See bug reports 8302 adn 7805
+          @class.stub(:existing_private_class_method) { :stub_value }
+          @class.rspec_reset
+          @class.send(:existing_private_class_method).should eq(:original_value)
+        end
+      end
+
+      it "returns values in order to consecutive calls" do
+        @instance.stub(:msg).and_return("1",2,:three)
+        @instance.msg.should eq("1")
+        @instance.msg.should eq(2)
+        @instance.msg.should eq(:three)
+      end
+
+      it "keeps returning last value in consecutive calls" do
+        @instance.stub(:msg).and_return("1",2,:three)
+        @instance.msg.should eq("1")
+        @instance.msg.should eq(2)
+        @instance.msg.should eq(:three)
+        @instance.msg.should eq(:three)
+        @instance.msg.should eq(:three)
+      end
+
+      it "yields a specified object" do
+        @instance.stub(:method_that_yields).and_yield(:yielded_obj)
+        current_value = :value_before
+        @instance.method_that_yields {|val| current_value = val}
+        current_value.should eq :yielded_obj
+        @instance.rspec_verify
+      end
+
+      it "yields multiple times with multiple calls to and_yield" do
+        @instance.stub(:method_that_yields_multiple_times).and_yield(:yielded_value).
+                                                       and_yield(:another_value)
+        current_value = []
+        @instance.method_that_yields_multiple_times {|val| current_value << val}
+        current_value.should eq [:yielded_value, :another_value]
+        @instance.rspec_verify
+      end
+
+      it "yields a specified object and return another specified object" do
+        yielded_obj = double("my mock")
+        yielded_obj.should_receive(:foo).with(:bar)
+        @instance.stub(:method_that_yields_and_returns).and_yield(yielded_obj).and_return(:baz)
+        @instance.method_that_yields_and_returns { |o| o.foo :bar }.should eq :baz
+      end
+
+      it "throws when told to" do
+        @stub.stub(:something).and_throw(:up)
+        expect { @stub.something }.to throw_symbol(:up)
+      end
+
+      it "throws with argument when told to" do
+        @stub.stub(:something).and_throw(:up, 'high')
+        expect { @stub.something }.to throw_symbol(:up, 'high')
+      end
+
+      it "overrides a pre-existing method" do
+        @stub.stub(:existing_instance_method).and_return(:updated_stub_value)
+        @stub.existing_instance_method.should eq :updated_stub_value
+      end
+
+      it "overrides a pre-existing stub" do
+        @stub.stub(:foo) { 'bar' }
+        @stub.stub(:foo) { 'baz' }
+        @stub.foo.should eq 'baz'
+      end
+
+      it "allows a stub and an expectation" do
+        @stub.stub(:foo).with("bar")
+        @stub.should_receive(:foo).with("baz")
+        @stub.foo("bar")
+        @stub.foo("baz")
+      end
+
+      it "calculates return value by executing block passed to #and_return" do
+        @stub.stub(:something).with("a","b","c").and_return { |a,b,c| c+b+a }
+        @stub.something("a","b","c").should eq "cba"
+        @stub.rspec_verify
+      end
+    end
+
+    describe "A method stub with args" do
+      before(:each) do
+        @stub = Object.new
+        @stub.stub(:foo).with("bar")
+      end
+
+      it "does not complain if not called" do
+      end
+
+      it "does not complain if called with arg" do
+        @stub.foo("bar")
+      end
+
+      it "complains if called with no arg" do
+        lambda do
+          @stub.foo
+        end.should raise_error(/received :foo with unexpected arguments/)
+      end
+
+      it "complains if called with other arg", :github_issue => [123,147] do
+        lambda do
+          @stub.foo("other")
+        end.should raise_error(/received :foo with unexpected arguments.*Please stub a default value/m)
+      end
+
+      it "does not complain if also mocked w/ different args" do
+        @stub.should_receive(:foo).with("baz")
+        @stub.foo("bar")
+        @stub.foo("baz")
+      end
+
+      it "complains if also mocked w/ different args AND called w/ a 3rd set of args" do
+        @stub.should_receive(:foo).with("baz")
+        @stub.foo("bar")
+        @stub.foo("baz")
+        lambda do
+          @stub.foo("other")
+        end.should raise_error
+      end
+
+      it "supports options" do
+        @stub.stub(:foo, :expected_from => "bar")
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe "expection set on previously stubbed method" do
+  it "fails if message is not received after expectation is set" do
+    double = double(:msg => nil)
+    double.msg
+    double.should_receive(:msg)
+    lambda { double.rspec_verify }.should raise_error(RSpec::Mocks::MockExpectationError)
+  end
+
+  it "outputs arguments of similar calls" do
+    double = double('double', :foo => true)
+    double.should_receive(:foo).with('first')
+    double.foo('second')
+    double.foo('third')
+    lambda do
+      double.rspec_verify
+    end.should raise_error(%Q|Double "double" received :foo with unexpected arguments\n  expected: ("first")\n       got: ("second"), ("third")|)
+    double.rspec_reset
+  end
+
+  context "with argument constraint on stub" do
+    it "matches any args if no arg constraint set on expectation" do
+      double = double("mock")
+      double.stub(:foo).with(3).and_return("stub")
+      double.should_receive(:foo).at_least(:once).and_return("expectation")
+      double.foo
+      double.rspec_verify
+    end
+
+    it "matches specific args set on expectation" do
+      double = double("mock")
+      double.stub(:foo).with(3).and_return("stub")
+      double.should_receive(:foo).at_least(:once).with(4).and_return("expectation")
+      double.foo(4)
+      double.rspec_verify
+    end
+
+    it "fails if expectation's arg constraint is not met" do
+      double = double("mock")
+      double.stub(:foo).with(3).and_return("stub")
+      double.should_receive(:foo).at_least(:once).with(4).and_return("expectation")
+      double.foo(3)
+      expect { double.rspec_verify }.to raise_error(/expected: \(4\)\s+got: \(3\)/)
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+module RSpec
+  module Mocks
+    describe TestDouble do
+      before(:all) do
+        Module.class_eval do
+          private
+          def use; end
+        end
+      end
+
+      after(:all) do
+        Module.class_eval do
+          undef use
+        end
+      end
+
+      it 'can be extended onto a module to make it a pure test double that can mock private methods' do
+        double = Module.new
+        double.stub(:use)
+        expect { double.use }.to raise_error(/private method `use' called/)
+
+        double = Module.new { TestDouble.extend_onto(self) }
+        double.should_receive(:use).and_return(:ok)
+        double.use.should be(:ok)
+      end
+
+      it 'sets the test double name when a name is passed' do
+        double = Module.new { TestDouble.extend_onto(self, "MyDouble") }
+        expect { double.foo }.to raise_error(/Mock "MyDouble" received/)
+      end
+
+      it 'stubs the methods passed in the stubs hash' do
+        double = Module.new do
+          TestDouble.extend_onto(self, "MyDouble", :a => 5, :b => 10)
+        end
+
+        double.a.should eq(5)
+        double.b.should eq(10)
+      end
+
+      it 'indicates what type of test double it is in error messages' do
+        double = Module.new do
+          TestDouble.extend_onto(self, "A", :__declared_as => "ModuleMock")
+        end
+        expect { double.foo }.to raise_error(/ModuleMock "A"/)
+      end
+
+      it 'is declared as a mock by default' do
+        double = Module.new { TestDouble.extend_onto(self) }
+        expect { double.foo }.to raise_error(/Mock received/)
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,40 @@
+require "spec_helper"
+
+describe "a double receiving to_ary" do
+  shared_examples "to_ary" do
+    it "returns nil" do
+      expect do
+        obj.to_ary.should be_nil
+      end.to raise_error(NoMethodError)
+    end
+    
+    it "doesn't respond" do
+      obj.should_not respond_to(:to_ary)
+    end
+
+    it "can be overridden with a stub" do
+      obj.stub(:to_ary) { :non_nil_value }
+      obj.to_ary.should be(:non_nil_value)
+    end
+    
+    it "responds when overriden" do
+      obj.stub(:to_ary) { :non_nil_value }
+      obj.should respond_to(:to_ary)
+    end
+
+    it "supports Array#flatten" do
+      obj = double('foo')
+      [obj].flatten.should eq([obj])
+    end
+  end
+
+  context "double as_null_object" do
+    let(:obj) { double('obj').as_null_object }
+    include_examples "to_ary"
+  end
+
+  context "double without as_null_object" do
+    let(:obj) { double('obj') }
+    include_examples "to_ary"
+  end
+end