quickie 0.2.0 → 0.3.0

data/CHANGELOG

@@ -1,3 +1,6 @@
+0.3.0
+  - Implemented method stubs.
+
 0.2.0
   - Improved actual vs. expected reporting.
   - Improved user experience when running within IRB or Pry.

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    quickie (0.2.0)
+    quickie (0.3.0)
 
 GEM
   remote: http://rubygems.org/

data/README.md

@@ -1,8 +1,10 @@
 ## Quickie ##
-Quickie is micro library for quick in-place testing of your Ruby code. It adds two useful
-methods: <code>Object#should</code> and <code>Object#should\_not</code> for positive and
-negative assertions. With Quickie you can conveniently bundle tests together with your
-Ruby code, typically within <code>if $0 == \_\_FILE\_\_</code> conditional statement.
+Quickie is micro library for quick in-place testing of your Ruby code. It adds three
+useful methods: <code>Object#should</code> and <code>Object#should\_not</code> for
+positive and negative assertions, and <code>Object#stub</code> for method stubbing.
+
+With Quickie you can conveniently bundle tests along with your Ruby code, typically
+within <code>if $0 == \_\_FILE\_\_</code> conditional statement.
 
 ### System Requirements ###
 Ruby 1.9.2 or later.
@@ -14,24 +16,18 @@ Ruby 1.9.2 or later.
     # Cloning the repository
     $ git clone git://github.com/michaeldv/quickie.git
 
-### Usage Example ###
+### Usage Example - Assertions ###
 
-    $ cat > sample.rb
+    $ cat > 1.rb
     class Account                             # Back account class.
       attr_reader :balance                    # Current account balance.
       
-      def initialize(amount)                  # Open the account.
-        @balance = amount                     # Accept initial deposit.
-      end
-      
-      def deposit(amount)                     # Accept account deposit.
-        @balance += amount                    # Update current balance.
+      def initialize(amount = 0)              # Open the account.
+        @balance = amount.abs                 # Accept initial deposit.
       end
       
-      def withdraw(amount)                    # Withdraw from the account.
-        cash = [ @balance, amount ].min       # Can't withdraw more than the balance.
-        @balance -= cash                      # Update current balance.
-        cash
+      def deposit(amount)                     # Accept a deposit.
+        @balance += amount.abs                # Update current balance.
       end
       
       def status                              # Display account status.
@@ -46,30 +42,72 @@ Ruby 1.9.2 or later.
       acc.balance.should == 100               # Initial balance should be $100.
       acc.deposit(200)                        # Deposit $200 more.
       acc.balance.should != 100               # The balance should get updated.
-      acc.balance.should == 300               # It should be $100 + $200 = $300.
+      acc.balance.should == 300               # $100 + $200 = $300.
       
       String.should === acc.status            # Account#status returns a string.
       acc.status.should_not =~ /\$$/          # Status string should contain the balance.
-      acc.status.should =~ /\$\d+$/           # The balance is one or more digits.
-      
-      acc.withdraw(500).should == 300         # Withdrawal that exeeds the balance is not allowed.
-      acc.balance.should == 0                 # Current balance should drop to zero.
-      acc.status.should !~ /\$[1-9]+$/        # Status no longer shows positive number.
-      acc.status.should =~ /\$0$/             # It shows $0.
+      acc.status.should =~ /\$\d+\.*\d*$/     # Balance contains digits with optional separator.
     end
     ^D
-    $ ruby sample.rb 
-    ..........
+    $ ruby 1.rb
+    ......
+    
+    Passed: 6, not quite: 0, total tests: 6.
+
+### Usage Example - Method Stubs ###
+To set up a stub with optional return value use <code>obj.stub(:method, :return => value)</code>.
+To remove existing stub and restore original method use <code>obj.stub(:method, :remove)</code>.
+
+    $ cat > 2.rb
+    require "net/http"
+    require "json"
+    require "uri"
+    
+    class GemStats                            # Get gems stats from rubygems.org.
+      attr_reader :downloads
+      
+      def initialize(gem, version)
+        uri = URI.parse("http://rubygems.org/api/v1/downloads/#{gem}-#{version}.json")
+        response = Net::HTTP.get_response(uri)
+        @downloads = JSON.parse(response.body)
+      end
+      
+      def total
+        @downloads["total_downloads"]
+      end
+      
+      def version
+        @downloads["version_downloads"]
+      end
+    end
     
-    Passed: 10, not quite: 0, total tests: 10.
+    if $0 == __FILE__
+      require "quickie"
+
+      response = { :total_downloads => 999_999, :version_downloads => 999 }.to_json
+      response.stub(:body, :return => response)
+      Net::HTTP.stub(:get_response, :return => response)
+      
+      stats = GemStats.new(:awesome_print, '1.0.2')
+      
+      Hash.should === stats.downloads         # Downloads should ba a hash.
+      stats.downloads.keys.size.should == 2   # It should have two keys.
+      stats.total.should == 999_999           # Total downloads should match test data.
+      stats.version.should == 999             # Ditto for version.
+    end
+    ^D
+    $ ruby 2.rb 
+    ....
+        
+    Passed: 4, not quite: 0, total tests: 4.
 
 ### Testing Quickie ###
 Quickie code is tested by the Quickie itself.
 
     $ ruby test/quickie_test.rb
-    ....................
+    ................................
     
-    Passed: 20, not quite: 0, total tests: 20.
+    Passed: 32, not quite: 0, total tests: 32.
 
 ### Note on Patches/Pull Requests ###
 * Fork the project on Github.

data/lib/quickie.rb

@@ -11,5 +11,6 @@ abort "Quickie requires Ruby 1.9.2 or later" if RUBY_VERSION < "1.9.2"
 
 require File.dirname(__FILE__) + "/quickie/runner"
 require File.dirname(__FILE__) + "/quickie/matcher"
+require File.dirname(__FILE__) + "/quickie/stub"
 require File.dirname(__FILE__) + "/quickie/version"
 require File.dirname(__FILE__) + "/quickie/core_ext/object"

data/lib/quickie/core_ext/object.rb

@@ -10,4 +10,9 @@ class Object
     end
     alias_method :"#{verb}_be", verb
   end
+
+  define_method :stub do |method, options = {}|
+    Quickie::Stub.new(self, method, options)
+  end
+  alias_method :stub!, :stub
 end

data/lib/quickie/stub.rb

@@ -0,0 +1,109 @@
+# Copyright (c) 2011-12 Michael Dvorkin
+#
+# Quickie is freely distributable under the terms of MIT license.
+# See LICENSE file or http://www.opensource.org/licenses/mit-license.php
+#------------------------------------------------------------------------------
+module Quickie
+  class Stub
+    #
+    # To set up a stub with optional return value:
+    #   obj.stub(:method, :return => something)
+    #
+    # To remove existing stub and restore original method:
+    #   obj.stub(:method, :remove)
+    #
+    #--------------------------------------------------------------------------
+    def initialize(object, method, options = {})
+      options = { options => true } if options.is_a?(Symbol)
+      @object, @options = object, options
+      @@stash ||= []
+      #
+      # Create a new stub by intercepting the method or remove existing stub
+      # by restoring the original method.
+      #
+      unless @options[:remove]
+        intercept(method)
+      else
+        restore(method)
+      end
+    end
+
+    private
+
+    # Same as class << @object; self; end -- comes with Ruby 1.9.
+    #--------------------------------------------------------------------------
+    def metaclass
+      @object.singleton_class
+    end
+
+    # Unique name the original method gets stashed under when creating a stub.
+    #--------------------------------------------------------------------------
+    def moniker(method)
+      :"__#{method}__#{@object.__id__}"
+    end
+
+    # Return method's visibility, nil if public.
+    #--------------------------------------------------------------------------
+    def visibility(method)
+      if metaclass.private_method_defined?(method)
+        :private
+      elsif metaclass.protected_method_defined?(method)
+        :protected
+      end
+    end
+
+    # Set up a stub by stashing the original method under different name and
+    # then rediefining the method to return the requested value.
+    #--------------------------------------------------------------------------
+    def intercept(method)
+      new_name = moniker(method)
+      unless @object.respond_to? new_name
+        stash(method, new_name)
+        redefine(method)
+      end
+    end
+
+    # Preserve original method by creating its alias with the unique name.
+    #--------------------------------------------------------------------------
+    def stash(method, new_name)
+      metaclass.class_eval do
+        if method_defined?(method) || private_method_defined?(method)
+          alias_method new_name, method
+        end
+      end
+      @@stash << new_name
+    end
+
+    # Create a stub that returns requested value.
+    #--------------------------------------------------------------------------
+    def redefine(method)
+      return_value = @options[:return]
+      metaclass.class_eval do
+        define_method method do |*args, &block|
+          return_value
+        end
+      end
+      #
+      # Set visibility attribute if the origial method is not public.
+      #
+      private_or_protected = visibility(method)
+      metaclass.class_eval("#{private_or_protected} :#{method}") if private_or_protected
+    end
+
+    # Remove the stub and restore the original method.
+    #--------------------------------------------------------------------------
+    def restore(method)
+      stashed_name = moniker(method)
+      if @@stash.include? stashed_name          # Was it ever stubbed?
+        metaclass.instance_eval do
+          if method_defined?(stashed_name) || private_method_defined?(stashed_name)
+            remove_method method                # Remove the stub.
+            alias_method method, stashed_name   # Restore the original method from stash.
+            remove_method stashed_name          # Remove stashed copy.
+          end
+        end
+        @@stash.delete stashed_name
+      end
+    end
+  end
+end

data/lib/quickie/version.rb

@@ -5,6 +5,6 @@
 #------------------------------------------------------------------------------
 module Quickie
   def self.version
-    '0.2.0'
+    '0.3.0'
   end
 end

data/test/matcher_test.rb

@@ -0,0 +1,65 @@
+# Copyright (c) 2011-12 Michael Dvorkin
+#
+# Quickie is freely distributable under the terms of MIT license.
+# See LICENSE file or http://www.opensource.org/licenses/mit-license.php
+#------------------------------------------------------------------------------
+require "stringio"
+require File.expand_path(File.dirname(__FILE__) + "/../lib/quickie")
+
+# Use Quickie to test itself. The methodology is as follows:
+#
+#   1. Write regular Quickie test.
+#   2. Capture the output of the test.
+#   3. Make sure captured output matches the expectation.
+#
+# In addition, we hack the Quickie trace/stats so that failed captured
+# tests are not shown/counted in the actual results.
+#--------------------------------------------------------------------------
+def capture
+  stats = Quickie::Runner.class_variable_get(:@@stats)
+  trace = Quickie::Runner.class_variable_get(:@@trace)
+
+  standard, $stdout = $stdout, StringIO.new
+  yield
+  $stdout.string
+ensure
+  if $stdout.string == '.'
+    stats[:success] -= 1
+  else
+    stats[:failure] -= 1
+    trace.pop
+  end
+  $stdout = standard
+end
+
+# Should - passing specs.
+#--------------------------------------------------------------------------
+capture { "abc".should == "abc" }.should == "."
+capture { "abc".should != "xyz" }.should == "."
+capture { "abc".should =~ /AB/i }.should == "."
+capture { "abc".should !~ /XY/i }.should == "."
+capture { 1234567.should_be > 0 }.should == "."
+
+# Should Not - passing specs.
+#--------------------------------------------------------------------------
+capture { "abc".should_not != "abc" }.should == "."
+capture { "abc".should_not == "xyz" }.should == "."
+capture { "abc".should_not !~ /AB/i }.should == "."
+capture { "abc".should_not =~ /XY/i }.should == "."
+capture { 1234567.should_not_be < 0 }.should == "."
+
+# Should - failing specs.
+#--------------------------------------------------------------------------
+capture { "abc".should != "abc" }.should == "F"
+capture { "abc".should == "xyz" }.should == "F"
+capture { "abc".should !~ /AB/i }.should == "F"
+capture { "abc".should =~ /XY/i }.should == "F"
+capture { 1234567.should_be < 0 }.should == "F"
+
+# Should Not - failing specs.
+#--------------------------------------------------------------------------
+capture { "abc".should_not == "abc" }.should == "F"
+capture { "abc".should_not != "xyz" }.should == "F"
+capture { "abc".should_not =~ /AB/i }.should == "F"
+capture { "abc".should_not !~ /XY/i }.should == "F"
+capture { 1234567.should_not_be > 0 }.should == "F"

data/test/quickie_test.rb

@@ -3,63 +3,5 @@
 # Quickie is freely distributable under the terms of MIT license.
 # See LICENSE file or http://www.opensource.org/licenses/mit-license.php
 #------------------------------------------------------------------------------
-require "stringio"
-require File.expand_path(File.dirname(__FILE__) + "/../lib/quickie")
-
-# Use Quickie to test itself. The methodology is as follows:
-#
-#   1. Write regular Quickie test.
-#   2. Capture the output of the test.
-#   3. Make sure captured output matches the expectation.
-#
-# In addition, we hack the Quickie trace/stats so that failed captured
-# tests are not shown/counted in the actual results.
-#--------------------------------------------------------------------------
-def capture
-  stats = Quickie::Runner.class_variable_get(:@@stats)
-  trace = Quickie::Runner.class_variable_get(:@@trace)
-
-  standard, $stdout = $stdout, StringIO.new
-  yield
-  $stdout.string
-ensure
-  if $stdout.string == '.'
-    stats[:success] -= 1
-  else
-    stats[:failure] -= 1
-    trace.pop
-  end
-  $stdout = standard
-end
-
-# Should - passing specs.
-#--------------------------------------------------------------------------
-capture { "abc".should == "abc" }.should == "."
-capture { "abc".should != "xyz" }.should == "."
-capture { "abc".should =~ /AB/i }.should == "."
-capture { "abc".should !~ /XY/i }.should == "."
-capture { 1234567.should_be > 0 }.should == "."
-
-# Should Not - passing specs.
-#--------------------------------------------------------------------------
-capture { "abc".should_not != "abc" }.should == "."
-capture { "abc".should_not == "xyz" }.should == "."
-capture { "abc".should_not !~ /AB/i }.should == "."
-capture { "abc".should_not =~ /XY/i }.should == "."
-capture { 1234567.should_not_be < 0 }.should == "."
-
-# Should - failing specs.
-#--------------------------------------------------------------------------
-capture { "abc".should != "abc" }.should == "F"
-capture { "abc".should == "xyz" }.should == "F"
-capture { "abc".should !~ /AB/i }.should == "F"
-capture { "abc".should =~ /XY/i }.should == "F"
-capture { 1234567.should_be < 0 }.should == "F"
-
-# Should Not - failing specs.
-#--------------------------------------------------------------------------
-capture { "abc".should_not == "abc" }.should == "F"
-capture { "abc".should_not != "xyz" }.should == "F"
-capture { "abc".should_not =~ /AB/i }.should == "F"
-capture { "abc".should_not !~ /XY/i }.should == "F"
-capture { 1234567.should_not_be > 0 }.should == "F"
+require File.expand_path(File.dirname(__FILE__) + "/matcher_test")
+require File.expand_path(File.dirname(__FILE__) + "/stub_test")

data/test/stub_test.rb

@@ -0,0 +1,29 @@
+# Copyright (c) 2011-12 Michael Dvorkin
+#
+# Quickie is freely distributable under the terms of MIT license.
+# See LICENSE file or http://www.opensource.org/licenses/mit-license.php
+#------------------------------------------------------------------------------
+require File.expand_path(File.dirname(__FILE__) + "/../lib/quickie")
+
+numbers = [ 1, 2, 3 ]
+letters = %w(a b c)
+
+numbers.stub! :join, :return => 42              # Stub numbers#join to return arbitrary value.
+numbers.join.should == 42                       # Test numbers.join().
+numbers.join(",").should == 42                  # Test numbers.join(arg).
+letters.join.should == "abc"                    # letters array is unaffected by numbers#join.
+
+letters.stub! :join, :return => "Hello, world!" # Now stub letters#join.
+letters.join.should == "Hello, world!"          # Test letters.join().
+letters.join(",").should == "Hello, world!"     # Test letters.join(arg).
+numbers.join.should == 42                       # numbers#join stub is unaffected by letters#join stub.
+numbers.join(",").should == 42                  # Ditto.
+
+numbers.stub :join, :remove                     # Remove numbers#join stub.
+numbers.join.should == "123"                    # numbers.join() should work as expected.
+numbers.join(",").should == "1,2,3"             # numbers.join(arg) should work as expected.
+letters.join.should == "Hello, world!"          # letters#join remains stubbed.
+
+letters.stub :join, :remove                     # Now remove letters#join stub.
+letters.join.should == "abc"                    # letters.join() should work as expected.
+letters.join(",").should == "a,b,c"             # letters.join(arg) should work as expected.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: quickie
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -11,8 +11,8 @@ bindir: bin
 cert_chain: []
 date: 2012-01-06 00:00:00.000000000 Z
 dependencies: []
-description: Quickie adds Object#should and Object#should_not methods for quick testing
-  of your Ruby code
+description: Quickie adds Object#should, Object#should_not, and Object#stub methods
+  for quick and easy testing of your Ruby code
 email: mike@dvorkin.net
 executables: []
 extensions: []
@@ -27,9 +27,12 @@ files:
 - lib/quickie/core_ext/object.rb
 - lib/quickie/matcher.rb
 - lib/quickie/runner.rb
+- lib/quickie/stub.rb
 - lib/quickie/version.rb
 - lib/quickie.rb
+- test/matcher_test.rb
 - test/quickie_test.rb
+- test/stub_test.rb
 - .gitignore
 homepage: http://github.com/michaeldv/quickie
 licenses: []
@@ -55,4 +58,7 @@ rubygems_version: 1.8.11
 signing_key: 
 specification_version: 3
 summary: Micro framework for in-place testing of Ruby code
-test_files: []
+test_files:
+- test/matcher_test.rb
+- test/quickie_test.rb
+- test/stub_test.rb