stubberry 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 84ce1669272b052fded99ad9ba06ff354ef8dec1891a47e288140b554f159bdc
-  data.tar.gz: e113462e1d879af411a08b81dac5f77ce9d5f9341c700b6b4a2559c72dae5368
+  metadata.gz: 5548414865196ce42a7b4bd38b5692e40f9d7eeda451bb0482bc839dc6e59291
+  data.tar.gz: a52fe5153a697cf2239178a250f40c4f1e19a37d78fccaabca71ed1fb6b084a0
 SHA512:
-  metadata.gz: dd67bcee9b9ef05fe6fc89c5223fa59560ea2229b3835517463e88543256623fc2568277732e38317e95ee8d2573c4d1da4ad72136da2cd0ba639071a9ddd6cc
-  data.tar.gz: 7db15cd29b4d85cbc03a20a701aa693c57c5f11ad8c2d81c1298c0753b84282a639f279f0fa3753e295d40b9a70539dc2631676654d36f34c54e9afe7531a4af
+  metadata.gz: 1c0049bda0ce93dcdf6291d0cdc378f7280ddaed71cdef7fcc48fb61f5bbd5560a5fa8afd8223c7b70a267c7fae9acbd35801abf8382f27dcdef78f9beb659ee
+  data.tar.gz: da8c024937350a5d9ba2961e749e579b248d10533f87c67e98aea39ed999d52d1005c54b4167ad77978057e0d54100181a09ad7f80e0c6f80dba2ca3e24fe02f

data/CHANGELOG.md

@@ -1,3 +1,13 @@
+# 0.2.1
+* new module with assertion methods added 
+* assert_method_called added, this is a flow assertion, you can check the params, and you can check that method was called inside the block, 
+  without stubbing objects and interfering with the original flow 
+* minimal ruby version set to 2.5 ( so we can replace indirect invocations via send(:*_method ) to direct invocations )
+* singleton_classes is now properly cleared after, see PR: https://github.com/seattlerb/minitest/pull/891
+* some methods got '__' prefixes, just to prevent naming collisions  
+  
+  
+
 # 0.1.1
 * initial gem release
 * Stubberry::Object module with stub_must, stub_must_not, stub_must_all, stub_if_* methods

data/README.md

@@ -1,15 +1,21 @@
 # Stubberry
 Pay attention it has 2Bs and 2Rs in naming :)
 
-This gem is planned to be a ultimate sweet collection of stubbing methods for all kinds of testing.
-Feel free to provide any enrichment suggestions.
+This gem is planned to be an ultimate sweet collection of stubbing methods for any kinds of testing.
+Any new cool stubbing suggestions are welcome.
 
 ## Installation
 
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'stubberry'
+# stubberry extends Object methods, so it should not be required in production
+group :test, :development do
+    gem 'stubberry'
+end
+
+#OR 
+gem 'stubberry', group: [:test, :development]
 ```
 
 And then execute:
@@ -31,13 +37,12 @@ Set of stubbing methods added to an Object class hence available for any class o
 
 ```ruby
 
-# a copy/paste of an Objects stub method enriched with
-# raise error functionality whenever stubbed method wasn't called
 # stub_must( name, val_or_callable, *block_args )
+# raise error functionality whenever stubbed method wasn't called
 
-test 'check call params with a call must happened' do 
+test 'check mehtod "run" params and execution' do 
   class_or_obj.stub_must(:run, -> ( param ) {
-    # Now you can be sure: either you have an expected param, OR 
+    # Now you can be sure that execution was here and either you have an expected param, OR 
     # if call didn't happened you will see a StandardError raised 
     assert_equal( param, 1 )
   } ) { class_or_obj.run(1) }
@@ -49,15 +54,19 @@ Rem: I know about Mock object, but I don't like it. You may consider approach wi
 But I do like an error to be aligned to the check, running mock.verify some place after check did happened, feels unnatural and uncomfortable to me
 
 ```ruby
-# the reverse method of stub_must -- will raise an issue whenever method
-# was called inside a stubbing block, ensures that flow didn't reach given method 
+
 # stub_must_not( name, message = nil ) 
+# the reverse method of stub_must -- will raise an issue whenever method
+# **was** called inside a stubbing block, ensures that flow didn't reach given method 
 test 'call must not happened' do
+  # nothing raised
   class_or_obj.stub_must_not(:run) { class_or_obj.call(1) }
+  # StandardError will be raised: 
+  class_or_obj.stub_must_not(:run) { class_or_obj.run(1) }
 end
 
-# just for fun multiple stub_must in one call 
 # stub_must_all( name_to_var_or_callable, &block )
+# just for fun multiple stub_must in one call, will raise one error for any amount of missing method's calls
 test 'all calls should happened' do
   class_or_obj.stub_must_all(
     run: true,
@@ -68,10 +77,11 @@ test 'all calls should happened' do
   end
 end
 
-# stub only if respond_to otherwise just execute block. 
-# It's a really rare case, I used only once for incompatible gems versions test 
-# 
 # stub_if_def(name, val_or_callable, *block_args, &block)
+# stub only if method present on the object, otherwise just execute block. 
+# It's a really rare case, I used only once for incompatible gems versions test. 
+# When I needed to check that the execution flow can survive missing methods. 
+#
 test 'all calls should happened' do
   class_or_obj.stub_if_def( :not_def, -> (param) { assert_equal(param, :param) } ) do
     # when there is nothing to stub, just yield
@@ -111,6 +121,32 @@ test 'object with a given id got method stubbed' do
 end
 ```
 
+### Stubberry::Assertions
+
+Control flow without interference, you want to be sure that method called and stubbing either to verbose or problematic. 
+
+```ruby
+
+class YouTest < Minitest::TestCase
+  
+    include Stubberry::Assertions
+
+    test 'save called without object interference' do 
+      cmnt = Comment.new
+      assert_difference( -> { Comment.count } ) do 
+          assert_method_called( cmnt, :save ) { cmnt.save }
+      end
+    end
+    
+    test 'gently check method params' do
+      cmnt = Comment.new
+      assert_method_called( cmnt, :save, -> (options) {
+        assert_equal( options, {validate: false} )
+      } ) { cmnt.save(validate: false) }
+    end
+end
+```
+
 
 ## Development
 

data/lib/stubberry/active_record.rb

@@ -14,16 +14,16 @@ module Stubberry::ActiveRecord
   # we adding after_find callback extending object with self.class.extend_any
   # default implementation of self.class.extend_any does nothing
   included do
-    after_find {|obj| self.class.extend_any(obj) }
+    after_find {|obj| self.class.__extend_any(obj) }
   end
 
   module ClassMethods
 
     # This method could be used whenever there is a need for stubbing
     # the exact ActiveRecord object attributes inside some execution flow
-    # __without__ underlying record change
+    # __WITHOUT__!!  underlying record change
     def stub_orm_attr(id, obj_or_attributes )
-      stub(:extend_any, -> (obj) {
+      stub(:__extend_any, -> (obj) {
         return unless obj.id == id && obj.is_a?( self )
         obj.assign_attributes( obj_or_attributes.try(:attributes) || obj_or_attributes )
       }) do
@@ -33,23 +33,27 @@ module Stubberry::ActiveRecord
 
     # This method could be used whenever there is a need for stubbing
     # the specific Active Record object's methods inside some flow piece
-    # with ANY way of object retrieval, making
+    # with ANY way of object retrieval
     def stub_orm_method(id, method, val_or_callable, *block_args  )
-      stub(:extend_any, -> (obj) {
+      stub(:__extend_any, -> (obj) {
         return unless obj.id == id && obj.is_a?( self )
-        define_stub_method(obj, method, val_or_callable, *block_args )
+        __define_stub_method(obj, method, val_or_callable, *block_args )
       }) do
         yield
       end
     ensure
-      undef_all(id, method)
+      __revert_all_methods(id, method)
     end
 
     private_class_method
 
-    def define_stub_method( object, method, val_or_callable, *block_args )
-      old_method = stub_method_name(method, obj: object)
-      object.singleton_class.send :alias_method, old_method, method
+    def __define_stub_method(object, method, val_or_callable, *block_args )
+      method_new_name = __stub_method_name(method, obj: object)
+
+      __define_dynamic_method_replacement( object, method )
+
+      object.singleton_class.alias_method( method_new_name, method )
+      
       object.define_singleton_method method do |*args, &blk|
         if val_or_callable.respond_to? :call
           val_or_callable.call(*args, &blk)
@@ -58,27 +62,35 @@ module Stubberry::ActiveRecord
           val_or_callable
         end
       end
-      stubbed_objects(old_method) << object
+      __stubbed_objects(method_new_name) << object
+    end
+
+    def __define_dynamic_method_replacement( object, method )
+      # this means method is dynamic 
+      return unless object.respond_to?( method ) && !object.methods.map(&:to_s).include?( method.to_s )
+
+      object.define_singleton_method( method ) { | *args, **kargs, &block | super(*args, **kargs, &block) }
     end
 
-    def stub_method_name( method, obj: nil, id: nil)
+    def __stub_method_name(method, obj: nil, id: nil)
       # __stub_class_method_id
       "__stub_#{to_s}_#{method}_#{obj&.id || id}"
     end
 
-    def undef_all(id, method)
-      old_method = stub_method_name( method, id: id)
-      stubbed_objects(old_method).map(&:singleton_class).each do |metaclass|
+    def __revert_all_methods(id, method)
+      method_new_name = __stub_method_name(method, id: id)
+
+      __stubbed_objects(method_new_name).map(&:singleton_class).each do |metaclass|
         metaclass.send :undef_method, method
-        metaclass.send :alias_method, method, old_method
-        metaclass.send :undef_method, old_method
+        metaclass.send :alias_method, method, method_new_name
+        metaclass.send :undef_method, method_new_name
       end
     end
 
-    def stubbed_objects(method_name)
-      (@@extended_obj ||= {})[method_name] ||= []
+    def __stubbed_objects(method_name)
+      (@@__extended_objects ||= {})[method_name] ||= []
     end
 
-    def extend_any(_obj); :do_nothing end
+    def __extend_any(_obj); :do_nothing end
   end
-end if defined?(ActiveSupport::Concern)
+end if defined?(ActiveRecord)

data/lib/stubberry/assertions.rb

@@ -0,0 +1,34 @@
+module Stubberry::Assertions
+
+  # it close to Object stub definition except its not
+  # stubbing the original method instead its just controlling the flow
+  # with minimum side effects
+  def assert_method_called( object, method, inspect_params_callable = nil )
+    base_method_new_name = "__old_#{method}_method"
+    metaclass = object.singleton_class
+
+    singleton_has_stubbing_method = object.singleton_methods.map(&:to_s).include?( method.to_s )
+
+    # dynamic methods should be explicitly defined
+    if object.respond_to?( method ) && !object.methods.map(&:to_s).include?( method.to_s )
+      metaclass.define_method( method ) { |*args, **kargs, &block| super(*args, **kargs, &block) }
+    end
+
+    metaclass.alias_method base_method_new_name, method
+
+    call_happened = []
+
+    metaclass.define_method( method ) do |*args, **kargs, &blk|
+      inspect_params_callable.call(*args, **kargs) if inspect_params_callable
+      call_happened << true
+      send(base_method_new_name, *args, **kargs, &blk)
+    end
+
+    yield.tap { raise "#{method} wasn't called" if call_happened.length == 0 }
+
+  ensure
+    metaclass.__stbr_clear_singleton_class( method, base_method_new_name, singleton_has_stubbing_method )
+  end
+
+end
+

data/lib/stubberry/object.rb

@@ -1,30 +1,22 @@
 module Stubberry::Object
-  # a copy/paste of an Objects stub method enriched with
-  # raise error functionality whenever stubbed method wasn't called
+  # this is an enrichment of an original stub method from the minitest/mock
   def stub_must( name, val_or_callable, *block_args )
-    new_name = "__minitest_stub__#{name}"
-    call_happened_method_name = "__#{name}_call_happened"
+    method_new_name = "__minitest_stub__#{name}"
 
-    metaclass = class << self; self; end
+    singleton_has_stubbing_method = singleton_methods.map(&:to_s).include?( name.to_s )
 
-    if respond_to? name and not methods.map(&:to_s).include? name.to_s then
-      metaclass.send :define_method, name do |*args|
-        super(*args)
-      end
+    if respond_to?( name ) && !methods.map(&:to_s).include?( name.to_s )
+      singleton_class.define_method( name ) { |*args, **kargs, &block| super(*args, **kargs, &block) }
     end
 
-    metaclass.send :alias_method, new_name, name
+    singleton_class.alias_method( method_new_name, name )
 
-    # this will make a closure without spoiling class with any instance vars and so
     call_happened = []
-    metaclass.send :define_method, call_happened_method_name do
-      call_happened << true
-    end
 
-    metaclass.send :define_method, name do |*args, &blk|
-      __send__(call_happened_method_name)
+    singleton_class.define_method( name ) do |*args, &blk|
+      call_happened << true
 
-      if val_or_callable.respond_to? :call then
+      if val_or_callable.respond_to?( :call )
         val_or_callable.call(*args, &blk)
       else
         blk.call(*block_args) if blk
@@ -33,34 +25,31 @@ module Stubberry::Object
     end
 
     (yield self).tap do
-      raise  "#{name} wasn't called" if call_happened.length == 0
+      raise "#{name} wasn't called" if call_happened.length == 0
     end
   ensure
-    metaclass.send :undef_method, name
-    metaclass.send :alias_method, name, new_name
-    metaclass.send :undef_method, new_name
-    metaclass.send :undef_method, call_happened_method_name
+    singleton_class.__stbr_clear_singleton_class( name, method_new_name, singleton_has_stubbing_method )
   end
 
   # the reverse method of stub_must -- will raise an issue whenever method
   # was called inside a stubbing block
   def stub_must_not( name, message = nil )
-    new_name = "__minitest_stub__#{name}"
+    method_new_name = "__minitest_stub__#{name}"
+    singleton_has_stubbing_method = singleton_methods.map(&:to_s).include?( name.to_s )
 
     metaclass = class << self; self; end
 
     if respond_to?(name) && !methods.map(&:to_s).include?( name.to_s )
-      metaclass.define_method( name ) { | *args | super(*args) }
+      metaclass.define_method( name ) { | *args, **kargs, &block | super(*args, **kargs, &block) }
     end
 
-    metaclass.alias_method( new_name, name )
+    metaclass.alias_method( method_new_name, name )
+
     metaclass.define_method( name ) { |*| raise message || "#{name} was called!" }
 
     yield self
   ensure
-    metaclass.undef_method( name )
-    metaclass.alias_method( name, new_name )
-    metaclass.undef_method( new_name )
+    metaclass.__stbr_clear_singleton_class( name, method_new_name, singleton_has_stubbing_method )
   end
 
   # just for fun multiple stub_must in one call
@@ -79,6 +68,13 @@ module Stubberry::Object
     # stub only if respond otherwise just execute
     respond_to?( name ) ? stub_must(name, val_or_callable, *block_args, &block) : yield
   end
+
+  def __stbr_clear_singleton_class( name, new_name, had_method_before)
+    raise Stubberry::Error.new('This is a singleton_class methods only!') unless singleton_class?
+    remove_method( name )
+    alias_method( name, new_name ) if had_method_before
+    remove_method( new_name )
+  end
 end
 
 Object.include(Stubberry::Object)

data/lib/stubberry/version.rb

@@ -1,3 +1,3 @@
 module Stubberry
-  VERSION = "0.1.1"
+  VERSION = "0.2.0"
 end

data/lib/stubberry.rb

@@ -1,8 +1,8 @@
 require "stubberry/version"
 require "stubberry/object"
 require "stubberry/active_record"
+require "stubberry/assertions"
 
 module Stubberry
   class Error < StandardError; end
-  # Your code goes here...
 end

data/stubberry.gemspec

@@ -27,7 +27,7 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.required_ruby_version = '>= 2.4'
+  spec.required_ruby_version = '>= 2.5'
   spec.add_development_dependency "activerecord", ">= 6.1"
 
   spec.add_development_dependency "bundler", ">= 1"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: stubberry
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - alekseyl
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-11-17 00:00:00.000000000 Z
+date: 2022-01-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -115,6 +115,7 @@ files:
 - bin/setup
 - lib/stubberry.rb
 - lib/stubberry/active_record.rb
+- lib/stubberry/assertions.rb
 - lib/stubberry/object.rb
 - lib/stubberry/version.rb
 - stubberry.gemspec
@@ -134,7 +135,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.4'
+      version: '2.5'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="