muack 1.3.0 → 1.5.1

data/test/test_any_instance_of.rb

@@ -57,8 +57,8 @@ describe Muack::AnyInstanceOf do
   end
 
   would 'mock with multiple any_instance_of call' do
-    any_instance_of(klass){ |inst| mock(inst).f(is_a(Fixnum)){ |i| i+1 } }
-    any_instance_of(klass){ |inst| mock(inst).f(is_a(Fixnum)){ |i| i+2 } }
+    any_instance_of(klass){ |inst| mock(inst).f(is_a(Integer)){ |i| i+1 } }
+    any_instance_of(klass){ |inst| mock(inst).f(is_a(Integer)){ |i| i+2 } }
     obj = klass.new
     obj.f(2).should.eq 3
     obj.f(2).should.eq 4
@@ -112,4 +112,18 @@ describe Muack::AnyInstanceOf do
 
     obj.f.should.eq 0
   end
+
+  # Brought from rspec-mocks and it's currently failing on rspec-mocks
+  would 'stub any_instance_of on module extending it self' do
+    mod = Module.new {
+      extend self
+      def hello; :hello; end
+    }
+
+    any_instance_of(mod){ |inst| stub(inst).hello{ :stub } }
+
+    expect(mod.hello).eq(:stub)
+    expect(Muack.verify)
+    expect(mod.hello).eq(:hello)
+  end
 end

data/test/test_from_readme.rb

@@ -2,8 +2,7 @@
 require 'muack/test'
 
 describe 'from README.md' do
-  readme = File.read(
-             "#{File.dirname(File.expand_path(__FILE__))}/../README.md")
+  readme = File.read("#{__dir__}/../README.md")
   codes  = readme.scan(/``` ruby(.+?)```/m).map(&:first)
 
   after{ Muack.reset }
@@ -12,15 +11,14 @@ describe 'from README.md' do
     include Muack::API
 
     def describe desc, &block
-      @executor.describe(desc, &block)
-      @executor.execute(Pork.execute_mode, @stat)
+      @suite.describe(desc, &block)
+      Pork::Executor.execute(:stat => @stat, :suite => @suite)
     end
 
     def results; @results ||= []; end
     def p res  ; results << res ; end
 
     def verify expects
-      return if results.empty?
       results.zip(expects).each do |(res, exp)|
         next if exp == 'ok'
         if exp.start_with?('raise')
@@ -34,10 +32,10 @@ describe 'from README.md' do
 
   codes.each.with_index do |code, index|
     would 'pass from README.md #%02d' % index do
-      executor, stat = Class.new(self.class){ init }, pork_stat
+      suite, stat = Class.new(self.class){ init }, pork_stat
       context = Module.new do
         extend Context
-        @executor, @stat = executor, stat
+        @suite, @stat = suite, stat
       end
       begin
         context.instance_eval(code, 'README.md', 0)

data/test/test_keyargs.rb

@@ -0,0 +1,160 @@
+
+require 'muack/test'
+
+describe Muack::Mock do
+  after do
+    Muack.verify.should.eq true
+    Muack::EnsureReset.call
+  end
+
+  describe 'passing single hash' do
+    would 'hash literal' do
+      mock(Obj).say({}, &:itself)
+
+      expect(Obj.say({})).eq({})
+    end
+
+    would 'hash literal with satisfying check' do
+      mock(Obj).say(is_a(Hash), &:itself)
+
+      expect(Obj.say({})).eq({})
+    end
+
+    would 'hash value' do
+      arg = {}
+
+      mock(Obj).say(arg, &:itself)
+
+      expect(Obj.say(arg)).eq(arg)
+    end
+
+    would 'non-empty hash' do
+      mock(Obj).say(a: 0, &:itself)
+
+      expect(Obj.say(a: 0)).eq(a: 0)
+    end
+
+    would 'non-empty hash with satisfying check' do
+      mock(Obj).say(where(a: 0), &:itself)
+
+      expect(Obj.say(a: 0)).eq(a: 0)
+    end
+  end
+
+  describe 'keyargs mock' do
+    copy :tests do
+      would 'local block' do
+        mock(obj).say.with_any_args.returns{ |a:| a }
+
+        expect(instance.say(a: 0)).eq(0)
+      end
+
+      would 'instance method' do
+        mock(obj).bonjour(a: 0, b: 1)
+
+        expect(instance.bonjour(a: 0, b: 1)).eq([0, 1])
+      end
+
+      would 'prepended method' do
+        mock(obj).prepend_bonjour(a: 0, b: 1)
+
+        expect(instance.prepend_bonjour(a: 0, b: 1)).eq([0, 1])
+      end
+    end
+
+    describe 'with direct mock' do
+      def obj
+        Obj
+      end
+
+      def instance
+        obj
+      end
+
+      paste :tests
+
+      would 'singleton method' do
+        mock(obj).single_bonjour(a: 0, b: 1)
+
+        expect(instance.single_bonjour(a: 0, b: 1)).eq([0, 1])
+      end
+    end
+
+    describe 'with any_instance_of' do
+      def obj
+        any_instance_of(Cls)
+      end
+
+      def instance
+        @instance ||= Cls.new
+      end
+
+      paste :tests
+    end
+
+    would 'peek_args' do
+      mock(Obj).say.with_any_args.
+        peek_args{ |a:| [{a: a.succ}] }.
+        returns{ |a:| a.succ }
+
+      expect(Obj.say(a: 0)).eq(2)
+    end
+
+    would 'peek_args with instance_exec' do
+      mock(Obj).say.with_any_args.
+        peek_args(instance_exec: true){ |a:| [{a: object_id}] }.
+        returns{ |a:| a }
+
+      expect(Obj.say(a: 0)).eq(Obj.object_id)
+    end
+  end
+
+  describe 'proxy new' do
+    would 'handle initialize via ordinal new' do
+      kargs_initialize = Class.new do
+        def initialize a:
+          @a = a
+        end
+        attr_reader :a
+      end
+
+      mock(kargs_initialize).new(a: 0)
+
+      expect(kargs_initialize.new(a: 0).a).eq(0)
+    end
+
+    would 'handle overridden new without keyword arguments' do
+      kargs_initialize = Class.new do
+        def initialize a:
+          @a = a
+        end
+        attr_reader :a
+
+        def self.new a
+          super(a: a)
+        end
+      end
+
+      mock(kargs_initialize).new(0)
+
+      expect(kargs_initialize.new(0).a).eq(0)
+    end
+
+    would 'handle overridden new with keyword arguments' do
+      kargs_initialize = Class.new do
+        def initialize a
+          @a = a
+        end
+        attr_reader :a
+
+        def self.new a:
+          super(a)
+        end
+      end
+
+      mock(kargs_initialize).new(a: 0)
+
+      expect(kargs_initialize.new(a: 0).a).eq(0)
+    end
+  end
+end

data/test/test_mock.rb

@@ -102,6 +102,30 @@ describe Muack::Mock do
       Muack.verify.should.eq true
       obj.f       .should.eq 0
     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
+
+        mock(c0).f{:g}
+
+        expect(c0.f).eq :g
+        expect(c1.f).eq :f
+      end
+
+      would 'with prepend' do
+        m = Module.new{ def f; :f; end }
+        c0 = Class.new{ prepend m }.new
+        c1 = Class.new{ prepend m }.new
+
+        mock(c0).f{:g}
+
+        expect(c0.f).eq :g
+        expect(c1.f).eq :f
+      end
+    end
   end
 
   describe 'Muack.verify==false' do

data/test/test_modifier.rb

@@ -37,19 +37,19 @@ describe Muack::Modifier do
 
   describe 'peek_args' do
     would 'with lexical scope' do
-      str = 'ff'
+      str = String.new('ff')
       stub(str).to_i.peek_args{16}
       str.to_i.should.eq 255
     end
 
     would 'with dynamic scope' do
-      str = '16'
+      str = String.new('16')
       stub(str).to_i.peek_args(:instance_exec => true){Integer(self)}
       str.to_i.should.eq 22
     end
 
     would 'modify' do
-      str = 'ff'
+      str = String.new('ff')
       stub(str).to_i(is_a(Integer)).peek_args{ |radix| radix * 2 }
       str.to_i(8).should.eq 255
     end
@@ -82,19 +82,19 @@ describe Muack::Modifier do
 
   describe 'peek_return' do
     would 'with lexical scope' do
-      str = 'ff'
+      str = String.new('ff')
       stub(str).to_i.peek_return{16}
       str.to_i.should.eq 16
     end
 
     would 'with dynamic scope' do
-      str = '16'
+      str = String.new('16')
       stub(str).to_i.peek_return(:instance_exec => true){Integer(self)+1}
       str.to_i.should.eq 17
     end
 
     would 'modify' do
-      str = 'ff'
+      str = String.new('ff')
       stub(str).to_i(is_a(Integer)).peek_return{ |result| result * 2 }
       str.to_i(16).should.eq 510
     end

data/test/test_prepend.rb

@@ -0,0 +1,121 @@
+
+require 'muack/test'
+
+describe 'mock with prepend' do
+  after do
+    verify
+  end
+
+  def verify
+    expect(Muack.verify).eq true
+  end
+
+  def generate
+    klass = Class.new do
+      def greet
+        'hi'
+      end
+    end
+
+    mod = Module.new do
+      def greet
+        hello
+      end
+
+      def hello
+        'hello'
+      end
+      private :hello
+    end
+
+    perform(klass, mod)
+  end
+
+  copy :test do
+    would 'mock' do
+      obj = generate
+
+      mock(obj).hello{'mocked'}
+
+      expect(obj.greet).eq 'mocked'
+      verify
+      expect(obj.greet).eq 'hello'
+      expect(obj).not.respond_to? :hello
+    end
+
+    would 'mock proxy' do
+      obj = generate
+
+      mock(obj).hello
+
+      expect(obj.greet).eq 'hello'
+      verify
+      expect(obj.greet).eq 'hello'
+      expect(obj).not.respond_to? :hello
+    end
+  end
+
+  describe 'prepend on class mock with object' do
+    def perform(klass, mod)
+      klass.prepend(mod)
+      klass.new
+    end
+
+    paste :test
+  end
+
+  describe 'extend on object mock with object' do
+    def perform(klass, mod)
+      obj = klass.new
+      obj.extend(mod)
+      obj
+    end
+
+    paste :test
+  end
+
+  describe 'include on singleton_class mock with object' do
+    def perform(klass, mod)
+      obj = klass.new
+      obj.singleton_class.include(mod)
+      obj
+    end
+
+    paste :test
+  end
+
+  describe 'prepend on singleton_class mock with object' do
+    def perform(klass, mod)
+      obj = klass.new
+      obj.singleton_class.prepend(mod)
+      obj
+    end
+
+    paste :test
+  end
+
+  # Brought from rspec-mocks and it's currently failing on rspec-mocks
+  # See https://github.com/rspec/rspec-mocks/pull/1218
+  would "handle stubbing prepending methods that were only defined on the prepended module" do
+    to_be_prepended = Module.new do
+      def value
+        "#{super}_prepended".to_sym
+      end
+
+      def value_without_super
+        :prepended
+      end
+    end
+
+    object = Object.new
+    object.singleton_class.send(:prepend, to_be_prepended)
+    expect(object.value_without_super).eq :prepended
+
+    stub(object).value_without_super{ :stubbed }
+
+    expect(object.value_without_super).eq :stubbed
+
+    expect(Muack.verify)
+    expect(object.value_without_super).eq :prepended
+  end
+end

data/test/test_proxy.rb

@@ -53,6 +53,21 @@ describe Muack::Mock do
       Obj.aloha.should.eq [0, 1]
     end
 
+    would 'proxy and call the original method for keyargs' do
+      mock(Obj).bonjour(a: :b, b: :a)
+      mock(Obj).bonjour
+      Obj.bonjour(a: :b, b: :a).should.eq %i[b a]
+      Obj.bonjour.should.eq [0, 1]
+    end
+
+    would 'proxy and call the original method for fake keyargs' do
+      args = {a: :b, b: :a}
+      mock(Obj).ciao(args)
+      mock(Obj).ciao
+      Obj.ciao(args).should.eq %i[b a]
+      Obj.ciao.should.eq [0, 1]
+    end
+
     would 'proxy and call the block with super' do
       mock(Str).class.peek_return{ |k| k.name.reverse }
       Str.class.should.eq 'gnirtS'
@@ -60,9 +75,9 @@ describe Muack::Mock do
 
     would 'mock proxy and call, mock proxy and call' do
       mock(Obj).class.peek_return{ |k| k.name.reverse }
-      Obj.class.should.eq 'tcejbO'
+      Obj.class.should.eq 'slC'
       mock(Obj).class.peek_return{ |k| k.name.upcase }
-      Obj.class.should.eq 'OBJECT'
+      Obj.class.should.eq 'CLS'
     end
 
     would 'stub proxy and call, stub proxy and call' do
@@ -74,12 +89,12 @@ describe Muack::Mock do
 
     would 'stub proxy with any times' do
       stub(Obj).class.peek_return{ |k| k.name.downcase }
-      3.times{ Obj.class.should.eq 'object' }
+      3.times{ Obj.class.should.eq 'cls' }
     end
 
     would 'stub proxy and spy' do
       stub(Obj).class.peek_return{ |k| k.name.downcase }
-      Obj.class.should.eq 'object'
+      Obj.class.should.eq 'cls'
       spy(Obj).class
     end
   end