minispec 0.0.1

data/test/mocks/spies/return.rb

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

data/test/mocks/spies/throw.rb

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

data/test/mocks/spies/yield.rb

@@ -0,0 +1,101 @@
+class MinispecTest::Spies::Unit
+
+  should 'pass when yield expected and occurred' do
+    o.y {|a,b|}
+    expect(o).received(:y).and_yield
+  end
+
+  should 'pass when yield not expected and not occurred' do
+    o = Class.new { def y; end }.new
+    proxy(o, :y)
+    o.y
+    expect(o).received(:y).without_yield
+  end
+
+  should ':fail when yield expected but not occurred' do
+    o.a
+    expect(o).received(:a).and_yield
+  end
+
+  should ':fail when yield occurred but not expected' do
+    o.y {|a,b|}
+    expect(o).received(:y).without_yield
+  end
+
+  should 'pass when yielded with expected arguments' do
+    o.y {|a, b|}
+    expect(o).received(:y).and_yield(1, 2)
+  end
+
+  should ':fail when yielded with wrong arguments' do
+    o.y {|a, b|}
+    expect(o).received(:y).and_yield(4, 5)
+  end
+
+  should 'pass when proc validates yielded arguments' do
+    o.y {|a, b|}
+    expect(o).received(:y).and_yield {|args| args == [[1, 2]]}
+  end
+
+  should ':fail when proc does not validate yielded arguments' do
+    o.y {|a, b|}
+    expect(o).received(:y).and_yield {|a,b| false}
+  end
+
+  should 'not raise when arity not respected and proc used' do
+    refute { o.y {|a|} }.raise
+    expect(o).received(:y)
+  end
+
+  should 'use same expectation for all messages' do
+    o.y {|a,b|}
+    o.x {|a,b|}
+    expect(o).received(:y, :x).and_yield([1, 2])
+  end
+
+  should 'pass when multiple yielded arguments match expected ones' do
+    o.y {|a,b|}
+    o.x {|a,b|}
+    expect(o).received(:y, :x).and_yield([1, 2], [1, 2])
+  end
+
+  should 'work well when multiple Array arguments yielded' do
+    o.define_singleton_method(:Y) {|&b| b.call([1, [2]])}
+    proxy(o, :Y)
+    o.Y {|a,b|}
+    o.x {|a,b|}
+    expect(o).received(:Y, :x).and_yield([[[1, [2]]]], [1, 2])
+  end
+
+  should 'pass when proc validates multiple yielded arguments' do
+    o.define_singleton_method(:Y) {|&b| b.call([1, [2]])}
+    proxy(o, :Y)
+    o.Y {|a,b|}
+    o.x {|a,b|}
+    expect(o).received(:Y, :x).and_yield {|y,x| y == [[[1, [2]]]] && x == [[1, 2]]}
+  end
+
+  should ':fail when multiple yielded arguments does not match expected ones' do
+    o.y {|a,b|}
+    o.x {|a,b|}
+    expect(o).received(:y, :x).and_yield(1, 0)
+  end
+
+  should ':fail when proc does not validate multiple yielded arguments' do
+    o.y {|a,b|}
+    o.x {|a,b|}
+    expect(o).received(:y, :x).and_yield {|*a| false}
+  end
+
+  should ':fail when multiple yields expected but none occurred' do
+    o.a
+    o.b
+    expect(o).received(:a, :b).and_yield
+  end
+
+  should ':fail when at least one yield occurred but none expected' do
+    o.a {}
+    o.x {|a,b|}
+    expect(o).received(:a, :x).without_yield
+  end
+end

data/test/mocks/test__doubles.rb

@@ -0,0 +1,98 @@
+class MinispecTest
+  class Stubs < self
+    class Unit
+      include Minispec
+
+      it 'uses first argument as name' do
+        d = double(:a, :b)
+        is(d.inspect) == :a
+      end
+
+      it 'creates anonymous doubles when no args given' do
+        d = double
+        does(d.inspect) =~ /#<Object/
+      end
+
+      it 'uses first argument as name and rest as stubs' do
+        d = double(:a, :b, :c)
+        is(d.inspect) == :a
+        refute(d).respond_to?(:a)
+        does(d).respond_to?(:b)
+        does(d).respond_to?(:c)
+      end
+
+      it 'uses hashes for stubs' do
+        a = double(:a, b: :c)
+        is(a.b) == :c
+      end
+
+      it 'uses given block for returned value' do
+        a = double(:a, :b) {:c}
+        is(a.b) == :c
+      end
+
+      it 'creates public stubs' do
+        d = double(:a, :b)
+        does(d.public_methods).include?(:b)
+      end
+
+      it 'creates private stubs' do
+        d = double
+        private_stub(d, :a)
+        does(d.private_methods).include?(:a)
+        does { d.a }.raise? NoMethodError, /private method\W+a/
+      end
+
+      it 'creates protected stubs' do
+        d = double
+        protected_stub(d, :a)
+        does(d.protected_methods).include?(:a)
+        does { d.a }.raise? NoMethodError, /protected method\W+a/
+      end
+
+      it 'defines chained stubs' do
+        @a = nil
+        d = double(:chained, 'a.b.c') {|*a| @a = true; a}
+
+        does(d).respond_to?(:a)
+        d.a
+        is(@a).nil?
+
+        does(d.a).respond_to?(:b)
+        d.a.b
+        is(@a).nil?
+
+        does(d.a.b).respond_to?(:c)
+        expect(d.a.b.c(:x, :y)).to_contain :x, :y
+        is(@a).true?
+      end
+
+      it 'plays well with expectations' do
+        d = double(:dbl, :a)
+        expect(d).to_receive(:a)
+        d.a
+      end
+
+      class SomeError < ArgumentError; end
+      it 'plays well with raise expectations' do
+        d = double(:dbl, :a) { raise SomeError }
+        expect(d).to_receive(:a).and_raise SomeError
+        d.a rescue nil
+      end
+
+      it 'plays well with throw expectations' do
+        d = double(:dbl, :a) { throw :ArgumentError }
+        expect(d).to_receive(:a).and_throw :ArgumentError
+        d.a rescue nil
+      end
+
+      it 'plays well with yield expectations' do
+        d = double(:dbl, :a) { |&b| b.call :x }
+        expect(d).to_receive(:a).and_yield :x
+        d.a {|a|}
+      end
+    end
+
+    define_tests(Unit)
+  end
+end

data/test/mocks/test__expectations.rb

@@ -0,0 +1,27 @@
+class MinispecTest
+  class Expectations < self
+
+    class O
+      def a(*a); :a; end
+      def b(*a); :b; end
+      def c(*a); :c; end
+      def d; :d; end
+      def e; raise(ArgumentError, 'some blah'); end
+      def r; raise(ArgumentError, 'some blah'); end
+      def t; throw(:s); end
+      def w; throw(:s); end
+      def x(&b); yield(1, 2); end
+      def y(&b); yield(1, 2); end
+      def z; :a; end
+    end
+
+    class Unit
+      include Minispec
+      continue_on_failures true
+      let(:o) { O.new }
+    end
+
+    Dir[File.expand_path('../expectations/*.rb', __FILE__)].each {|f| require(f)}
+    define_tests(Unit)
+  end
+end

data/test/mocks/test__mocks.rb

@@ -0,0 +1,197 @@
+class MinispecTest
+  class Mocks < self
+    class Unit
+      include Minispec
+
+      let(:o) { Object.new }
+
+      it 'creates a stub that returns nil' do
+        mock(o, :a)
+        is(o.a).nil?
+      end
+
+      it 'creates a stub that returns a value' do
+        mock(o, :a) {:a}
+        is(o.a) == :a
+      end
+
+      it 'is mocking using a Hash' do
+        mock(o, a: :x, b: :y)
+        does(o).respond_to?(:a)
+        is(o.a) == :x
+        does(o).respond_to?(:b)
+        is(o.b) == :y
+      end
+
+      it 'raise ArgumentError when using constraints on Hash mocks' do
+        does { mock(o, a: :b).with(1) {1} }.raise?(ArgumentError, /can not be used/i)
+        # though error raised, methods should be successfully mocked
+        assert(o.a) == :b
+      end
+
+      it ':fails if expectation not met' do
+        mock(o, :a)
+      end
+
+      it 'calls various stubs depending on given args' do
+        mock(o, :a){0}
+        mock(o, :a).with(1) {1}
+        mock(o, :a).with(2) {2}
+        is(o.a) == 0
+        is(o.a(1)) == 1
+        is(o.a(2)) == 2
+      end
+
+      it 'is mocking private methods' do
+        private_mock(o, :a)
+        does(o.private_methods).include?(:a)
+        does { o.a }.raise? NoMethodError, /private method\W+a/
+        o.send(:a)
+      end
+
+      it 'mocking private methods using a Hash' do
+        private_mock(o, a: :b)
+        does(o.private_methods).include?(:a)
+        does { o.a }.raise? NoMethodError, /private method\W+a/
+        assert(o.send(:a)) == :b
+      end
+
+      it 'is mocking protected methods' do
+        protected_mock(o, :a)
+        does(o.protected_methods).include?(:a)
+        does { o.a }.raise? NoMethodError, /protected method\W+a/
+        o.send(:a)
+      end
+
+      it 'mocking protected methods using a Hash' do
+        protected_mock(o, a: :b)
+        does(o.protected_methods).include?(:a)
+        does { o.a }.raise? NoMethodError, /protected method\W+a/
+        assert(o.send(:a)) == :b
+      end
+
+      it 'keeps the visibility of existing methods' do
+        o = Class.new do
+          def a; end
+          protected
+          def b; p :blah; end
+          private
+          def c; end
+        end.new
+
+        mock(o, :a)
+        o.send(:a)
+        does(o.public_methods).include?(:a)
+
+        mock(o, :b)
+        o.send(:b)
+        does(o.protected_methods).include?(:b)
+
+        mock(o, :c)
+        o.send(:c)
+        does(o.private_methods).include?(:c)
+      end
+
+      it 'uses `with_any` with a block to define a catchall return' do
+        mock(o, :a).
+          with(1) { :one }.
+          with_any { :A }
+        assert(o.a) == :A
+        assert(o.a(:blah)) == :A
+        assert(o.a(1)) == :one
+      end
+
+      it 'uses `with_any` with a value to define a catchall return' do
+        mock(o, :a).
+          with(1) { :one }.
+          with_any(:A)
+        assert(o.a) == :A
+        assert(o.a(:blah)) == :A
+        assert(o.a(1)) == :one
+      end
+
+      it 'is mocking multiple methods at once' do
+        mocks(o, :a, :b)
+        does(o).respond_to?(:a)
+        does(o).respond_to?(:b)
+        o.a
+        o.b
+      end
+
+      it 'is mocking multiple methods at once and :fail if a least one message not received' do
+        mocks(o, :a, :b)
+        o.a
+        # o.b  intentionally commented
+      end
+
+      it 'uses given block for all mocks' do
+        mocks(o, :a, :b) {:x}
+        assert(o.a) == :x
+        assert(o.b) == :x
+      end
+
+      it 'uses same constraints for all mocks' do
+        mocks(o, :a, :b).
+          with(1) {:one}.
+          with(2) {:two}.
+          with_any(:any)
+
+        assert(o.a) == :any
+        assert(o.a(:what, :ever)) == :any
+
+        assert(o.b) == :any
+        assert(o.b(:blah)) == :any
+
+        assert(o.a(1)) == :one
+        assert(o.b(1)) == :one
+
+        assert(o.a(2)) == :two
+        assert(o.b(2)) == :two
+        o.a
+        o.b
+      end
+
+      it 'defines multiple private stubs' do
+        private_mocks(o, :a, :b)
+        does(o.private_methods).include?(:a)
+        does(o.private_methods).include?(:b)
+        does { o.a }.raise? NoMethodError, /private method\W+a/
+        does { o.b }.raise? NoMethodError, /private method\W+b/
+        o.send(:a)
+        o.send(:b)
+      end
+
+      it 'defines multiple protected stubs' do
+        protected_mocks(o, :a, :b)
+        does(o.protected_methods).include?(:a)
+        does(o.protected_methods).include?(:b)
+        does { o.a }.raise? NoMethodError, /protected method\W+a/
+        does { o.b }.raise? NoMethodError, /protected method\W+b/
+        o.send(:a)
+        o.send(:b)
+      end
+
+      it 'enforces public visibility on protected methods' do
+        o = Class.new do
+          protected
+          def a; end
+        end.new
+        does { o.a }.raise? NoMethodError, /protected method\W+a/
+        public_mock(o, :a) { :a }
+        assert(o.a) == :a
+      end
+
+      it 'enforces public visibility on private methods' do
+        o = Class.new do
+          private
+          def a; end
+        end.new
+        does { o.a }.raise? NoMethodError, /private method\W+a/
+        public_mock(o, :a) { :a }
+        assert(o.a) == :a
+      end
+    end
+
+    define_tests(Unit)
+  end
+end