rd_stump 0.0.2

data/History.txt

@@ -0,0 +1,4 @@
+== 0.0.1 2008-10-03
+
+* 1 major enhancement:
+  * Initial release

data/License.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Jeremy McAnally
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Manifest.txt

@@ -0,0 +1,23 @@
+History.txt
+License.txt
+Manifest.txt
+PostInstall.txt
+README.rdoc
+Rakefile
+config/hoe.rb
+config/requirements.rb
+lib/stump.rb
+lib/stump/metaid.rb
+lib/stump/mock.rb
+lib/stump/mocks.rb
+lib/stump/proxy.rb
+lib/stump/stub.rb
+lib/stump/core_ext/test_case.rb
+lib/stump/version.rb
+setup.rb
+tasks/deployment.rake
+tasks/environment.rake
+test/test_helper.rb
+test/test_proxy.rb
+test/test_mock.rb
+test/test_stub.rb

data/PostInstall.txt

@@ -0,0 +1,7 @@
+
+For more information on stump, see http://stump.rubyforge.org
+
+NOTE: Change this information in PostInstall.txt 
+You can also delete it if you don't want it.
+
+

data/README.rdoc

@@ -0,0 +1,118 @@
+= stump
+
+* http://www.github.com/jeremymcanally/stump
+
+== DESCRIPTION:
+
+Stubbing and mocking that isn't painful, fanciful, and doesn't inspire any sort of contempt or bitterness.
+
+== FEATURES/PROBLEMS:
+
+* Stubbing right on the object.
+
+    # Returns 'hey!'
+    MyClass.stub!(:thing, :return => "hey!")
+    # Returns nil
+    your_object.stub!(:hello)
+
+* Pure stub objects.
+
+    my_stub = stub(:thing, :return => "dude, a thing!")
+    my_stub.thing   # => "dude, a thing!"
+
+* Mocking right on the object.
+
+    my_object = "things are fun"
+    my_object.mock!(:fancy, "ooo fancy!")
+    my_object.fancy # => "ooo fancy!"
+
+* Pure mock objects.
+
+    my_mock = mock(:hello, :return => "what fun is this?")
+    my_mock.hello   # => "what fun is this?"
+
+* Proxying objects.
+
+    class Greeting
+      def bonjour
+        "Bonjour!"
+      end
+    end
+
+    greet_me = Greeting.new
+    greet_me.proxy!(:bonjour)
+    greet_me.bonjour  # => "Bonjour!"
+
+    greet_you = Greeting.new
+    greet_you.proxy!(:bonjour)
+    
+    # finish test...
+    # ! Unmet expectations: #<Greeting:0x371d24> expected hello
+
+== SYNOPSIS:
+
+    # Stub class methods
+    MyClass.stub!(:thing, :return => "hey!")
+    # Stub method on object
+    your_object.stub!(:my_method)
+    # Stub method on object, requiring parameters
+    my_object.stub!(:other_method) do |arg1, arg2|
+      puts arg1
+      puts arg2
+    end
+  
+    # Mock method on object
+    MyClass.mock!(:my_method, :return => "hehe")
+    # Mock method on object, requiring parameters
+    my_obj.mock!(:hehe, :return => nil) do |arg1, arg2, arg3|
+      # Fun party!
+    end
+  
+    # Sets expectation it will receive a method, calling the real method
+    MyClass.proxy!(:the_method)
+    # Returns static value but still has side effects of real method call
+    MyClass.proxy!(:that_method, :return => "poop")
+    
+== NOTES:
+
+* Be sure you call +super+ in +teardown+ if you create your own +teardown+ methods.  Otherwise your mocks won't get verified!
+
+== REQUIREMENTS:
+
+* Test::Unit (batteries included with Ruby)
+
+== INSTALL:
+
+    $ gem sources -a http://gems.github.com
+    $ sudo gem install jeremymcanally-stump
+
+
+== ACKNOWLEDGEMENTS:
+
+* Thanks to Jim Weirich for Flexmock, David Chelmisky et. al. for RSpec's mocking stuff, and Brian Takita for rr.  All of those things fed into stump.
+* BIG thanks to Nathan Sutton (fowlduck) for helping me work through how to get +proxy!+ to work with ActiveRecord/method_missing.
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2008 Jeremy McAnally
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,4 @@
+require 'config/requirements'
+require 'config/hoe' # setup Hoe + all gem configuration
+
+Dir['tasks/**/*.rake'].each { |rake| load rake }

data/config/hoe.rb

@@ -0,0 +1,73 @@
+require 'stump/version'
+
+AUTHOR = 'Jeremy McAnally'  # can also be an array of Authors
+EMAIL = "jeremy@entp.com"
+DESCRIPTION = "Stubbing and mocking that isn't painful."
+GEM_NAME = 'stump' # what ppl will type to install your gem
+RUBYFORGE_PROJECT = 'stump' # The unix name for your project
+HOMEPATH = "http://#{RUBYFORGE_PROJECT}.rubyforge.org"
+DOWNLOAD_PATH = "http://rubyforge.org/projects/#{RUBYFORGE_PROJECT}"
+EXTRA_DEPENDENCIES = [
+#  ['activesupport', '>= 1.3.1']
+]    # An array of rubygem dependencies [name, version]
+
+@config_file = "~/.rubyforge/user-config.yml"
+@config = nil
+RUBYFORGE_USERNAME = "unknown"
+def rubyforge_username
+  unless @config
+    begin
+      @config = YAML.load(File.read(File.expand_path(@config_file)))
+    rescue
+      puts <<-EOS
+ERROR: No rubyforge config file found: #{@config_file}
+Run 'rubyforge setup' to prepare your env for access to Rubyforge
+ - See http://newgem.rubyforge.org/rubyforge.html for more details
+      EOS
+      exit
+    end
+  end
+  RUBYFORGE_USERNAME.replace @config["username"]
+end
+
+
+REV = nil
+# UNCOMMENT IF REQUIRED:
+# REV = YAML.load(`svn info`)['Revision']
+VERS = Stump::VERSION::STRING + (REV ? ".#{REV}" : "")
+RDOC_OPTS = ['--quiet', '--title', 'stump documentation',
+    "--opname", "index.html",
+    "--line-numbers",
+    "--main", "README",
+    "--inline-source"]
+
+class Hoe
+  def extra_deps
+    @extra_deps.reject! { |x| Array(x).first == 'hoe' }
+    @extra_deps
+  end
+end
+
+# Generate all the Rake tasks
+# Run 'rake -T' to see list of generated tasks (from gem root directory)
+$hoe = Hoe.new(GEM_NAME, VERS) do |p|
+  p.developer(AUTHOR, EMAIL)
+  p.description = DESCRIPTION
+  p.summary = DESCRIPTION
+  p.url = HOMEPATH
+  p.rubyforge_name = RUBYFORGE_PROJECT if RUBYFORGE_PROJECT
+  p.test_globs = ["test/**/test_*.rb"]
+  p.clean_globs |= ['**/.*.sw?', '*.gem', '.config', '**/.DS_Store']  #An array of file patterns to delete on clean.
+
+  # == Optional
+  p.changes = p.paragraphs_of("History.txt", 0..1).join("\n\n")
+  #p.extra_deps = EXTRA_DEPENDENCIES
+
+    #p.spec_extras = {}    # A hash of extra values to set in the gemspec.
+  end
+
+CHANGES = $hoe.paragraphs_of('History.txt', 0..1).join("\\n\\n")
+PATH    = (RUBYFORGE_PROJECT == GEM_NAME) ? RUBYFORGE_PROJECT : "#{RUBYFORGE_PROJECT}/#{GEM_NAME}"
+$hoe.remote_rdoc_dir = File.join(PATH.gsub(/^#{RUBYFORGE_PROJECT}\/?/,''), 'rdoc')
+$hoe.rsync_args = '-av --delete --ignore-errors'
+$hoe.spec.post_install_message = File.open(File.dirname(__FILE__) + "/../PostInstall.txt").read rescue ""

data/config/requirements.rb

@@ -0,0 +1,15 @@
+require 'fileutils'
+include FileUtils
+
+require 'rubygems'
+%w[rake hoe newgem rubigen].each do |req_gem|
+  begin
+    require req_gem
+  rescue LoadError
+    puts "This Rakefile requires the '#{req_gem}' RubyGem."
+    puts "Installation: gem install #{req_gem} -y"
+    exit
+  end
+end
+
+$:.unshift(File.join(File.dirname(__FILE__), %w[.. lib]))

data/lib/stump.rb

@@ -0,0 +1,11 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'stump/version'
+require 'stump/metaid'
+require 'stump/core_ext/test_case'
+
+require 'stump/stub'
+require 'stump/mocks'
+require 'stump/mock'
+require 'stump/proxy'

data/lib/stump/core_ext/test_case.rb

@@ -0,0 +1,21 @@
+module Test
+  module Unit
+    class TestCase
+      def stumpdown!
+        begin
+          if !Stump::Mocks.failures.nil? && !Stump::Mocks.failures.empty?
+            fails = Stump::Mocks.failures.map {|object, method| "#{object.inspect} expected #{method}"}.join(", ")
+          
+            flunk "Unmet expectations: #{fails}"
+          end
+        ensure
+          Stump::Mocks.clear!
+        end
+      end
+      
+      def teardown
+        stumpdown!
+      end
+    end
+  end
+end

data/lib/stump/metaid.rb

@@ -0,0 +1,17 @@
+# thanks _why
+# http://whytheluckystiff.net/articles/seeingMetaclassesClearly.html
+class Object
+  # The hidden singleton lurks behind everyone
+  def metaclass; class << self; self; end; end
+  def meta_eval &blk; metaclass.instance_eval &blk; end
+
+  # Adds methods to a metaclass
+  def meta_def name, &blk
+    meta_eval { define_method name, &blk }
+  end
+
+  # Defines an instance method within a class
+  def class_def name, &blk
+    class_eval { define_method name, &blk }
+  end
+end

data/lib/stump/mock.rb

@@ -0,0 +1,51 @@
+class Object
+  # Create a mock method on an object.  A mock object will place an expectation
+  # on behavior and cause a test failure if it's not fulfilled.
+  # 
+  # ==== Examples
+  #
+  #    my_string = "a wooden rabbit"
+  #    my_string.mock!(:retreat!, :return => "run away!  run away!")
+  #    my_string.mock!(:question, :return => "what is the airspeed velocity of an unladen sparrow?")
+  #    
+  #    # test/your_test.rb
+  #    my_string.retreat!    # => "run away!  run away!"
+  #    # If we let the test case end at this point, it fails with:
+  #    # Unmet expectation: #<Sparrow:1ee7> expected question
+  #
+  def mock!(method, options = {}, &block)    
+    Stump::Mocks.add([self, method])
+    
+    behavior =  if block_given?
+                  lambda do |*args| 
+                    raise ArgumentError if block.arity >= 0 && args.length != block.arity
+                    
+                    Stump::Mocks.verify([self, method])
+                    block.call(args)
+                  end
+                else
+                  lambda do |*args|                     
+                    Stump::Mocks.verify([self, method])
+                    return options[:return]
+                  end
+                end
+
+    meta_def method, &behavior
+  end
+end
+
+module Kernel
+  # Create a pure mock object rather than mocking specific methods on an object.
+  #
+  # ==== Examples
+  # 
+  #     my_mock = mock(:thing, :return => "whee!")
+  #     my_mock.thing    # => "whee"
+  #
+  def mock(method, options = {}, &block)
+    mock_object = Object.new
+    mock_object.mock!(method, options, &block)
+    mock_object
+  end
+end
+

data/lib/stump/mocks.rb

@@ -0,0 +1,23 @@
+module Stump
+  # A class to track the mocks and proxies that have been satisfied
+  class Mocks
+    class <<self
+      def add(mock)
+        @mocks ||= []
+        @mocks << mock
+      end
+      
+      def verify(mock)
+        @mocks.delete(mock)
+      end
+      
+      def failures
+        @mocks
+      end
+      
+      def clear!
+        @mocks = []
+      end
+    end
+  end
+end

data/lib/stump/proxy.rb

@@ -0,0 +1,115 @@
+class Object
+  # Creates a proxy method on an object.  In this setup, it places an expectation on an object (like a mock)
+  # but still calls the original method.  So if you want to make sure the method is called and still return
+  # its value, or simply want to invoke the side effects of a method and return a stubbed value, then you can
+  # do that.
+  #
+  # ==== Examples
+  #
+  #     class Parrot
+  #       def speak!
+  #         puts @words
+  #       end
+  #
+  #       def say_this(words)
+  #         @words = words
+  #         "I shall say #{words}!"
+  #       end
+  #     end
+  #
+  #     # => test/your_test.rb
+  #     sqawky = Parrot.new
+  #     sqawky.proxy!(:say_this)
+  #     # Proxy method still calls original method...
+  #     sqawky.say_this("hey")   # => "I shall say hey!"
+  #     sqawky.speak!            # => "hey"
+  #
+  #     sqawky.proxy!(:say_this, "herro!")
+  #     # Even though we return a stubbed value...
+  #     sqawky.say_this("these words")   # => "herro!"
+  #     # ...the side effects are still there.
+  #     sqawky.speak!                    # => "these words"
+  #
+  # TODO: This implementation is still very rough.  Needs refactoring and refining.  Won't 
+  # work on ActiveRecord attributes, for example.
+  #
+  def proxy!(method, options = {}, &block)
+    Stump::Mocks.add([self, method])
+    
+    if respond_to?(method)
+      proxy_existing_method(method, options, &block)
+    else
+      proxy_missing_method(method, options, &block)
+    end
+  end
+  
+  protected
+  def proxy_existing_method(method, options = {}, &block)
+    method_alias = "__old_#{method}"
+    
+    meta_eval do
+      module_eval("alias #{method_alias} #{method}")
+    end
+    
+    check_arity = Proc.new do |args|
+      arity = method(method_alias.to_sym).arity
+      if ((arity >= 0) ?
+          (args.length != arity) :
+          (args.length < ~arity))
+        # Negative arity means some params are optional, so we check
+        # for the minimum required.  Sadly, we can't tell what the
+        # maximum is.
+        raise ArgumentError
+      end
+    end
+    
+    behavior = if options[:return]
+                  lambda do |*args| 
+                    check_arity.call(args)
+                    
+                    Stump::Mocks.verify([self, method])
+
+                    if method(method_alias.to_sym).arity == 0
+                      send(method_alias)
+                    else
+                      send(method_alias, *args)
+                    end
+
+                    return options[:return]
+                  end
+                else
+                  lambda do |*args| 
+                    check_arity.call(args)
+
+                    Stump::Mocks.verify([self, method])
+                    
+                    if method(method_alias.to_sym).arity == 0
+                      return send(method_alias)
+                    else
+                      return send(method_alias, *args)
+                    end
+                  end
+                end
+
+    meta_def method, &behavior
+  end
+  
+  def proxy_missing_method(method, options = {}, &block)
+    behavior = if options[:return]
+                  lambda do |*args|
+                    Stump::Mocks.verify([self, method])
+                    
+                    method_missing(method, args)
+                    return options[:return]
+                  end
+                else
+                  lambda do |*args|
+                    Stump::Mocks.verify([self, method])
+      
+                    method_missing(method, args)
+                  end
+                end
+    
+    meta_def method, &behavior
+  end
+end