aidmock 0.1.0

data/lib/aidmock/method_descriptor.rb

@@ -0,0 +1,136 @@
+# Copyright (c) 2011 Wilker Lúcio
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+module Aidmock
+  class MethodDescriptor
+    attr_accessor :name, :type, :arguments, :class_method
+    alias :class_method? :class_method
+
+    def initialize(name, type, *arguments)
+      @name = name
+      @type = ::Aidmock::Matchers.create(type)
+      @arguments = arguments.map { |arg| ::Aidmock::Matchers.create(arg) }
+      @class_method = false
+    end
+
+    def verify(double)
+      verify_arguments(double)
+      verify_return(double)
+    end
+
+    def verify_arguments(double)
+      arguments = double.arguments
+      check_method_arity!(double)
+      current_matcher = 0
+
+      while arguments.length > 0
+        matcher = @arguments[current_matcher]
+
+        if matcher.instance_of? ::Aidmock::Matchers::SplatArgMatcher
+          arg = arguments
+          arguments = []
+        else
+          arg = arguments.shift
+        end
+
+        unless matcher.match?(arg)
+          raise Aidmock::MethodInterfaceArgumentsNotMatchError.new("argument value #{arg.inspect} doesn't match with #{matcher.inspect}")
+        end
+
+        current_matcher += 1
+      end
+    end
+
+    def verify_return(double)
+      double.result.each do |value|
+        unless @type.match?(value)
+          raise Aidmock::MethodInterfaceReturnNotMatchError.new("Return value #{value.inspect} doesn't match with #{@type.inspect}")
+        end
+      end
+    end
+
+    def arity
+      @arity ||= begin
+        arity = 0
+
+        @arguments.each do |arg|
+          arity += 1
+
+          if optional_arg? arg
+            arity *= -1
+            return arity
+          end
+        end
+
+        arity
+      end
+    end
+
+    def required_arity
+      @required_arity = begin
+        required = arity
+
+        if required < 0
+          required *= -1
+          required -= 1
+        end
+
+        required
+      end
+    end
+
+    def max_number_of_arguments
+      return nil if has_a_splat?
+
+      @arguments.length
+    end
+
+    protected
+
+    def check_method_arity!(double)
+      length = double.arguments.length
+      # in case of positive arity (fixed number of arguments)
+      if arity >= 0
+        if length != arity
+          raise Aidmock::MethodInterfaceArgumentsNotMatchError.new("error on mock method #{double.method.inspect}, expected #{arity} arguments, #{length} sent")
+        end
+      # on negative arity (variable number of arguments)
+      else
+        if length < required_arity
+          raise Aidmock::MethodInterfaceArgumentsNotMatchError.new("error on mock method #{double.method.inspect}, expected at least #{required_arity}, #{length} sent")
+        end
+
+        if max = max_number_of_arguments
+          if length > max
+            raise Aidmock::MethodInterfaceArgumentsNotMatchError.new("error on mock method #{double.method.inspect}, expected at most #{max}, #{length} sent")
+          end
+        end
+      end
+    end
+
+    def has_a_splat?
+      @arguments.last.instance_of? ::Aidmock::Matchers::SplatArgMatcher
+    end
+
+    def optional_arg?(arg)
+      arg.instance_of? Matchers::OptionalArgMatcher or arg.instance_of? Matchers::SplatArgMatcher
+    end
+  end
+end

data/lib/aidmock/sanity.rb

@@ -0,0 +1,79 @@
+# Copyright (c) 2011 Wilker Lúcio
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+module Aidmock
+  module Sanity
+    class << self
+      def sanitize
+        describe "Aidmock Sanity Checks:" do
+          Aidmock.interfaces.each_pair do |klass, interface|
+            context klass.to_s do
+              (interface.methods + interface.class_methods).each do |method|
+                it "have implemented interface for #{method.name}" do
+                  Aidmock::Sanity.sanitize_method(interface.klass, method)
+                end
+              end
+            end
+          end
+        end
+      end
+
+      def sanitize_interfaces
+        Aidmock.interfaces.each_pair do |klass, interface|
+          sanitize_interface(interface)
+        end
+      end
+
+      def sanitize_interface(interface)
+        (interface.methods + interface.class_methods).each do |method|
+          sanitize_method(interface.klass, method)
+        end
+      end
+
+      def sanitize_method(klass, method)
+        verify_method_defined(klass, method)
+        verify_method_arity(klass, method)
+      end
+
+      def verify_method_defined(klass, method)
+        return if method.name.instance_of? Regexp
+        object = method.class_method? ? klass : klass.allocate
+
+        unless object.respond_to? method.name
+          raise "Aidmock Sanity: method '#{method.name}' is not defined for #{klass}"
+        end
+      end
+
+      def verify_method_arity(klass, method)
+        return if method.name.instance_of? Regexp
+        object = method.class_method? ? klass : klass.allocate
+        defined_method = object.method(method.name)
+
+        unless method.arity == defined_method.arity
+          raise "Aidmock Sanity: method '#{method.name}' of #{klass} mismatch interface arity, #{defined_method.arity} for #{method.arity}"
+        end
+      end
+
+      protected
+
+
+    end
+  end
+end

data/lib/aidmock/void_class.rb

@@ -0,0 +1,27 @@
+# Copyright (c) 2011 Wilker Lúcio
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+module Aidmock
+  class VoidClass < BasicObject
+    def method_missing(name, *args, &block)
+      nil
+    end
+  end
+end

data/lib/aidmock.rb

@@ -0,0 +1,105 @@
+# Copyright (c) 2011 Wilker Lúcio
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+require 'aidmock/errors'
+require 'aidmock/basic_object' unless Kernel.const_defined? :BasicObject
+
+module Aidmock
+  autoload :Interface, 'aidmock/interface'
+  autoload :MethodDescriptor, 'aidmock/method_descriptor'
+  autoload :VoidClass, 'aidmock/void_class'
+  autoload :Frameworks, 'aidmock/frameworks'
+  autoload :Matchers, 'aidmock/matchers'
+  autoload :Sanity, 'aidmock/sanity'
+
+  class << self
+    attr_accessor :warn_undefined_interface
+    alias :warn_undefined_interface? :warn_undefined_interface
+
+    def interface(klass, &block)
+      interfaces[klass] = create_or_update_interface(klass, &block)
+    end
+
+    def stub(klass, stubs = {})
+    end
+
+    def verify
+      framework.mocks.each do |mock|
+        verify_double(mock)
+      end
+    end
+
+    def interfaces
+      @interfaces ||= {}
+    end
+
+    protected
+
+    def verify_double(double)
+      klass = extract_class(double.object)
+      chain = chain_for(klass)
+
+      if chain.length > 0
+        verify_double_on_chain(double, chain)
+      else
+        puts "Aidmock Warning: unsafe mocking on class #{klass}, please interface it" if warn_undefined_interface?
+      end
+    end
+
+    def verify_double_on_chain(double, chain)
+      method = find_method_on_chain(double, chain)
+
+      if method
+        method.verify(double)
+      else
+        raise MethodInterfaceNotDefinedError.new(%Q{Aidmock: method "#{double.method}" was not defined for "#{extract_class(double.object)}" interface})
+      end
+    end
+
+    def find_method_on_chain(double, chain)
+      chain.each do |interface|
+        method = interface.find_method(double)
+        return method if method
+      end
+
+      nil
+    end
+
+    def chain_for(klass)
+      klass.ancestors.select { |k| interfaces[k] }.map { |k| interfaces[k] }
+    end
+
+    def extract_class(object)
+      object.instance_of?(Class) ? object : object.class
+    end
+
+    def framework
+      ::Aidmock::Frameworks::RSpec
+    end
+
+    def create_or_update_interface(klass, &block)
+      interface = interfaces[klass] || Interface.new(klass)
+      interface.instance_eval &block
+      interface
+    end
+  end
+end
+
+Aidmock.warn_undefined_interface = true

data/spec/aidmock/frameworks/rspec_spec.rb

@@ -0,0 +1,212 @@
+# Copyright (c) 2011 Wilker Lúcio
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+require File.expand_path("../../../spec_helper", __FILE__)
+
+class Sample; end;
+class SampleWithInitializer
+  def initialize(name)
+    @name = name
+  end
+end
+
+describe Aidmock::Frameworks::RSpec do
+  framework = Aidmock::Frameworks::RSpec
+
+  context ".mocks" do
+    context "caller object" do
+      it "return the object" do
+        obj = Sample.new
+        obj.stub(:some_method)
+
+        framework.mocks[0].object.should == obj
+      end
+    end
+
+    context "method name" do
+      it "return the method name as a symbol" do
+        obj = mock
+        obj.stub(:some_method)
+
+        framework.mocks[0].method.should == :some_method
+      end
+    end
+
+    context "method result" do
+      before :each do
+        @obj = mock
+      end
+
+      it "return an blank array if no return is defined" do
+        @obj.stub(:some_method)
+        framework.should have_mock_result([])
+      end
+
+      it "return an array with the valid argument if one is passed" do
+        @obj.stub(:some_method).and_return("one")
+        framework.should have_mock_result(["one"])
+      end
+
+      it "return an array with all the returns in case of a multiple return" do
+        @obj.stub(:some_method).and_return("one", "two", "three")
+        framework.should have_mock_result(["one", "two", "three"])
+      end
+
+      it "return the value if it's used as a block" do
+        @obj.stub(:some_method) { "value" }
+        framework.should have_mock_result(["value"])
+      end
+
+      it "handles params for return" do
+        @obj.stub(:some_method) { |param| "#{param.haha} messed up"}
+
+        framework.should have_mock_result([" messed up"])
+      end
+    end
+
+    context "method arguments" do
+      before :each do
+        @obj = mock
+      end
+
+      it "return empty list if has no arguments" do
+        @obj.stub(:some_method)
+
+        args = framework.mocks[0].arguments
+        framework.mocks[0].arguments.should == []
+      end
+
+      it "return a list of arguments if they exists" do
+        @obj.stub(:some_method).with("hi", "dear")
+
+        framework.mocks[0].arguments.should have(2).items
+      end
+
+      context "any arg matcher" do
+        it "get nil as result" do
+          @obj.stub(:some_method).with(anything)
+
+          framework.should have_mock_arguments([nil])
+        end
+      end
+
+      context "no arg matcher" do
+        it "get an empty array" do
+          @obj.stub(:some_method).with(no_args)
+
+          framework.should have_mock_arguments([])
+        end
+      end
+
+      context "boolean matcher" do
+        it "get true as result" do
+          @obj.stub(:some_method).with(boolean)
+
+          framework.should have_mock_arguments([true])
+        end
+      end
+
+      context "hash including matcher" do
+        it "get a hash with key set" do
+          @obj.stub(:some_method).with(hash_including(:foo))
+
+          framework.should have_mock_arguments([{:foo => nil}])
+        end
+
+        it "get a hash with key and value set" do
+          @obj.stub(:some_method).with(hash_including(:foo => "bar"))
+
+          framework.should have_mock_arguments([{:foo => "bar"}])
+        end
+
+        it "get a hash with multiple keys and values" do
+          @obj.stub(:some_method).with(hash_including(:foo, :foo2 => "bar"))
+
+          framework.should have_mock_arguments([{:foo => nil, :foo2 => "bar"}])
+        end
+      end
+
+      context "hash not including matcher" do
+        it "get a blank hash" do
+          @obj.stub(:some_method).with(hash_not_including(:foo))
+
+          framework.should have_mock_arguments([{}])
+        end
+      end
+
+      context "duck type matcher" do
+        it "get a object that responds to duck methods" do
+          @obj.stub(:some_method).with(duck_type(:foo, :bar))
+
+          result = framework.mocks[0].arguments[0]
+          result.should respond_to(:foo, :bar)
+        end
+      end
+
+      context "instance of matcher" do
+        it "get a object that be an instance of that class" do
+          @obj.stub(:some_method).with(instance_of(String))
+
+          result = framework.mocks[0].arguments[0]
+          result.should be_an_instance_of(String)
+        end
+
+        it "get an object even if object needs an initializer" do
+          @obj.stub(:some_method).with(instance_of(SampleWithInitializer))
+
+          result = framework.mocks[0].arguments[0]
+          result.should be_an_instance_of(SampleWithInitializer)
+        end
+      end
+
+      context "kind of matcher" do
+        it "get a object that be an instance of that class" do
+          @obj.stub(:some_method).with(kind_of(String))
+
+          result = framework.mocks[0].arguments[0]
+          result.should be_a_kind_of(String)
+        end
+
+        it "get an object even if object needs an initializer" do
+          @obj.stub(:some_method).with(kind_of(SampleWithInitializer))
+
+          result = framework.mocks[0].arguments[0]
+          result.should be_a_kind_of(SampleWithInitializer)
+        end
+      end
+
+      context "equality proxy" do
+        it "get given value" do
+          @obj.stub(:some_method).with("foo")
+
+          framework.should have_mock_arguments(["foo"])
+        end
+      end
+
+      context "regexp matcher" do
+        it "get the regexp" do
+          @obj.stub(:some_method).with(/foo/)
+
+          framework.should have_mock_arguments(["(?-mix:foo)"])
+        end
+      end
+    end
+  end
+end

data/spec/aidmock/interface_spec.rb

@@ -0,0 +1,66 @@
+# Copyright (c) 2011 Wilker Lúcio
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+describe Aidmock::Interface do
+  Interface = Aidmock::Interface
+  MockDescriptor = Aidmock::Frameworks::MockDescriptor
+
+  context "finding the method" do
+    it "find the method defined by exact name" do
+      interface = Interface.new(Object)
+      method = interface.method(:some, nil)
+      double = MockDescriptor.new(nil, :some, nil, [])
+
+      interface.find_method(double).should == method
+    end
+
+    it "find the method defined by and regular expression" do
+      interface = Interface.new(Object)
+      method = interface.method(/find_by_.+/, nil)
+      double = MockDescriptor.new(nil, :find_by_name, nil, [])
+
+      interface.find_method(double).should == method
+    end
+
+    it "find method on class" do
+      interface = Interface.new(Object)
+      method = interface.class_method(:some, nil)
+      double = MockDescriptor.new(Object, :some, nil, [])
+
+      interface.find_method(double).should == method
+    end
+
+    it "not find an class method on instance search" do
+      interface = Interface.new(Object)
+      method = interface.class_method(:some, nil)
+      double = MockDescriptor.new(nil, :some, nil, [])
+
+      interface.find_method(double).should == nil
+    end
+
+    it "not find an instance method on class search" do
+      interface = Interface.new(Object)
+      method = interface.method(:some, nil)
+      double = MockDescriptor.new(Object, :some, nil, [])
+
+      interface.find_method(double).should == nil
+    end
+  end
+end