derickbailey-notamock 0.0.1

data/lib/not_a_mock/matchers/anything_matcher.rb

@@ -0,0 +1,28 @@
+require 'not_a_mock/matchers/call_matcher'
+
+module NotAMock
+  module Matchers
+    # Matcher for
+    #   object.should have_been_called
+    class AnythingMatcher < CallMatcher
+  
+      def initialize(parent = nil)
+        super parent
+      end
+  
+      def matches_without_parents?
+        @calls = CallRecorder.instance.calls_by_object(@object)
+        !@calls.empty?
+      end
+  
+      def failure_message_without_parents
+        if matched?
+          " was called"
+        else
+          " was never called"
+        end
+      end
+  
+    end
+  end
+end

data/lib/not_a_mock/matchers/args_matcher.rb

@@ -0,0 +1,74 @@
+require 'not_a_mock/matchers/call_matcher'
+
+module NotAMock
+  module Matchers
+    # Matcher for
+    #  with(...)
+    #
+    # == Argument Matchers
+    #
+    # Not A Mock supports the use of RSpec's patterns for argument matching
+    # in mocks, and extends them. The most useful are listed below.
+    #
+    # === Anything Matcher
+    #
+    # The +anything+ pattern will match any value. For example:
+    #
+    #   object.should have_received(:message).with(1, anything, 3)
+    #
+    # will match the following calls:
+    #
+    #   object.message(1, 2, 3)
+    #   object.message(1, 'Boo!', 3)
+    #
+    # but not:
+    #
+    #    object.message(3, 2, 1)
+    #    object.message(1, 2, 3, 4)
+    #
+    # === In Any Order Matcher
+    #
+    # The +in_any_order+ pattern will match an array argument, but won't care
+    # about order of elements in the array. For example:
+    #
+    #   object.should have_received(:message).with(in_any_order([3, 2, 1]))
+    #
+    # will match the following calls:
+    #
+    #   object.message([3, 2, 1])
+    #   object.message([1, 2, 3])
+    #
+    # but not:
+    #
+    #   object.message([1, 2, 3, 4])
+    class ArgsMatcher < CallMatcher
+  
+      def initialize(args, parent = nil)
+        super parent
+        @args = args
+      end
+  
+      def matches_without_parents?
+        @calls = @parent.calls.select {|entry| @args == entry[:args] }
+        !@calls.empty?
+      end
+  
+      def failure_message_without_parents
+        if matched?
+          if @args.empty?
+            ", without args"
+          else
+            ", with args #{@args.inspect}"
+          end
+        else
+          if @args.empty?
+            ", but not without args"
+          else
+            ", but not with args #{@args.inspect}"
+          end
+        end
+      end
+  
+    end
+  end
+end

data/lib/not_a_mock/matchers/call_matcher.rb

@@ -0,0 +1,64 @@
+module NotAMock
+  module Matchers
+    class CallMatcher
+  
+      def initialize(parent = nil)
+        @parent = parent
+      end
+  
+      def matches?(object)
+        @object = object
+        @matched = parent_matches? && matches_without_parents?
+      end
+  
+      def matched?; @matched end
+      
+      attr_reader :calls
+  
+      def failure_message
+        if parent_matched?
+          parent_failure_message + failure_message_without_parents
+        else
+          parent_failure_message
+        end
+      end
+      
+      def negative_failure_message
+        failure_message
+      end
+
+      def with(*args)
+        ArgsMatcher.new(args, self)
+      end
+  
+      def without_args
+        ArgsMatcher.new([], self)
+      end
+  
+      def and_returned(result)
+        ResultMatcher.new(result, self)
+      end
+  
+      def exactly(n)
+        TimesMatcher.new(n, self)
+      end
+      def once;  exactly(1) end
+      def twice; exactly(2) end
+  
+    protected
+    
+      def parent_matches?
+        @parent.nil? || @parent.matches?(@object)
+      end
+      
+      def parent_matched?
+        @parent.nil? || @parent.matched?
+      end
+      
+      def parent_failure_message
+        @parent ? @parent.failure_message : @object.inspect
+      end
+
+    end
+  end
+end

data/lib/not_a_mock/matchers/method_matcher.rb

@@ -0,0 +1,29 @@
+require 'not_a_mock/matchers/call_matcher'
+
+module NotAMock
+  module Matchers
+    # Matcher for
+    #   object.should have_received(...)
+    class MethodMatcher < CallMatcher
+  
+      def initialize(method, parent = nil)
+        super parent
+        @method = method
+      end
+  
+      def matches_without_parents?
+        @calls = CallRecorder.instance.calls_by_object_and_method(@object, @method)
+        !@calls.empty?
+      end
+  
+      def failure_message_without_parents
+        if matched?
+          " received #{@method}"
+        else
+          " didn't receive #{@method}"
+        end
+      end
+  
+    end
+  end
+end

data/lib/not_a_mock/matchers/result_matcher.rb

@@ -0,0 +1,29 @@
+require 'not_a_mock/matchers/call_matcher'
+
+module NotAMock
+  module Matchers
+    # Matcher for
+    #   and_returned(...)
+    class ResultMatcher < CallMatcher
+  
+      def initialize(result, parent = nil)
+        super parent
+        @result = result
+      end
+  
+      def matches_without_parents?
+        @calls = @parent.calls.select {|entry| entry[:result] == @result }
+        !@calls.empty?
+      end
+  
+      def failure_message_without_parents
+        if matched?
+          ", and returned #{@result.inspect}"
+        else
+          ", but didn't return #{@result.inspect}"
+        end
+      end
+  
+    end
+  end
+end

data/lib/not_a_mock/matchers/times_matcher.rb

@@ -0,0 +1,46 @@
+require 'not_a_mock/matchers/call_matcher'
+
+module NotAMock
+  module Matchers
+    # Matcher for +once+, +twice+, and
+    #   exactly(n).times
+    class TimesMatcher < CallMatcher
+  
+      def initialize(times, parent = nil)
+        super parent
+        @times = times
+      end
+  
+      def matches_without_parents?
+        @calls = @parent.calls
+        @calls.length == @times
+      end
+  
+      def failure_message_without_parents
+        if matched?
+          ", #{times_in_english(@parent.calls.length)}"
+        else
+          ", but #{times_in_english(@parent.calls.length, true)}"
+        end
+      end
+  
+      def times
+        self
+      end
+  
+    private
+
+      def times_in_english(times, only = false)
+        case times
+          when 1
+            only ? "only once" : "once"
+          when 2
+            "twice"
+          else
+            "#{times} times"
+        end
+      end
+  
+    end
+  end
+end

data/lib/not_a_mock/object_extensions.rb

@@ -0,0 +1,107 @@
+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)
+  	obj = self
+    case method
+      when Symbol
+        NotAMock::CallRecorder.instance.untrack_method(obj, method)
+        NotAMock::Stubber.instance.unstub_method(obj, method)
+        stubber = NotAMock::Stubber.instance.stub_method(obj, method, &block)
+        NotAMock::CallRecorder.instance.track_method(obj, method)
+      when Hash
+        stub_methods(method)
+      else
+        raise ArgumentError
+    end
+    stubber
+  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,85 @@
+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])
+      	stubmethod = NotAMock::StubMethod.new(&block)
+        @stubbed_methods[[object, method]] = stubmethod
+        add_hook(object, method)
+      end
+      stubmethod
+    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 |key, value|
+      	object = key[0]
+      	method = key[1]
+        remove_hook(object, method) 
+      end
+      @stubbed_methods = {}
+    end
+    
+    #Retrieve the stub method data and code for stubbed +method+ on the +object+
+    def get_stubmethod(object, method)
+    	@stubbed_methods[[object, method]]
+    end
+    
+  private
+
+    def add_hook(object, method)
+      method_exists = method_at_any_level?(object, method.to_s)
+      object.meta_eval do
+        alias_method("__unstubbed_#{method}", method) if method_exists
+      end
+      object.instance_eval(<<-EOF, __FILE__, __LINE__)
+        def #{method}(*args, &block)
+          stubmethod = Stubber.instance.get_stubmethod(self, :#{method})
+          stubmethod.yield_to_block(&block)
+          stubmethod.execute_return_block(*args)
+        end   
+      EOF
+    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