minispec 0.0.1

data/test/mocks/expectations/caller.rb

@@ -0,0 +1,55 @@
+class MinispecTest::Expectations::Unit
+
+  should 'pass when caller matches given String' do
+    expect(o).to_receive(:a).with_caller([__FILE__, __LINE__ + 1]*':')
+    o.a
+  end
+  should ':fail when caller does NOT matches given String' do
+    expect(o).to_receive(:a).with_caller('blah')
+    o.a
+  end
+
+  should 'pass when caller validated by given Proc' do
+    expect(o).to_receive(:a).with_caller {|callers| callers[0].find {|l| l =~ /#{__FILE__}/}}
+    o.a
+  end
+  should ':fail when caller NOT validated by given Proc' do
+    expect(o).to_receive(:a).with_caller { false }
+    o.a
+  end
+
+  should 'pass when all callers matches given String' do
+    expect(o).to_receive(:a, :b).with_caller(__FILE__)
+    o.a
+    o.b
+  end
+  should ':fail when at least one caller does NOT match given String' do
+    expect(o).to_receive(:a, :b).with_caller('blah')
+    o.a
+    o.b
+  end
+
+  should 'pass when all callers validated by given Proc' do
+    expect(o).to_receive(:a, :b).with_caller do |a,b|
+      a[0].any? {|l| l =~ /#{__FILE__}/} && b[0].any? {|l| l =~ /#{__FILE__}/}
+    end
+    o.a
+    o.b
+  end
+  should ':fail when at least one caller NOT validated by given Proc' do
+    expect(o).to_receive(:a, :b).with_caller { false }
+    o.a
+    o.b
+  end
+
+  should 'pass when each caller matches its String' do
+    expect(o).to_receive(:a, :b).with_caller(__FILE__, [__FILE__, __LINE__ + 2]*':')
+    o.a
+    o.b
+  end
+  should ':fail when at least one caller does NOT match its String' do
+    expect(o).to_receive(:a, :b).with_caller(__FILE__, 'blah')
+    o.a
+    o.b
+  end
+end

data/test/mocks/expectations/generic.rb

@@ -0,0 +1,35 @@
+class MinispecTest::Expectations::Unit
+
+  should 'pass if message received' do
+    expect(o).to_receive(:a)
+    o.a
+  end
+
+  should ':fail if message not received' do
+    expect(o).to_receive(:a)
+  end
+
+  should 'pass when no message expected and none received' do
+    expect(o).to_not.receive(:a)
+  end
+
+  should ':fail when message received but not expected' do
+    expect(o).to_not.receive(:a)
+    o.a
+  end
+
+  should 'pass when no messages expected and none received' do
+    expect(o).to_not.receive(:a, :b)
+  end
+
+  should ':fail when at least one message received but not expected' do
+    expect(o).to_not.receive(:a, :b)
+    o.a
+  end
+
+  should ':fail when all messages received but not expected' do
+    expect(o).to_not.receive(:a, :b)
+    o.a
+    o.b
+  end
+end

data/test/mocks/expectations/order.rb

@@ -0,0 +1,46 @@
+class MinispecTest::Expectations::Unit
+
+  should 'pass when messages received in expected order' do
+    expect(o).to_receive(:a, :b, :c).ordered
+    o.a
+    o.b
+    o.c
+  end
+
+  should 'pass when middle messages missing' do
+    expect(o).to_receive(:a, :c).ordered
+    o.a
+    # b intentionally not called to make sure it iterates only through expected messages
+    o.c
+  end
+
+  should ':fail when messages received in wrong order' do
+    expect(o).to_receive(:a, :b).ordered
+    o.b
+    o.c
+    o.a
+  end
+
+  should 'pass when same sequence repeated n times' do
+    expect(o).to_receive(:a, :b).ordered(2)
+    o.a
+    o.b
+    o.a
+    o.b
+  end
+
+  should ':fail when expected sequence not respected' do
+    expect(o).to_receive(:a, :b).ordered(2)
+    o.a
+    o.b
+    o.a
+  end
+
+  should ':fail when used with a single expected message' do
+    expect { expect(o).to_receive(:a).ordered }.raise(ArgumentError, /multiple/i)
+  end
+
+  should ':fail when a non-Integer given' do
+    expect { expect(o).to_receive(:a, :b).ordered('2') }.to_raise(ArgumentError, /integer/i)
+  end
+end

data/test/mocks/expectations/raise.rb

@@ -0,0 +1,166 @@
+class MinispecTest::Expectations
+  class Unit
+
+    begin # single expectation
+      should 'pass when raise expected and occurred' do
+        expect(o).to_receive(:r).and_raise
+        o.r rescue nil
+      end
+
+      should 'pass when raise not expected and not occurred' do
+        expect(o).to_receive(:a).without_raise
+        o.a
+      end
+
+      should ':fail when raise expected but not occurred' do
+        expect(o).to_receive(:a).and_raise
+        o.a
+      end
+
+      should ':fail when raise occurred but not expected' do
+        expect(o).to_receive(:r).without_raise
+        o.r rescue nil
+      end
+
+      should 'pass when raised an expected error' do
+        expect(o).to_receive(:r).and_raise(ArgumentError)
+        o.r rescue nil
+      end
+
+      should ':fail when raised an unexpected error' do
+        expect(o).to_receive(:r).and_raise(RuntimeError)
+        o.r rescue nil
+        o.r rescue nil
+      end
+
+      should 'pass when raised an expected message' do
+        expect(o).to_receive(:r).and_raise(ArgumentError, 'some blah')
+        o.r rescue nil
+      end
+
+      should 'pass when raised message matches expected one' do
+        expect(o).to_receive(:r).and_raise(ArgumentError, /blah/)
+        o.r rescue nil
+      end
+
+      should ':fail when raised an unexpected message' do
+        expect(o).to_receive(:r).and_raise(ArgumentError, 'another blah')
+        o.r rescue nil
+      end
+
+      should ':fail when raised message does not match expected one' do
+        expect(o).to_receive(:r).and_raise(ArgumentError, /x/)
+        o.r rescue nil
+      end
+
+      should 'pass when given block validates raised exception' do
+        expect(o).to_receive(:r).and_raise {|r| r.any? {|x| x.class == ArgumentError}}
+        o.r rescue nil
+      end
+
+      should ':fail when given block does not validate raised exception' do
+        expect(o).to_receive(:r).and_raise {false}
+        o.r rescue nil
+      end
+    end
+
+    begin # multiple expectations
+
+      should 'pass when one expectation used for all messages' do
+        expect(o).to_receive(:e, :r).and_raise(ArgumentError)
+        o.e rescue nil
+        o.r rescue nil
+      end
+      should 'pass when one expectation used for all messages and error matching used' do
+        expect(o).to_receive(:e, :r).and_raise([ArgumentError, 'some blah'])
+        o.e rescue nil
+        o.r rescue nil
+      end
+
+      should ':fail when one expectation used for all messages and type does not match' do
+        expect(o).to_receive(:e, :r).and_raise(Exception)
+        o.e rescue nil
+        o.r rescue nil
+      end
+
+      should ':fail when one expectation used for all messages, type matches but message does not' do
+        expect(o).to_receive(:e, :r).and_raise([ArgumentError, 'some error'])
+        o.e rescue nil
+        o.r rescue nil
+      end
+
+      should ':fail when one expectation used for all messages
+        and at least one message does not raise at all' do
+        expect(o).to_receive(:a, :r).and_raise(ArgumentError)
+        o.a
+        o.r rescue nil
+      end
+
+      should 'pass when each message uses own expectation' do
+        expect(o).to_receive(:e, :r).and_raise(ArgumentError, ArgumentError)
+        o.e rescue nil
+        o.r rescue nil
+      end
+
+      should ':fail when each message uses own expectation
+        and at least message does not raise as expected' do
+        expect(o).to_receive(:e, :r).and_raise(ArgumentError, Exception)
+        o.e rescue nil
+        o.r rescue nil
+      end
+
+      should ':fail when each message uses own expectation
+        and at least message does not raise at all' do
+        expect(o).to_receive(:a, :r).and_raise(ArgumentError, Exception)
+        o.a
+        o.r rescue nil
+      end
+
+      should 'pass when each message uses own expectation and error matching used' do
+        expect(o).to_receive(:e, :r).and_raise([ArgumentError, /blah/], [ArgumentError, /blah/])
+        o.e rescue nil
+        o.r rescue nil
+      end
+
+      should ':fail when each message uses own expectation and error matching used
+        and at least one message does not raise as expected' do
+        expect(o).to_receive(:e, :r).and_raise([ArgumentError, /blah/], [ArgumentError, /doh/])
+        o.e rescue nil
+        o.r rescue nil
+      end
+
+      should ':fail when at least one raise occurred but none expected' do
+        expect(o).to_receive(:a, :r).without_raise
+        o.a
+        o.r rescue nil
+      end
+
+      should ':fail when multiple raises expected but none occurred' do
+        expect(o).to_receive(:a, :b).and_raise
+        o.a
+        o.b
+      end
+
+      should 'pass when no raises expected and none occurred' do
+        expect(o).to_receive(:a, :b).without_raise
+        o.a
+        o.b
+      end
+
+      should 'pass when given block validates raised exceptions' do
+        expect(o).to_receive(:r, :e).and_raise do |r,e|
+          r.any? {|x| x.class == ArgumentError} &&
+            e.any? {|x| x.class == ArgumentError}
+        end
+        o.r rescue nil
+        o.e rescue nil
+      end
+
+      should ':fail when given block does not validate raised exceptions' do
+        expect(o).to_receive(:r, :e).and_raise {false}
+        o.r rescue nil
+        o.e rescue nil
+      end
+    end
+  end
+end

data/test/mocks/expectations/return.rb

@@ -0,0 +1,71 @@
+class MinispecTest::Expectations::Unit
+
+  should 'pass when correct value returned' do
+    expect(o).to_receive(:a).and_return(:a)
+    o.a
+  end
+
+  should ':fail when wrong value returned' do
+    expect(o).to_receive(:a).and_return(:b)
+    o.a
+  end
+
+  should 'pass when proc validates returned value' do
+    expect(o).to_receive(:a).and_return {|r| r[0] == :a}
+    o.a
+  end
+
+  should 'yield multiple returned values when message received multiple times' do
+    expect(o).to_receive(:a).and_return {|r| r[0] == :a && r[1] == :a}
+    o.a
+    o.a
+  end
+
+  should ':fail when proc does not validate returned value' do
+    expect(o).to_receive(:a).and_return {false}
+    o.a
+  end
+
+  should 'pass when returned values matches expected ones' do
+    expect(o).to_receive(:a, :b).and_return(:a, :b)
+    o.a
+    o.b
+  end
+
+  should 'pass when all messages returns same value' do
+    expect(o).to_receive(:a, :z).and_return(:a)
+    o.a
+    o.z
+  end
+
+  should ':fail when a single value expected and a at least one message does not return it' do
+    expect(o).to_receive(:a, :b).and_return(:a)
+    o.a
+    o.b
+  end
+
+  should ':fail when at least one message returns a unexpected value' do
+    expect(o).to_receive(:a, :b).and_return(:a, :x)
+    o.a
+    o.b
+  end
+
+  should 'pass when proc validates returned values' do
+    expect(o).to_receive(:a, :b).and_return {|a,b| a[0] == :a && b[0] == :b}
+    o.a
+    o.b
+  end
+
+  should 'yield multiple returned values when multiple messages received multiple times' do
+    expect(o).to_receive(:a, :b).and_return {|a,b| a[0] == :a && a[1] == :a && b[0] == :b}
+    o.a
+    o.a
+    o.b
+  end
+
+  should ':fail when proc does not validate returned values' do
+    expect(o).to_receive(:a, :b).and_return {false}
+    o.a
+    o.b
+  end
+end

data/test/mocks/expectations/throw.rb

@@ -0,0 +1,113 @@
+class MinispecTest::Expectations::Unit
+
+  should 'pass when throw expected and occurred' do
+    expect(o).to_receive(:t).and_throw(:s)
+    o.t rescue nil
+  end
+
+  should ':fail when throw expected but not occurred' do
+    expect(o).to_receive(:a).and_throw(:s)
+    o.a
+  end
+
+  should ':fail when throw occurred but not expected' do
+    expect(o).to_receive(:t).without_throw
+    o.t rescue nil
+  end
+
+  should 'pass when throw not expected and not occurred' do
+    expect(o).to_receive(:a).without_throw
+    o.a
+  end
+
+  should 'pass when an expected symbol thrown' do
+    expect(o).to_receive(:t).and_throw :s
+    o.t rescue nil
+  end
+
+  should ':fail when thrown an unexpected symbol' do
+    expect(o).to_receive(:t).and_throw :x
+    o.t rescue nil
+  end
+
+  should 'pass when given block validates thrown symbol' do
+    expect(o).to_receive(:t).and_throw {|t| t[0] == :s}
+    o.t rescue nil
+  end
+
+  should ':fail when given block does not validate thrown symbol' do
+    expect(o).to_receive(:t).and_throw {false}
+    o.t rescue nil
+  end
+
+  should 'pass when given block validates thrown symbols' do
+    expect(o).to_receive(:t, :w).and_throw {|t,w| t[0] == :s && w[0] == :s}
+    o.t rescue nil
+    o.w rescue nil
+  end
+
+  should ':fail when given block does not validate thrown symbols' do
+    expect(o).to_receive(:t, :w).and_throw {false}
+    o.t rescue nil
+    o.w rescue nil
+    o.w rescue nil
+  end
+
+  should 'pass when all messages uses same expectation' do
+    expect(o).to_receive(:t, :w).and_throw :s
+    o.t rescue nil
+    o.w rescue nil
+  end
+
+  should ':fail when all messages uses same expectation
+    and at least one message throws a wrong symbol' do
+    expect(o).to_receive(:t, :w).and_throw :x
+    o.t rescue nil
+    o.w rescue nil
+  end
+
+  should ':fail when all messages uses same expectation
+    ad at least one message does not throw any symbol' do
+    expect(o).to_receive(:t, :z).and_throw :t
+    o.t rescue nil
+    o.z rescue nil
+  end
+
+  should 'pass when each message uses own expectation' do
+    expect(o).to_receive(:t, :w).and_throw :s, :s
+    o.t rescue nil
+    o.w rescue nil
+  end
+
+  should ':fail when each message uses own expectation
+    and at least one message does not throw as expected' do
+    expect(o).to_receive(:t, :w).and_throw :s, :x
+    o.t rescue nil
+    o.w rescue nil
+  end
+
+  should ':fail when each message uses own expectation
+    and at least one message does not throw at all' do
+    expect(o).to_receive(:t, :z).and_throw :s, :z
+    o.t rescue nil
+    o.z
+  end
+
+  should ':fail when at least one throw occurred but none expected' do
+    expect(o).to_receive(:a, :t).without_throw
+    o.a
+    o.t rescue nil
+  end
+
+  should ':fail when multiple thrown expected but none occurred' do
+    expect(o).to_receive(:a, :b).and_throw :s, :s
+    o.a
+    o.b
+  end
+
+  should 'pass when no thrown expected and none expected' do
+    expect(o).to_receive(:a, :b).without_throw
+    o.a
+    o.b
+  end
+end