deckshuffler 0.0.2

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

@@ -0,0 +1,113 @@
+require File.dirname(__FILE__) + '/../../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/plugins/rspec/spec/spec/mocks/null_object_mock_spec.rb

@@ -0,0 +1,40 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+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
+  end
+end

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

@@ -0,0 +1,53 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+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/plugins/rspec/spec/spec/mocks/options_hash_spec.rb

@@ -0,0 +1,42 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+module Spec
+  module Mocks
+    describe "calling :should_receive with an options hash" do
+      before do
+        @options = ::Spec::Runner::Options.new(StringIO.new, StringIO.new)
+        @reporter = ::Spec::Runner::Reporter.new(@options)
+        @behaviour = Class.new(::Spec::DSL::Example).describe("My Behaviour")
+      end
+
+      it "should report the file and line submitted with :expected_from" do
+        example_definition = @behaviour.create_example_definition "spec" do
+          mock = Spec::Mocks::Mock.new("a mock")
+          mock.should_receive(:message, :expected_from => "/path/to/blah.ext:37")
+          mock.rspec_verify
+        end
+        example = @behaviour.new(example_definition)
+        proxy = ::Spec::DSL::ExampleRunner.new(@options, example)
+        
+        @reporter.should_receive(:example_finished) do |spec, error|
+          error.backtrace.detect {|line| line =~ /\/path\/to\/blah.ext:37/}.should_not be_nil
+        end
+        proxy.run
+      end
+
+      it "should use the message supplied with :message" do
+        example_definition = @behaviour.create_example_definition "spec" do
+          mock = Spec::Mocks::Mock.new("a mock")
+          mock.should_receive(:message, :message => "recebi nada")
+          mock.rspec_verify
+        end
+        example = @behaviour.new(example_definition)
+        proxy = ::Spec::DSL::ExampleRunner.new(@options, example)
+        @reporter.should_receive(:example_finished) do |spec, error|
+          error.message.should == "recebi nada"
+        end
+        proxy.run
+      end
+    end
+  end
+end

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

@@ -0,0 +1,106 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+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/)
+      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)
+        @object.fuhbar
+        lambda do
+          @object.rspec_verify
+        end.should raise_error(Spec::Mocks::MockExpectationError)
+      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')
+        @object.foobar
+        lambda do
+          @object.rspec_verify
+        end.should raise_error(Spec::Mocks::MockExpectationError)
+      end
+      
+      it "should use report nil in the error message" do
+        @this_will_resolve_to_nil.should_receive(:foobar)
+        lambda do
+          @this_will_resolve_to_nil.rspec_verify
+        end.should raise_error(Spec::Mocks::MockExpectationError, /NilClass.*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
+  end
+end

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

@@ -0,0 +1,66 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+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/plugins/rspec/spec/spec/mocks/passing_mock_argument_constraints_spec.rb

@@ -0,0 +1,154 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+module Spec
+  module Mocks
+    describe "mock argument constraints", :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 constraints with DEPRECATED symbols" do
+      it_should_behave_like "mock argument constraints"
+
+      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 numeric" do
+        @mock.should_receive(:random_call).with(:numeric)
+        @mock.random_call(1)
+      end
+
+      it "should accept float as numeric" do
+        @mock.should_receive(:random_call).with(: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 string" do
+        @mock.should_receive(:random_call).with(:string)
+        @mock.random_call("a string")
+      end
+      
+      it "should match no args 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
+    end
+
+    describe Methods, "handling argument constraints" do
+      it_should_behave_like "mock argument constraints"
+
+      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 an_instance_of(Numeric)" do
+        @mock.should_receive(:random_call).with(an_instance_of(Numeric))
+        @mock.random_call(1)
+      end
+
+      it "should accept float as an_instance_of(Numeric)" do
+        @mock.should_receive(:random_call).with(an_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
+    end
+    
+    describe Methods, "handling non-constraint arguments" do
+
+      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
+      
+      it "should match against a Matcher" do
+        @mock.should_receive(:msg).with(equal(37))
+        @mock.msg(37)
+      end
+    end
+  end
+end