derickbailey-notamock 0.0.1

data/lib/not_a_mock/stubmethod.rb

@@ -0,0 +1,26 @@
+require 'singleton'
+
+module NotAMock
+	class StubMethod		
+		def initialize(&block)
+			@block = block
+			@yield_values = []
+		end
+		
+		def yields(*args, &block)
+			@yield_values = args
+			(@block = block) unless block.nil?
+		end
+		
+		def execute_return_block(*args)
+			return_value = nil
+			(return_value = @block.call(*args)) unless @block.nil?
+			return_value
+		end
+		
+		def yield_to_block(&block)
+			return if block.nil?
+			block.call(*@yield_values)
+		end
+	end
+end

data/spec/call_recording_spec.rb

@@ -0,0 +1,68 @@
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
+require 'not_a_mock'
+
+class TrackedClass
+  def my_method(argument)
+    "result"
+  end
+end
+
+describe "A recorded method" do
+  
+  before do
+    @recorder = NotAMock::CallRecorder.instance
+    @object = TrackedClass.new
+    @object.track_method(:my_method)
+  end
+  
+  it "should record a method call" do
+    @object.my_method("argument")
+    
+    @recorder.calls.should include(:object => @object, :method => :my_method, :args => ["argument"], :result => "result")
+  end
+  
+  it "should not record calls after untrack_method" do
+    @object.my_method("argument 1")
+    @object.untrack_method(:my_method)
+    @object.my_method("argument 2")
+    
+    @recorder.calls.should include(:object => @object, :method => :my_method, :args => ["argument 1"], :result => "result")
+    @recorder.calls.should_not include(:object => @object, :method => :my_method, :args => ["argument 2"], :result => "result")
+  end
+  
+  it "should not record calls after stop_all_recording" do
+    @object.track_method(:my_method)
+    @object.my_method("argument 1")
+    @recorder.untrack_all
+    @object.my_method("argument 2")
+    
+    @recorder.calls.should include(:object => @object, :method => :my_method, :args => ["argument 1"], :result => "result")
+    @recorder.calls.should_not include(:object => @object, :method => :my_method, :args => ["argument 2"], :result => "result")
+  end
+  
+  it "should not break when track_method is called again" do
+    @object.track_method(:my_method)
+    @object.my_method("argument 1")
+    @object.untrack_method(:my_method)
+    @object.my_method("argument 2")
+    
+    @recorder.calls.should include(:object => @object, :method => :my_method, :args => ["argument 1"], :result => "result")
+    @recorder.calls.should_not include(:object => @object, :method => :my_method, :args => ["argument 2"], :result => "result")
+  end
+  
+  it "should not break when untrack_method is called more than once" do
+    @object.track_method(:my_method)
+    @object.my_method("argument 1")
+    @object.untrack_method(:my_method)
+    @object.untrack_method(:my_method)
+    @object.my_method("argument 2")
+    
+    @recorder.calls.should include(:object => @object, :method => :my_method, :args => ["argument 1"], :result => "result")
+    @recorder.calls.should_not include(:object => @object, :method => :my_method, :args => ["argument 2"], :result => "result")
+  end
+  
+  after do
+    @recorder.reset
+  end
+  
+end

data/spec/matchers_spec.rb

@@ -0,0 +1,217 @@
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
+require 'not_a_mock'
+
+class TrackedClass < Object
+  def initialize(*calls)
+    calls.each do |call|
+      NotAMock::CallRecorder.instance.calls << call.merge(:object => self)
+    end
+  end
+  
+  def inspect
+    "TrackedClass"
+  end
+end
+
+describe NotAMock::Matchers::AnythingMatcher do
+  
+  it "should match if a method was called" do
+    @object = TrackedClass.new({ :method => :length, :args => [], :result => nil })
+    @matcher = have_been_called
+    @matcher.matches?(@object).should be_true
+    @matcher.negative_failure_message.should == "TrackedClass was called"
+  end
+
+  it "should not match if a method wasn't called" do
+    @object = TrackedClass.new
+    @matcher = have_been_called
+    @matcher.matches?(@object).should be_false
+    @matcher.failure_message.should == "TrackedClass was never called"
+  end
+    
+  after do
+    NotAMock::CallRecorder.instance.reset
+  end
+  
+end
+
+describe NotAMock::Matchers::MethodMatcher do
+  
+  it "should match a called method" do
+    @object = TrackedClass.new({ :method => :length, :args => [], :result => nil })
+    @matcher = have_received(:length)
+    @matcher.matches?(@object).should be_true
+    @matcher.negative_failure_message.should == "TrackedClass received length"
+  end
+  
+  it "should not match an uncalled method" do
+    @object = TrackedClass.new
+    @matcher = have_received(:width)
+    @matcher.matches?(@object).should be_false
+    @matcher.failure_message.should == "TrackedClass didn't receive width"
+  end
+    
+  after do
+    NotAMock::CallRecorder.instance.reset
+  end
+  
+end
+
+describe NotAMock::Matchers::ArgsMatcher, "matching calls with arguments " do
+  
+  before do
+    @object = TrackedClass.new({ :method => :length, :args => [1, [2, 3, 4], 5], :result => nil })
+  end
+  
+  it "should match a called method with the correct arguments" do
+    @matcher = have_received(:length).with(1, [2, 3, 4], 5)
+    @matcher.matches?(@object).should be_true
+    @matcher.negative_failure_message.should == "TrackedClass received length, with args [1, [2, 3, 4], 5]"
+  end
+  
+  it "should not match a called method with the wrong arguments" do
+    @matcher = have_received(:length).with(3, 2, 1)
+    @matcher.matches?(@object).should be_false
+    @matcher.failure_message.should == "TrackedClass received length, but not with args [3, 2, 1]"
+  end
+  
+  it "should match a called method with a wildcard argument" do
+    @matcher = have_received(:length).with(1, anything, 5)
+    @matcher.matches?(@object).should be_true
+    @matcher.matches?(@object).should be_true
+    @matcher.negative_failure_message.should == "TrackedClass received length, with args [1, anything, 5]"
+  end
+  
+  it "should match a called method with a wildcard argument" do
+    @matcher = have_received(:length).with(1, in_any_order([4, 3, 2]), 5)
+    @matcher.matches?(@object).should be_true
+    @matcher.matches?(@object).should be_true
+    @matcher.negative_failure_message.should == "TrackedClass received length, with args [1, in_any_order([4, 3, 2]), 5]"
+  end
+  
+  after do
+    NotAMock::CallRecorder.instance.reset
+  end
+  
+end
+
+describe NotAMock::Matchers::ArgsMatcher, "matching calls without arguments" do
+  
+  before do
+    @object = TrackedClass.new(
+      { :method => :length, :args => [1, 2, 3], :result => nil },
+      { :method => :width,  :args => [], :result => nil }
+    )    
+  end
+  
+  it "should match a method called without arguments" do
+    @matcher = have_received(:width).without_args
+    @matcher.matches?(@object).should be_true
+    @matcher.negative_failure_message.should == "TrackedClass received width, without args"    
+  end
+  
+  it "should not match a method called with arguments" do
+    @matcher = have_received(:length).without_args
+    @matcher.matches?(@object).should be_false
+    @matcher.failure_message.should == "TrackedClass received length, but not without args"    
+  end
+  
+  after do
+    NotAMock::CallRecorder.instance.reset
+  end
+  
+end
+
+describe NotAMock::Matchers::ResultMatcher do
+  
+  before do
+    @object = TrackedClass.new(
+      { :method => :length, :args => [], :result => 13 },
+      { :method => :width,  :args => [], :result => 42 }
+    )    
+  end
+
+  it "should match a method that returned the correct result" do
+    @matcher = have_received(:length).and_returned(13)
+    @matcher.matches?(@object).should be_true
+    @matcher.negative_failure_message.should == "TrackedClass received length, and returned 13"
+  end
+  
+  it "should not match a method the returned the wrong result" do
+    @matcher = have_received(:width).and_returned(13)
+    @matcher.matches?(@object).should be_false
+    @matcher.failure_message.should == "TrackedClass received width, but didn't return 13"
+  end
+    
+  after do
+    NotAMock::CallRecorder.instance.reset
+  end
+  
+end
+
+describe NotAMock::Matchers::TimesMatcher do
+  
+  before do
+    @object = TrackedClass.new(
+      { :method => :once,   :args => [], :result => nil },
+      { :method => :twice,  :args => [], :result => nil },
+      { :method => :twice,  :args => [], :result => nil },
+      { :method => :thrice, :args => [], :result => nil },
+      { :method => :thrice, :args => [], :result => nil },
+      { :method => :thrice, :args => [], :result => nil }
+    )
+  end
+  
+  it "should match a method that was called once" do
+    @matcher = have_received(:once).once
+    @matcher.matches?(@object).should be_true
+    @matcher.negative_failure_message.should == "TrackedClass received once, once"
+  end
+
+  it "should match a method that was called twice" do
+    @matcher = have_received(:twice).twice
+    @matcher.matches?(@object).should be_true
+    @matcher.negative_failure_message.should == "TrackedClass received twice, twice"
+  end
+  
+  it "should match a method that was called 3 times" do
+    @matcher = have_received(:thrice).exactly(3).times
+    @matcher.matches?(@object).should be_true
+    @matcher.negative_failure_message.should == "TrackedClass received thrice, 3 times"
+  end  
+  
+  it "should not match a method a method that was called the wrong number of times" do
+    @matcher = have_received(:thrice).once
+    @matcher.matches?(@object).should be_false
+    @matcher.failure_message.should == "TrackedClass received thrice, but 3 times"
+  end
+  
+  after do
+    NotAMock::CallRecorder.instance.reset
+  end
+  
+end
+
+describe "A chain of matchers" do
+  
+  before do
+    @object = TrackedClass.new({ :method => :length, :args => [1, 2, 3], :result => 42 })
+  end
+  
+  it "should match the correct method, args, and result" do
+    @matcher = have_received(:length).with(1, 2, 3).and_returned(42)
+    @matcher.matches?(@object).should be_true
+    @matcher.negative_failure_message.should == "TrackedClass received length, with args [1, 2, 3], and returned 42"
+  end
+  
+  it "should not match the correct method, but with the incorrect args" do
+    @matcher = have_received(:length).with(3, 2, 1).and_returned(42)
+    @matcher.matches?(@object).should be_false
+    @matcher.failure_message.should == "TrackedClass received length, but not with args [3, 2, 1]"
+  end
+  
+  after do
+    NotAMock::CallRecorder.instance.reset
+  end
+  
+end

data/spec/stub_active_record_spec.rb

@@ -0,0 +1,29 @@
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
+require 'not_a_mock'
+
+class ExampleActiveRecord < ActiveRecord::Base
+end
+
+describe "A stubbed ActiveRecord object" do
+  
+  before do
+    @example = ExampleActiveRecord.stub_instance
+  end
+  
+  it "should return a valid id" do
+    lambda { @example.id }.should_not raise_error(NoMethodError)
+    @example.id.should be_an_instance_of(Fixnum)
+  end
+  
+  it "should return the id as a string for to_param" do
+    lambda { @example.to_param }.should_not raise_error(NoMethodError)
+    @example.to_param.should be_an_instance_of(String)
+    @example.to_param.should == @example.id.to_s
+  end
+  
+  after do
+    NotAMock::CallRecorder.instance.reset
+    NotAMock::Stubber.instance.reset
+  end
+  
+end

data/spec/stub_instance_spec.rb

@@ -0,0 +1,49 @@
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
+require 'not_a_mock'
+
+describe "A stub instance" do
+  
+  before do
+    @object = String.stub_instance(:length => 42, :id => 99)
+  end
+  
+  it "should return the right result for a stubbed method" do
+    @object.length.should == 42
+  end
+  
+  it "should return its name when inspected" do
+    @object.inspect.should == "Stub String"
+  end
+  
+  it "should handle the id method being stubbed" do
+    @object.id.should == 99
+  end
+  
+  it "should raise an error when a method that's not stubbed is called" do
+    lambda { @object.whatever }.should raise_error(NoMethodError)
+  end
+  
+  it "should record a call to a stubbed method" do
+    @object.length
+    NotAMock::CallRecorder.instance.calls.should include(:object => @object, :method => :length, :args => [], :result => 42)
+  end
+  
+  it "should allow adding of new stubbed methods" do
+    @object.stub_method(:width => 7)
+    @object.width.should == 7
+  end
+  
+  it "should identify itself as the underlying object" do
+    @object.is_a?(String).should be_true
+    @object.should be_kind_of(String)
+    @object.should be_kind_of(Object)
+    @object.should be_instance_of(String)
+    @object.class.should == String
+  end
+  
+  after do
+    NotAMock::CallRecorder.instance.reset
+    NotAMock::Stubber.instance.reset
+  end 
+  
+end

data/spec/stub_method_spec.rb

@@ -0,0 +1,242 @@
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
+require 'not_a_mock'
+
+describe "A stubbed method replacing an existing instance method" do
+  
+  before do
+    @object = "Hello, world!"
+    @object.stub_method(:length => 42)
+  end
+  
+  it "should return the stubbed result" do
+    @object.length.should == 42
+  end
+  
+  it "should return the original result after stubbing is removed" do
+    @object.unstub_method(:length)
+    @object.length.should == 13
+  end
+  
+  it "should return the original result after a reset" do
+    NotAMock::Stubber.instance.reset
+    @object.length.should == 13
+  end
+  
+  it "should return the new result if re-stubbed" do
+    @object.stub_method(:length => 24)
+    @object.length.should == 24
+  end
+  
+  it "should record a call to the stubbed method" do
+    @object.length
+    NotAMock::CallRecorder.instance.calls.should include(:object => @object, :method => :length, :args => [], :result => 42)
+  end
+  
+  it "should return a call to the stubbed method if re-stubbed" do
+    @object.stub_method(:length => 24)
+    @object.length
+    NotAMock::CallRecorder.instance.calls.should include(:object => @object, :method => :length, :args => [], :result => 24)
+  end
+  
+  after do
+    NotAMock::CallRecorder.instance.reset
+    NotAMock::Stubber.instance.reset
+  end
+
+end
+
+describe "A stubbed method with no existing instance method" do
+  
+  before do
+    @object = "Hello, world!"
+    @object.stub_method(:blah => 42)
+  end
+  
+  it "should return the stubbed result" do
+    @object.blah.should == 42
+  end
+  
+  it "should raise a NoMethodError when the method is called after stubbing is removed" do
+    @object.unstub_method(:blah)
+    lambda { @object.blah }.should raise_error(NoMethodError)
+  end
+  
+  it "should raise a NoMethodError when the method is called after all stubbing is removed" do
+    NotAMock::Stubber.instance.reset
+    lambda { @object.blah }.should raise_error(NoMethodError)
+  end
+  
+  it "should record a call to the stubbed method" do
+    @object.blah
+    NotAMock::CallRecorder.instance.calls.should include(:object => @object, :method => :blah, :args => [], :result => 42)
+  end
+  
+  after do
+    NotAMock::CallRecorder.instance.reset
+    NotAMock::Stubber.instance.reset
+  end
+  
+end
+
+describe "A stubbed class method" do
+  
+  before do
+    Time.stub_method(:now => 42)
+  end
+  
+  it "should return the stubbed result" do
+    Time.now.should == 42
+  end
+  
+  it "should return the original result after stubbing is removed" do
+    Time.unstub_method(:now)
+    Time.now.should_not == 42
+  end
+  
+  it "should return the original result after a reset" do
+    NotAMock::Stubber.instance.reset
+    Time.now.should_not == 42
+  end
+
+  after do
+    NotAMock::CallRecorder.instance.reset
+    NotAMock::Stubber.instance.reset
+  end
+  
+end
+
+describe "A stubbed private method" do
+  before do
+    class Privateer
+      private
+      
+      def self.stubbed
+        false
+      end
+    end
+    
+    Privateer.stub_method(:stubbed => true)
+  end
+  
+  it "should return the stubbed result" do
+    Privateer.send(:stubbed).should be_true
+  end
+  
+  it "should return the original result after stubbing is removed" do
+    Privateer.unstub_method(:stubbed)
+    Privateer.send(:stubbed).should be_false
+  end
+  
+  it "should return the original result after a reset" do
+    NotAMock::Stubber.instance.reset
+    Privateer.send(:stubbed).should be_false
+  end
+
+  after do
+    NotAMock::CallRecorder.instance.reset
+    NotAMock::Stubber.instance.reset
+  end
+end
+
+describe "A stubbed protected method" do
+  before :each do
+    class Protector
+      protected
+      
+      def self.stubbed
+        false
+      end
+    end
+    
+    Protector.stub_method(:stubbed => true)
+  end
+  
+  it "should return the stubbed result" do
+    Protector.send(:stubbed).should be_true
+  end
+  
+  it "should return the original result after stubbing is removed" do
+    Protector.unstub_method(:stubbed)
+    Protector.send(:stubbed).should be_false
+  end
+  
+  it "should return the original result after a reset" do
+    NotAMock::Stubber.instance.reset
+    Protector.send(:stubbed).should be_false
+  end
+
+  after do
+    NotAMock::CallRecorder.instance.reset
+    NotAMock::Stubber.instance.reset
+  end
+end
+
+describe "A method stubbed with a block" do
+  
+  before do
+    @object = "Hello, world!"
+    @object.stub_method(:length) do |*args|
+      args.reverse
+    end
+  end
+  
+  it "should return the result of the block" do
+    @object.length(1, 2, 3).should == [3, 2, 1]
+  end
+  
+  after do
+    NotAMock::CallRecorder.instance.reset
+    NotAMock::Stubber.instance.reset
+  end
+  
+end
+
+describe "A method stubbed to raise an exception" do
+  
+  before do
+    @object = "Hello, world!"
+    @object.stub_method_to_raise(:length => ArgumentError)
+  end
+
+  it "should raise the exception when called" do
+    lambda { @object.length }.should raise_error(ArgumentError)  
+  end
+  
+  it "should return the original result after stubbing is removed" do
+    @object.unstub_method(:length)
+    @object.length.should == 13
+  end
+  
+  after do
+    NotAMock::CallRecorder.instance.reset
+    NotAMock::Stubber.instance.reset
+  end
+  
+end
+
+describe "Object#stub_method" do
+  
+  it "should stub a method with a name ending in '?'" do
+    @object = "Hello, world!"
+    @object.stub_method(:is_great? => true)
+    @object.is_great?.should be_true
+  end
+  
+  it "should stub the []= method" do
+    @object = Array.new
+    @object.stub_method(:[]= => nil)
+    @object[0] = 7
+    @object.length.should == 0
+  end
+  
+  it "should raise an ArgumentError if called with something other than a symbol or hash" do
+    @object = "Hello, world!"
+    lambda { @object.stub_method(7) }.should raise_error(ArgumentError)
+  end
+
+  after do
+    NotAMock::CallRecorder.instance.reset
+    NotAMock::Stubber.instance.reset
+  end
+  
+end