pupu 0.0.2 → 0.0.3.pre

data/vendor/rspec/spec/spec/mocks/multiple_return_value_spec.rb

@@ -1,113 +0,0 @@
-require 'spec_helper'
-
-module Spec
-  module Mocks
-    describe "a Mock expectation with multiple return values and no specified count" do
-      before(:each) do
-        @mock = Mock.new("mock")
-        @return_values = ["1",2,Object.new]
-        @mock.should_receive(:message).and_return(@return_values[0],@return_values[1],@return_values[2])
-      end
-      
-      it "should return values in order to consecutive calls" do
-        @mock.message.should == @return_values[0]
-        @mock.message.should == @return_values[1]
-        @mock.message.should == @return_values[2]
-        @mock.rspec_verify
-      end
-
-      it "should complain when there are too few calls" do
-        third = Object.new
-        @mock.message.should == @return_values[0]
-        @mock.message.should == @return_values[1]
-        lambda { @mock.rspec_verify }.should raise_error(MockExpectationError, "Mock \"mock\" expected :message with (any args) 3 times, but received it twice")
-      end
-
-      it "should complain when there are too many calls" do
-        third = Object.new
-        @mock.message.should == @return_values[0]
-        @mock.message.should == @return_values[1]
-        @mock.message.should == @return_values[2]
-        @mock.message.should == @return_values[2]
-        lambda { @mock.rspec_verify }.should raise_error(MockExpectationError, "Mock \"mock\" expected :message with (any args) 3 times, but received it 4 times")
-      end
-    end
-
-    describe "a Mock expectation with multiple return values with a specified count equal to the number of values" do
-      before(:each) do
-        @mock = Mock.new("mock")
-        @return_values = ["1",2,Object.new]
-        @mock.should_receive(:message).exactly(3).times.and_return(@return_values[0],@return_values[1],@return_values[2])
-      end
-
-      it "should return values in order to consecutive calls" do
-        @mock.message.should == @return_values[0]
-        @mock.message.should == @return_values[1]
-        @mock.message.should == @return_values[2]
-        @mock.rspec_verify
-      end
-
-      it "should complain when there are too few calls" do
-        third = Object.new
-        @mock.message.should == @return_values[0]
-        @mock.message.should == @return_values[1]
-        lambda { @mock.rspec_verify }.should raise_error(MockExpectationError, "Mock \"mock\" expected :message with (any args) 3 times, but received it twice")
-      end
-
-      it "should complain when there are too many calls" do
-        third = Object.new
-        @mock.message.should == @return_values[0]
-        @mock.message.should == @return_values[1]
-        @mock.message.should == @return_values[2]
-        @mock.message.should == @return_values[2]
-        lambda { @mock.rspec_verify }.should raise_error(MockExpectationError, "Mock \"mock\" expected :message with (any args) 3 times, but received it 4 times")
-      end
-    end
-
-    describe "a Mock expectation with multiple return values specifying at_least less than the number of values" do
-      before(:each) do
-        @mock = Mock.new("mock")
-        @mock.should_receive(:message).at_least(:twice).with(no_args).and_return(11, 22)
-      end
-      
-      it "should use last return value for subsequent calls" do
-        @mock.message.should equal(11)
-        @mock.message.should equal(22)
-        @mock.message.should equal(22)
-        @mock.rspec_verify
-      end
-
-      it "should fail when called less than the specified number" do
-        @mock.message.should equal(11)
-        lambda { @mock.rspec_verify }.should raise_error(MockExpectationError, "Mock \"mock\" expected :message with (no args) twice, but received it once")
-      end
-    end
-    describe "a Mock expectation with multiple return values with a specified count larger than the number of values" do
-      before(:each) do
-        @mock = Mock.new("mock")
-        @mock.should_receive(:message).exactly(3).times.and_return(11, 22)
-      end
-      
-      it "should use last return value for subsequent calls" do
-        @mock.message.should equal(11)
-        @mock.message.should equal(22)
-        @mock.message.should equal(22)
-        @mock.rspec_verify
-      end
-
-      it "should fail when called less than the specified number" do
-        @mock.message.should equal(11)
-        lambda { @mock.rspec_verify }.should raise_error(MockExpectationError, "Mock \"mock\" expected :message with (any args) 3 times, but received it once")
-      end
-
-      it "should fail when called greater than the specified number" do
-        @mock.message.should equal(11)
-        @mock.message.should equal(22)
-        @mock.message.should equal(22)
-        @mock.message.should equal(22)
-        lambda { @mock.rspec_verify }.should raise_error(MockExpectationError, "Mock \"mock\" expected :message with (any args) 3 times, but received it 4 times")
-      end
-    end
-  end
-end
-

data/vendor/rspec/spec/spec/mocks/nil_expectation_warning_spec.rb

@@ -1,53 +0,0 @@
-require 'spec_helper'
-
-module Spec
-  module Mocks
-
-    describe "an expectation set on nil" do
-      
-      it "should issue a warning with file and line number information" do
-        expected_warning = %r%An expectation of :foo was set on nil. Called from #{__FILE__}:#{__LINE__+3}(:in `block \(2 levels\) in <module:Mocks>')?. Use allow_message_expectations_on_nil to disable warnings.%
-        Kernel.should_receive(:warn).with(expected_warning)
-
-        nil.should_receive(:foo)
-        nil.foo
-      end
-      
-      it "should issue a warning when the expectation is negative" do
-        Kernel.should_receive(:warn)
-
-        nil.should_not_receive(:foo)
-      end
-      
-      it "should not issue a warning when expectations are set to be allowed" do
-        allow_message_expectations_on_nil
-        Kernel.should_not_receive(:warn)
-        
-        nil.should_receive(:foo)
-        nil.should_not_receive(:bar)
-        nil.foo
-      end
-
-    end
-    
-    describe "#allow_message_expectations_on_nil" do
-      
-      it "should not effect subsequent examples" do
-        example_group = Class.new(::Spec::Example::ExampleGroupDouble)
-        example_group.it("when called in one example that doesn't end up setting an expectation on nil") do
-                        allow_message_expectations_on_nil
-                      end
-        example_group.it("should not effect the next exapmle ran") do
-                        Kernel.should_receive(:warn)
-                        nil.should_receive(:foo)
-                        nil.foo
-                      end
-                              
-        example_group.run(Spec::Runner.options).should be_true
-                  
-      end
-
-    end
-    
-  end
-end

data/vendor/rspec/spec/spec/mocks/null_object_mock_spec.rb

@@ -1,54 +0,0 @@
-require 'spec_helper'
-
-module Spec
-  module Mocks
-    describe "a mock acting as a NullObject" do
-      before(:each) do
-        @mock = Mock.new("null_object", :null_object => true)
-      end
-
-      it "should allow explicit expectation" do
-        @mock.should_receive(:something)
-        @mock.something
-      end
-
-      it "should fail verification when explicit exception not met" do
-        lambda do
-          @mock.should_receive(:something)
-          @mock.rspec_verify
-        end.should raise_error(MockExpectationError)
-      end
-
-      it "should ignore unexpected methods" do
-        @mock.random_call("a", "d", "c")
-        @mock.rspec_verify
-      end
-
-      it "should expected message with different args first" do
-        @mock.should_receive(:message).with(:expected_arg)
-        @mock.message(:unexpected_arg)
-        @mock.message(:expected_arg)
-      end
-
-      it "should expected message with different args second" do
-        @mock.should_receive(:message).with(:expected_arg)
-        @mock.message(:expected_arg)
-        @mock.message(:unexpected_arg)
-      end
-    end
-
-    describe "#null_object?" do
-      it "should default to false" do
-        obj = mock('anything')
-        obj.should_not be_null_object
-      end
-    end
-    
-    describe "#as_null_object" do
-      it "should set the object to null_object" do
-        obj = mock('anything').as_null_object
-        obj.should be_null_object
-      end
-    end
-  end
-end

data/vendor/rspec/spec/spec/mocks/once_counts_spec.rb

@@ -1,53 +0,0 @@
-require 'spec_helper'
-
-module Spec
-  module Mocks
-    describe "OnceCounts" do
-      before(:each) do
-        @mock = mock("test mock")
-      end
-
-      it "once should fail when called once with wrong args" do
-        @mock.should_receive(:random_call).once.with("a", "b", "c")
-        lambda do
-          @mock.random_call("d", "e", "f")
-        end.should raise_error(MockExpectationError)
-        @mock.rspec_reset
-      end
-
-      it "once should fail when called twice" do
-        @mock.should_receive(:random_call).once
-        @mock.random_call
-        @mock.random_call
-        lambda do
-          @mock.rspec_verify
-        end.should raise_error(MockExpectationError)
-      end
-      
-      it "once should fail when not called" do
-        @mock.should_receive(:random_call).once
-        lambda do
-          @mock.rspec_verify
-        end.should raise_error(MockExpectationError)
-      end
-
-      it "once should pass when called once" do
-        @mock.should_receive(:random_call).once
-        @mock.random_call
-        @mock.rspec_verify
-      end
-
-      it "once should pass when called once with specified args" do
-        @mock.should_receive(:random_call).once.with("a", "b", "c")
-        @mock.random_call("a", "b", "c")
-        @mock.rspec_verify
-      end
-
-      it "once should pass when called once with unspecified args" do
-        @mock.should_receive(:random_call).once
-        @mock.random_call("a", "b", "c")
-        @mock.rspec_verify
-      end
-    end
-  end
-end

data/vendor/rspec/spec/spec/mocks/options_hash_spec.rb

@@ -1,35 +0,0 @@
-require 'spec_helper'
-
-module Spec
-  module Mocks
-    describe "calling :should_receive with an options hash" do
-      it "should report the file and line submitted with :expected_from" do
-        begin
-          mock = Spec::Mocks::Mock.new("a mock")
-          mock.should_receive(:message, :expected_from => "/path/to/blah.ext:37")
-          mock.rspec_verify
-        rescue Exception => e
-        ensure
-          e.backtrace.to_s.should =~ /\/path\/to\/blah.ext:37/m
-        end
-      end
-
-      it "should use the message supplied with :message" do
-        lambda {
-          m = Spec::Mocks::Mock.new("a mock")
-          m.should_receive(:message, :message => "recebi nada")
-          m.rspec_verify
-        }.should raise_error("recebi nada")
-      end
-      
-      it "should use the message supplied with :message after a similar stub" do
-        lambda {
-          m = Spec::Mocks::Mock.new("a mock")
-          m.stub!(:message)
-          m.should_receive(:message, :message => "from mock")
-          m.rspec_verify
-        }.should raise_error("from mock")
-      end
-    end
-  end
-end

data/vendor/rspec/spec/spec/mocks/partial_mock_spec.rb

@@ -1,164 +0,0 @@
-require 'spec_helper'
-
-module Spec
-  module Mocks
-    describe "using a Partial Mock," do
-      before(:each) do
-        @object = Object.new
-      end
-    
-      it "should name the class in the failure message" do
-        @object.should_receive(:foo)
-        lambda do
-          @object.rspec_verify
-        end.should raise_error(Spec::Mocks::MockExpectationError, /<Object:.*> expected/)
-      end
-    
-      it "should name the class in the failure message when expectation is on class" do
-        Object.should_receive(:foo)
-        lambda do
-          Object.rspec_verify
-        end.should raise_error(Spec::Mocks::MockExpectationError, /<Object \(class\)>/)
-      end
-    
-      it "should not conflict with @options in the object" do
-        @object.instance_eval { @options = Object.new }
-        @object.should_receive(:blah)
-        @object.blah
-      end
-            
-      it "should_not_receive should mock out the method" do
-        @object.should_not_receive(:fuhbar)
-        lambda do
-          @object.fuhbar
-        end.should raise_error(MockExpectationError, /<Object:.*> expected :fuhbar with \(no args\) 0 times/)
-      end
-    
-      it "should_not_receive should return a negative message expectation" do
-        @object.should_not_receive(:foobar).should be_kind_of(NegativeMessageExpectation)
-      end
-    
-      it "should_receive should mock out the method" do
-        @object.should_receive(:foobar).with(:test_param).and_return(1)
-        @object.foobar(:test_param).should equal(1)
-      end
-    
-      it "should_receive should handle a hash" do
-        @object.should_receive(:foobar).with(:key => "value").and_return(1)
-        @object.foobar(:key => "value").should equal(1)
-      end
-    
-      it "should_receive should handle an inner hash" do
-        hash = {:a => {:key => "value"}}
-        @object.should_receive(:foobar).with(:key => "value").and_return(1)
-        @object.foobar(hash[:a]).should equal(1)
-      end
-    
-      it "should_receive should return a message expectation" do
-        @object.should_receive(:foobar).should be_kind_of(MessageExpectation)
-        @object.foobar
-      end
-    
-      it "should_receive should verify method was called" do
-        @object.should_receive(:foobar).with(:test_param).and_return(1)
-        lambda do
-          @object.rspec_verify
-        end.should raise_error(Spec::Mocks::MockExpectationError)
-      end
-    
-      it "should_receive should also take a String argument" do
-        @object.should_receive('foobar')
-        @object.foobar
-      end
-      
-      it "should_not_receive should also take a String argument" do
-        @object.should_not_receive('foobar')
-        lambda do
-          @object.foobar   
-        end.should raise_error(Spec::Mocks::MockExpectationError)
-      end
-      
-      it "should use report nil in the error message" do
-        allow_message_expectations_on_nil
-        
-        @this_will_resolve_to_nil.should_receive(:foobar)
-        lambda do
-          @this_will_resolve_to_nil.rspec_verify
-        end.should raise_error(Spec::Mocks::MockExpectationError, /nil expected :foobar with/)
-      end
-    end
-    
-    describe "Partially mocking an object that defines ==, after another mock has been defined" do
-      before(:each) do
-        stub("existing mock", :foo => :foo)
-      end
-      
-      class PartiallyMockedEquals
-        attr_reader :val
-        def initialize(val)
-          @val = val
-        end
-        
-        def ==(other)
-          @val == other.val
-        end
-      end
-      
-      it "should not raise an error when stubbing the object" do
-        o = PartiallyMockedEquals.new :foo
-        lambda { o.stub!(:bar) }.should_not raise_error(NoMethodError)
-      end
-    end
-
-    describe "Method visibility when using partial mocks" do
-      class MockableClass
-        def public_method
-          private_method
-          protected_method
-        end
-        protected
-        def protected_method; end
-        private
-        def private_method; end
-      end
-
-      before(:each) do
-        @object = MockableClass.new
-      end
-
-      it 'should keep public methods public' do
-        @object.should_receive(:public_method)
-        with_ruby('1.9') do
-          @object.public_methods.should include(:public_method)
-        end
-        with_ruby('1.8') do
-          @object.public_methods.should include('public_method')
-        end
-        @object.public_method
-      end
-
-      it 'should keep private methods private' do
-        @object.should_receive(:private_method)
-        with_ruby('1.9') do
-          @object.private_methods.should include(:private_method)
-        end
-        with_ruby('1.8') do
-          @object.private_methods.should include('private_method')
-        end
-        @object.public_method
-      end
-
-      it 'should keep protected methods protected' do
-        @object.should_receive(:protected_method)
-        with_ruby('1.9') do
-          @object.protected_methods.should include(:protected_method)
-        end
-        with_ruby('1.8') do
-          @object.protected_methods.should include('protected_method')
-        end
-        @object.public_method
-      end
-
-    end
-  end
-end

data/vendor/rspec/spec/spec/mocks/partial_mock_using_mocks_directly_spec.rb

@@ -1,66 +0,0 @@
-require 'spec_helper'
-
-module Spec
-module Mocks
-describe "PartialMockUsingMocksDirectly" do
-    before(:each) do
-      
-        klass=Class.new
-        klass.class_eval do
-          def existing_method
-            :original_value
-          end
-        end
-        @obj = klass.new
-      
-    end
-    
-    # See http://rubyforge.org/tracker/index.php?func=detail&aid=10263&group_id=797&atid=3149
-    # specify "should clear expectations on verify" do
-    #     @obj.should_receive(:msg)
-    #     @obj.msg
-    #     @obj.rspec_verify
-    #     lambda do
-    #       @obj.msg
-    #     end.should raise_error(NoMethodError)
-    #   
-    # end
-    it "should fail when expected message is not received" do
-        @obj.should_receive(:msg)
-        lambda do
-          @obj.rspec_verify
-        end.should raise_error(MockExpectationError)
-      
-    end
-    it "should fail when message is received with incorrect args" do
-        @obj.should_receive(:msg).with(:correct_arg)
-        lambda do
-          @obj.msg(:incorrect_arg)
-        end.should raise_error(MockExpectationError)
-        @obj.msg(:correct_arg)
-      
-    end
-    it "should pass when expected message is received" do
-        @obj.should_receive(:msg)
-        @obj.msg
-        @obj.rspec_verify
-      
-    end
-    it "should pass when message is received with correct args" do
-        @obj.should_receive(:msg).with(:correct_arg)
-        @obj.msg(:correct_arg)
-        @obj.rspec_verify
-      
-    end
-    it "should revert to original method if existed" do
-        @obj.existing_method.should equal(:original_value)
-        @obj.should_receive(:existing_method).and_return(:mock_value)
-        @obj.existing_method.should equal(:mock_value)
-        @obj.rspec_verify
-        @obj.existing_method.should equal(:original_value)
-      
-    end
-  
-end
-end
-end

data/vendor/rspec/spec/spec/mocks/passing_argument_matchers_spec.rb

@@ -1,145 +0,0 @@
-require 'spec_helper'
-
-module Spec
-  module Mocks
-    describe "mock argument matchers", :shared => true do
-      before(:each) do
-        @mock = Mock.new("test mock")
-        Kernel.stub!(:warn)
-      end
-      
-      after(:each) do
-        @mock.rspec_verify
-      end
-    end
-    
-    describe Methods, "handling argument matchers" do
-      it_should_behave_like "mock argument matchers"
-
-      it "should accept true as boolean()" do
-        @mock.should_receive(:random_call).with(boolean())
-        @mock.random_call(true)
-      end
-
-      it "should accept false as boolean()" do
-        @mock.should_receive(:random_call).with(boolean())
-        @mock.random_call(false)
-      end
-
-      it "should accept fixnum as kind_of(Numeric)" do
-        @mock.should_receive(:random_call).with(kind_of(Numeric))
-        @mock.random_call(1)
-      end
-
-      it "should accept float as an_instance_of(Numeric)" do
-        @mock.should_receive(:random_call).with(kind_of(Numeric))
-        @mock.random_call(1.5)
-      end
-      
-      it "accepts fixnum as instance_of(Fixnum)" do
-        @mock.should_receive(:random_call).with(instance_of(Fixnum))
-        @mock.random_call(1)
-      end
-
-      it "should NOT accept fixnum as instance_of(Numeric)" do
-        @mock.should_not_receive(:random_call).with(instance_of(Numeric))
-        @mock.random_call(1)
-      end
-
-      it "should NOT accept float as instance_of(Numeric)" do
-        @mock.should_not_receive(:random_call).with(instance_of(Numeric))
-        @mock.random_call(1.5)
-      end
-
-      it "should accept string as anything()" do
-        @mock.should_receive(:random_call).with("a", anything(), "c")
-        @mock.random_call("a", "whatever", "c")
-      end
-
-      it "should match duck type with one method" do
-        @mock.should_receive(:random_call).with(duck_type(:length))
-        @mock.random_call([])
-      end
-
-      it "should match duck type with two methods" do
-        @mock.should_receive(:random_call).with(duck_type(:abs, :div))
-        @mock.random_call(1)
-      end
-      
-      it "should match no args against any_args()" do
-        @mock.should_receive(:random_call).with(any_args)
-        @mock.random_call()
-      end
-      
-      it "should match one arg against any_args()" do
-        @mock.should_receive(:random_call).with(any_args)
-        @mock.random_call("a string")
-      end
-      
-      it "should match no args against no_args()" do
-        @mock.should_receive(:random_call).with(no_args)
-        @mock.random_call()
-      end
-      
-      it "should match hash with hash_including same hash" do
-        @mock.should_receive(:random_call).with(hash_including(:a => 1))
-        @mock.random_call(:a => 1)
-      end
-        
-    end
-
-    describe Methods, "handling block matchers" do
-      it_should_behave_like "mock argument matchers"
-      
-      it "should match arguments against RSpec expectations" do
-        @mock.should_receive(:random_call).with {|arg1, arg2, arr, *rest|
-          arg1.should == 5
-          arg2.should have_at_least(3).characters
-          arg2.should have_at_most(10).characters
-          arr.map {|i| i * 2}.should == [2,4,6]
-          rest.should == [:fee, "fi", 4]
-        }
-        @mock.random_call 5, "hello", [1,2,3], :fee, "fi", 4
-      end
-    end
-    
-    describe Methods, "handling non-matcher arguments" do
-      
-      before(:each) do
-        @mock = Mock.new("test mock")
-      end
-      
-      it "should match non special symbol (can be removed when deprecated symbols are removed)" do
-        @mock.should_receive(:random_call).with(:some_symbol)
-        @mock.random_call(:some_symbol)
-      end
-
-      it "should match string against regexp" do
-        @mock.should_receive(:random_call).with(/bcd/)
-        @mock.random_call("abcde")
-      end
-
-      it "should match regexp against regexp" do
-        @mock.should_receive(:random_call).with(/bcd/)
-        @mock.random_call(/bcd/)
-      end
-      
-      it "should match against a hash submitted and received by value" do
-        @mock.should_receive(:random_call).with(:a => "a", :b => "b")
-        @mock.random_call(:a => "a", :b => "b")
-      end
-      
-      it "should match against a hash submitted by reference and received by value" do
-        opts = {:a => "a", :b => "b"}
-        @mock.should_receive(:random_call).with(opts)
-        @mock.random_call(:a => "a", :b => "b")
-      end
-      
-      it "should match against a hash submitted by value and received by reference" do
-        opts = {:a => "a", :b => "b"}
-        @mock.should_receive(:random_call).with(:a => "a", :b => "b")
-        @mock.random_call(opts)
-      end
-    end
-  end
-end