deckshuffler 0.0.2

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

@@ -0,0 +1,52 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+module Spec
+  module Mocks
+    describe "PreciseCounts" do
+      before(:each) do
+        @mock = mock("test mock")
+      end
+
+      it "should fail when exactly n times method is called less than n times" do
+        @mock.should_receive(:random_call).exactly(3).times
+        @mock.random_call
+        @mock.random_call
+        lambda do
+          @mock.rspec_verify
+        end.should raise_error(MockExpectationError)
+      end
+
+      it "should fail when exactly n times method is never called" do
+        @mock.should_receive(:random_call).exactly(3).times
+        lambda do
+          @mock.rspec_verify
+        end.should raise_error(MockExpectationError)
+      end
+
+      it "should pass if exactly n times method is called exactly n times" do
+        @mock.should_receive(:random_call).exactly(3).times
+        @mock.random_call
+        @mock.random_call
+        @mock.random_call
+        @mock.rspec_verify
+      end
+
+      it "should pass multiple calls with different args and counts" do
+        @mock.should_receive(:random_call).twice.with(1)
+        @mock.should_receive(:random_call).once.with(2)
+        @mock.random_call(1)
+        @mock.random_call(2)
+        @mock.random_call(1)
+        @mock.rspec_verify
+      end
+
+      it "should pass mutiple calls with different args" do
+        @mock.should_receive(:random_call).once.with(1)
+        @mock.should_receive(:random_call).once.with(2)
+        @mock.random_call(1)
+        @mock.random_call(2)
+        @mock.rspec_verify
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+module Spec
+  module Mocks
+    describe "a mock" do
+      before(:each) do
+        @mock = mock("mock", :null_object => true)
+      end
+      it "should answer false for received_message? when no messages received" do
+        @mock.received_message?(:message).should be_false
+      end
+      it "should answer true for received_message? when message received" do
+        @mock.message
+        @mock.received_message?(:message).should be_true
+      end
+      it "should answer true for received_message? when message received with correct args" do
+        @mock.message 1,2,3
+        @mock.received_message?(:message, 1,2,3).should be_true
+      end
+      it "should answer false for received_message? when message received with incorrect args" do
+        @mock.message 1,2,3
+        @mock.received_message?(:message, 1,2).should be_false
+      end
+    end
+  end
+end

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

@@ -0,0 +1,215 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+module Spec
+  module Mocks
+    describe "A method stub" do
+      before(:each) do
+        @class = Class.new do
+          def self.existing_class_method
+            :original_value
+          end
+
+          def existing_instance_method
+            :original_value
+          end
+        end
+        @obj = @class.new
+      end
+
+      it "should allow for a mock expectation to temporarily replace a method stub on a mock" do
+        mock = Spec::Mocks::Mock.new("a mock")
+        mock.stub!(:msg).and_return(:stub_value)
+        mock.should_receive(:msg).with(:arg).and_return(:mock_value)
+        mock.msg(:arg).should equal(:mock_value)
+        mock.msg.should equal(:stub_value)
+        mock.msg.should equal(:stub_value)
+        mock.rspec_verify
+      end
+
+      it "should allow for a mock expectation to temporarily replace a method stub on a non-mock" do
+        @obj.stub!(:msg).and_return(:stub_value)
+        @obj.should_receive(:msg).with(:arg).and_return(:mock_value)
+        @obj.msg(:arg).should equal(:mock_value)
+        @obj.msg.should equal(:stub_value)
+        @obj.msg.should equal(:stub_value)
+        @obj.rspec_verify
+      end
+
+      it "should ignore when expected message is not received" do
+        @obj.stub!(:msg)
+        lambda do
+          @obj.rspec_verify
+        end.should_not raise_error
+      end
+      
+      it "should clear itself on rspec_verify" do
+        @obj.stub!(:this_should_go).and_return(:blah)
+        @obj.this_should_go.should == :blah
+        @obj.rspec_verify
+        lambda do
+          @obj.this_should_go
+        end.should raise_error
+      end
+
+      it "should ignore when expected message is received" do
+        @obj.stub!(:msg)
+        @obj.msg
+        @obj.rspec_verify
+      end
+
+      it "should ignore when message is received with args" do
+        @obj.stub!(:msg)
+        @obj.msg(:an_arg)
+        @obj.rspec_verify
+      end
+
+      it "should return expected value when expected message is received" do
+        @obj.stub!(:msg).and_return(:return_value)
+        @obj.msg.should equal(:return_value)
+        @obj.rspec_verify
+      end
+      
+      it "should return values in order to consecutive calls" do
+        return_values = ["1",2,Object.new]
+        @obj.stub!(:msg).and_return(return_values[0],return_values[1],return_values[2])
+        @obj.msg.should == return_values[0]
+        @obj.msg.should == return_values[1]
+        @obj.msg.should == return_values[2]
+      end
+
+      it "should keep returning last value in consecutive calls" do
+        return_values = ["1",2,Object.new]
+        @obj.stub!(:msg).and_return(return_values[0],return_values[1],return_values[2])
+        @obj.msg.should == return_values[0]
+        @obj.msg.should == return_values[1]
+        @obj.msg.should == return_values[2]
+        @obj.msg.should == return_values[2]
+        @obj.msg.should == return_values[2]
+      end
+
+      it "should revert to original instance method if existed" do
+        @obj.existing_instance_method.should equal(:original_value)
+        @obj.stub!(:existing_instance_method).and_return(:mock_value)
+        @obj.existing_instance_method.should equal(:mock_value)
+        @obj.rspec_verify
+        # TODO JRUBY: This causes JRuby to fail with:
+        # NativeException in 'Stub should revert to original instance method if existed'
+        # java.lang.ArrayIndexOutOfBoundsException: 0
+        # org.jruby.internal.runtime.methods.IterateCallable.internalCall(IterateCallable.java:63)
+        # org.jruby.internal.runtime.methods.AbstractCallable.call(AbstractCallable.java:64)
+        # org.jruby.runtime.ThreadContext.yieldInternal(ThreadContext.java:574)
+        # org.jruby.runtime.ThreadContext.yieldSpecificBlock(ThreadContext.java:549)
+        # org.jruby.runtime.Block.call(Block.java:158)
+        # org.jruby.RubyProc.call(RubyProc.java:118)
+        # org.jruby.internal.runtime.methods.ProcMethod.internalCall(ProcMethod.java:69)
+        # org.jruby.internal.runtime.methods.AbstractMethod.call(AbstractMethod.java:58)
+        # org.jruby.RubyObject.callMethod(RubyObject.java:379)
+        # org.jruby.RubyObject.callMethod(RubyObject.java:331)
+        # org.jruby.evaluator.EvaluationState.evalInternal(EvaluationState.java:472)
+        # org.jruby.evaluator.EvaluationState.evalInternal(EvaluationState.java:462)
+        # org.jruby.evaluator.EvaluationState.evalInternal(EvaluationState.java:390)
+        # org.jruby.evaluator.EvaluationState.eval(EvaluationState.java:133)
+        @obj.existing_instance_method.should equal(:original_value)
+      end
+      
+      it "should revert to original class method if existed" do
+        @class.existing_class_method.should equal(:original_value)
+        @class.stub!(:existing_class_method).and_return(:mock_value)
+        @class.existing_class_method.should equal(:mock_value)
+        @class.rspec_verify
+        @class.existing_class_method.should equal(:original_value)
+      end
+
+      it "should clear itself on rspec_verify" do
+        @obj.stub!(:this_should_go).and_return(:blah)
+        @obj.this_should_go.should == :blah
+        @obj.rspec_verify
+        lambda do
+          @obj.this_should_go
+        end.should raise_error
+      end
+      
+      it "should support yielding" do
+        @obj.stub!(:method_that_yields).and_yield(:yielded_value)
+        current_value = :value_before
+        @obj.method_that_yields {|val| current_value = val}
+        current_value.should == :yielded_value
+        @obj.rspec_verify
+      end
+
+      it "should support yielding multiple times" do
+        @obj.stub!(:method_that_yields_multiple_times).and_yield(:yielded_value).
+                                                       and_yield(:another_value)
+        current_value = []
+        @obj.method_that_yields_multiple_times {|val| current_value << val}
+        current_value.should == [:yielded_value, :another_value]
+        @obj.rspec_verify
+      end
+
+      it "should throw when told to" do
+        @mock.stub!(:something).and_throw(:blech)
+        lambda do
+          @mock.something
+        end.should throw_symbol(:blech)
+      end
+      
+      it "should support overriding w/ a new stub" do
+        @stub.stub!(:existing_instance_method).and_return(:updated_stub_value)
+        @stub.existing_instance_method.should == :updated_stub_value
+      end
+      
+      it "should support stub with" do
+        @stub.stub!(:foo).with("bar")
+        @stub.should_receive(:foo).with("baz")
+        @stub.foo("bar")
+        @stub.foo("baz")
+      end
+    end
+    
+    describe "A method stub with args" do
+      before(:each) do
+        @stub = Object.new
+        @stub.stub!(:foo).with("bar")
+      end
+
+      it "should not complain if not called" do
+      end
+
+      it "should not complain if called with arg" do
+        @stub.foo("bar")
+      end
+
+      it "should complain if called with no arg" do
+        lambda do
+          @stub.foo
+        end.should raise_error
+      end
+
+      it "should complain if called with other arg" do
+        lambda do
+          @stub.foo("other")
+        end.should raise_error
+      end
+
+      it "should not complain if also mocked w/ different args" do
+        @stub.should_receive(:foo).with("baz")
+        @stub.foo("bar")
+        @stub.foo("baz")
+      end
+
+      it "should complain 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 "should support options" do
+        @stub.stub!(:foo, :expected_from => "bar")
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,67 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+module Spec
+  module Mocks
+    describe "TwiceCounts" do
+      before(:each) do
+        @mock = mock("test mock")
+      end
+
+      it "twice should fail when call count is higher than expected" do
+        @mock.should_receive(:random_call).twice
+        @mock.random_call
+        @mock.random_call
+        @mock.random_call
+        lambda do
+          @mock.rspec_verify
+        end.should raise_error(MockExpectationError)
+      end
+      
+      it "twice should fail when call count is lower than expected" do
+        @mock.should_receive(:random_call).twice
+        @mock.random_call
+        lambda do
+          @mock.rspec_verify
+        end.should raise_error(MockExpectationError)
+      end
+      
+      it "twice should fail when called twice with wrong args on the first call" do
+        @mock.should_receive(:random_call).twice.with("1", 1)
+        lambda do
+          @mock.random_call(1, "1")
+        end.should raise_error(MockExpectationError)
+        @mock.rspec_reset
+      end
+      
+      it "twice should fail when called twice with wrong args on the second call" do
+        @mock.should_receive(:random_call).twice.with("1", 1)
+        @mock.random_call("1", 1)
+        lambda do
+          @mock.random_call(1, "1")
+        end.should raise_error(MockExpectationError)
+        @mock.rspec_reset
+      end
+      
+      it "twice should pass when called twice" do
+        @mock.should_receive(:random_call).twice
+        @mock.random_call
+        @mock.random_call
+        @mock.rspec_verify
+      end
+      
+      it "twice should pass when called twice with specified args" do
+        @mock.should_receive(:random_call).twice.with("1", 1)
+        @mock.random_call("1", 1)
+        @mock.random_call("1", 1)
+        @mock.rspec_verify
+      end
+      
+      it "twice should pass when called twice with unspecified args" do
+        @mock.should_receive(:random_call).twice
+        @mock.random_call("1")
+        @mock.random_call(1)
+        @mock.rspec_verify
+      end
+    end
+  end
+end

data/vendor/plugins/rspec/spec/spec/package/bin_spec_spec.rb

@@ -0,0 +1,12 @@
+require "#{File.dirname(__FILE__)}/../../spec_helper"
+
+describe "The bin/spec script" do
+  it "should have no warnings" do
+    spec_path = "#{File.dirname(__FILE__)}/../../../bin/spec"
+    output = nil
+    IO.popen("ruby -w #{spec_path} --help 2>&1") do |io|
+      output = io.read
+    end
+    output.should_not =~ /warning/n
+  end
+end

data/vendor/plugins/rspec/spec/spec/runner/command_line_spec.rb

@@ -0,0 +1,140 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+module Spec
+  module Runner
+    describe CommandLine, ".run" do
+      before do
+        @err = StringIO.new
+        @out = StringIO.new
+      end
+
+      it "should run directory" do
+        file = File.dirname(__FILE__) + '/../../../examples'
+        Spec::Runner::CommandLine.run(OptionParser.parse([file], @err, @out))
+
+        @out.rewind
+        @out.read.should =~ /\d+ examples, 0 failures, 3 pending/n
+      end
+
+      it "should run file" do
+        file = File.dirname(__FILE__) + '/../../../failing_examples/predicate_example.rb'
+        Spec::Runner::CommandLine.run(OptionParser.parse([file], @err, @out))
+
+        @out.rewind
+        @out.read.should =~ /2 examples, 1 failure/n
+      end
+
+      it "should raise when file does not exist" do
+        file = File.dirname(__FILE__) + '/doesntexist'
+
+        lambda {
+          Spec::Runner::CommandLine.run(OptionParser.parse([file], @err, @out))
+        }.should raise_error
+      end
+
+      it "should return true when in --generate-options mode" do
+        Spec::Runner::CommandLine.run(
+          OptionParser.parse(['--generate-options', '/dev/null'], @err, @out)
+        ).should be_true
+      end
+
+      it "should dump even if Interrupt exception is occurred" do
+        behaviour = Class.new(::Spec::DSL::Example).describe("behaviour") do
+          it "no error" do
+          end
+
+          it "should interrupt" do
+            raise Interrupt
+          end
+        end
+
+        options = ::Spec::Runner::Options.new(@err, @out)
+        ::Spec::Runner::Options.should_receive(:new).with(@err, @out).and_return(options)
+        options.reporter.should_receive(:dump)
+        options.add_behaviour(behaviour)
+
+        Spec::Runner::CommandLine.run(OptionParser.parse([], @err, @out))
+      end
+
+      it "should heckle when options have heckle_runner" do
+        behaviour = Class.new(::Spec::DSL::Example).describe("behaviour") do
+          it "no error" do
+          end
+        end
+        options = ::Spec::Runner::Options.new(@err, @out)
+        ::Spec::Runner::Options.should_receive(:new).with(@err, @out).and_return(options)
+        options.add_behaviour behaviour
+
+        heckle_runner = mock("heckle_runner")
+        heckle_runner.should_receive(:heckle_with)
+        $rspec_mocks.__send__(:mocks).delete(heckle_runner)
+
+        options.heckle_runner = heckle_runner
+        options.add_behaviour(behaviour)
+
+        Spec::Runner::CommandLine.run(OptionParser.parse([], @err, @out))
+        heckle_runner.rspec_verify
+      end
+
+      it "should run examples backwards if options.reverse is true" do
+        options = ::Spec::Runner::Options.new(@err, @out)
+        ::Spec::Runner::Options.should_receive(:new).with(@err, @out).and_return(options)
+        options.reverse = true
+
+        b1 = Class.new(Spec::DSL::Example)
+        b2 = Class.new(Spec::DSL::Example)
+
+        b1_suite = b1.suite
+        b1.should_receive(:suite).and_return(b1_suite)
+        b2_suite = b2.suite
+        b2.should_receive(:suite).and_return(b2_suite)
+
+        b2_suite.should_receive(:run).ordered
+        b1_suite.should_receive(:run).ordered
+
+        options.add_behaviour(b1)
+        options.add_behaviour(b2)
+
+        Spec::Runner::CommandLine.run(OptionParser.parse([], @err, @out))
+      end
+
+      it "should pass its Description to the reporter" do
+        behaviour = Class.new(::Spec::DSL::Example).describe("behaviour") do
+          it "should" do
+          end
+        end
+
+        options = ::Spec::Runner::Options.new(@err, @out)
+        ::Spec::Runner::Options.should_receive(:new).with(@err, @out).and_return(options)
+        options.reporter.should_receive(:add_behaviour).with(an_instance_of(Spec::DSL::BehaviourDescription))
+        options.add_behaviour(behaviour)
+        Spec::Runner::CommandLine.run(OptionParser.parse([], @err, @out))
+      end
+
+      it "runs only selected Examples when options.examples is set" do
+        options = ::Spec::Runner::Options.new(@err, @out)
+        ::Spec::Runner::Options.should_receive(:new).with(@err, @out).and_return(options)
+
+        options.examples << "behaviour should"
+        should_has_run = false
+        should_not_has_run = false
+        behaviour = Class.new(::Spec::DSL::Example).describe("behaviour") do
+          it "should" do
+            should_has_run = true
+          end
+          it "should not" do
+            should_not_has_run = true
+          end
+        end
+
+        options.reporter.should_receive(:add_behaviour).with(an_instance_of(Spec::DSL::BehaviourDescription))
+
+        options.add_behaviour behaviour
+        Spec::Runner::CommandLine.run(OptionParser.parse([], @err, @out))
+
+        should_has_run.should be_true
+        should_not_has_run.should be_false
+      end
+    end
+  end
+end