minispec 0.0.1

data/test/mocks/test__proxies.rb

@@ -0,0 +1,61 @@
+class MinispecTest
+  class Proxies < self
+    class Unit
+      include Minispec
+
+      def restore_originals
+        __ms__mocks__restore_originals
+      end
+
+      class O
+        def x; __method__; end
+
+        protected
+        def y; __method__; end
+
+        private
+        def z; __method__; end
+      end
+
+      let(:o) { O.new }
+
+      it 'is proxying only once' do
+        proxy(o, :x)
+        position = @__ms__proxies[o].index(:x)
+        assert(position).not.nil?
+        proxy(o, :x)
+        expect(o).to_receive(:x)
+        o.x
+        assert(@__ms__proxies[o][position]) == :x
+      end
+
+      it 'is proxying public methods' do
+        proxy(o, :x)
+        expect(o).to_receive(:x)
+        assert(o.x) == :x
+        assert(o).received(:x)
+      end
+
+      it 'is proxying protected methods' do
+        proxy(o, :y)
+        expect(o).to_receive(:y)
+        assert(o.send(:y)) == :y
+        assert(o).received(:y)
+      end
+
+      it 'is proxying private methods' do
+        proxy(o, :z)
+        expect(o).to_receive(:z)
+        assert(o.send(:z)) == :z
+        assert(o).received(:z)
+      end
+
+      should 'raise NoMethodError when trying to proxify an un-existing method' do
+        does { proxy(o, :a) }.raise? NoMethodError
+      end
+
+    end
+
+    define_tests(Unit)
+  end
+end

data/test/mocks/test__spies.rb

@@ -0,0 +1,43 @@
+class MinispecTest
+  class Spies < 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 }
+      before do
+        %w[
+          a
+          b
+          c
+          d
+          e
+          r
+          t
+          w
+          x
+          y
+          z
+        ].each {|m| proxy(o, m.to_sym)}
+      end
+    end
+
+    Dir[File.expand_path('../spies/*.rb', __FILE__)].each {|f| require(f)}
+
+    define_tests(Unit)
+  end
+end

data/test/mocks/test__stubs.rb

@@ -0,0 +1,427 @@
+class MinispecTest
+  class Stubs < self
+    class Unit
+      include Minispec
+      continue_on_failures true
+
+      def restore_originals
+        __ms__mocks__restore_originals
+      end
+
+      let(:o) { Object.new }
+
+      it 'creates stubs' do
+        stub(o, :a)
+        does(o).respond_to?(:a)
+      end
+
+      it 'uses hash value as return value' do
+        stub(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 stubs' do
+        does { stub(o, a: :b).with(1) {1} }.raise?(ArgumentError, /can not be used/i)
+        # though error raised, methods should be successfully stubbed
+        assert(o.a) == :b
+      end
+
+      it 'calls given block' do
+        stub(o, :a) {:x}
+        does(o).respond_to?(:a)
+        is(o.a) == :x
+      end
+
+      it 'calls the block associated with given args' do
+        stub(o, :a).with(1, 2) {:ot}
+        is(o.a(1, 2)) == :ot
+
+        stub(o, :a).with(4, 5) {:ff}
+        is(o.a(4, 5)) == :ff
+
+        stub(o, :a).with(:x) {:x}
+        is(o.a(:x))   == :x
+      end
+
+      it 'calls the main block if no block associated with given args' do
+        stub(o, :a) {:main}
+        stub(o, :a).with(1) {1}
+        is(o.a) == :main
+        is(o.a(1)) == 1
+        is(o.a(2)) == :main
+      end
+
+      it 'returns nil if no main block nor block associated with given args' do
+        o = Class.new do
+          def a; :a; end
+        end.new
+        stub(o, :a).with(1) {1}
+        is(o.a(1)) == 1
+        is(o.a).nil?
+      end
+
+      it 'returns nil if no main block nor block associated with given args nor original defined' do
+        stub(o, :a)
+        is(o.a).nil?
+      end
+
+      it 'pass original as first argument' do
+        o = Class.new do
+          attr_reader :original_called
+          def a; @original_called = true; end
+        end.new
+        stub(o, :a) do |original|
+          is(o.original_called).nil?
+          original.call
+          is(o.original_called).true?
+        end
+        o.a
+      end
+
+      it 'pass args alongside original' do
+        o = Class.new do
+          attr_reader :original_called
+          def a; @original_called = true; end
+        end.new
+        stub(o, :a).with(1, 2) do |original, *args|
+          is(o.original_called).nil?
+          assert(args) == [1, 2]
+          original.call
+          is(o.original_called).true?
+        end
+        o.a(1, 2)
+      end
+
+      it 'pass given block alongside original and args' do
+        args = nil
+        o = Class.new do
+          def a(*a); yield(*a); end
+        end.new
+        stub(o, :a).with(1, 2) do |original, *a, &p|
+          original.call(*a, &p)
+        end
+        o.a(1, 2) {|*a| args = a}
+        assert(args) == [1, 2]
+      end
+
+      it 'creates public stubs' do
+        stub(o, :a)
+        does(o.public_methods).include?(:a)
+      end
+
+      it 'creates private stubs' do
+        private_stub(o, :a)
+        does(o.private_methods).include?(:a)
+        does { o.a }.raise? NoMethodError, /private method\W+a/
+      end
+
+      it 'creates private stubs with a Hash' do
+        private_stub(o, :a => :b)
+        assert(o.send(:a)) == :b
+      end
+
+      it 'creates private stubs with a block' do
+        private_stub(o, :a) {:b}
+        assert(o.send(:a)) == :b
+      end
+
+      it 'adds arguments constraints on private stubs' do
+        private_stub(o, :a).
+          with(1) {:one}.
+          with_any(:any)
+        assert(o.send(:a)) == :any
+        assert(o.send(:a, :blah)) == :any
+        assert(o.send(:a, 1)) == :one
+      end
+
+      it 'creates protected stubs' do
+        protected_stub(o, :a)
+        does(o.protected_methods).include?(:a)
+        does { o.a }.raise? NoMethodError, /protected method\W+a/
+      end
+
+      it 'creates protected stubs with a Hash' do
+        protected_stub(o, :a => :b)
+        assert(o.send(:a)) == :b
+      end
+
+      it 'creates protected stubs with a block' do
+        protected_stub(o, :a) {:b}
+        assert(o.send(:a)) == :b
+      end
+
+      it 'adds arguments constraints on protected stubs' do
+        protected_stub(o, :a).
+          with(1) {:one}.
+          with_any(:any)
+        assert(o.send(:a)) == :any
+        assert(o.send(:a, :blah)) == :any
+        assert(o.send(:a, 1)) == :one
+      end
+
+      it 'keeps the visibility of existing methods' do
+        o = Class.new do
+          def a; end
+          protected
+          def b; end
+          private
+          def c; end
+        end.new
+
+        stub(o, :a)
+        does(o.public_methods).include?(:a)
+
+        stub(o, :b)
+        does(o.protected_methods).include?(:b)
+
+        stub(o, :c)
+        does(o.private_methods).include?(:c)
+      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_stub(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_stub(o, :a) { :a }
+        assert(o.a) == :a
+      end
+
+      it 'stub :nil? method' do
+        o = nil
+        is(o.nil?) == true
+        stub(o, :nil?) { :blah }
+        is(o.nil?) == :blah
+      end
+
+      it 'defines chained stubs' do
+        @a = nil
+        stub(o, 'a.b.c') {|*a| @a = true; a}
+
+        does(o).respond_to?(:a)
+        o.a
+        is(@a).nil?
+
+        does(o.a).respond_to?(:b)
+        o.a.b
+        is(@a).nil?
+
+        does(o.a.b).respond_to?(:c)
+        expect(o.a.b.c(:x, :y)).to_contain :x, :y
+        is(@a).true?
+      end
+
+      it 'defines chained stubs with a Hash' do
+        stub(o, 'a.b.c' => 1, 'x.y.z' => 2)
+
+        does(o).respond_to?(:a)
+        does(o.a).respond_to?(:b)
+        does(o.a.b).respond_to?(:c)
+        assert(o.a.b.c) == 1
+
+        does(o).respond_to?(:x)
+        does(o.x).respond_to?(:y)
+        does(o.x.y).respond_to?(:z)
+        assert(o.x.y.z) == 2
+      end
+
+      test 'chained stubs works with arguments filters' do
+        stub(o, 'a.b').
+          with(1) {:one}.
+          with(2) {:two}.
+          with_any(:any)
+        assert(o.a.b) == :any
+        assert(o.a.b(:bl, :ah)) == :any
+        assert(o.a.b(1)) == :one
+        assert(o.a.b(2)) == :two
+      end
+
+      it 'passes the given block with last method in the chain' do
+        stub(o, 'b.c') {|&b| b.call(2)}
+        assert(o.b.c {|y| y ** 2}) == 4
+      end
+
+      it 'adds expectations on chained stubs' do
+        stub(o, 'a.b.c')
+        expect(o).to_receive(:a)
+        expect(o.a).to_receive(:b)
+        expect(o.a.b).to_receive(:c)
+        o.a.b.c
+      end
+
+      it 'restore stubbed singleton methods' do
+        o.define_singleton_method(:a) {:a}
+        stub(o, :a) {:b}
+        is(o.a) == :b
+        restore_originals
+        is(o.a) == :a
+      end
+
+      it 'restore stubbed public methods' do
+        o = Class.new do
+          def a; :a; end
+        end.new
+        stub(o, :a) {:b}
+        is(o.a) == :b
+        restore_originals
+        is(o.a) == :a
+      end
+
+      it 'restore stubbed protected methods' do
+        o = Class.new do
+          protected
+          def a; :a; end
+        end.new
+        stub(o, :a) {:b}
+        is(o.__send__(:a)) == :b
+        restore_originals
+        is(o.__send__(:a)) == :a
+      end
+
+      it 'restore stubbed private methods' do
+        o = Class.new do
+          private
+          def a; :a; end
+        end.new
+        stub(o, :a) {:b}
+        is(o.__send__(:a)) == :b
+        restore_originals
+        is(o.__send__(:a)) == :a
+      end
+
+      it 'restore stubbed chained methods' do
+        o.define_singleton_method(:a) {:a}
+        stub(o, 'a.b.c') {:b}
+        assert(o.a) != :a
+        restore_originals
+        is(o.a) == :a
+      end
+
+      it 'restore :nil? method' do
+        o = nil
+        is(o.nil?) == true
+        stub(o, :nil?) { :blah }
+        is(o.nil?) == :blah
+        restore_originals
+        is(o.nil?) == true
+      end
+
+      it 'undefines early unexisting public methods' do
+        assure(o).does_not.respond_to? :a
+        assert { o.a }.raise NoMethodError
+
+        stub(o, :a) {:a}
+        does(o).respond_to? :a
+        is(o.a) == :a
+
+        restore_originals
+
+        assure(o).does_not.respond_to? :a
+        assert { o.a }.raise NoMethodError
+      end
+
+      it 'undefines early unexisting protected methods' do
+        assert(o.protected_methods).does_not.include? :a
+
+        protected_stub(o, :a) {:a}
+        does(o.protected_methods).include? :a
+
+        restore_originals
+
+        assert(o.protected_methods).does_not.include? :a
+      end
+
+      it 'undefines early unexisting private methods' do
+        assert(o.private_methods).does_not.include? :a
+
+        private_stub(o, :a) {:a}
+        does(o.private_methods).include? :a
+
+        restore_originals
+
+        assert(o.private_methods).does_not.include? :a
+      end
+
+      it 'uses `returns` with a block to define a catchall return' do
+        stub(o, :a).
+          with_any { :A }.
+          with(1) { :one }
+        assert(o.a) == :A
+        assert(o.a(:blah)) == :A
+        assert(o.a(1)) == :one
+      end
+
+      it 'uses `returns` with a value to define a catchall return' do
+        stub(o, :a).
+          with_any(:A).
+          with(1) { :one }
+        assert(o.a) == :A
+        assert(o.a(:blah)) == :A
+        assert(o.a(1)) == :one
+      end
+
+      it 'defines multiple stubs at once' do
+        stubs(o, :a, :b)
+        does(o).respond_to?(:a)
+        does(o).respond_to?(:b)
+      end
+
+      it 'uses the given block for all stubs' do
+        stubs(o, :a, :b) {:x}
+        assert(o.a) == :x
+        assert(o.b) == :x
+      end
+
+      it 'uses same constraints for all stubs' do
+        stubs(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
+      end
+
+      it 'defines multiple private stubs' do
+        private_stubs(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/
+      end
+
+      it 'defines multiple protected stubs' do
+        protected_stubs(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/
+      end
+    end
+
+    define_tests(Unit)
+  end
+end