muack 0.7.3 → 1.0.0

data/test/test_any_instance_of.rb

@@ -2,10 +2,10 @@
 require 'muack/test'
 
 describe Muack::AnyInstanceOf do
-  klass = Class.new{ def f; 0; end }
+  klass = Class.new{ def f; 0; end; private; def g; 1; end }
 
   should 'mock any_instance_of' do
-    any_instance_of(klass){ |instance| mock(instance).say{ true } }
+    any_instance_of(klass){ |inst| mock(inst).say{ true } }
     obj = klass.new
     obj.say              .should.eq true
     obj.respond_to?(:say).should.eq true
@@ -13,16 +13,33 @@ describe Muack::AnyInstanceOf do
     obj.respond_to?(:say).should.eq false
   end
 
+  should 'mock any_instance_of with instance_exec' do
+    any_instance_of(klass){ |inst|
+      mock(inst).say.returns(:instance_exec => true){ f } }
+    obj = klass.new
+    obj.say              .should.eq obj.f
+    Muack.verify         .should.eq true
+    obj.respond_to?(:say).should.eq false
+  end
+
   should 'proxy any_instance_of' do
-    any_instance_of(klass){ |instance| mock(instance).f.proxy }
+    any_instance_of(klass){ |inst| mock(inst).f }
     obj = klass.new
     obj.f       .should.eq 0
     Muack.verify.should.eq true
     obj.f       .should.eq 0
   end
 
-  should 'proxy any_instance_of with a block' do
-    any_instance_of(klass){ |instance| mock(instance).f{ |i| i+1 }.proxy }
+  should 'proxy any_instance_of for private methods' do
+    any_instance_of(klass){ |inst| mock(inst).g.peek_return{|i|i+1} }
+    obj = klass.new
+    obj.__send__(:g).should.eq 2
+    Muack.verify    .should.eq true
+    obj.__send__(:g).should.eq 1
+  end
+
+  should 'proxy any_instance_of with peek_return' do
+    any_instance_of(klass){ |inst| mock(inst).f.peek_return{|i|i+1} }
     obj = klass.new
     obj.f       .should.eq 1
     Muack.verify.should.eq true
@@ -30,8 +47,8 @@ describe Muack::AnyInstanceOf do
   end
 
   should 'proxy with multiple any_instance_of call' do
-    any_instance_of(klass){ |instance| mock(instance).f{ |i| i+1 }.proxy }
-    any_instance_of(klass){ |instance| mock(instance).f{ |i| i+2 }.proxy }
+    any_instance_of(klass){ |inst| mock(inst).f.peek_return{ |i| i+1 } }
+    any_instance_of(klass){ |inst| mock(inst).f.peek_return{ |i| i+2 } }
     obj = klass.new
     obj.f.should.eq 1
     obj.f.should.eq 2
@@ -49,8 +66,15 @@ describe Muack::AnyInstanceOf do
     obj.f.should.eq 0
   end
 
+  should 'share the same counts for different instances' do
+    times = 2
+    any_instance_of(klass){ |inst| mock(inst).f{0}.times(times) }
+    times.times{ klass.new.f.should.eq 0 }
+    Muack.verify.should.eq true
+  end
+
   should 'stub proxy with any_instance_of and spy' do
-    any_instance_of(klass){ |inst| stub(inst).f{ |i| i+3 }.proxy }
+    any_instance_of(klass){ |inst| stub(inst).f.peek_return{ |i| i+3 } }
     obj = klass.new
     obj.f.should.eq 3
     obj.f.should.eq 3

data/test/test_from_readme.rb

@@ -0,0 +1,40 @@
+
+require 'muack/test'
+
+describe 'from README.md' do
+  readme = File.read(
+             "#{File.dirname(File.expand_path(__FILE__))}/../README.md")
+  codes  = readme.scan(/``` ruby(.+?)```/m).map(&:first)
+
+  after{ Muack.reset }
+
+  Context = Module.new{
+    def p res
+      (@results ||= []) << res
+    end
+
+    def verify expects
+      return unless @results
+      @results.zip(expects).each do |(res, exp)|
+        next if exp == 'ok'
+        if exp.start_with?('raise')
+          res.should.kind_of eval(exp.sub('raise', ''))
+        else
+          res.should.eq eval(exp)
+        end
+      end
+    end
+  }
+
+  codes.each.with_index do |code, index|
+    should 'pass from README.md #%02d' % index do
+      context = Module.new{extend Context}
+      begin
+        context.instance_eval(code, 'README.md', 0)
+      rescue Muack::Failure => e
+        context.p e
+      end
+      context.verify(code.scan(/# (.+)/).map(&:first))
+    end
+  end
+end

data/test/test_mock.rb

@@ -22,6 +22,21 @@ describe Muack::Mock do
       Obj.to_s.should.eq 'zoo'
     end
 
+    should 'pass the actual block' do
+      mock(Obj).say{ |&block| block.call('Hi') }
+      Obj.say{ |msg| msg }.should.eq 'Hi'
+    end
+
+    should 'mock private method and preserve privacy' do
+      mock(Obj).private{ 'sai' }
+      Obj.respond_to?(:private      ).should.eq false
+      Obj.respond_to?(:private, true).should.eq true
+      Obj.__send__(:private).should.eq 'sai'
+      Muack.verify.should.eq true
+      Obj.respond_to?(:private      ).should.eq false
+      Obj.__send__(:private).should.eq 'pri'
+    end
+
     should 'mock twice' do
       mock(Obj).say(true){ Obj.saya }
       mock(Obj).saya{ 'coo' }
@@ -37,25 +52,31 @@ describe Muack::Mock do
       Muack.reset
     end
 
-    should 'mock multiple times' do
-      3.times{ |i| mock(Obj).say(i){ i } }
-      3.times{ |i| Obj.say(i).should.eq i }
+    should 'mix mock and stub' do
+      mock(Obj).say { 0 }
+      stub(Obj).saya{ 1 }
+      3.times{ Obj.saya.should.eq 1 }
+               Obj.say .should.eq 0
     end
 
-    should 'mock multiple times with times(n) modifier' do
-      mock(Obj).say{ 0 }.times(3)
-      3.times{ |i| Obj.say.should.eq 0 }
+    should 'mix mock and stub with conflicting method, latter wins' do
+      stub(Obj).say{0}
+      mock(Obj).say{1}
+      Obj.say.should.eq 1
     end
 
-    should 'mock 0 times with times(0) modifier' do
-      mock(Obj).say{ 0 }.times(0).should.kind_of Muack::Modifier
+    should 'mix mock and stub with conflicting method, try to hit stub' do
+      stub(Obj).say{0}
+      mock(Obj).say{1}
+      Obj.say.should.eq 1
+      lambda{ Obj.say }.should.raise(Muack::Expected)
     end
 
-    should 'mix mock and stub' do
-      mock(Obj).say { 0 }
-      stub(Obj).saya{ 1 }
-      3.times{ Obj.saya.should.eq 1 }
-               Obj.say .should.eq 0
+    should 'mix mock and stub with conflicting method, mock never called' do
+      mock(Obj).say{0}
+      stub(Obj).say{1}
+      Obj.say.should.eq 1
+      lambda{ Muack.verify }.should.raise(Muack::Expected)
     end
 
     should 'unnamed mock' do
@@ -76,16 +97,6 @@ describe Muack::Mock do
       Muack.verify.should.eq true
       obj.f       .should.eq 0
     end
-
-    should 'return values with returns with a value' do
-      mock(Obj).say.returns(0)
-      Obj.say.should.eq 0
-    end
-
-    should 'return values with returns with a block' do
-      mock(Obj).say.returns{0}
-      Obj.say.should.eq 0
-    end
   end
 
   describe 'Muack.verify==false' do
@@ -107,7 +118,7 @@ describe Muack::Mock do
     end
 
     should 'have correct message for multiple mocks with the same name' do
-      2.times{ mock(Obj).say }
+      2.times{ mock(Obj).say{} }
       begin
         3.times{ Obj.say }
         'never'.should.eq 'reach'
@@ -121,7 +132,7 @@ describe Muack::Mock do
     end
 
     should 'have correct message for mocks with special satisfier' do
-      mock(Obj).say(anything)
+      mock(Obj).say(anything){}
       begin
         Obj.say(1)
         Obj.say(2)
@@ -188,7 +199,7 @@ describe Muack::Mock do
 
     should 'show first not enough calls' do
       mock(Obj).say{ 'boo' }.times(2)
-      mock(Obj).saya        .times(2)
+      mock(Obj).saya{}      .times(2)
       begin
         Obj.say
         Muack.verify

data/test/test_modifier.rb

@@ -0,0 +1,102 @@
+
+require 'muack/test'
+
+describe Muack::Modifier do
+  after do
+    Muack.verify.should.eq true
+    Muack::EnsureReset.call
+  end
+
+  describe 'times' do
+    should 'mock multiple times' do
+      3.times{ |i| mock(Obj).say(i){ i } }
+      3.times{ |i| Obj.say(i).should.eq i }
+    end
+
+    should 'mock multiple times with times(n) modifier' do
+      mock(Obj).say{ 0 }.times(3)
+      3.times{ |i| Obj.say.should.eq 0 }
+    end
+
+    should 'mock 0 times with times(0) modifier' do
+      mock(Obj).say{ 0 }.times(0).should.kind_of Muack::Modifier
+    end
+  end
+
+  describe 'returns' do
+    should 'return with lexical scope' do
+      mock(Obj).say.returns{0}
+      Obj.say.should.eq 0
+    end
+
+    should 'return with dynamic scope' do
+      mock(Obj).say.returns(:instance_exec => true){object_id}
+      Obj.say.should.eq Obj.object_id
+    end
+  end
+
+  describe 'peek_args' do
+    should 'with lexical scope' do
+      str = 'ff'
+      stub(str).to_i.peek_args{16}
+      str.to_i.should.eq 255
+    end
+
+    should 'with dynamic scope' do
+      str = '16'
+      stub(str).to_i.peek_args(:instance_exec => true){Integer(self)}
+      str.to_i.should.eq 22
+    end
+
+    should 'modify' do
+      str = 'ff'
+      stub(str).to_i(is_a(Integer)).peek_args{ |radix| radix * 2 }
+      str.to_i(8).should.eq 255
+    end
+
+    should 'preserve args' do
+      stub(Obj).say{|*a|a}.with_any_args.peek_args{|*a|a}
+      Obj.say(0,1).should.eq [0,1]
+    end
+
+    should 'pass first args' do
+      stub(Obj).say{|*a|a}.with_any_args.peek_args{|a|a}
+      Obj.say(0,1).should.eq [0]
+    end
+
+    should 'pass nothing with nil' do
+      stub(Obj).say{|*a|a}.with_any_args.peek_args{}
+      Obj.say(0,1).should.eq []
+    end
+
+    should 'pass nothing with empty array' do
+      stub(Obj).say{|*a|a}.with_any_args.peek_args{[]}
+      Obj.say(0,1).should.eq []
+    end
+
+    should 'pass an empty array with [[]]' do
+      stub(Obj).say{|*a|a}.with_any_args.peek_args{[[]]}
+      Obj.say(0,1).should.eq [[]]
+    end
+  end
+
+  describe 'peek_return' do
+    should 'with lexical scope' do
+      str = 'ff'
+      stub(str).to_i.peek_return{16}
+      str.to_i.should.eq 16
+    end
+
+    should 'with dynamic scope' do
+      str = '16'
+      stub(str).to_i.peek_return(:instance_exec => true){Integer(self)+1}
+      str.to_i.should.eq 17
+    end
+
+    should 'modify' do
+      str = 'ff'
+      stub(str).to_i(is_a(Integer)).peek_return{ |result| result * 2 }
+      str.to_i(16).should.eq 510
+    end
+  end
+end

data/test/test_proxy.rb

@@ -9,57 +9,62 @@ describe Muack::Mock do
     end
 
     should 'proxy with regular method' do
-      mock(Str).reverse.proxy
+      mock(Str).reverse
       Str.reverse.should.eq 'ooM'
     end
 
+    should 'proxy with private method' do
+      mock(Obj).private.peek_return(&:reverse)
+      Obj.__send__(:private).should.eq 'irp'
+    end
+
     should 'proxy multiple times' do
-      2.times{ mock(Str).reverse.proxy }
+      2.times{ mock(Str).reverse }
       2.times{ Str.reverse.should.eq 'ooM' }
     end
 
     should 'proxy multiple times with super method' do
-      2.times{ mock(Str).class.proxy }
+      2.times{ mock(Str).class }
       2.times{ Str.class.should.eq String }
     end
 
     should 'return modifier itself for any modifier methods' do
-      mock(Str).to_s.proxy.returns{ |s| s.reverse }.times(2).
+      mock(Str).to_s.peek_return{ |s| s.reverse }.times(2).
         with_any_args.with_any_args
       2.times{ Str.to_s.should.eq 'ooM' }
     end
 
     should 'proxy and call the block' do
-      mock(Obj).method_missing(:inspect){ |str| str.reverse }.proxy
+      mock(Obj).method_missing(:inspect).peek_return{ |str| str.reverse }
       Obj.inspect.should.eq 'jbo'
     end
 
     should 'proxy and call the block with super' do
-      mock(Str).class{ |k| k.name.reverse }.proxy
+      mock(Str).class.peek_return{ |k| k.name.reverse }
       Str.class.should.eq 'gnirtS'
     end
 
     should 'mock proxy and call, mock proxy and call' do
-      mock(Obj).class{ |k| k.name.reverse }.proxy
+      mock(Obj).class.peek_return{ |k| k.name.reverse }
       Obj.class.should.eq 'tcejbO'
-      mock(Obj).class{ |k| k.name.upcase }.proxy
+      mock(Obj).class.peek_return{ |k| k.name.upcase }
       Obj.class.should.eq 'OBJECT'
     end
 
     should 'stub proxy and call, stub proxy and call' do
-      stub(Obj).kind_of?(Object){ |b| !b }.proxy
+      stub(Obj).kind_of?(Object).peek_return{ |b| !b }
       Obj.kind_of?(Object).should.eq false
-      stub(Obj).kind_of?(String){ |b| b.to_s }.proxy
+      stub(Obj).kind_of?(String).peek_return{ |b| b.to_s }
       Obj.kind_of?(String).should.eq 'false'
     end
 
     should 'stub proxy with any times' do
-      stub(Obj).class{ |k| k.name.downcase }.proxy
+      stub(Obj).class.peek_return{ |k| k.name.downcase }
       3.times{ Obj.class.should.eq 'object' }
     end
 
     should 'stub proxy and spy' do
-      stub(Obj).class{ |k| k.name.downcase }.proxy
+      stub(Obj).class.peek_return{ |k| k.name.downcase }
       Obj.class.should.eq 'object'
       spy(Obj).class
     end
@@ -72,7 +77,7 @@ describe Muack::Mock do
     end
 
     should 'raise Expected error if passing unexpected argument' do
-      mock(Str).reverse.proxy
+      mock(Str).reverse
       Str.reverse.should.eq 'ooM'
       begin
         Str.reverse

data/test/test_satisfy.rb

@@ -247,6 +247,11 @@ describe Muack::Satisfy do
       matcher.inspect.should.start_with expected
     end
 
+    should 'not crash for top-level subclass' do
+      Class.new(Muack::Satisfy){ def self.name; 'TopLevel'; end }.new.
+        api_name.should.eq 'top_level'
+    end
+
     should 'satisfy' do
       mock(Str).say(satisfy{ |arg| arg % 2 == 0 }){ |arg| arg + 1 }
       Str.say(14).should.eq 15
@@ -270,7 +275,7 @@ describe Muack::Satisfy do
     end
   end
 
-  describe Muack::Satisfy::Union do
+  describe Muack::Satisfy::Disj do
     should 'have human readable to_s and inspect' do
       matcher = is_a(TrueClass) | is_a(FalseClass)
       expected = 'Muack::API.is_a(TrueClass) | Muack::API.is_a(FalseClass)'
@@ -303,7 +308,7 @@ describe Muack::Satisfy do
     end
   end
 
-  describe Muack::Satisfy::Inter do
+  describe Muack::Satisfy::Conj do
     should 'have human readable to_s and inspect' do
       matcher = respond_to(:ancestors) & is_a(Class)
       expected = 'Muack::API.respond_to(:ancestors) & Muack::API.is_a(Class)'

data/test/test_stub.rb

@@ -33,6 +33,11 @@ describe Muack::Stub do
       Str.say('  ').should.eq 'Hoo'
     end
 
+    should 'pass the actual block' do
+      stub(Obj).say{ |&block| block.call('Hi') }
+      Obj.say{ |msg| msg }.should.eq 'Hi'
+    end
+
     should 'accept block form' do
       stub(Obj){ |o| o.say{0}; o.saya{1} }
       Obj.saya.should.eq 1
@@ -46,13 +51,13 @@ describe Muack::Stub do
     end
 
     should 'work with spy twice' do
-      stub(Obj).say
+      stub(Obj).say{}
       2.times{ Obj.say.should.eq nil }
       spy(Obj).say.times(2)
     end
 
     should 'work with spy spy' do
-      stub(Obj).say
+      stub(Obj).say{}
       2.times{ Obj.say.should.eq nil }
       2.times{ spy(Obj).say }
     end
@@ -90,7 +95,7 @@ describe Muack::Stub do
     end
 
     should 'raise Expected if the spy is not satisfied' do
-      stub(Obj).say
+      stub(Obj).say{}
       spy( Obj).say
       begin
         Muack.verify
@@ -105,7 +110,7 @@ describe Muack::Stub do
     end
 
     should 'raise Expected if the spy is not satisfied enough' do
-      stub(Obj).say
+      stub(Obj).say{}
       Obj.say
       spy( Obj).say(0)
       begin
@@ -119,7 +124,7 @@ describe Muack::Stub do
     end
 
     should 'show correct times for under satisfaction' do
-      stub(Obj).say
+      stub(Obj).say{}
       2.times{ Obj.say }
       spy( Obj).say.times(3)
       begin
@@ -135,7 +140,7 @@ describe Muack::Stub do
     end
 
     should 'show correct times for over satisfaction' do
-      stub(Obj).say
+      stub(Obj).say{}
       2.times{ Obj.say }
       spy( Obj).say
       begin