muack 0.5.2 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b0cc50c953e21826fe85b70e03238b3c22486195
-  data.tar.gz: 621fad09a9fb9fe21edd940d33e60d0415c12c5f
+  metadata.gz: f7727020cca0c41dfd846c0b7628aec71c2cbb59
+  data.tar.gz: 9fb966eb9e9e1dc65d8f0e938d2d0a619813f204
 SHA512:
-  metadata.gz: f9453f77aeadc5efcecfd33e6785a7ec4d8700c01e72367910f6b68be0480dc2e3699f87c5658c2ce41601ad78b3f3ca2800ba78aa4ccde9d8ee6ea8234e14a8
-  data.tar.gz: 0d69e0c4d3c544ef7e69c2b60691f369086cac70f2284167dadfc03613087fa2bd78476675ddf9f8504a811eca1abbeb625312082b33f043bb241ccf8928ba41
+  metadata.gz: 669fbb6e488468cf698bf28782e989f70a7fa82c447b91ef4efdc62892add2bf828d9604d682fbe4b13780cf1599017fbfff22f5d7fa8bbb43c0603b7e5b5d97
+  data.tar.gz: b6465725ab6109aeead47a3bba111df9095434ec557017ad0141c1ff441e51054504f4217d19fc6b9e1ad2ef2e86e6fdd8cc59cc3568d2498b89bdd30e257dd4

data/CHANGES.md

@@ -1,5 +1,47 @@
 # CHANGES
 
+## Muack 0.7.0 -- 2013-06-27
+
+### Incompatible changes
+
+* Now instead of using mock_proxy, we use `proxy` as a modifier. That says
+  mock_proxy and stub_proxy no longer existed. like this:
+
+``` ruby
+mock(object).to_s.proxy
+stub(object).to_s.proxy
+```
+
+We change this due to the introduction of spies.
+
+### Enhancement
+
+* We have spies support now. Here's an example:
+
+``` ruby
+subject = Object.new
+stub(subject).foo(1)
+subject.foo(1)
+
+spy(subject).foo(1)
+spy(subject).bar # This doesn't verify immediately.
+Muack.verify     # This fails, saying `bar` was never called.
+```
+
+* It would now raise a `StubHasNoTimes` exception if you tried to set times
+  on stubs, which has no meanings in Muack. Use `mock` or `spy` instead if
+  you need to specify times.
+
+* Muack.reset and Muack.verify is now thread-safe.
+  You can run test cases concurrently now.
+
+* AnyInstanceOf now has a more readable inspect.
+* Improved various error messages. e.g. CannotFindInjectionName.
+* You can now set ENV['MUACK_RECURSION_LEVEL'] to raise the limit
+  to find a new method name when we're injecting a method. Normally
+  this should not happen, and it could be a bug in Muack. But instead of
+  putting a magic number 9 out there as before, this might be better.
+
 ## Muack 0.5.2 -- 2013-06-26
 
 * Add `returns` modifier which you can pass the return values if passing

data/README.md

@@ -101,27 +101,47 @@ User.find('42').times(0)
 User.find('42') # raises a Muack::Unexpected
 ```
 
-#### [mock_proxy](https://github.com/rr/rr/blob/e4b4907fd0488738affb4dab8ce88cbe9fa6580e/doc/03_api_overview.md#mockproxy)
+#### [proxy](https://github.com/rr/rr/blob/e4b4907fd0488738affb4dab8ce88cbe9fa6580e/doc/03_api_overview.md#mockproxy)
 
-Since I don't see how we gain from calling it mock.proxy, in Muack we
-just call it `mock_proxy`.
+Instead of calling `proxy` immediately after calling `mock`, we put
+`proxy` the last because it's a method from `Muack::Modifier`.
 
 ``` ruby
 view = controller.template
-mock_proxy(view).render(:partial => "right_navigation")
-mock_proxy(view).render(:partial => "user_info") do |html|
+mock(view).render(:partial => "right_navigation").proxy
+mock(view).render(:partial => "user_info") do |html|
+  html.should include("John Doe")
+  "Different html"
+end.proxy
+```
+
+If you feel it is weird to put proxy the last, you can also use
+`returns` modifier to put the block last as this:
+
+``` ruby
+view = controller.template
+mock(view).render(:partial => "right_navigation").proxy
+mock(view).render(:partial => "user_info").proxy.returns do |html|
   html.should include("John Doe")
   "Different html"
 end
 ```
 
-#### [stub_proxy](https://github.com/rr/rr/blob/e4b4907fd0488738affb4dab8ce88cbe9fa6580e/doc/03_api_overview.md#stubproxy)
+The same goes to `stub`.
 
-The same goes to `stub_proxy`.
+``` ruby
+view = controller.template
+stub(view).render(:partial => "user_info") do |html|
+  html.should include("Joe Smith")
+  html
+end.proxy
+```
+
+Or use `returns`:
 
 ``` ruby
 view = controller.template
-stub_proxy(view).render(:partial => "user_info") do |html|
+stub(view).render(:partial => "user_info").proxy.returns do |html|
   html.should include("Joe Smith")
   html
 end
@@ -141,6 +161,27 @@ any_instance_of(User) do |u|
 end
 ```
 
+#### [Spies](https://github.com/rr/rr/blob/e4b4907fd0488738affb4dab8ce88cbe9fa6580e/doc/03_api_overview.md#spies)
+
+We don't try to provide different methods for different testing framework,
+so that we don't have to create so many testing framework adapters, and
+try to be smart to find the correct adapter. There are simply too many
+testing frameworks out there. Ruby's built-in test/unit and minitest have
+a lot of different versions, so does rspec.
+
+Here we just try to do it the Muack's way:
+
+
+``` ruby
+subject = Object.new
+stub(subject).foo(1)
+subject.foo(1)
+
+spy(subject).foo(1)
+spy(subject).bar # This doesn't verify immediately.
+Muack.verify     # This fails, saying `bar` was never called.
+```
+
 #### [Block form](https://github.com/rr/rr/blob/e4b4907fd0488738affb4dab8ce88cbe9fa6580e/doc/03_api_overview.md#block-syntax)
 
 Block form is also supported. However we don't support `instance_eval` form.

data/lib/muack.rb

@@ -10,12 +10,13 @@ module Muack
   end
 
   def self.session
-    @session ||= Muack::Session.new
+    Thread.current[:muack_session] ||= Muack::Session.new
   end
 
   def self.reset
-    @session && @session.reset
-    @session = nil
+    session = Thread.current[:muack_session]
+    session && session.reset
+    Thread.current[:muack_session] = nil
   end
 
   module API
@@ -30,13 +31,8 @@ module Muack
       if block_given? then yield(ret) else ret end
     end
 
-    def mock_proxy obj=Object.new
-      ret = Muack.session.mock_proxy(obj)
-      if block_given? then yield(ret) else ret end
-    end
-
-    def stub_proxy obj=Object.new
-      ret = Muack.session.stub_proxy(obj)
+    def spy obj
+      ret = Muack.session.spy(obj)
       if block_given? then yield(ret) else ret end
     end
 

data/lib/muack/any_instance_of.rb

@@ -1,4 +1,8 @@
 
 module Muack
-  AnyInstanceOf = Class.new(Struct.new(:singleton_class))
+  class AnyInstanceOf < Struct.new(:singleton_class)
+    def inspect
+      "Muack::API.any_instance_of(#{singleton_class})"
+    end
+  end
 end

data/lib/muack/definition.rb

@@ -1,5 +1,6 @@
 
 module Muack
-  Definition  = Class.new(Struct.new(:msg, :args, :block, :original_method))
+  Definition  = Class.new(Struct.new(:msg, :args, :block,
+                                     :original_method, :proxy))
   WithAnyArgs = Object.new
 end

data/lib/muack/error.rb

@@ -0,0 +1,18 @@
+
+module Muack
+  Error = Class.new(NotImplementedError)
+  class CannotFindInjectionName < Error
+    def initialize t, msg
+      super "\nCan't find a new method name for :#{msg}, tried #{t} times." \
+            "\nSet ENV['MUACK_RECURSION_LEVEL'] to raise this limit."
+    end
+  end
+
+  class StubHasNoTimes < Error
+    def initialize obj, defi, times
+      super "\nUse mocks if you want to specify times.\ne.g. "          \
+            "mock(#{obj.inspect}).#{defi.msg}(#{defi.args.join(', ')})" \
+            ".times(#{times})"
+    end
+  end
+end

data/lib/muack/mock.rb

@@ -2,6 +2,7 @@
 require 'muack/definition'
 require 'muack/modifier'
 require 'muack/failure'
+require 'muack/error'
 
 module Muack
   class Mock < BasicObject
@@ -16,7 +17,7 @@ module Muack
 
     # Public API: Bacon needs this, or we often ended up with stack overflow
     def inspect
-      "#<#{class << self; self; end.superclass} object=#{object.inspect}>"
+      "Muack::API.#{__mock_class.name[/\w+$/].downcase}(#{object.inspect})"
     end
 
     # Public API: Define mocked method
@@ -41,12 +42,17 @@ module Muack
       __mock_defis[defi.msg].pop
     end
 
+    # used for Muack::Modifier#times to determine if it's a mock or not
+    def __mock_class
+      (class << self; self; end).superclass
+    end
+
     # used for mocked object to dispatch mocked method
-    def __mock_dispatch msg, actual_args, actual_block
+    def __mock_dispatch msg, actual_args
       if defi = __mock_defis[msg].shift
         __mock_disps_push(defi)
         if __mock_check_args(defi.args, actual_args)
-          __mock_block_call(defi, actual_args, actual_block)
+          defi
         else
           Mock.__send__(:raise, # Wrong argument
             Unexpected.new(object, [defi], msg, actual_args))
@@ -63,6 +69,25 @@ module Muack
       end
     end
 
+    # used for mocked object to dispatch mocked method
+    def __mock_dispatch_call disp, actual_args, actual_block
+      if disp.proxy
+        value = yield # need the original context for proxy or AnyInstanceOf
+        if disp.block
+          disp.block.call(value)
+        else
+          value
+        end
+      elsif block = disp.block
+        arity = block.arity
+        if arity < 0
+          block.call(*actual_args             , &actual_block)
+        else
+          block.call(*actual_args.first(arity), &actual_block)
+        end
+      end
+    end
+
     # used for Muack::Session#verify
     def __mock_verify
       __mock_defis.values.all?(&:empty?) || begin
@@ -94,7 +119,7 @@ module Muack
     private
     def __mock_inject_method defi
       __mock_injected[defi.msg] = defi
-      target = object.singleton_class
+      target = object.singleton_class # would be the class in AnyInstanceOf
       Mock.store_original_method(target, defi)
        __mock_inject_mock_method(target, defi)
     end
@@ -108,8 +133,9 @@ module Muack
     end
 
     def self.find_new_name klass, message, level=0
-      raise "Cannot find a suitable method name, tried #{level+1} times." if
-        level >= 9
+      if level >= (::ENV['MUACK_RECURSION_LEVEL'] || 9).to_i
+        raise CannotFindInjectionName.new(level+1, message)
+      end
 
       new_name = "__muack_mock_#{level}_#{message}".to_sym
       if klass.instance_methods(false).include?(new_name)
@@ -122,21 +148,17 @@ module Muack
     def __mock_inject_mock_method target, defi
       mock = self # remember the context
       target.__send__(:define_method, defi.msg){|*actual_args, &actual_block|
-        mock.__mock_dispatch(defi.msg, actual_args, actual_block)
+        disp = mock.__mock_dispatch(defi.msg, actual_args)
+        mock.__mock_dispatch_call(disp, actual_args, actual_block){
+          if disp.original_method
+            __send__(disp.original_method, *actual_args, &actual_block)
+          else
+            super(*actual_args, &actual_block)
+          end
+        }
       }
     end
 
-    def __mock_block_call defi, actual_args, actual_block
-      if block = defi.block
-        arity = block.arity
-        if arity < 0
-          block.call(*actual_args             , &actual_block)
-        else
-          block.call(*actual_args.first(arity), &actual_block)
-        end
-      end
-    end
-
     def __mock_check_args expected_args, actual_args
       if expected_args == [WithAnyArgs]
         true

data/lib/muack/modifier.rb

@@ -1,5 +1,5 @@
 
-require 'muack/definition'
+require 'muack/error'
 
 module Muack
   class Modifier < Struct.new(:mock, :defi)
@@ -12,10 +12,21 @@ module Muack
     # Public API
     def returns val=nil, &block
       defi.block = block || lambda{ val }
+      self
+    end
+
+    # Public API
+    def proxy
+      defi.proxy = true
+      self
     end
 
     # Public API
     def times number
+      if mock.__mock_class == Stub
+        raise StubHasNoTimes.new(object, defi, number)
+      end
+
       if number >= 1
         (number - 1).times{ mock.__mock_defis_push(defi) }
       elsif number == 0

data/lib/muack/session.rb

@@ -1,18 +1,17 @@
 
 require 'muack/mock'
 require 'muack/stub'
-require 'muack/proxy'
+require 'muack/spy'
 require 'muack/any_instance_of'
 
 module Muack
   class Session < Hash
-    def mock       obj; self["mk #{obj.__id__}"] ||= Mock     .new(obj); end
-    def stub       obj; self["sb #{obj.__id__}"] ||= Stub     .new(obj); end
-    def mock_proxy obj; self["mp #{obj.__id__}"] ||= MockProxy.new(obj); end
-    def stub_proxy obj; self["sp #{obj.__id__}"] ||= StubProxy.new(obj); end
+    def mock obj; self["mk #{obj.__id__}"] ||= Mock.new(obj)      ; end
+    def stub obj; self["sb #{obj.__id__}"] ||= Stub.new(obj)      ; end
+    def spy  obj; self["sy #{obj.__id__}"] ||= Spy .new(stub(obj)); end
 
-    def any_instance_of klass
-      (@any_instance_of ||= {})[klass.__id__] ||= AnyInstanceOf.new(klass)
+    def any_instance_of kls
+      (@others ||= {})["ai #{kls.__id__}"] ||= AnyInstanceOf.new(kls)
     end
 
     def verify
@@ -20,6 +19,7 @@ module Muack
     end
 
     def reset
+      instance_variable_defined?(:@others) && @others.clear
       each_value(&:__mock_reset)
       clear
     end

data/lib/muack/spy.rb

@@ -0,0 +1,23 @@
+
+require 'muack/mock'
+
+module Muack
+  class Spy < Mock
+    def initialize stub
+      super(stub.object)
+      @secret = stub.__mock_disps.values.flatten # steal disps
+    end
+
+    # used for Muack::Session#verify
+    def __mock_verify
+      @secret.each{ |defi| __mock_dispatch(defi.msg, defi.args) }
+      super # simulate dispatching before passing to mock to verify
+    end
+
+    # used for Muack::Session#reset, but spies never leave any track
+    def __mock_reset; end
+
+    private
+    def __mock_inject_method defi; end # spies don't leave any track
+  end
+end

data/lib/muack/stub.rb

@@ -7,12 +7,11 @@ module Muack
     def __mock_verify; true; end
 
     # used for mocked object to dispatch mocked method
-    def __mock_dispatch msg, actual_args, actual_block
-      defi = __mock_defis[msg].find{ |d|
-        __mock_check_args(d.args, actual_args)
-      }
-      if defi
-        __mock_block_call(defi, actual_args, actual_block)
+    def __mock_dispatch msg, actual_args
+      if defi = __mock_defis[msg].find{ |d|
+                  __mock_check_args(d.args, actual_args) }
+        __mock_disps_push(defi) # our spies are interested in this
+        defi
       else
         Mock.__send__(:raise, # Wrong argument
           Unexpected.new(object, __mock_defis[msg], msg, actual_args))

data/lib/muack/version.rb

@@ -1,4 +1,4 @@
 
 module Muack
-  VERSION = '0.5.2'
+  VERSION = '0.7.0'
 end

data/muack.gemspec

@@ -2,11 +2,11 @@
 
 Gem::Specification.new do |s|
   s.name = "muack"
-  s.version = "0.5.2"
+  s.version = "0.7.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Lin Jen-Shin (godfat)"]
-  s.date = "2013-06-26"
+  s.date = "2013-06-27"
   s.description = "Muack -- Yet another mocking library.\n\nBasically it's an [RR][] clone, but much faster under heavy use.\nIt's 32x times faster (750s vs 23s) for running [Rib][] tests.\n\n[RR]: https://github.com/rr/rr\n[Rib]: https://github.com/godfat/rib"
   s.email = ["godfat (XD) godfat.org"]
   s.files = [
@@ -21,12 +21,13 @@ Gem::Specification.new do |s|
   "lib/muack.rb",
   "lib/muack/any_instance_of.rb",
   "lib/muack/definition.rb",
+  "lib/muack/error.rb",
   "lib/muack/failure.rb",
   "lib/muack/mock.rb",
   "lib/muack/modifier.rb",
-  "lib/muack/proxy.rb",
   "lib/muack/satisfy.rb",
   "lib/muack/session.rb",
+  "lib/muack/spy.rb",
   "lib/muack/stub.rb",
   "lib/muack/test.rb",
   "lib/muack/version.rb",

data/test/test_any_instance_of.rb

@@ -2,8 +2,9 @@
 require 'muack/test'
 
 describe Muack::AnyInstanceOf do
+  klass = Class.new{ def f; 0; end }
+
   should 'mock any_instance_of' do
-    klass = Class.new
     any_instance_of(klass){ |instance| mock(instance).say{ true } }
     obj = klass.new
     obj.say              .should.eq true
@@ -13,17 +14,15 @@ describe Muack::AnyInstanceOf do
   end
 
   should 'proxy any_instance_of' do
-    klass = Class.new{ def f; true; end }
-    any_instance_of(klass){ |instance| mock_proxy(instance).f }
+    any_instance_of(klass){ |instance| mock(instance).f.proxy }
     obj = klass.new
-    obj.f       .should.eq true
+    obj.f       .should.eq 0
     Muack.verify.should.eq true
-    obj.f       .should.eq true
+    obj.f       .should.eq 0
   end
 
   should 'proxy any_instance_of with a block' do
-    klass = Class.new{ def f; 0; end }
-    any_instance_of(klass){ |instance| mock_proxy(instance).f{ |i| i+1 } }
+    any_instance_of(klass){ |instance| mock(instance).f{ |i| i+1 }.proxy }
     obj = klass.new
     obj.f       .should.eq 1
     Muack.verify.should.eq true
@@ -31,9 +30,8 @@ describe Muack::AnyInstanceOf do
   end
 
   should 'proxy with multiple any_instance_of call' do
-    klass = Class.new{ def f; 0; end }
-    any_instance_of(klass){ |instance| mock_proxy(instance).f{ |i| i+1 } }
-    any_instance_of(klass){ |instance| mock_proxy(instance).f{ |i| i+2 } }
+    any_instance_of(klass){ |instance| mock(instance).f{ |i| i+1 }.proxy }
+    any_instance_of(klass){ |instance| mock(instance).f{ |i| i+2 }.proxy }
     obj = klass.new
     obj.f.should.eq 1
     obj.f.should.eq 2
@@ -42,13 +40,54 @@ describe Muack::AnyInstanceOf do
   end
 
   should 'mock with multiple any_instance_of call' do
-    klass = Class.new{ def f; 0; end }
     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 } }
     obj = klass.new
-    obj.f(0).should.eq 1
-    obj.f(0).should.eq 2
+    obj.f(2).should.eq 3
+    obj.f(2).should.eq 4
+    Muack.verify.should.eq true
+    obj.f.should.eq 0
+  end
+
+  should 'stub proxy with any_instance_of and spy' do
+    any_instance_of(klass){ |inst| stub(inst).f{ |i| i+3 }.proxy }
+    obj = klass.new
+    obj.f.should.eq 3
+    obj.f.should.eq 3
+    spy(any_instance_of(klass)).f.times(2)
     Muack.verify.should.eq true
     obj.f.should.eq 0
   end
+
+  should 'stub with any_instance_of and spy under satisfied' do
+    any_instance_of(klass){ |inst| stub(inst).f{ 5 } }
+    obj = klass.new
+    obj.f.should.eq 5
+    spy(any_instance_of(klass)).f.times(2)
+    begin
+      Muack.verify
+    rescue Muack::Expected => e
+      expected = /Muack::API\.any_instance_of\(.+?\)\.f\(\)/
+      e.expected      .should =~ expected
+      e.expected_times.should.eq 2
+      e.actual_times  .should.eq 1
+    end
+    obj.f.should.eq 0
+  end
+
+  should 'stub with any_instance_of and spy over satisfied' do
+    any_instance_of(klass){ |inst| stub(inst).f{ 2 } }
+    obj = klass.new
+    2.times{ obj.f.should.eq 2 }
+    spy(any_instance_of(klass)).f
+    begin
+      Muack.verify
+    rescue Muack::Expected => e
+      expected = /Muack::API\.any_instance_of\(.+?\)\.f\(\)/
+      e.expected      .should =~ expected
+      e.expected_times.should.eq 1
+      e.actual_times  .should.eq 2
+    end
+    obj.f.should.eq 0
+  end
 end

data/test/test_mock.rb

@@ -8,6 +8,10 @@ describe Muack::Mock do
       Muack::EnsureReset.call
     end
 
+    should 'inspect' do
+      mock(Obj).inspect.should.eq "Muack::API.mock(obj)"
+    end
+
     should 'mock with regular method' do
       mock(Obj).say(true){ 'boo' }
       Obj.say(true).should.eq 'boo'
@@ -58,10 +62,6 @@ describe Muack::Mock do
       mock.say{1}.object.say.should.eq 1
     end
 
-    should 'inspect' do
-      mock(Obj).inspect.should.eq "#<Muack::Mock object=obj>"
-    end
-
     should 'mock and call, mock and call' do
       mock(Obj).say{0}
       Obj.say.should.eq 0
@@ -94,7 +94,7 @@ describe Muack::Mock do
       Muack::EnsureReset.call
     end
 
-    should 'raise Muack::Unexpected error if passing unexpected argument' do
+    should 'raise Unexpected error if passing unexpected argument' do
       mock(Obj).say(true){ 'boo' }
       begin
         Obj.say(false)
@@ -144,7 +144,7 @@ describe Muack::Mock do
       end
     end
 
-    should 'raise Muack::Unexpected when calling with diff sig' do
+    should 'raise Unexpected when calling with diff sig' do
       mock(Obj).say(true){1}
       Obj.say(true).should.eq 1
       begin
@@ -157,7 +157,7 @@ describe Muack::Mock do
       end
     end
 
-    should 'raise Muack::Expected error if mock methods not called' do
+    should 'raise Expected error if mock methods not called' do
       mock(Obj).say(true){ 'boo' }
       begin
         Muack.verify

data/test/test_proxy.rb

@@ -1,7 +1,7 @@
 
 require 'muack/test'
 
-describe Muack::Proxy do
+describe Muack::Mock do
   describe 'Muack.verify==true' do
     after do
       Muack.verify.should.eq true
@@ -9,48 +9,60 @@ describe Muack::Proxy do
     end
 
     should 'proxy with regular method' do
-      mock_proxy(Str).reverse
+      mock(Str).reverse.proxy
       Str.reverse.should.eq 'ooM'
     end
 
     should 'proxy multiple times' do
-      2.times{ mock_proxy(Str).reverse }
+      2.times{ mock(Str).reverse.proxy }
       2.times{ Str.reverse.should.eq 'ooM' }
     end
 
     should 'proxy multiple times with super method' do
-      2.times{ mock_proxy(Str).class }
+      2.times{ mock(Str).class.proxy }
       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).
+        with_any_args.with_any_args
+      2.times{ Str.to_s.should.eq 'ooM' }
+    end
+
     should 'proxy and call the block' do
-      mock_proxy(Obj).method_missing(:inspect){ |str| str.reverse }
+      mock(Obj).method_missing(:inspect){ |str| str.reverse }.proxy
       Obj.inspect.should.eq 'jbo'
     end
 
     should 'proxy and call the block with super' do
-      mock_proxy(Str).class{ |k| k.name.reverse  }
+      mock(Str).class{ |k| k.name.reverse }.proxy
       Str.class.should.eq 'gnirtS'
     end
 
-    should 'mock_proxy and call, mock_proxy and call' do
-      mock_proxy(Obj).class{ |k| k.name.reverse }
+    should 'mock proxy and call, mock proxy and call' do
+      mock(Obj).class{ |k| k.name.reverse }.proxy
       Obj.class.should.eq 'tcejbO'
-      mock_proxy(Obj).class{ |k| k.name.upcase }
+      mock(Obj).class{ |k| k.name.upcase }.proxy
       Obj.class.should.eq 'OBJECT'
     end
 
-    should 'stub_proxy and call, stub_proxy and call' do
-      stub_proxy(Obj).kind_of?(Object){ |b| !b }
+    should 'stub proxy and call, stub proxy and call' do
+      stub(Obj).kind_of?(Object){ |b| !b }.proxy
       Obj.kind_of?(Object).should.eq false
-      stub_proxy(Obj).kind_of?(String){ |b| b.to_s }
+      stub(Obj).kind_of?(String){ |b| b.to_s }.proxy
       Obj.kind_of?(String).should.eq 'false'
     end
 
-    should 'stub_proxy with any times' do
-      stub_proxy(Obj).class{ |k| k.name.downcase }
+    should 'stub proxy with any times' do
+      stub(Obj).class{ |k| k.name.downcase }.proxy
       3.times{ Obj.class.should.eq 'object' }
     end
+
+    should 'stub proxy and spy' do
+      stub(Obj).class{ |k| k.name.downcase }.proxy
+      Obj.class.should.eq 'object'
+      spy(Obj).class
+    end
   end
 
   describe 'Muack.verify==false' do
@@ -59,8 +71,8 @@ describe Muack::Proxy do
       Muack::EnsureReset.call
     end
 
-    should 'raise Muack::Expected error if passing unexpected argument' do
-      mock_proxy(Str).reverse
+    should 'raise Expected error if passing unexpected argument' do
+      mock(Str).reverse.proxy
       Str.reverse.should.eq 'ooM'
       begin
         Str.reverse

data/test/test_satisfy.rb

@@ -17,7 +17,7 @@ describe Muack::Satisfy do
       Muack::EnsureReset.call
     end
 
-    should 'raise Muack::Unexpected error if passing unexpected argument' do
+    should 'raise Unexpected error if passing unexpected argument' do
       mock(Obj).say(is_a(Array)){ 'boo' }
       begin
         Obj.say(false)
@@ -53,7 +53,7 @@ describe Muack::Satisfy do
       Muack::EnsureReset.call
     end
 
-    should 'raise Muack::Unexpected error if passing unexpected argument' do
+    should 'raise Unexpected error if passing unexpected argument' do
       mock(Obj).say(anything){ 'boo' }
       begin
         Obj.say(6, 7)
@@ -84,7 +84,7 @@ describe Muack::Satisfy do
       Muack::EnsureReset.call
     end
 
-    should 'raise Muack::Unexpected error if passing unexpected argument' do
+    should 'raise Unexpected error if passing unexpected argument' do
       mock(Obj).say(match(/\w/)){ 'boo' }
       begin
         Obj.say('!')
@@ -115,7 +115,7 @@ describe Muack::Satisfy do
       Muack::EnsureReset.call
     end
 
-    should 'raise Muack::Unexpected error if passing unexpected argument' do
+    should 'raise Unexpected error if passing unexpected argument' do
       mock(Obj).say(hash_including(:b => 2)){ 'boo' }
       begin
         Obj.say(:a => 1)
@@ -151,7 +151,7 @@ describe Muack::Satisfy do
       Muack::EnsureReset.call
     end
 
-    should 'raise Muack::Unexpected error if passing unexpected argument' do
+    should 'raise Unexpected error if passing unexpected argument' do
       mock(Obj).say(within(0..5)){ 'boo' }
       begin
         Obj.say(6)
@@ -182,7 +182,7 @@ describe Muack::Satisfy do
       Muack::EnsureReset.call
     end
 
-    should 'raise Muack::Unexpected error if passing unexpected argument' do
+    should 'raise Unexpected error if passing unexpected argument' do
       mock(Obj).say(satisfy{ |arg| arg % 2 == 0 }){ 'boo' }
       begin
         Obj.say(1)

data/test/test_stub.rb

@@ -2,12 +2,24 @@
 require 'muack/test'
 
 describe Muack::Stub do
+  should 'raise StubHasNoTimes with stub(obj).f.times(0)' do
+    lambda{ stub(Obj).f.times(0) }.should.raise(Muack::StubHasNoTimes)
+  end
+
   describe 'Muack.verify==true' do
     after do
       Muack.verify.should.eq true
       Muack::EnsureReset.call
     end
 
+    should 'inspect' do
+      stub(Obj).inspect.should.eq "Muack::API.stub(obj)"
+    end
+
+    should 'inspect' do
+      spy( Obj).inspect.should.eq "Muack::API.spy(obj)"
+    end
+
     should 'stub with regular method' do
       stub(Obj).say{ 'goo' }
       3.times{ Obj.say.should.eq 'goo' }
@@ -26,6 +38,24 @@ describe Muack::Stub do
       Obj.saya.should.eq 1
       Obj.say .should.eq 0
     end
+
+    should 'work with spy' do
+      stub(Obj).say{0}
+      Obj.say.should.eq 0
+      spy(Obj).say
+    end
+
+    should 'work with spy twice' do
+      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
+      2.times{ Obj.say.should.eq nil }
+      2.times{ spy(Obj).say }
+    end
   end
 
   describe 'Muack.verify==false' do
@@ -34,7 +64,7 @@ describe Muack::Stub do
       Muack::EnsureReset.call
     end
 
-    should 'raise Muack::Unexpected error if passing unexpected argument' do
+    should 'raise Unexpected error if passing unexpected argument' do
       stub(Obj).say(true){ 'boo' }
       begin
         Obj.say(false)
@@ -58,5 +88,66 @@ describe Muack::Stub do
         e.message .should.eq "\nExpected: #{e.expected}\n but was: #{e.was}"
       end
     end
+
+    should 'raise Expected if the spy is not satisfied' do
+      stub(Obj).say
+      spy( Obj).say
+      begin
+        Muack.verify
+        'never'.should.eq 'reach'
+      rescue Muack::Expected => e
+        e.expected      .should.eq 'obj.say()'
+        e.expected_times.should.eq 1
+        e.actual_times  .should.eq 0
+        e.message       .should.eq "\nExpected: obj.say()\n  " \
+                                   "called 1 times\n but was 0 times."
+      end
+    end
+
+    should 'raise Expected if the spy is not satisfied enough' do
+      stub(Obj).say
+      Obj.say
+      spy( Obj).say(0)
+      begin
+        Muack.verify
+        'never'.should.eq 'reach'
+      rescue Muack::Unexpected => e
+        e.expected.should.eq "obj.say(0)"
+        e.was     .should.eq 'obj.say()'
+        e.message .should.eq "\nExpected: #{e.expected}\n but was: #{e.was}"
+      end
+    end
+
+    should 'show correct times for under satisfaction' do
+      stub(Obj).say
+      2.times{ Obj.say }
+      spy( Obj).say.times(3)
+      begin
+        Muack.verify
+        'never'.should.eq 'reach'
+      rescue Muack::Expected => e
+        e.expected      .should.eq 'obj.say()'
+        e.expected_times.should.eq 3
+        e.actual_times  .should.eq 2
+        e.message       .should.eq "\nExpected: obj.say()\n  " \
+                                   "called 3 times\n but was 2 times."
+      end
+    end
+
+    should 'show correct times for over satisfaction' do
+      stub(Obj).say
+      2.times{ Obj.say }
+      spy( Obj).say
+      begin
+        Muack.verify
+        'never'.should.eq 'reach'
+      rescue Muack::Expected => e
+        e.expected      .should.eq 'obj.say()'
+        e.expected_times.should.eq 1
+        e.actual_times  .should.eq 2
+        e.message       .should.eq "\nExpected: obj.say()\n  " \
+                                   "called 1 times\n but was 2 times."
+      end
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: muack
 version: !ruby/object:Gem::Version
-  version: 0.5.2
+  version: 0.7.0
 platform: ruby
 authors:
 - Lin Jen-Shin (godfat)
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-26 00:00:00.000000000 Z
+date: 2013-06-27 00:00:00.000000000 Z
 dependencies: []
 description: |-
   Muack -- Yet another mocking library.
@@ -35,12 +35,13 @@ files:
 - lib/muack.rb
 - lib/muack/any_instance_of.rb
 - lib/muack/definition.rb
+- lib/muack/error.rb
 - lib/muack/failure.rb
 - lib/muack/mock.rb
 - lib/muack/modifier.rb
-- lib/muack/proxy.rb
 - lib/muack/satisfy.rb
 - lib/muack/session.rb
+- lib/muack/spy.rb
 - lib/muack/stub.rb
 - lib/muack/test.rb
 - lib/muack/version.rb

data/lib/muack/proxy.rb

@@ -1,39 +0,0 @@
-
-require 'muack/mock'
-require 'muack/stub'
-
-module Muack
-  module Proxy
-    def __mock_block_call defi, actual_args, actual_block
-      # handle block call in injected method, since we need to call origin
-      defi # but we still want to know which defi gets dispatched!
-    end
-
-    def __mock_inject_mock_method target, defi
-      mock = self # remember the context
-      target.__send__(:define_method, defi.msg){|*actual_args, &actual_block|
-        d = mock.__mock_dispatch(defi.msg, actual_args, actual_block)
-
-        ret = if d.original_method
-                __send__(d.original_method, *actual_args, &actual_block)
-              else
-                super(*actual_args, &actual_block)
-              end
-
-        if d.block
-          d.block.call(ret)
-        else
-          ret
-        end
-      }
-    end
-  end
-
-  class MockProxy < Mock
-    include Proxy
-  end
-
-  class StubProxy < Stub
-    include Proxy
-  end
-end