minispec 0.0.1

data/test/mocks/expectations/yield.rb

@@ -0,0 +1,109 @@
+class MinispecTest::Expectations::Unit
+
+  should 'pass when yield expected and occurred' do
+    expect(o).to_receive(:y).and_yield
+    o.y {|a,b|}
+  end
+
+  should 'pass when yield not expected and not occurred' do
+    o = Class.new { def y; end }.new
+    expect(o).to_receive(:y).without_yield
+    o.y
+  end
+
+  should ':fail when yield expected but not occurred' do
+    expect(o).to_receive(:a).and_yield
+    o.a
+  end
+
+  should ':fail when yield occurred but not expected' do
+    expect(o).to_receive(:y).without_yield
+    o.y {|a,b|}
+  end
+
+  should 'pass when yielded with expected arguments' do
+    expect(o).to_receive(:y).and_yield(1, 2)
+    o.y {|a, b|}
+  end
+
+  should 'flatten arguments when single value expected' do
+    o.define_singleton_method(:y) {|&b| b.call(1)}
+    expect(o).to_receive(:y).and_yield(1)
+    o.y {|a, b|}
+  end
+
+  should ':fail when yielded with wrong arguments' do
+    expect(o).to_receive(:y).and_yield(4, 5)
+    o.y {|a, b|}
+  end
+
+  should 'pass when proc validates yielded arguments' do
+    expect(o).to_receive(:y).and_yield {|args| args[0] == [1, 2]}
+    o.y {|a, b|}
+  end
+
+  should ':fail when proc does not validate yielded arguments' do
+    expect(o).to_receive(:y).and_yield {false}
+    o.y {|a, b|}
+  end
+
+  should 'not raise when arity not respected and proc used' do
+    expect(o).to_receive(:y)
+    assure { o.y {|a|} }.does_not.raise
+  end
+
+  should 'raise when arity not respected and lambda used' do
+    expect(o).to_receive(:y)
+    does { o.y(&lambda {|a|}) }.raise? ArgumentError, /2 for 1/
+  end
+
+  should 'use same expectation for all messages' do
+    expect(o).to_receive(:y, :x).and_yield([1, 2])
+    o.y {|a,b|}
+    o.x {|a,b|}
+  end
+
+  should 'pass when multiple yielded arguments match expected ones' do
+    expect(o).to_receive(:y, :x).and_yield([1, 2], [1, 2])
+    o.y {|a,b|}
+    o.x {|a,b|}
+  end
+
+  should 'flatten arguments when some message expects a single value' do
+    o.define_singleton_method(:y) {|&b| b.call(1)}
+    expect(o).to_receive(:y, :x).and_yield(1, [1, 2])
+    o.y {|a,b|}
+    o.x {|a,b|}
+  end
+
+  should 'NOT flatten arguments when validated by a block' do
+    o.define_singleton_method(:y) {|&b| b.call(1)}
+    expect(o).to_receive(:y, :x).and_yield {|y,x| y[0] == [1] && x[0] == [1, 2]}
+    o.y {|a,b|}
+    o.x {|a,b|}
+  end
+
+  should ':fail when at least one message does not yield as expected' do
+    expect(o).to_receive(:y, :x).and_yield([1, 2], 0)
+    o.y {|a,b|}
+    o.x {|a,b|}
+  end
+
+  should ':fail when proc does not validate multiple yielded arguments' do
+    expect(o).to_receive(:y, :x).and_yield {false}
+    o.y {|a,b|}
+    o.x {|a,b|}
+  end
+
+  should ':fail when multiple yields expected but none occurred' do
+    expect(o).to_receive(:a, :b).and_yield
+    o.a
+    o.b
+  end
+
+  should ':fail when at least one yield occurred but none expected' do
+    expect(o).to_receive(:a, :x).without_yield
+    o.a {}
+    o.x {|a,b|}
+  end
+end

data/test/mocks/spies/amount.rb

@@ -0,0 +1,68 @@
+class MinispecTest::Spies::Unit
+
+  should 'pass when received expected amount' do
+    o.a
+    o.a
+    expect(o).received(:a).count(2)
+  end
+
+  should ':fail when wrong amount expected' do
+    o.a
+    expect(o).received(:a).count(2)
+  end
+
+  should 'pass when proc validates received amount' do
+    o.a
+    o.a
+    expect(o).received(:a).count {|received| received == 2}
+  end
+
+  should ':fail when proc does not validate received amount' do
+    o.a
+    expect(o).received(:a).count {|received| false}
+  end
+
+  should 'pass when multiple messages uses one expectation' do
+    o.a
+    o.b
+    o.b
+    o.a
+    expect(o).received(:a, :b).count(2)
+  end
+
+  should ':fail when received multiple messages amount are wrong' do
+    o.a
+    o.b
+    o.b
+    expect(o).received(:a, :b).count(2)
+  end
+
+  should 'pass when each of multiple messages uses its own expectation' do
+    o.a
+    o.b
+    o.b
+    expect(o).received(:a, :b).count(1, 2)
+  end
+
+  should ':fail when at least one messages does not match its expectation' do
+    o.a
+    o.b
+    o.b
+    expect(o).received(:a, :b).count(1, 1)
+  end
+
+  should 'pass when proc validates received multiple messages amount' do
+    o.a
+    o.b
+    o.b
+    o.a
+    expect(o).received(:a, :b).count {|*r| r == [2, 2]}
+  end
+
+  should ':fail when proc does not validate received multiple messages amount' do
+    o.a
+    o.b
+    expect(o).received(:a, :b).count {|*r| false}
+  end
+
+end

data/test/mocks/spies/arguments.rb

@@ -0,0 +1,57 @@
+class MinispecTest::Spies::Unit
+
+  should 'pass when expected arguments matches given ones' do
+    o.a(1, 2)
+    expect(o).received(:a).with(1, 2)
+  end
+
+  should ':fail when wrong arguments given' do
+    o.a(1, 2)
+    expect(o).received(:a).with(4, 5)
+  end
+
+  should 'pass when proc validates arguments' do
+    o.a(1)
+    expect(o).received(:a).with {|a| a[0] == [1]}
+  end
+
+  should ':fail when proc does not validate arguments' do
+    o.a(1)
+    expect(o).received(:a).with {|a| false}
+  end
+
+  should 'pass when given multiple arguments matching expected ones' do
+    o.a 1
+    o.b 2
+    o.c 3
+    expect(o).received(:a, :b, :c).with(1, 2, 3)
+  end
+
+  it 'plays well with Array arguments' do
+    o.a [1]
+    o.b [4, 5, [6]]
+    o.c :c
+    expect(o).received(:a, :b, :c).with([1], [4, 5, [6]], :c)
+  end
+
+  should 'pass when proc validates passed arguments' do
+    o.a 1
+    o.b [2]
+    o.c 3
+    expect(o).received(:a, :b, :c).with {|a,b,c| a[0] == [1] && b[0] == [[2]] && c[0] == [3]}
+  end
+
+  should ':fail when at least one argument does not meet expectations' do
+    o.a 1
+    o.b 2
+    o.c 3
+    expect(o).received(:a, :b, :c).with(1, 2, 5)
+  end
+
+  should ':fail when proc does not validate passed arguments' do
+    o.a 1
+    o.b 2
+    o.c 3
+    expect(o).received(:a, :b, :c).with {|a| false}
+  end
+end

data/test/mocks/spies/generic.rb

@@ -0,0 +1,61 @@
+class MinispecTest::Spies::Unit
+
+  should 'pass if message received' do
+    o.a
+    expect(o).received(:a)
+  end
+
+  should ':fail if message not received' do
+    expect(o).received(:a)
+  end
+
+  should 'pass when no message expected and none received' do
+    assert(o).not.received(:a)
+  end
+
+  should ':fail when message sent but not expected' do
+    o.a
+    assert(o).not.received(:a)
+  end
+
+  should 'pass when no messages expected and none received' do
+    assert(o).not.received(:a, :b)
+  end
+
+  should ':fail when at least one message sent but none expected' do
+    o.a
+    assert(o).not.received(:a, :b)
+  end
+
+  should ':fail when all messages sent but none expected' do
+    o.a
+    o.b
+    assert(o).not.received(:a, :b)
+  end
+
+  it 'spies on multiple messages' do
+    o = Class.new do
+      def a; __method__; end
+      def b; __method__; end
+      def c; __method__; end
+    end.new
+    spy(o, :a, :b, :c)
+    o.a
+    o.b
+    o.c
+    assert(o).received(:a, :b, :c).and_returned(:a, :b, :c)
+  end
+
+  it 'spies on multiple messages and :fail when at least one message not received' do
+    o = Class.new do
+      def a; __method__; end
+      def b; __method__; end
+      def c; __method__; end
+    end.new
+    spy(o, :a, :b, :c)
+    o.a
+    # o.b intentionally commented
+    o.c
+    assert(o).received(:a, :b, :c)
+  end
+end

data/test/mocks/spies/order.rb

@@ -0,0 +1,38 @@
+class MinispecTest::Spies::Unit
+
+  should 'pass when messages received in expected order' do
+    o.a
+    o.b
+    o.c
+    assert(o).received(:a, :b, :c).ordered
+  end
+
+  should 'pass when middle messages missing' do
+    o.a
+    # b intentionally not called to make sure it iterates only through expected messages
+    o.c
+    assert(o).received(:a, :c).ordered
+  end
+
+  should ':fail when messages received in wrong order' do
+    o.b
+    o.c
+    o.a
+    assert(o).received(:a, :b).ordered
+  end
+
+  should 'pass when same sequence repeated n times' do
+    o.a
+    o.b
+    o.a
+    o.b
+    assert(o).received(:a, :b).ordered(2)
+  end
+
+  should ':fail when expected sequence not respected' do
+    o.a
+    o.b
+    o.a
+    assert(o).received(:a, :b).ordered(2)
+  end
+end

data/test/mocks/spies/raise.rb

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