muack 1.3.0 → 1.5.1

data/test/test_satisfying.rb

@@ -178,13 +178,13 @@ describe Muack::Satisfying do
     end
 
     would 'satisfy with satisfy' do
-      mock(Str).say(where(:b => is_a(Fixnum))){ |arg| arg[:b] }
+      mock(Str).say(where(:b => is_a(Integer))){ |arg| arg[:b] }
       Str.say(:b => 3).should.eq 3
       Muack.verify.should.eq true
     end
 
     would 'satisfy with satisfy recursive' do
-      spec = where(:a => {:b => is_a(Fixnum)})
+      spec = where(:a => {:b => is_a(Integer)})
       mock(Str).say(spec){ |arg| arg[:a][:b] }
       Str.say(:a => {:b => 1}).should.eq 1
       Muack.verify.should.eq true
@@ -208,13 +208,32 @@ describe Muack::Satisfying do
     end
 
     would 'raise Unexpected error if passing unsatisfied argument' do
-      mock(Obj).say(where(:a => 0, :b => is_a(Fixnum))){ 'boo' }
+      mock(Obj).say(where(:a => 0, :b => is_a(Integer))){ 'boo' }
       e = should.raise(Muack::Unexpected){Obj.say(:a => 0, :b => 1, :c => 2)}
       e.expected.should.eq \
-        'obj.say(Muack::API.where({:a=>0, :b=>Muack::API.is_a(Fixnum)}))'
+        'obj.say(Muack::API.where({:a=>0, :b=>Muack::API.is_a(Integer)}))'
       e.was     .should.eq 'obj.say({:a=>0, :b=>1, :c=>2})'
       e.message .should.eq "\nExpected: #{e.expected}\n but was: #{e.was}"
     end
+
+    would 'recurse' do
+      mock(Obj).say(where(:a =>
+                      having(:b =>
+                        allowing(:c => [is_a(Integer)])))){ 'boo' }
+      e = should.raise(Muack::Unexpected){Obj.say(:a => 0)}
+      e.expected.should.eq               \
+        'obj.say(Muack::API.where({:a=>' \
+          'Muack::API.having({:b=>'      \
+            'Muack::API.allowing({:c=>'  \
+              '[Muack::API.is_a(Integer)]})})}))'
+      e.was     .should.eq 'obj.say({:a=>0})'
+      e.message .should.eq "\nExpected: #{e.expected}\n but was: #{e.was}"
+    end
+
+    would 'respect all keys', :groups => [:only] do
+      mock(Obj).say(where(:a => 0)){ 'nnf' }
+      should.raise(Muack::Unexpected){Obj.say(:a => 0, :b => nil)}
+    end
   end
 
   describe Muack::Having do
@@ -232,13 +251,13 @@ describe Muack::Satisfying do
     end
 
     would 'satisfy with satisfy' do
-      mock(Str).say(having(:b => is_a(Fixnum))){ |arg| arg[:b] }
+      mock(Str).say(having(:b => is_a(Integer))){ |arg| arg[:b] }
       Str.say(:a => 1, :b => 2).should.eq 2
       Muack.verify.should.eq true
     end
 
     would 'satisfy with satisfy recursive' do
-      spec = having(:a => {:b => is_a(Fixnum)})
+      spec = having(:a => {:b => is_a(Integer)})
       mock(Str).say(spec){ |arg| arg[:a][:c] }
       Str.say(:a => {:b => 1, :c => 2}, :d => 3).should.eq 2
       Muack.verify.should.eq true
@@ -253,13 +272,18 @@ describe Muack::Satisfying do
     end
 
     would 'raise Unexpected error if passing unsatisfied argument' do
-      mock(Obj).say(having(:a => 0, :b => is_a(Fixnum))){ 'boo' }
+      mock(Obj).say(having(:a => 0, :b => is_a(Integer))){ 'boo' }
       e = should.raise(Muack::Unexpected){ Obj.say(:b => 1) }
       e.expected.should.eq \
-        'obj.say(Muack::API.having({:a=>0, :b=>Muack::API.is_a(Fixnum)}))'
+        'obj.say(Muack::API.having({:a=>0, :b=>Muack::API.is_a(Integer)}))'
       e.was     .should.eq 'obj.say({:b=>1})'
       e.message .should.eq "\nExpected: #{e.expected}\n but was: #{e.was}"
     end
+
+    would 'respect all keys' do
+      mock(Obj).say(having(:a => 0, :b => nil)){ 'nnf' }
+      should.raise(Muack::Unexpected){Obj.say(:a => 0)}
+    end
   end
 
   describe Muack::Allowing do
@@ -277,13 +301,13 @@ describe Muack::Satisfying do
     end
 
     would 'satisfy with satisfy' do
-      mock(Str).say(allowing(:a => is_a(Fixnum), :b => 1)){ |arg| arg[:a] }
+      mock(Str).say(allowing(:a => is_a(Integer), :b => 1)){ |arg| arg[:a] }
       Str.say(:a => 0).should.eq 0
       Muack.verify.should.eq true
     end
 
     would 'satisfy with satisfy recursive' do
-      spec = allowing(:a => {:b => is_a(Fixnum), :c => 1}, :d => 2)
+      spec = allowing(:a => {:b => is_a(Integer), :c => 1}, :d => 2)
       mock(Str).say(spec){ |arg| arg[:a][:b] }
       Str.say(:a => {:b => 0}).should.eq 0
       Muack.verify.should.eq true
@@ -305,6 +329,11 @@ describe Muack::Satisfying do
       e.was     .should.eq 'obj.say({:b=>"1", :c=>2})'
       e.message .should.eq "\nExpected: #{e.expected}\n but was: #{e.was}"
     end
+
+    would 'respect all keys' do
+      mock(Obj).say(allowing(:a => 0)){ 'nnf' }
+      should.raise(Muack::Unexpected){Obj.say(:a => 0, :b => nil)}
+    end
   end
 
   describe Muack::Satisfying do

data/test/test_spy.rb

@@ -0,0 +1,149 @@
+
+require 'muack/test'
+
+describe Muack::Spy do
+  describe 'Muack.verify==true' do
+    after do
+      Muack.verify.should.eq true
+      Muack::EnsureReset.call
+    end
+
+    would 'inspect' do
+      spy( Obj).inspect.should.eq "Muack::API.spy(obj)"
+    end
+
+    would 'work with spy' do
+      stub(Obj).say{0}
+      Obj.say.should.eq 0
+       spy(Obj).say
+    end
+
+    would 'work with spy twice' do
+      stub(Obj).say{}
+      2.times{ Obj.say.should.eq nil }
+       spy(Obj).say.times(2)
+    end
+
+    would 'work with spy spy' do
+      stub(Obj).say{}
+      2.times{ Obj.say.should.eq nil }
+      2.times{ spy(Obj).say }
+    end
+
+    would 'work with call spy and call spy' do
+      stub(Obj).say{}
+      2.times do
+        Obj.say.should.eq nil
+        spy(Obj).say
+      end
+    end
+
+    would 'verify spy arguments' do
+      stub(Obj).say(1){|a|a}
+      Obj.say(1).should.eq 1
+       spy(Obj).say(1)
+    end
+
+    would 'properly verify spy arguments' do
+      stub(Obj).say(is_a(String)){|a|a}
+      Obj.say('Hi!').should.eq 'Hi!'
+       spy(Obj).say(is_a(String))
+    end
+
+    would 'ignore messages spies not interested' do
+      stub(Obj).saya{0}
+      stub(Obj).sayb{1}
+      Obj.saya.should.eq 0
+      Obj.sayb.should.eq 1
+       spy(Obj).saya
+    end
+
+    would 'not care about the order' do
+      stub(Obj).say(is_a(Integer)){|i|i} # change to &:itself in the future
+           Obj .say(1).should.eq 1
+           Obj .say(2).should.eq 2
+       spy(Obj).say(2)
+       spy(Obj).say(1)
+    end
+  end
+
+  describe 'Muack.verify==false' do
+    after do
+      Muack.reset
+      Muack::EnsureReset.call
+    end
+
+    would 'raise Expected if it is not satisfied' do
+      stub(Obj).say{}
+       spy(Obj).say
+      e = should.raise(Muack::Expected){ Muack.verify }
+      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
+
+    would 'show correct times for under satisfaction' do
+      stub(Obj).say{}
+      2.times{ Obj.say }
+       spy(Obj).say.times(3)
+      e = should.raise(Muack::Expected){ Muack.verify }
+      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
+
+    would 'show correct times for over satisfaction' do
+      stub(Obj).say{}
+      2.times{ Obj.say }
+      spy(Obj).say
+      e = should.raise(Muack::Expected){ Muack.verify }
+      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
+
+    would 'raise Expected if arguments do not match' do
+      stub(Obj).say(is_a(Integer)){}
+           Obj .say(1)
+       spy(Obj).say(0)
+      e = should.raise(Muack::Unexpected){ Muack.verify }
+      e.expected.should.eq "obj.say(0)"
+      e.was     .should.eq 'obj.say(1)'
+      e.message .should.eq "\nExpected: #{e.expected}\n but was: #{e.was}"
+    end
+
+    would 'raise Expected if arguments do not match, show original args' do
+      stub(Obj).say(is_a(Integer)){}
+           Obj .say(0)
+           Obj .say(1)
+           Obj .say(2)
+       spy(Obj).say(within(1..1))
+       spy(Obj).say(within(0..0))
+      e = should.raise(Muack::Unexpected){ Muack.verify }
+      e.expected.should.eq "obj.say(Muack::API.within(0..0))\n" \
+                 "      or: obj.say(Muack::API.within(1..1))"
+      e.was     .should.eq 'obj.say(2)'
+      e.message .should.eq "\nExpected: #{e.expected}\n but was: #{e.was}"
+    end
+
+    would 'raise Expected if arguments do not match, show original args' do
+      stub(Obj).say(is_a(Integer)){}
+           Obj .say(2)
+           Obj .say(0)
+           Obj .say(1)
+       spy(Obj).say(within(1..1))
+       spy(Obj).say(within(0..0))
+      e = should.raise(Muack::Unexpected){ Muack.verify }
+      e.expected.should.eq "obj.say(Muack::API.within(1..1))\n" \
+                 "      or: obj.say(Muack::API.within(0..0))"
+      e.was     .should.eq 'obj.say(2)'
+      e.message .should.eq "\nExpected: #{e.expected}\n but was: #{e.was}"
+    end
+  end
+end

data/test/test_stub.rb

@@ -16,10 +16,6 @@ describe Muack::Stub do
       stub(Obj).inspect.should.eq "Muack::API.stub(obj)"
     end
 
-    would 'inspect' do
-      spy( Obj).inspect.should.eq "Muack::API.spy(obj)"
-    end
-
     would 'stub with regular method' do
       stub(Obj).say{ 'goo' }
       3.times{ Obj.say.should.eq 'goo' }
@@ -43,52 +39,6 @@ describe Muack::Stub do
       Obj.saya.should.eq 1
       Obj.say .should.eq 0
     end
-
-    would 'work with spy' do
-      stub(Obj).say{0}
-      Obj.say.should.eq 0
-       spy(Obj).say
-    end
-
-    would 'work with spy twice' do
-      stub(Obj).say{}
-      2.times{ Obj.say.should.eq nil }
-       spy(Obj).say.times(2)
-    end
-
-    would 'work with spy spy' do
-      stub(Obj).say{}
-      2.times{ Obj.say.should.eq nil }
-      2.times{ spy(Obj).say }
-    end
-
-    would 'work with call spy and call spy' do
-      stub(Obj).say{}
-      2.times do
-        Obj.say.should.eq nil
-        spy(Obj).say
-      end
-    end
-
-    would 'verify spy arguments' do
-      stub(Obj).say(1){|a|a}
-      Obj.say(1).should.eq 1
-       spy(Obj).say(1)
-    end
-
-    would 'properly verify spy arguments' do
-      stub(Obj).say(is_a(String)){|a|a}
-      Obj.say('Hi!').should.eq 'Hi!'
-       spy(Obj).say(is_a(String))
-    end
-
-    would 'ignore messages spies not interested' do
-      stub(Obj).saya{0}
-      stub(Obj).sayb{1}
-      Obj.saya.should.eq 0
-      Obj.sayb.should.eq 1
-       spy(Obj).saya
-    end
   end
 
   describe 'Muack.verify==false' do
@@ -113,50 +63,5 @@ describe Muack::Stub do
       e.was     .should.eq 'obj.say(false)'
       e.message .should.eq "\nExpected: #{e.expected}\n but was: #{e.was}"
     end
-
-    would 'raise Expected if the spy is not satisfied' do
-      stub(Obj).say{}
-       spy(Obj).say
-      e = should.raise(Muack::Expected){ Muack.verify }
-      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
-
-    would 'raise Expected if the spy is not satisfied enough' do
-      stub(Obj).say{}
-      Obj.say
-       spy(Obj).say(0)
-      e = should.raise(Muack::Unexpected){ Muack.verify }
-      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
-
-    would 'show correct times for under satisfaction' do
-      stub(Obj).say{}
-      2.times{ Obj.say }
-       spy(Obj).say.times(3)
-      e = should.raise(Muack::Expected){ Muack.verify }
-      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
-
-    would 'show correct times for over satisfaction' do
-      stub(Obj).say{}
-      2.times{ Obj.say }
-       spy(Obj).say
-      e = should.raise(Muack::Expected){ Muack.verify }
-      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

data/test/test_visibility.rb

@@ -0,0 +1,120 @@
+
+require 'muack/test'
+
+describe 'retain visibility' do
+  after do
+    expect(Muack.verify).eq true
+  end
+
+  def verify obj, visibility
+    expect(Muack.verify).eq true
+
+    if visibility == :public
+      expect(obj).respond_to? :hello
+    else
+      expect(obj).not.respond_to? :hello
+      expect(obj).respond_to? :hello, true
+    end
+  end
+
+  def generate visibility
+    klass = Class.new do
+      def greet
+        'hi'
+      end
+    end
+
+    mod = Module.new do
+      def greet
+        hello
+      end
+
+      def hello
+        'hello'
+      end
+      send visibility, :hello
+    end
+
+    perform(klass, mod)
+  end
+
+  copy :test do
+    %i[public protected private].each do |visibility|
+      would "stub with #{visibility}" do
+        obj = generate(visibility)
+
+        stub(obj).hello{'stubbed'}
+
+        verify(obj, visibility)
+      end
+
+      would "stub proxy with #{visibility}" do
+        obj = generate(visibility)
+
+        stub(obj).hello
+
+        verify(obj, visibility)
+      end
+    end
+  end
+
+  describe 'prepend on class stub with object' do
+    def perform(klass, mod)
+      klass.prepend(mod)
+      klass.new
+    end
+
+    paste :test
+  end
+
+  describe 'extend on object stub with object' do
+    def perform(klass, mod)
+      obj = klass.new
+      obj.extend(mod)
+      obj
+    end
+
+    paste :test
+  end
+
+  describe 'include on singleton_class stub 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 stub with object' do
+    def perform(klass, mod)
+      obj = klass.new
+      obj.singleton_class.prepend(mod)
+      obj
+    end
+
+    paste :test
+  end
+
+  # Brought from rspec-mocks
+  would "correctly restore the visibility of methods whose visibility has been tweaked on the singleton class" do
+    # hello is a private method when mixed in, but public on the module
+    # itself
+    mod = Module.new do
+      extend self
+      def hello; :hello; end
+
+      private :hello
+      class << self; public :hello; end
+    end
+
+    expect(mod.hello).eq :hello
+
+    stub(mod).hello{ :stub }
+
+    Muack.reset
+
+    expect(mod.hello).eq :hello
+  end
+end