hubbub 0.0.6

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

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+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/lib/vendor/plugins/rspec/spec/spec/mocks/record_messages_spec.rb

@@ -0,0 +1,26 @@
+require '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/lib/vendor/plugins/rspec/spec/spec/mocks/stub_chain_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+module Spec
+  module Mocks
+    describe "A chained method stub" do
+      before(:each) do
+        @subject = Object.new
+      end
+
+      it "returns expected value from chaining only one method call" do
+        @subject.stub_chain(:msg1).and_return(:return_value)
+        @subject.msg1.should equal(:return_value)
+      end
+
+      it "returns expected value from chaining two method calls" do
+        @subject.stub_chain(:msg1, :msg2).and_return(:return_value)
+        @subject.msg1.msg2.should equal(:return_value)
+      end
+
+      it "returns expected value from chaining four method calls" do
+        @subject.stub_chain(:msg1, :msg2, :msg3, :msg4).and_return(:return_value)
+        @subject.msg1.msg2.msg3.msg4.should equal(:return_value)
+      end
+
+      it "returns expected value from two chains with shared messages at the end" do
+        @subject.stub_chain(:msg1, :msg2, :msg3, :msg4).and_return(:first)
+        @subject.stub_chain(:msg5, :msg2, :msg3, :msg4).and_return(:second)
+
+        @subject.msg1.msg2.msg3.msg4.should equal(:first)
+        @subject.msg5.msg2.msg3.msg4.should equal(:second)
+      end
+
+      it "returns expected value from two chains with shared messages at the beginning" do
+        @subject.stub_chain(:msg1, :msg2, :msg3, :msg4).and_return(:first)
+        @subject.stub_chain(:msg1, :msg2, :msg3, :msg5).and_return(:second)
+
+        @subject.msg1.msg2.msg3.msg4.should equal(:first)
+        @subject.msg1.msg2.msg3.msg5.should equal(:second)
+      end
+    end
+  end
+end

data/lib/vendor/plugins/rspec/spec/spec/mocks/stub_implementation_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+module Spec
+  module Mocks
+    describe "stub implementation" do
+      context "with no args" do
+        it "execs the block when called" do
+          obj = stub()
+          obj.stub(:foo) { :bar }
+          obj.foo.should == :bar
+        end
+      end
+
+      context "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 == :bar
+        end
+      end
+
+      context "with variable args" do
+        it "execs the block when called" do
+          obj = stub()
+          obj.stub(:foo) {|*given| given.first}
+          obj.foo(:bar).should == :bar
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,203 @@
+require 'spec_helper'
+
+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
+        @instance = @class.new
+        @stub = Object.new
+      end
+
+      [:stub!, :stub].each do |method|
+        context "using #{method}" do
+          it "should return expected value when expected 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 "should ignore when expected message is received" do
+        @instance.stub!(:msg)
+        @instance.msg
+        lambda do
+          @instance.rspec_verify
+        end.should_not raise_error
+      end
+
+      it "should ignore when message is received with args" do
+        @instance.stub!(:msg)
+        @instance.msg(:an_arg)
+        lambda do
+          @instance.rspec_verify
+        end.should_not raise_error
+      end
+
+      it "should ignore when expected message is not received" do
+        @instance.stub!(:msg)
+        lambda do
+          @instance.rspec_verify
+        end.should_not raise_error
+      end
+
+      it "should handle multiple stubbed methods" do
+        @instance.stub!(:msg1 => 1, :msg2 => 2)
+        @instance.msg1.should == 1
+        @instance.msg2.should == 2
+      end
+
+      it "should clear itself when verified" do
+        @instance.stub!(:this_should_go).and_return(:blah)
+        @instance.this_should_go.should == :blah
+        @instance.rspec_verify
+        lambda do
+          @instance.this_should_go
+        end.should raise_error(NameError)
+      end
+
+      it "should return values in order to consecutive calls" do
+        return_values = ["1",2,Object.new]
+        @instance.stub!(:msg).and_return(return_values[0],return_values[1],return_values[2])
+        @instance.msg.should == return_values[0]
+        @instance.msg.should == return_values[1]
+        @instance.msg.should == return_values[2]
+      end
+
+      it "should keep returning last value in consecutive calls" do
+        return_values = ["1",2,Object.new]
+        @instance.stub!(:msg).and_return(return_values[0],return_values[1],return_values[2])
+        @instance.msg.should == return_values[0]
+        @instance.msg.should == return_values[1]
+        @instance.msg.should == return_values[2]
+        @instance.msg.should == return_values[2]
+        @instance.msg.should == return_values[2]
+      end
+
+      it "should revert to original instance method if there is one" do
+        @instance.existing_instance_method.should equal(:original_value)
+        @instance.stub!(:existing_instance_method).and_return(:mock_value)
+        @instance.existing_instance_method.should equal(:mock_value)
+        @instance.rspec_verify
+        @instance.existing_instance_method.should equal(:original_value)
+      end
+
+      it "should revert to original class method if there is one" 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 yield 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 == :yielded_obj
+        @instance.rspec_verify
+      end
+
+      it "should yield 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 == [:yielded_value, :another_value]
+        @instance.rspec_verify
+      end
+
+      it "should yield a specified object and return another specified object" do
+        yielded_obj = mock("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 == :baz
+      end
+
+      it "should throw when told to" do
+        @mock.stub!(:something).and_throw(:up)
+        lambda do
+          @mock.something
+        end.should throw_symbol(:up)
+      end
+
+      it "should override a pre-existing stub" do
+        @stub.stub!(:existing_instance_method).and_return(:updated_stub_value)
+        @stub.existing_instance_method.should == :updated_stub_value
+      end
+
+      it "should limit " 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
+        @mock.stub!(:something).with("a","b","c").and_return { |a,b,c| c+b+a }
+        @mock.something("a","b","c").should == "cba"
+        @mock.rspec_verify
+      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
+
+      it "should use 'Stub' in the failure message" do
+        stub = stub('name')
+        expect {stub.foo}.to raise_error(/Stub "name" received/)
+      end
+    end
+
+  end
+end

data/lib/vendor/plugins/rspec/spec/spec/mocks/stubbed_message_expectations_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+module Spec
+  module Mocks
+    describe "Example with stubbed and then called message" do
+      it "fails if the message is expected and then subsequently not called again" do
+        mock_obj = mock("mock", :msg => nil)
+        mock_obj.msg
+        mock_obj.should_receive(:msg)
+        lambda { mock_obj.rspec_verify }.should raise_error(Spec::Mocks::MockExpectationError)
+      end
+
+      it "outputs arguments of all similar calls" do
+        m = mock('mock', :foo => true)
+        m.should_receive(:foo).with('first')
+        m.foo('second')
+        m.foo('third')
+        lambda do
+          m.rspec_verify
+        end.should raise_error(%Q|Mock "mock" received :foo with unexpected arguments\n  expected: ("first")\n       got: (["second"], ["third"])|)
+        m.rspec_reset
+      end
+    end
+    
+  end
+end

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

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+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/lib/vendor/plugins/rspec/spec/spec/mocks/unstub_spec.rb

@@ -0,0 +1,127 @@
+require 'spec_helper'
+
+module Spec
+  module Mocks
+    describe Mock do
+      context "unstubbing a mock object with a stub" do
+        it "should remove the stub" do
+          a_mock = mock 'an object', :foo => :bar
+
+          a_mock.unstub! :foo
+          a_mock.should_not respond_to(:foo)
+        end
+      end
+
+      context "unstubbing a real object with a stub" do
+        before do
+          @obj = Object.new
+        end
+
+        it "should raise a NoMethodError if the message is called after unstubbing" do
+          @obj.stub!(:foo).and_return :bar
+          @obj.unstub!(:foo)
+
+          lambda {
+            @obj.foo
+          }.should raise_error(NoMethodError)
+        end
+
+        it "should only clear the stub specified" do
+          @obj.stub!(:foo).and_return :bar
+          @obj.stub!(:other).and_return :baz
+
+          @obj.unstub!(:foo)
+
+          @obj.other.should == :baz
+        end
+
+        it "should no longer respond_to? the method" do
+          @obj.stub!(:foo).and_return :bar
+          @obj.unstub!(:foo)
+
+          @obj.should_not respond_to(:foo)
+        end
+
+        it "should unstub using a string (should convert the string to a symbol)" do
+          @obj.stub!(:foo)
+
+          @obj.unstub!("foo")
+
+          @obj.should_not respond_to(:foo)
+        end
+
+        it "should restore a previous method definition" do
+          def @obj.foo
+            :a_result
+          end
+
+          @obj.stub!(:foo).and_return :stubbed_result
+          @obj.unstub!(:foo)
+
+          @obj.foo.should == :a_result
+        end
+
+        it "should have unstub as an alias of unstub!" do
+          @obj.stub!(:foo).and_return :bar
+
+          @obj.unstub(:foo)
+
+          lambda {
+            @obj.foo
+          }.should raise_error(NoMethodError)
+        end
+
+        it "should raise a MockExpectationError if it is not stubbed" do
+          lambda {
+            @obj.unstub!(:foo)
+          }.should raise_error(MockExpectationError, "The method `foo` was not stubbed or was already unstubbed")
+        end
+
+        it "should raise a MockExpectationError if it was already unstubbed" do
+          @obj.stub!(:foo)
+          @obj.unstub!(:foo)
+
+          lambda {
+            @obj.unstub!(:foo)
+          }.should raise_error(MockExpectationError, "The method `foo` was not stubbed or was already unstubbed")
+        end
+
+        it "should use the correct message name in the error" do
+          @obj.stub!(:bar)
+          @obj.unstub!(:bar)
+
+          lambda {
+            @obj.unstub!(:bar)
+          }.should raise_error(MockExpectationError, "The method `bar` was not stubbed or was already unstubbed")
+        end
+
+        it "should raise a MockExpectationError if the method is defined, but not stubbed" do
+          def @obj.meth; end
+
+          lambda {
+            @obj.unstub!(:meth)
+          }.should raise_error(MockExpectationError)
+        end
+
+        it "should be able to restub a after unstubbing" do
+          @obj.stub!(:foo).and_return :bar
+
+          @obj.unstub!(:foo)
+
+          @obj.stub!(:foo).and_return :baz
+
+          @obj.foo.should == :baz
+        end
+
+        it "should remove only the first stub if multiple stubs have been defined" do
+          @obj.stub!(:foo).and_return :first
+          @obj.stub!(:foo).and_return :second
+
+          @obj.unstub!(:foo)
+
+          @obj.foo.should == :first
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+require 'spec_helper'
+require 'ruby_forker'
+
+describe "The bin/spec script" do
+  include RubyForker
+  
+  it "should have no warnings" do
+    output = ruby "-w -Ilib bin/spec --help"
+    output.should_not =~ /warning/n
+  end
+  
+  it "should show the help w/ no args" do
+    output = ruby "-w -Ilib bin/spec"
+    output.should =~ /^Usage: spec/
+  end
+end