muack 1.5.1 → 1.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 77dfffce2bb5df1930472ff39a8280bd9a1a69f6e81d1f0173d02099b5cdeaf9
-  data.tar.gz: aabb83e37e3ae995c02ad1ba1e938866cd3e036fa8a3f7682273a80255c60f90
+  metadata.gz: 012f658496e2711ec98bf468ffbb58ddfe339eafe03c4618e3cc9b91025b0b03
+  data.tar.gz: 505dbe6462efb20502468cf75f23459afa4589a8cd9d5f5ebc24eaf9a4d004ea
 SHA512:
-  metadata.gz: 01e57727b0e41455e69a5c4f0f6552b14d1efc192b08435d4b154abe68d86bf62e058cc54196ca05fb1519a301ae7c4fd3bc9924e25a2036c44d1b5a3c3a7843
-  data.tar.gz: 2324f6b087b7d79c46c5727078fce53a2f178ff8474bbed48af3750e447ad6e16168b788d148ca3c3a347a6a11ac578b923aa5effeb81013a9ab5e159d5508e3
+  metadata.gz: 9b538db391549b7da213ab0be7af6f58f71682277e897aae341285daecb47aad5bedfee581e0602908df4a5be55e5faa471d4bf8127a5cd68190058e22dc422c
+  data.tar.gz: 2d3ca26974fa4b73f2dd394ccf0323ebb720a40f3f6c30c72736680f4399f714a4a141998abf799dc846c4f1e0d2d4e3716fb719a256cfd2dd3618a57572be27

data/.travis.yml

@@ -7,6 +7,7 @@ script: 'ruby -vwr bundler/setup -S rake test'
 
 matrix:
   include:
+    - rvm: 2.3
     - rvm: 2.4
       env: RUBYOPT=--enable-frozen-string-literal
     - rvm: 2.5
@@ -17,5 +18,5 @@ matrix:
       env: RUBYOPT=--enable-frozen-string-literal
     - rvm: ruby-head
       env: RUBYOPT=--enable-frozen-string-literal
-    - rvm: jruby
+    - rvm: jruby-9.2
       env: RUBYOPT=--enable-frozen-string-literal

data/CHANGES.md

@@ -1,5 +1,18 @@
 # CHANGES
 
+## Muack 1.6.0 -- 2020-12-06
+
+### Enhancement
+
+* Fix a few cases for mocking against modules/classes with prepended modules,
+  especially when `any_instance_of` is also used in combination. Previously,
+  it's either not mocking correctly or it may affect modules/classes which
+  also use the same prepended modules. For mocking prepended methods, an
+  internal `MuackPrepended` module will be prepended into the modules/classes
+  to properly override the prepended methods. This module cannot be removed
+  between tests because there's no way to do that with current Rubies.
+* Performance could be potentially slightly improved with Ruby 2.6+
+
 ## Muack 1.5.1 -- 2020-12-06
 
 ### Bugs fixed

data/lib/muack/definition.rb

@@ -2,7 +2,7 @@
 module Muack
   Definition  = Struct.new(:msg, :args, :returns,
                            :peek_args, :peek_return,
-                           :original_method, :visibility)
+                           :target, :original_method, :visibility)
   ActualCall  = Struct.new(:msg, :args, :block)
   WithAnyArgs = Object.new
 end

data/lib/muack/mock.rb

@@ -112,22 +112,18 @@ module Muack
     private
     def __mock_inject_method defi
       __mock_injected[defi.msg] = defi
-      # a) ancestors.first is the first module in the method chain.
-      #    it's just the singleton_class when nothing was prepended,
-      #    otherwise the last prepended module.
-      # b) would be the class in AnyInstanceOf.
-      target = object.singleton_class.ancestors.first
+      target = Mock.prepare_target(object.singleton_class, defi.msg)
+      defi.target = target
       Mock.store_original_method(target, defi)
       __mock_inject_mock_method(target, defi)
     end
 
     def __mock_reset_method defi
-      object.singleton_class.ancestors.first.module_eval do
+      defi.target.module_eval do
         remove_method(defi.msg)
         # restore original method
-        if public_instance_methods(false).include?(defi.original_method) ||
-           protected_instance_methods(false).include?(defi.original_method) ||
-           private_instance_methods(false).include?(defi.original_method)
+        if defi.original_method &&
+           Mock.direct_method_defined?(self, defi.original_method)
           alias_method(defi.msg, defi.original_method)
           __send__(defi.visibility, defi.msg)
           remove_method(defi.original_method)
@@ -135,18 +131,68 @@ module Muack
       end
     end
 
-    def self.store_original_method klass, defi
-      visibility = if klass.public_instance_methods(false).include?(defi.msg)
-        :public
-      elsif klass.protected_instance_methods(false).include?(defi.msg)
-        :protected
-      elsif klass.private_instance_methods(false).include?(defi.msg)
-        :private
+    if ::Class.instance_method(:method_defined?).arity == 1 # Ruby 2.5-
+      def self.direct_method_defined? mod, msg
+        mod.public_instance_methods(false).include?(msg) ||
+          mod.protected_instance_methods(false).include?(msg) ||
+          mod.private_instance_methods(false).include?(msg)
       end
 
-      if visibility # store original method
-        original_method = find_new_name(klass, defi.msg)
-        klass.__send__(:alias_method, original_method, defi.msg)
+      def self.method_visibility mod, msg
+        if mod.public_instance_methods(false).include?(msg)
+          :public
+        elsif mod.protected_instance_methods(false).include?(msg)
+          :protected
+        elsif mod.private_instance_methods(false).include?(msg)
+          :private
+        end
+      end
+    else # Ruby 2.6+
+      def self.direct_method_defined? mod, msg
+        mod.method_defined?(msg, false) || # this doesn't cover private method
+          mod.private_method_defined?(msg, false)
+      end
+
+      def self.method_visibility mod, msg
+        if mod.public_method_defined?(msg, false)
+          :public
+        elsif mod.protected_method_defined?(msg, false)
+          :protected
+        elsif mod.private_method_defined?(msg, false)
+          :private
+        end
+      end
+    end
+
+    def self.prepare_target singleton_class, msg
+      if singleton_class == singleton_class.ancestors.first # no prepended mod
+        singleton_class
+      else # check if we need to prepend an internal module to override
+        index = singleton_class.ancestors.index(singleton_class)
+        prepended_modules = singleton_class.ancestors[0...index]
+
+        if prepended_modules.find{ |m| direct_method_defined?(m, msg) }
+          # prepend an internal module to override the prepended module(s)
+          name = :MuackPrepended
+          if singleton_class.const_defined?(name)
+            singleton_class.const_get(name)
+          else
+            prepended = ::Module.new
+            singleton_class.const_set(name, prepended)
+            singleton_class.private_constant(name)
+            singleton_class.prepend(prepended)
+            prepended
+          end
+        else # we don't need to override so singleton class is enough
+          singleton_class
+        end
+      end
+    end
+
+    def self.store_original_method mod, defi
+      if visibility = method_visibility(mod, defi.msg)
+        original_method = find_new_name(mod, defi.msg)
+        mod.__send__(:alias_method, original_method, defi.msg)
         defi.original_method = original_method
         defi.visibility = visibility
       else
@@ -154,14 +200,14 @@ module Muack
       end
     end
 
-    def self.find_new_name klass, message, level=0
+    def self.find_new_name mod, message, level=0
       if level >= (::ENV['MUACK_RECURSION_LEVEL'] || 9).to_i
         raise CannotFindInjectionName.new(level+1, message)
       end
 
       new_name = "__muack_#{name}_#{level}_#{message}".to_sym
-      if klass.instance_methods(false).include?(new_name)
-        find_new_name(klass, message, level+1)
+      if direct_method_defined?(mod, new_name)
+        find_new_name(mod, message, level+1)
       else
         new_name
       end

data/lib/muack/version.rb

@@ -1,4 +1,4 @@
 
 module Muack
-  VERSION = '1.5.1'
+  VERSION = '1.6.0'
 end

data/muack.gemspec

@@ -1,9 +1,9 @@
 # -*- encoding: utf-8 -*-
-# stub: muack 1.5.1 ruby lib
+# stub: muack 1.6.0 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "muack".freeze
-  s.version = "1.5.1"
+  s.version = "1.6.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
   s.require_paths = ["lib".freeze]

data/test/test_mock.rb

@@ -104,10 +104,73 @@ describe Muack::Mock do
     end
 
     describe 'not affect the original module' do
-      would 'with include' do
-        m = Module.new{ def f; :f; end }
-        c0 = Class.new{ include m }.new
-        c1 = Class.new{ include m }.new
+      def mod
+        @mod ||= Module.new{ def f; :f; end }
+      end
+
+      def setup type
+        m = mod
+        Array.new(2).map{ Class.new{ public_send(type, m) }.new }
+      end
+
+      would 'with include and mock' do
+        c0, c1 = setup(:include)
+
+        mock(c0).f{:g}
+
+        expect(c0.f).eq :g
+        expect(c1.f).eq :f
+      end
+
+      would 'with prepend and mock' do
+        c0, c1 = setup(:prepend)
+
+        mock(c0).f{:g}
+
+        expect(c0.f).eq :g
+        expect(c1.f).eq :f
+      end
+
+      would 'with include and mock any_instance_of C0' do
+        c0, c1 = setup(:include)
+
+        mock(any_instance_of(c0.class)).f{:g}
+
+        expect(c0.f).eq :g
+        expect(c1.f).eq :f
+      end
+
+      would 'with prepend and mock any_instance_of C0' do
+        c0, c1 = setup(:prepend)
+
+        mock(any_instance_of(c0.class)).f{:g}
+
+        expect(c0.f).eq :g
+        expect(c1.f).eq :f
+      end
+
+      would 'with include and mock any_instance_of M' do
+        c0, c1 = setup(:include)
+
+        mock(any_instance_of(mod)).f{:g}.times(2)
+
+        expect(c0.f).eq :g
+        expect(c1.f).eq :g
+      end
+
+      would 'with prepend and mock any_instance_of M' do
+        c0, c1 = setup(:prepend)
+
+        mock(any_instance_of(mod)).f{:g}.times(2)
+
+        expect(c0.f).eq :g
+        expect(c1.f).eq :g
+      end
+
+      would 'with extend on the instance' do
+        m = mod
+        c0 = Class.new.new.extend(m)
+        c1 = Class.new{ prepend m }.new
 
         mock(c0).f{:g}
 
@@ -115,9 +178,10 @@ describe Muack::Mock do
         expect(c1.f).eq :f
       end
 
-      would 'with prepend' do
-        m = Module.new{ def f; :f; end }
-        c0 = Class.new{ prepend m }.new
+      would 'with prepend on the singleton class of instance' do
+        m = mod
+        c0 = Class.new.new
+        c0.singleton_class.prepend m
         c1 = Class.new{ prepend m }.new
 
         mock(c0).f{:g}
@@ -125,6 +189,83 @@ describe Muack::Mock do
         expect(c0.f).eq :g
         expect(c1.f).eq :f
       end
+
+      describe 'with prepend on any_instance_of' do
+        describe 'on prepended method' do
+          would 'have a muack prepended module' do
+            m = mod
+            c = Class.new{ prepend m }
+            ancestors_size = c.ancestors.size
+
+            mock(any_instance_of(c)).f{:g}
+
+            expect(c.new.f).eq :g
+            expect(c).const_defined?(:MuackPrepended)
+            expect(c.ancestors.size).eq ancestors_size + 1
+
+            expect(Muack.verify).eq true
+
+            # Make sure there's only one MuackPrepended
+            mock(any_instance_of(c)).f{:h}
+            expect(c.ancestors.size).eq ancestors_size + 1
+            expect(c.new.f).eq :h
+          end
+        end
+
+        describe 'on non-prepended method' do
+          would 'not have a muack prepended module' do
+            m = mod
+            c = Class.new{ def g; :g; end; prepend m }
+            ancestors_size = c.ancestors.size
+
+            mock(any_instance_of(c)).g{:m}
+
+            expect(c.new.f).eq :f
+            expect(c.new.g).eq :m
+            expect(c).not.const_defined?(:MuackPrepended)
+            expect(c.ancestors.size).eq ancestors_size
+          end
+        end
+      end
+
+      describe 'any_instance_of on a module which has a prepended module' do
+        before do
+          @m0 = m0 = Module.new{ def f; :m0; end }
+          @m1 = m1 = Module.new{ def f; :m1; end; prepend m0 }
+          @c0 = Class.new{ prepend m0 }.new
+          @c1 = Class.new{ prepend m1 }.new
+        end
+
+        would 'any_instance_of m0' do
+          mock(any_instance_of(@m0)).f{:g}.times(2)
+
+          expect(@c0.f).eq :g
+          expect(@c1.f).eq :g
+        end
+
+        would 'any_instance_of m1' do
+          skip
+
+          mock(any_instance_of(@m1)).f{:g}
+
+          expect(@c0.f).eq :m0
+          expect(@c1.f).eq :g # m1 does not know c1 thus no way to pass this
+        end
+
+        would 'any_instance_of c0.class' do
+          mock(any_instance_of(@c0.class)).f{:g}
+
+          expect(@c0.f).eq :g
+          expect(@c1.f).eq :m0
+        end
+
+        would 'any_instance_of c1.class' do
+          mock(any_instance_of(@c1.class)).f{:g}
+
+          expect(@c0.f).eq :m0
+          expect(@c1.f).eq :g
+        end
+      end
     end
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: muack
 version: !ruby/object:Gem::Version
-  version: 1.5.1
+  version: 1.6.0
 platform: ruby
 authors:
 - Lin Jen-Shin (godfat)