not_a_mock 1.0.0

data/lib/not_a_mock/object_extensions.rb

@@ -0,0 +1,105 @@
+class Object
+  
+  # Call this on any object or class with a list of method names. Any future
+  # calls to those methods will be recorded in NotAMock::CallRecorder.
+  #
+  # See NotAMock::Matchers for info on how to test which methods have been
+  # called, with what arguments, etc.
+  def track_methods(*methods)
+    if methods.empty?
+      self.public_methods(false).map {|method_name| methods << method_name.to_s.to_sym}
+    end
+
+    methods.each do |method|
+      NotAMock::CallRecorder.instance.track_method(self, method)
+    end
+  end
+  alias_method(:track_method, :track_methods)
+  alias_method(:log_calls_to, :track_methods)  # For backwards compatibility.
+  
+  # Stop recording calls for the given methods.
+  def untrack_methods(*methods)
+    methods.each do |method|
+      NotAMock::CallRecorder.instance.untrack_method(self, method)
+    end
+  end
+  alias_method(:untrack_method, :untrack_methods)
+  
+  # If passed a symbol and a block, this replaces the named method on this
+  # object with a stub version that evaluates the block and returns the result.
+  #
+  # If passed a hash, this is an alias for stub_methods.
+  #
+  # Calls to stubbed methods are recorded in the NotAMock::CallRecorder,
+  # so you can later make assertions about them as described in
+  # NotAMock::Matchers.
+  def stub_method(method, &block)
+    case method
+      when Symbol
+        NotAMock::CallRecorder.instance.untrack_method(self, method)
+        NotAMock::Stubber.instance.unstub_method(self, method)
+        NotAMock::Stubber.instance.stub_method(self, method, &block)
+        NotAMock::CallRecorder.instance.track_method(self, method)
+      when Hash
+        stub_methods(method)
+      else
+        raise ArgumentError
+    end
+  end
+  
+  # Takes a hash of method names mapped to results, and replaces each named
+  # method on this object with a stub version returning the corresponding result.
+  #
+  # Calls to stubbed methods are recorded in the NotAMock::CallRecorder,
+  # so you can later make assertions about them as described in
+  # NotAMock::Matchers.
+  def stub_methods(methods)
+    methods.each do |method, result|
+      stub_method(method) {|*args| result }
+    end
+  end
+  
+  # Takes a hash of method names mapped to exceptions, and replaces each named
+  # method on this object with a stub version returning the corresponding exception.
+  def stub_methods_to_raise(methods)
+    methods.each do |method, exception|
+      stub_method(method) {|*args| raise exception }
+    end
+  end
+  alias_method(:stub_method_to_raise, :stub_methods_to_raise)
+  
+  # Removes the stubbed versions of the given methods and restores the
+  # original methods.
+  def unstub_methods(*methods)
+    methods.each do |method, result|
+      NotAMock::CallRecorder.instance.untrack_method(self, method)
+      NotAMock::Stubber.instance.unstub_method(self, method)
+    end
+  end
+  alias_method(:unstub_method, :unstub_methods)
+  
+  class << self
+    # Called on a class, creates a stub instance of that class. Takes a hash of
+    # method names and their returns values, and creates those methods on the new
+    # stub instance.
+    #
+    # See NotAMock::Stub for more details about the returned objects.
+    def stub_instance(methods = {})
+      NotAMock::Stub.new(self, methods)
+    end
+  end
+  
+  # Returns the metaclass of this object. For an explanation of metaclasses, see:
+  # http://whytheluckystiff.net/articles/seeingMetaclassesClearly.html
+  def metaclass
+    class << self
+      self
+    end
+  end
+  
+  # Evaluates the block in the context of this object's metaclass.
+  def meta_eval(&block)
+    metaclass.instance_eval(&block)
+  end
+  
+end

data/lib/not_a_mock/rspec_mock_framework_adapter.rb

@@ -0,0 +1,16 @@
+module NotAMock
+  module RspecMockFrameworkAdapter
+    
+    def setup_mocks_for_rspec
+    end
+    
+    def verify_mocks_for_rspec
+    end
+    
+    def teardown_mocks_for_rspec
+      NotAMock::CallRecorder.instance.reset
+      NotAMock::Stubber.instance.reset
+    end
+    
+  end
+end

data/lib/not_a_mock/stub.rb

@@ -0,0 +1,40 @@
+module NotAMock
+  # Instances returned by Object.stub_instance are NotAMock::Stub objects.
+  # These do their best to masquerade as the real thing.
+  class Stub
+    
+    # This is normall only called from Object.stub_instance.
+    def initialize(stubbed_class, methods = {}) #:nodoc:
+      @stubbed_class = stubbed_class
+      methods.each do |method, result|
+        self.meta_eval do
+          define_method(method) { result }
+        end
+        track_method(method)
+      end
+    end
+    
+    # Returns "Stub StubbedClass".
+    def inspect
+      "Stub #{@stubbed_class.to_s}"
+    end
+  
+    # Returns true if the class of the stubbed object or one of its superclasses is klass. 
+    def is_a?(klass)
+      @stubbed_class.ancestors.include?(klass)
+    end
+    
+    alias_method :kind_of?, :is_a?
+    
+    # Returns true if the class of the stubbed object is klass.
+    def instance_of?(klass)
+      @stubbed_class == klass
+    end
+    
+    # Returns the class of the stubbed object.
+    def class
+      @stubbed_class
+    end
+
+  end
+end

data/lib/not_a_mock/stubber.rb

@@ -0,0 +1,69 @@
+require 'singleton'
+require 'not_a_mock/object_extensions'
+
+module NotAMock
+  # The Stubber is a singleton that keeps track of all the stub methods
+  # installed in any object.
+  class Stubber
+    include Singleton
+  
+    def initialize
+      @stubbed_methods = []
+    end
+  
+    # Stub +method+ on +object+ to evalutate +block+ and return the result.
+    # 
+    # You should call Object#stub_method rathing than calling this directly.
+    def stub_method(object, method, &block) #:nodoc:
+      unless @stubbed_methods.include?([object, method])
+        @stubbed_methods << [object, method]
+        add_hook(object, method, &block)
+      end
+    end
+        
+    # Remove the stubbed +method+ on +object+.
+    #
+    # You should call Object#unstub_methods rather than calling this directly.
+    def unstub_method(object, method) #:nodoc:
+      if @stubbed_methods.delete([object, method])
+        remove_hook(object, method)
+      end
+    end
+  
+    # Removes all stub methods.
+    def reset
+      @stubbed_methods.each do |object, method|
+        remove_hook(object, method) 
+      end
+      @stubbed_methods = []
+    end
+    
+  private
+
+    def add_hook(object, method, &block)
+      method_exists = method_at_any_level?(object, method.to_s)
+      object.meta_eval do
+        alias_method("__unstubbed_#{method}", method) if method_exists
+        define_method(method, &block)
+      end
+    end
+  
+    def remove_hook(object, method)
+      method_exists = method_at_any_level?(object, "__unstubbed_#{method}")
+      object.meta_eval do
+        if method_exists
+          alias_method(method, "__unstubbed_#{method}")
+          remove_method("__unstubbed_#{method}")
+        else
+          remove_method(method)
+        end
+      end
+    end
+    
+    def method_at_any_level?(object, method)
+      object.methods.include?(method) ||
+      object.protected_methods.include?(method) ||
+      object.private_methods.include?(method)
+    end
+  end
+end

data/lib/not_a_mock.rb

@@ -0,0 +1,14 @@
+require 'not_a_mock/active_record_extensions'
+require 'not_a_mock/argument_constraint_extensions'
+require 'not_a_mock/call_recorder'
+require 'not_a_mock/matchers'
+require 'not_a_mock/matchers/anything_matcher'
+require 'not_a_mock/matchers/args_matcher'
+require 'not_a_mock/matchers/call_matcher'
+require 'not_a_mock/matchers/method_matcher'
+require 'not_a_mock/matchers/result_matcher'
+require 'not_a_mock/matchers/times_matcher'
+require 'not_a_mock/object_extensions'
+require 'not_a_mock/rspec_mock_framework_adapter'
+require 'not_a_mock/stubber'
+require 'not_a_mock/stub'

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