mocoso 0.0.2 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c12b98f62eb01e570daf1a9101b16a168837ec7d
-  data.tar.gz: cafcefb94d91446ff97bfb0e8ab72883be345101
+  metadata.gz: e5c21876105f80fb7e2c5f0f72b09406e83be714
+  data.tar.gz: af2c896fb182aa84454381aaa4060b3a04245078
 SHA512:
-  metadata.gz: af1706795d43d65d19045663aee87eaf42448ef47c6a1147193282bf522000be8dfccb1800bd852c0bb5e09451dbab42d968ca943ba749c70354ca88a19a96f2
-  data.tar.gz: 1a2aeaea3ae9b6f2b86a7c922c353c9c4173ffb00638c506921f7715ceba1315b5fac551241097175a15a9738a99a8b851dc04748e5f30cdf0854b451c32a686
+  metadata.gz: a5e18f8f38ba523988872a90be55bd2a3d0685258741fb13e238657c612c48c7fedbb1a2e9fa032f100b1ecb1d0385c817d62cfa7ad4b5b3b83c0ebf8960a402
+  data.tar.gz: 5f717db7f95cf129560e2e2c2f40b710d88860593e240d9d9afba63ee1fe99b5ac90ee8138f2edf3907933b2b7a5352c1332be6875527537c48227b9c908132f

data/README.md

@@ -12,7 +12,7 @@ Motivation
 Yes, there are a lot of good libraries out there, but I wanted one that
 meets the following criteria:
 
-* Provides features to restore stubbed methods to their original implementations.
+* Always restore stubbed methods to their original implementations.
 * Doesn't allow to stub or mock undefined methods.
 * Doesn't monkey-patch any class or object.
 * Test-framework agnostic (Doesn't need integration code).
@@ -36,14 +36,18 @@ A quick example (uses [Cutest][cutest]):
 
     test 'mocking a class method' do
       user = User.new
-      expect User, :find, with: [1], return: user
-      assert_equal user, User.find(1)
+
+      expect User, :find, with: [1], return: user do
+        assert_equal user, User.find(1)
+      end
     end
 
     test 'stubbing an instance method' do
       user = User.new
-      stub user, valid?: true
-      assert user.valid?
+
+      stub user, valid?: true do
+        assert user.valid?
+      end
     end
 
 Check [Official Documentation][docs] for more details.

data/lib/mocoso.rb

@@ -1,6 +1,6 @@
 # Yet Another Simple Stub & Mock library, that also:
 #
-#   - Provides features to restore stubbed methods to their original implementations.
+#   - Always restore stubbed methods to their original implementations.
 #   - Doesn't allow to stub or mock undefined methods.
 #   - Doesn't monkey-patch any class or object.
 #   - Test-framework agnostic (Doesn't need integration code).
@@ -22,14 +22,18 @@
 #
 #     test 'mocking a class method' do
 #       user = User.new
-#       expect User, :find, with: [1], return: user
-#       assert_equal user, User.find(1)
+#
+#       expect User, :find, with: [1], return: user do
+#         assert_equal user, User.find(1)
+#       end
 #     end
 #
 #     test 'stubbing an instance method' do
 #       user = User.new
-#       stub user, valid?: true
-#       assert user.valid?
+#
+#       stub user, valid?: true do
+#         assert user.valid?
+#       end
 #     end
 #
 # Note: this example uses the test framework Cutest[1]:
@@ -44,33 +48,35 @@
 module Mocoso
   # Raised by #expect when a expectation is not fulfilled.
   #
-  #   Mocoso.expect object, :method, with: 'argument', returns: nil
-  #
-  #   object.method 'unexpected argument'
-  #   # => Mocoso::ExpectationError: Expected ["argument"], got ["unexpected argument"]
+  #   Mocoso.expect object, :method, with: 'argument', returns: nil do
+  #     object.method 'unexpected argument'
+  #     # => Mocoso::ExpectationError: Expected ["argument"], got ["unexpected argument"]
+  #   end
   #
   ExpectationError = Class.new StandardError
 
-  # Rewrites each method from `methods` and defined in +object+. `methods` is a
+  # Rewrites each method from +methods+ and defined in +object+. +methods+ is a
   # Hash that represents stubbed method name symbols as keys and corresponding
-  # return values as values.
+  # return values as values. The methods are restored after the given +block+
+  # is executed.
   #
   #   signup = SignupForm.new params[:user]
   #
   #   signup.valid? # => false
-  #   signup.save   # => false
-  #
-  #   Mocoso.stub signup, valid?: true, signup: true
   #
-  #   signup.valid? # => true
-  #   signup.save   # => true
+  #   Mocoso.stub signup, :valid?, true do
+  #     signup.valid? # => true
+  #   end
   #
   # You can pass a callable object (responds to +call+) as a value:
   #
-  #   Mocoso.stub subject, foo: -> { "foo" }, bar: ->(value) { value }
+  #   Mocoso.stub subject, foo: -> { "foo" } do
+  #     subject.foo # => "foo"
+  #   end
   #
-  #   subject.foo        # => "foo"
-  #   subject.bar('foo') # => "foo"
+  #   Mocoso.stub subject, :bar, ->(value) { value } do
+  #     subject.bar('foo') # => "foo"
+  #   end
   #
   # If you try to stub a method that is not defined by the +object+,
   # it raises an error.
@@ -78,79 +84,32 @@ module Mocoso
   #   Mocoso.stub Object.new, undefined: nil
   #   # => NameError: undefined method `undefined' for class `Object'
   #
-  # Note that it will rewrite the method(s) in +object+. If you want to stub a
-  # method without side effects, you should pass a block.
-  #
-  #   User.all.length
-  #   # => 5
-  #
-  #   Mocoso.stub User, all: [] do
-  #     User.all.length
-  #     # => 0
-  #   end
-  #
-  #   User.all.length
-  #   # => 5
-  #
-  def stub object, methods
+  def stub object, method, result, &block
     metaclass = object.singleton_class
+    stubbed_method = "__mocoso_#{method}"
 
-    methods.each do |method, result|
-      metaclass.send :alias_method, stub_method_name(method), method
+    metaclass.send :alias_method, stubbed_method, method
 
-      if result.respond_to?(:call)
-        metaclass.send(:define_method, method) { |*args| result.call(*args) }
-      else
-        metaclass.send(:define_method, method) { result }
-      end
-    end
-
-    if block_given?
-      begin
-        yield
-      ensure
-        unstub object, methods.keys
-      end
+    if result.respond_to?(:call)
+      metaclass.send(:define_method, method) { |*args| result.(*args) }
+    else
+      metaclass.send(:define_method, method) { result }
     end
-  end
-
-  # Removes the specified stubbed +methods+ (added by calls to #stub or #expect) and
-  # restores the original behaviour of the methods before they were stubbed.
-  #
-  #   object.foo # => "foo"
-  #
-  #   Mocoso.stub object, foo: 'new foo'
-  #   object.foo # => "new foo"
-  #
-  #   Mocoso.unstub object, [:foo]
-  #   object.foo #=> "foo"
-  #
-  # I personally use a block on #stub or #expect to avoid side effects, because if
-  # you #unstub a method which still has unsatisfied expectations, you may be
-  # removing the only way those expectations can be satisfied. Use it on your
-  # own responsibility.
-  #
-  # This method was born as a helper for #stub.
-  #
-  def unstub object, methods
-    metaclass = object.singleton_class
 
-    methods.each do |method|
+    begin
+      yield
+    ensure
       metaclass.send :undef_method, method
-      metaclass.send :alias_method, method, stub_method_name(method)
-      metaclass.send :undef_method, stub_method_name(method)
+      metaclass.send :alias_method, method, stubbed_method
+      metaclass.send :undef_method, stubbed_method
     end
   end
 
-  def stub_method_name name
-    "__mocoso_#{name}"
-  end
-  private :stub_method_name
-
   # Expect that method +method+ is called with the arguments specified in the
   # +:with+ option (defaults to +[]+ if it's not given) and returns the value
-  # specified in the +:return+ option. If expectations are not met, it raises
-  # Mocoso::ExpectationError error.
+  # specified in the +:returns+ option. If expectations are not met, it raises
+  # Mocoso::ExpectationError error. It uses #stub internally, so it will restore
+  # the methods to their original implementation after the +block+ is executed.
   #
   #   class User < Model
   #   end
@@ -158,40 +117,19 @@ module Mocoso
   #   user = User[1]
   #
   #   Mocoso.expect user, :update, with: [{ name: 'new name' }], returns: true
+  #     subject.update unexpected: nil
+  #     # => Mocoso::ExpectationError: Expected [{:name=>"new name"}], got [{:unexpected=>nil}]
   #
-  #   subject.update unexpected: nil
-  #   # => Mocoso::ExpectationError: Expected [{:name=>"new name"}], got [{:unexpected=>nil}]
-  #
-  #   user.update name: 'new name'
-  #   # => true
-  #
-  # Note that it will rewrite the method in +object+. If you want to set an
-  # expectation without side effects, you should pass a block.
-  #
-  #   User.exists? 1
-  #   # => false
-  #
-  #   Mocoso.expect User, :exists?, with: [1], returns: true do
-  #     User.exists? 1
+  #     user.update name: 'new name'
   #     # => true
   #   end
   #
-  #   User.exists? 1
-  #   # => false
-  #
-  def expect object, method, options
+  def expect object, method, with: [], returns:, &block
     expectation = -> *params {
-      with = options.fetch(:with) { [] }
-
       raise ExpectationError, "Expected #{with}, got #{params}" if params != with
-
-      options[:return]
+      returns
     }
 
-    if block_given?
-      stub object, method => expectation, &proc
-    else
-      stub object, method => expectation
-    end
+    stub object, method, expectation, &block
   end
 end

data/mocoso.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |s|
   s.name        = 'mocoso'
-  s.version     = '0.0.2'
+  s.version     = '0.1.0'
   s.summary     = 'A simple stub & mock library'
   s.description = s.summary
   s.authors     = ['Francesco Rodríguez']

data/test/scary_mocks_and_nice_stubs.rb

@@ -17,104 +17,66 @@ setup do
   Subject.new
 end
 
-test 'raises error if object not respond to the given method' do |subject|
-  assert_raise { stub(subject, nan: nil, undefined: nil) }
+test 'raises error if block is not given' do |subject|
+  assert_raise { stub(subject, foo: 'foo') }
 end
 
-test 'stubs methods and return new values' do |subject|
-  before_foo = subject.foo
-  before_bar = subject.bar
-
-  stub subject, foo: 'new foo', bar: 'new bar'
-
-  assert subject.foo != before_foo
-  assert subject.bar != before_bar
+test 'raises error if object not respond to the given method' do |subject|
+  assert_raise(NameError) { stub(subject, :nan, nil) }
 end
 
-test 'stubs method with a callable object' do |subject|
+test 'stubbed method return new value' do |subject|
   before = subject.foo
 
-  stub subject, foo: -> { 'new foo' }
+  stub subject, :foo, 'new foo' do
+    assert_equal 'new foo', subject.foo
+  end
 
-  assert subject.foo != before
-  assert_equal 'new foo', subject.foo
+  assert_equal before, subject.foo
 end
 
-test 'stubs method with a callable object with arguments' do |subject|
+test 'stubs method with a callable object' do |subject|
   before = subject.foo
 
-  stub subject, foo: ->(a) { "new #{a}" }
+  stub subject, :foo, -> { 'new foo' } do
+    assert_equal 'new foo', subject.foo
+  end
 
-  assert subject.foo('foo') != before
-  assert_equal 'new foo', subject.foo('foo')
+  assert_equal before, subject.foo
 end
 
-test 'stubs method without side effects if a block is given' do
-  before = Subject.foo
+test 'stubs method with a callable object that requires arguments' do |subject|
+  before = subject.foo
 
-  stub Subject, foo: 'new foo' do
-    assert before != Subject.foo
+  stub subject, :foo, ->(a) { "new #{a}" } do
+    assert_equal 'new foo', subject.foo('foo')
   end
 
-  assert_equal before, Subject.foo
+  assert_equal before, subject.foo
 end
 
 test 'succeeds if expectations are met' do |subject|
-  expect subject, :baz, with: ['value'], return: 'result'
+  expect subject, :baz, with: ['value'], returns: 'result' do
+    assert_equal 'result', subject.baz('value')
+  end
 
-  assert_equal 'result', subject.baz('value')
+  assert_equal 'baz', subject.baz('baz')
 end
 
 test 'raises an error if expectation are not met' do |subject|
-  expect subject, :baz, with: ['value'], return: 'result'
-
-  assert_raise(Mocoso::ExpectationError) { subject.baz('another') }
-end
-
-test 'expectation without side effects if a block is given' do |subject|
-  expect subject, :baz, with: ['value'], return: 'mocked' do
-    assert_equal 'mocked', subject.baz('value')
+  expect subject, :baz, with: ['value'], returns: 'result' do
+    assert_raise(Mocoso::ExpectationError) { subject.baz('another') }
   end
-
-  assert_equal 'original', subject.baz('original')
 end
 
-test 'expectation without arguments' do |subject|
-  expect subject, :foo, return: 'new foo'
-
-  assert_equal 'new foo', subject.foo
+test 'expectation without with option defaults to empty array' do |subject|
+  expect subject, :foo, returns: 'new foo' do
+    assert_equal 'new foo', subject.foo
+  end
 end
 
 test 'expectation with multiple arguments' do |subject|
-  expect subject, :foo, with: ['new foo', { optional: true }], return: 'new foo'
-
-  assert_equal 'new foo', subject.foo('new foo', optional: true)
-end
-
-test 'unstub removes specified stubbed methods' do |subject|
-  before_foo = subject.foo
-  before_bar = subject.bar
-
-  stub subject, foo: 'new foo', bar: 'new bar', baz: 'new baz'
-
-  assert before_foo != subject.foo
-  assert before_bar != subject.bar
-
-  unstub subject, [:foo, :bar]
-
-  assert_equal before_foo, subject.foo
-  assert_equal before_bar, subject.bar
-  assert_equal 'new baz', subject.baz
-end
-
-test 'unstub removes specified expectations' do
-  before = Subject.foo
-
-  expect Subject, :foo, return: 'new foo'
-
-  assert_equal 'new foo', Subject.foo
-
-  unstub Subject, [:foo]
-
-  assert_equal before, Subject.foo
+  expect subject, :foo, with: ['new foo', { optional: true }], returns: 'new foo' do
+    assert_equal 'new foo', subject.foo('new foo', optional: true)
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mocoso
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.1.0
 platform: ruby
 authors:
 - Francesco Rodríguez
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-10-03 00:00:00.000000000 Z
+date: 2013-10-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cutest