soveran-override 0.0.6 → 0.0.7

data/README.markdown

@@ -49,7 +49,7 @@ It is a common pattern to set expectations for method calls. You can do
 it with the `expect` function:
 
     user = User.spawn :name => "Foobar"
-    expect(User, :find, :return => user, :params => [:first, { :include => :friendships }])
+    expect(User, :find, :with => [:first, { :include => :friendships }], :return => user)
 
 And then:
 
@@ -68,7 +68,8 @@ of calls received by the redefined method. The RSpec equivalent of
 triggers an exception if the method is not called. While it is a handy
 feature, it encourages coupling and testing internals, so my advice
 would be to use it scarcely and to try to refactor your code so it
-doesn't follow this testing anti-pattern.
+doesn't follow this testing anti-pattern. Check the tests for more
+examples.
 
 Installation
 ------------

data/lib/override.rb

@@ -1,60 +1,3 @@
-# Override
-#
-# This is the pure esence of the stubbing concept: it takes an object,
-# a hash of methods/results, and proceeds to rewrite each method in the
-# object. It can be used as a stubbing strategy in most cases, and I'd
-# say that cases that don't fit this pattern have a very bad code smell,
-# because are either dealing with internals or with side effects.
-#
-# Usage
-#
-#     require 'override'
-#
-#     @user = User.spawn
-#     override(@user, :name => "Foobar", :email => "foobar@example.org")
-#     override(User, :find => @user)
-#
-# Or alternatively:
-#
-#     override(User, :find => override(User.spawn, :name => "Foobar, :email => "foobar@example.org"))
-#
-# In case you don't know what spawn means, check my other library for
-# testing at http://github.com/soveran/spawner.
-#
-# Note: the arity strictness in Ruby 1.9 demands for that trick that
-# drops the arguments passed to the redefined method. It's not necessary
-# in Ruby 1.8.
-#
-# You can also send lambdas that will become the body of the redefined method:
-#
-#     user = User.spawn :name => "Foobar"
-#     override(User, :find => lambda { |id| raise ArgumentError unless id == 1; user })
-#
-# And then, in your tests:
-#
-#     assert_raise ArgumentError do
-#       User.find(2)
-#     end
-#
-#     assert_nothing_raised do
-#       User.find(1)
-#     end
-#
-#     assert_equal "Foobar", User.find(1).name
-#
-# It is a common pattern to set expectations for method calls. You can
-# do it with the expect function:
-#
-#     user = User.spawn :name => "Foobar"
-#     expect(User, :find, :return => user, :params => [:first, { :include => :friendships }])
-#
-# And then:
-#
-#     assert_equal "Foobar", User.find(:first, :include => :friendships).name
-#     assert_raise ArgumentError do
-#       User.find(:all)
-#     end
-#
 require "rubygems"
 require "metaid"
 
@@ -64,15 +7,13 @@ def override object, methods
       object.meta_def(method, &result.to_proc) :
       object.meta_def(method) { |*_| result }
   end
-
   object
 end
 
 def expect object, method, options
   expectation = lambda do |*params|
-    raise ArgumentError unless params == options[:params]
+    raise ArgumentError unless params == options[:with]
     options[:return]
   end
-
   override(object, method => expectation)
 end

data/test/all_test.rb

@@ -17,11 +17,22 @@ class Foo
     "Qux"
   end
 
+  def nom
+    Bar.foo(1, 2, 3)
+    true
+  end
+
   def == other
     bar == other.bar
   end
 end
 
+class Bar
+  def self.foo(a, b, c)
+    "Bar/Foo"
+  end
+end
+
 class Callable
   def to_proc
     lambda do |name|
@@ -37,11 +48,11 @@ class TestOverride < Test::Unit::TestCase
       override(@foo, :bar => "Hello")
     end
 
-    test "work without arguments" do
+    should "work without arguments" do
       assert_equal "Hello", @foo.bar
     end
 
-    test "discard arguments" do
+    should "discard arguments" do
       assert_equal "Hello", @foo.bar(1)
     end
   end
@@ -52,17 +63,17 @@ class TestOverride < Test::Unit::TestCase
       @foo2 = Foo.new
     end
 
-    test "work for string returns" do
+    should "work for string returns" do
       override(@foo, :bar => "Hello")
       assert_equal "Hello", @foo.bar
     end
 
-    test "work for numeric returns" do
+    should "work for numeric returns" do
       override(@foo, :bar => 23)
       assert_equal 23, @foo.bar
     end
 
-    test "work for object returns" do
+    should "work for object returns" do
       override(@foo, :bar => @foo2)
       assert_equal @foo2, @foo.bar
     end
@@ -73,19 +84,19 @@ class TestOverride < Test::Unit::TestCase
       @foo = Foo.new
     end
 
-    test "work for methods that used to receive blocks" do
+    should "work for methods that used to receive blocks" do
       override(@foo, :baz => "Hey!")
       assert_equal "Hey!", @foo.baz { |x| x }
     end
 
-    test "work for methods that used to receive arguments" do
+    should "work for methods that used to receive arguments" do
       override(@foo, :qux => "Yay!")
       assert_equal "Yay!", @foo.qux(1, 2, 3)
     end
   end
 
   context "rewriting multiple methods at once" do
-    test "override all the passed methods" do
+    should "override all the passed methods" do
       override(@foo, :bar => 1, :baz => 2, :qux => 3)
       assert_equal 1, @foo.bar
       assert_equal 2, @foo.baz
@@ -94,13 +105,13 @@ class TestOverride < Test::Unit::TestCase
   end
 
   context "chaining successive calls" do
-    test "return the object and allow chained calls" do
+    should "return the object and allow chained calls" do
       assert_equal 1, override(@foo, :bar => 1).bar
     end
   end
 
   context "dealing with a proc as the result value" do
-    test "uses the proc as the body of the method" do
+    should "uses the proc as the body of the method" do
       override(@foo, :bar => lambda { |name| "Hello #{name}" })
       assert_equal "Hello World", @foo.bar("World")
     end
@@ -118,7 +129,7 @@ class TestOverride < Test::Unit::TestCase
       override(@foo, :bar => lambda { |id| raise ArgumentError unless id == 1; user })
     end
 
-    test "lambdas should be able to raise exceptions" do
+    should "lambdas should be able to raise exceptions" do
       assert_raise ArgumentError do
         @foo.bar(2)
       end
@@ -139,11 +150,11 @@ class TestOverride < Test::Unit::TestCase
       override(@foo, :baz => lambda { @name })
     end
 
-    test "succeeds when the lambda returns a local variable" do
+    should "succeeds when the lambda returns a local variable" do
       assert_equal "Michel", @foo.bar
     end
 
-    test "fails when the lambda is supposed to return an instance variable" do
+    should "fails when the lambda is supposed to return an instance variable" do
       assert_equal nil, @foo.baz
     end
   end
@@ -153,7 +164,7 @@ class TestOverride < Test::Unit::TestCase
       override(@foo, :bar => Callable.new)
     end
 
-    test "coerces the value into a proc" do
+    should "coerces the value into a proc" do
       assert_equal "Hello World", @foo.bar("World")
     end
   end
@@ -163,23 +174,23 @@ class TestOverride < Test::Unit::TestCase
       override(@foo, :bar => lambda { lambda { "Hey!" } })
     end
 
-    test "returns a lambda if it's wraped inside a proc" do
+    should "returns a lambda if it's wraped inside a proc" do
       assert_equal "Hey!", @foo.bar.call
     end
   end
 
   context "setting expectations" do
     setup do
-      expect(@foo, :bar, :return => true, :params => ["Michel", 32])
+      expect(@foo, :bar, :with => ["Michel", 32], :return => true)
     end
 
-    test "raises an error if expectations are not met" do
+    should "raises an error if expectations are not met" do
       assert_raise ArgumentError do
         @foo.bar "Michel", 31
       end
     end
 
-    test "succeeds if expectations are met" do
+    should "succeeds if expectations are met" do
       assert_nothing_raised do
         @foo.bar "Michel", 32
       end
@@ -188,13 +199,41 @@ class TestOverride < Test::Unit::TestCase
 
   context "setting expectations with hashes in the param list" do
     setup do
-      expect(@foo, :bar, :return => true, :params => ["Michel", { :include => :friendships, :select => "name" }])
+      expect(@foo, :bar, :with => ["Michel", { :include => :friendships, :select => "name" }], :return => true)
     end
 
-    test "succeeds if expectations are met" do
+    should "succeeds if expectations are met" do
       assert_nothing_raised do
         @foo.bar "Michel", { :select => "name", :include => :friendships, :select => "name" }
       end
     end
   end
+
+  context "side effects" do
+    setup do
+      @foo = Foo.new
+      expect(Bar, :foo, :with => [1, 2, 3], :return => "Bar/Bar")
+    end
+
+    should "don't affect the interface" do
+      assert_equal true, @foo.nom
+    end
+
+    should "detect the method call as a side effect" do
+      override(Bar, :foo => lambda { |*_| raise ArgumentError })
+      assert_raise ArgumentError do
+        @foo.nom
+      end
+    end
+
+    should "don't affect the interfaces!" do
+      @foo = Foo.new
+      expect(Bar, :foo, :with => [1, 2, 3], :return => "Bar/Bar")
+      assert_equal true, @foo.nom
+      override(Bar, :foo => lambda { |*_| raise ArgumentError })
+      assert_raise ArgumentError do
+        @foo.nom
+      end
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: soveran-override
 version: !ruby/object:Gem::Version 
-  version: 0.0.6
+  version: 0.0.7
 platform: ruby
 authors: 
 - Michel Martens