muack 1.1.1 → 1.1.2

data/test/test_coat.rb

@@ -0,0 +1,48 @@
+
+require 'muack/test'
+
+describe Muack::Coat do
+  after do
+    Muack.verify.should.eq true
+    Muack::EnsureReset.call
+  end
+
+  would 'wear out' do
+    coat(Str).to_s{ 'Coat' }
+    Str.to_s.should.eq 'Coat'
+    Str.to_s.should.eq 'Moo'
+  end
+
+  would 'wear out 2 times' do
+    coat(Str).to_s{ 'Coat' }.times(2)
+    2.times{ Str.to_s.should.eq 'Coat' }
+    Str.to_s.should.eq 'Moo'
+  end
+
+  would 'call the original method' do
+    coat(Str).to_s{ Str.to_s.reverse }
+    Str.to_s.should.eq 'ooM'
+    Str.to_s.should.eq 'Moo'
+  end
+
+  would 'raise Expected error if coated method is not called' do
+    coat(Obj).say{ 'nnf' }
+    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 error if coated method is not called' do
+    coat(Obj).say{ 'nnf' }.times(2)
+    Obj.say.should.eq 'nnf'
+    e = should.raise(Muack::Expected){ Muack.verify }
+    e.expected      .should.eq 'obj.say()'
+    e.expected_times.should.eq 2
+    e.actual_times  .should.eq 1
+    e.message       .should.eq "\nExpected: obj.say()\n  " \
+                               "called 2 times\n but was 1 times."
+  end
+end

data/test/test_from_readme.rb

@@ -9,7 +9,7 @@ describe 'from README.md' do
   after{ Muack.reset }
 
   Context = Module.new{
-    include Muack::API
+    include Pork::API, Muack::API
 
     def results; @results ||= []; end
     def p res  ; results << res ; end
@@ -19,7 +19,7 @@ describe 'from README.md' do
       results.zip(expects).each do |(res, exp)|
         next if exp == 'ok'
         if exp.start_with?('raise')
-          res.should.kind_of eval(exp.sub('raise', ''))
+          res.should.kind_of? eval(exp.sub('raise', ''))
         else
           res.should.eq eval(exp)
         end
@@ -28,7 +28,7 @@ describe 'from README.md' do
   }
 
   codes.each.with_index do |code, index|
-    should 'pass from README.md #%02d' % index do
+    would 'pass from README.md #%02d' % index do
       context = Module.new{extend Context}
       begin
         context.instance_eval(code, 'README.md', 0)

data/test/test_mock.rb

@@ -8,31 +8,31 @@ describe Muack::Mock do
       Muack::EnsureReset.call
     end
 
-    should 'inspect' do
+    would 'inspect' do
       mock(Obj).inspect.should.eq "Muack::API.mock(obj)"
     end
 
-    should 'mock with regular method' do
+    would 'mock with regular method' do
       mock(Obj).say(true){ 'boo' }
       Obj.say(true).should.eq 'boo'
     end
 
-    should 'mock existing method' do
+    would 'mock existing method' do
       mock(Obj).to_s{ 'zoo' }
       Obj.to_s.should.eq 'zoo'
     end
 
-    should 'pass the actual block' do
+    would 'pass the actual block' do
       mock(Obj).say{ |&block| block.call('Hi') }
       Obj.say{ |msg| msg }.should.eq 'Hi'
     end
 
-    should 'pass multiple arguments' do
+    would 'pass multiple arguments' do
       mock(Obj).say{ |*args| args.reverse }.with_any_args
       Obj.say(0, 1).should.eq [1, 0]
     end
 
-    should 'mock private method and preserve privacy' do
+    would '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
@@ -42,13 +42,13 @@ describe Muack::Mock do
       Obj.__send__(:private).should.eq 'pri'
     end
 
-    should 'mock twice' do
+    would 'mock twice' do
       mock(Obj).say(true){ Obj.saya }
       mock(Obj).saya{ 'coo' }
       Obj.say(true).should.eq 'coo'
     end
 
-    should 'also mock with with' do
+    would 'also mock with with' do
       mock(Str).method_missing(:say, 0){ 0 }
       Str.say(0).should.eq 0
       Muack.verify.should.eq true
@@ -57,45 +57,45 @@ describe Muack::Mock do
       Muack.reset
     end
 
-    should 'mix mock and stub' do
+    would '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 'mix mock and stub with conflicting method, latter wins' do
+    would '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 'mix mock and stub with conflicting method, try to hit stub' do
+    would '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 with conflicting method, mock never called' do
+    would '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
+    would 'unnamed mock' do
       mock.say{1}.object.say.should.eq 1
     end
 
-    should 'mock and call, mock and call' do
+    would 'mock and call, mock and call' do
       mock(Obj).say{0}
       Obj.say.should.eq 0
       mock(Obj).say{1}
       Obj.say.should.eq 1
     end
 
-    should 'not remove original singleton method' do
+    would 'not remove original singleton method' do
       obj = Class.new{ def self.f; 0; end }
       2.times{ mock(obj).f{ 1 }  }
       2.times{ obj.f.should.eq 1 }
@@ -110,111 +110,85 @@ describe Muack::Mock do
       Muack::EnsureReset.call
     end
 
-    should 'raise Unexpected error if passing unexpected argument' do
+    would 'raise Unexpected error if passing unexpected argument' do
       mock(Obj).say(true){ 'boo' }
-      begin
-        Obj.say(false)
-        'never'.should.eq 'reach'
-      rescue Muack::Unexpected => e
-        e.expected.should.eq 'obj.say(true)'
-        e.was     .should.eq 'obj.say(false)'
-        e.message .should.eq "\nExpected: #{e.expected}\n but was: #{e.was}"
-      end
+      e = should.raise(Muack::Unexpected){ Obj.say(false) }
+      e.expected.should.eq 'obj.say(true)'
+      e.was     .should.eq 'obj.say(false)'
+      e.message .should.eq "\nExpected: #{e.expected}\n but was: #{e.was}"
     end
 
-    should 'have correct message for multiple mocks with the same name' do
+    would 'have correct message for multiple mocks with the same name' do
       2.times{ mock(Obj).say{} }
-      begin
-        3.times{ Obj.say }
-        'never'.should.eq 'reach'
-      rescue Muack::Expected => e
-        e.expected.should.eq 'obj.say()'
-        e.expected_times.should.eq 2
-        e.actual_times  .should.eq 3
-        e.message       .should.eq "\nExpected: obj.say()\n  " \
-                                   "called 2 times\n but was 3 times."
-      end
+      e = should.raise(Muack::Expected){ 3.times{ Obj.say } }
+      e.expected.should.eq 'obj.say()'
+      e.expected_times.should.eq 2
+      e.actual_times  .should.eq 3
+      e.message       .should.eq "\nExpected: obj.say()\n  " \
+                                 "called 2 times\n but was 3 times."
     end
 
-    should 'have correct message for mocks with special satisfier' do
+    would 'have correct message for mocks with special satisfier' do
       mock(Obj).say(anything){}
-      begin
+      e = should.raise(Muack::Expected) do
         Obj.say(1)
         Obj.say(2)
-        'never'.should.eq 'reach'
-      rescue Muack::Expected => e
-        expected = 'obj.say(Muack::API.anything())'
-        e.expected.should.eq expected
-        e.expected_times.should.eq 1
-        e.actual_times  .should.eq 2
-        e.message       .should.eq "\nExpected: #{expected}\n  " \
-                                   "called 1 times\n but was 2 times."
       end
+      expected = 'obj.say(Muack::API.anything())'
+      e.expected.should.eq expected
+      e.expected_times.should.eq 1
+      e.actual_times  .should.eq 2
+      e.message       .should.eq "\nExpected: #{expected}\n  " \
+                                 "called 1 times\n but was 2 times."
     end
 
-    should 'raise if a mock with times(0) gets called' do
+    would 'raise if a mock with times(0) gets called' do
       mock(Obj).say.times(0)
-      begin
-        Obj.say
-        'never'.should.eq 'reach'
-      rescue Muack::Unexpected => e
-        e.expected.should.eq nil
-        e.was     .should.eq 'obj.say()'
-        e.message .should.eq "\nUnexpected call: #{e.was}"
-      end
+      e = should.raise(Muack::Unexpected){ Obj.say }
+      e.expected.should.eq nil
+      e.was     .should.eq 'obj.say()'
+      e.message .should.eq "\nUnexpected call: #{e.was}"
     end
 
-    should 'raise if a mock with times(0) gets called with diff sig' do
+    would 'raise if a mock with times(0) gets called with diff sig' do
       mock(Obj).say.times(0)
-      begin
-        Obj.say(true)
-        'never'.should.eq 'reach'
-      rescue Muack::Unexpected => e
-        e.expected.should.eq nil
-        e.was     .should.eq 'obj.say(true)'
-        e.message .should.eq "\nUnexpected call: #{e.was}"
-      end
+      e = should.raise(Muack::Unexpected){ Obj.say(true) }
+      e.expected.should.eq nil
+      e.was     .should.eq 'obj.say(true)'
+      e.message .should.eq "\nUnexpected call: #{e.was}"
     end
 
-    should 'raise Unexpected when calling with diff sig' do
+    would 'raise Unexpected when calling with diff sig' do
       mock(Obj).say(true){1}
       Obj.say(true).should.eq 1
-      begin
-        Obj.say
-        'never'.should.eq 'reach'
-      rescue Muack::Unexpected => e
-        e.expected.should.eq 'obj.say(true)'
-        e.was     .should.eq 'obj.say()'
-        e.message .should.eq "\nExpected: #{e.expected}\n but was: #{e.was}"
-      end
+      e = should.raise(Muack::Unexpected){ Obj.say }
+      e.expected.should.eq 'obj.say(true)'
+      e.was     .should.eq 'obj.say()'
+      e.message .should.eq "\nExpected: #{e.expected}\n but was: #{e.was}"
     end
 
-    should 'raise Expected error if mock methods not called' do
+    would 'raise Expected error if mock methods not called' do
       mock(Obj).say(true){ 'boo' }
-      begin
-        Muack.verify
-      rescue Muack::Expected => e
-        e.expected      .should.eq 'obj.say(true)'
-        e.expected_times.should.eq 1
-        e.actual_times  .should.eq 0
-        e.message       .should.eq "\nExpected: obj.say(true)\n  " \
-                                   "called 1 times\n but was 0 times."
-      end
+      e = should.raise(Muack::Expected){ Muack.verify }
+      e.expected      .should.eq 'obj.say(true)'
+      e.expected_times.should.eq 1
+      e.actual_times  .should.eq 0
+      e.message       .should.eq "\nExpected: obj.say(true)\n  " \
+                                 "called 1 times\n but was 0 times."
     end
 
-    should 'show first not enough calls' do
+    would 'show first not enough calls' do
       mock(Obj).say{ 'boo' }.times(2)
       mock(Obj).saya{}      .times(2)
-      begin
+      e = should.raise(Muack::Expected) do
         Obj.say
         Muack.verify
-      rescue Muack::Expected => e
-        e.expected      .should.eq 'obj.say()'
-        e.expected_times.should.eq 2
-        e.actual_times  .should.eq 1
-        e.message       .should.eq "\nExpected: obj.say()\n  " \
-                                   "called 2 times\n but was 1 times."
       end
+      e.expected      .should.eq 'obj.say()'
+      e.expected_times.should.eq 2
+      e.actual_times  .should.eq 1
+      e.message       .should.eq "\nExpected: obj.say()\n  " \
+                                 "called 2 times\n but was 1 times."
     end
   end
 end

data/test/test_modifier.rb

@@ -8,92 +8,92 @@ describe Muack::Modifier do
   end
 
   describe 'times' do
-    should 'mock multiple times' do
+    would '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
+    would '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
+    would '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
+    would 'return with lexical scope' do
       mock(Obj).say.returns{0}
       Obj.say.should.eq 0
     end
 
-    should 'return with dynamic scope' do
+    would '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
+    would '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
+    would '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
+    would '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
+    would '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
+    would '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
+    would '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
+    would '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
+    would '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
+    would '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
+    would '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
+    would 'modify' do
       str = 'ff'
       stub(str).to_i(is_a(Integer)).peek_return{ |result| result * 2 }
       str.to_i(16).should.eq 510