mocha 0.1.2 → 0.2.0

data/README

@@ -2,21 +2,22 @@
 
 Mocha is a library for mocking and stubbing within tests using a syntax like that of JMock[http://www.jmock.org] and SchMock[http://rubyforge.org/projects/schmock].
 
-Mocha comes in three parts:
+Mocha comes in four parts:
 
 1. Mocha - traditional mock objects with expectations and verification
 2. Stubba - allows mocking and stubbing of methods on real (non-mock) classes
 3. AutoMocha - magically provides mocks in the place of undefined classes
+4. SmartTestCase - allows addition of multiple setup and teardown methods for a Test::Unit::TestCase
 
 Stubba and AutoMocha are the main difference between this mocking library and others like FlexMock[http://onestepback.org/software/flexmock] and RSpec[http://rspec.rubyforge.org].
 
 == Provenance
 
-Mocha and Stubba have been created by amalgamating a number of techniques developed by me (James[http:blog.floehopper.org]) and my Reevoo[http://www.reevoo.com] colleagues (Ben[http://www.reevoo.com/blogs/bengriffiths/], Chris[http://blog.seagul.co.uk] and Paul[http://po-ru.com]) into a common syntax. They are both in use on real-world Rails[http://www.rubyonrails.org] projects. AutoMocha is more experimental and is at an earlier stage of development.
+Mocha and Stubba have been created by amalgamating a number of techniques developed by me (James[http:blog.floehopper.org]) and my Reevoo[http://www.reevoo.com] colleagues (Ben[http://www.reevoo.com/blogs/bengriffiths/], Chris[http://blog.seagul.co.uk] and Paul[http://po-ru.com]) into a common syntax. They are both in use on real-world Rails[http://www.rubyonrails.org] projects. AutoMocha is more experimental and is at an earlier stage of development. SmartTestCase has been exrtacted from Mocha and Stubba to remove duplication and allow its use in isolation.
 
 == Download and Installation
 
-You can download Mocha from here[http://rubyforge.org/projects/mocha] or install Mocha with the following command.
+You can download Mocha from here[http://rubyforge.org/projects/mocha] or install it with the following command.
 
  $ gem install mocha
 
@@ -44,20 +45,17 @@ See MochaAcceptanceTest, StubbaAcceptanceTest, AutoMochaAcceptanceTest and unit
 
   end
 
-	require 'rubygems'
-	require 'mocha'
-	require 'test/unit'
+  require 'rubygems'
+  require 'mocha'
+  require 'test/unit'
 
   class EnterpriseTest < Test::Unit::TestCase
 
-    include Mocha
-
     def test_should_boldly_go
-      dilithium = Mock.new
-      dilithium.expects(:nuke).with(:anti_matter).at_least_once
+      dilithium = mock()
+      dilithium.expects(:nuke).with(:anti_matter).at_least_once  # auto-verified at end of test
       enterprise = Enterprise.new(dilithium)
       enterprise.go(2)
-      dilithium.verify
     end
 
   end
@@ -148,12 +146,10 @@ See MochaAcceptanceTest, StubbaAcceptanceTest, AutoMochaAcceptanceTest and unit
 
   class OrderTest < Test::Unit::TestCase
 
-    include Mocha
-
     # illustrates stubbing of previously undefined class Comment
     def test_should_return_accepted_comments_for_this_article
-      unaccepted_comment = Mock.new(:accepted? => false)
-      accepted_comment = Mock.new(:accepted? => true)
+      unaccepted_comment = stub(:accepted? => false)
+      accepted_comment = stub(:accepted? => true)
       comments = [unaccepted_comment, accepted_comment]
       Comment.stubs(:find_all_by_article_id).returns(comments)
       article = Article.new

data/RELEASE

@@ -0,0 +1,51 @@
+= 0.2.0
+
+* Small change to SetupAndTeardown#teardown_stubs suggested by Luke Redpath (http://www.lukeredpath.co.uk) to allow use of Stubba with RSpec (http://rspec.rubyforge.org).
+* Reorganized directory structure and extracted addition of setup and teardown methods into SmartTestCase mini-library.
+* Addition of auto-verify for Mocha (but not Stubba). This means there is more significance in the choice of expects or stubs in that any expects on a mock will automatically get verified.
+
+So instead of...
+
+  wotsit = Mocha.new
+  wotsit.expects(:thingummy).with(5).returns(10)
+  doobrey = Doobrey.new(wotsit)
+  doobrey.hoojamaflip
+  wotsit.verify
+
+you need to do...
+
+  wotsit = mock()
+  wotsit.expects(:thingummy).with(5).returns(10)
+  doobrey = Doobrey.new(wotsit)
+  doobrey.hoojamaflip
+  # no need to verify
+
+There are also shortcuts as follows...
+
+instead of...
+
+  wotsit = Mocha.new
+  wotsit.expects(:thingummy).returns(10)
+  wotsit.expects(:summat).returns(25)
+
+you can have...
+
+  wotsit = mock(:thingummy => 5, :summat => 25)
+
+and instead of...
+
+  wotsit = Mocha.new
+  wotsit.stubs(:thingummy).returns(10)
+  wotsit.stubs(:summat).returns(25)
+
+you can have...
+
+  wotsit = stub(:thingummy => 5, :summat => 25)
+
+= 0.1.2
+
+* Minor tweaks
+
+= 0.1.1
+
+* Initial release.

data/Rakefile

@@ -1,6 +1,7 @@
 require 'rubygems'
 require 'rake/rdoctask'
 require 'rake/gempackagetask'
+require 'rake/contrib/sshpublisher'
 
 desc "Default task is currently to run all tests"
 task :default => :test_all
@@ -13,9 +14,32 @@ end
 
 desc 'Generate RDoc'
 Rake::RDocTask.new do |task|
+  task.main = 'README'
+  task.title = 'Mocha'
   task.rdoc_dir = 'doc'
-  task.options << '--title Mocha --main README --line-numbers --inline-source'
-  task.rdoc_files.include('README', 'lib/**/*.rb')
+  task.options << "--line-numbers" << "--inline-source"
+  task.rdoc_files.include('README', 'RELEASE', 'agiledox.txt', 'lib/**/*.rb')
+end
+
+desc "Upload RDoc to RubyForge"
+task :publish_rdoc => [:rdoc] do
+  Rake::SshDirPublisher.new("jamesmead@rubyforge.org", "/var/www/gforge-projects/mocha", "doc").upload
+end
+
+desc "Generate agiledox-like documentation for tests"
+file 'agiledox.txt' do
+  File.open('agiledox.txt', 'w') do |output|
+    tests = FileList['test/**/*_test.rb']
+    tests.each do |file|
+      m = %r".*/([^/].*)_test.rb".match(file)
+      output << m[1]+" should:\n"
+      test_definitions = File::readlines(file).select {|line| line =~ /.*def test.*/}
+      test_definitions.sort.each do |definition|
+        m = %r"test_(should_)?(.*)".match(definition)
+        output << " - "+m[2].gsub(/_/," ") << "\n"
+      end
+    end
+  end
 end
 
 Gem::manage_gems
@@ -23,7 +47,7 @@ Gem::manage_gems
 specification = Gem::Specification.new do |s|
 	s.name   = "mocha"
   s.summary = "Mocking and stubbing library"
-	s.version = "0.1.2"
+	s.version = "0.2.0"
 	s.author = 'James Mead'
 	s.description = <<-EOF
     Mocking and stubbing library with JMock/SchMock syntax, which allows mocking and stubbing of methods on real (non-mock) classes.

data/TODO

@@ -1,20 +1,15 @@
-- check examples in readme
+- make verify method private (makes this unnecessary - fail if attempt to verify stub)
+- auto-verify for stubs?
+- allow hash parameter for stubs and expects methods particularly for stubba
 - write rdoc for most important methods/classes e.g. expectation
-- mock() method on test case to hide implementation detail of Mocha.new
-- include functionality into test case using module include for more flexibility - instead of re-opening test/unit/test_case
-- improve implementation of test case setup/teardown
-- experienced problem when including a module with setup method into a TestCase derived class (something like nil.unstub_all in teardown)
+- remove mocha/stubba from call stack when assertion error raised
 - test for setting expectations on class methods (and instance methods?) from within TestCase#setup
-- test for verifying expectations from within TestCase#teardown
 - use Object#inspect(:mocha) instead of Object#mocha_inspect?
 - allow stubbing of private/protected methods?
 - should all instances share expectations for any_instance or should each instance have their own - in which case how do we provide access to the instances
-- check if mocking 'new' method is still possible
 - detect existing or added definition of mocha methods e.g. expects and alias to __expects?
-- think more about different behaviour for expects/stubs
-- auto-verify? default to on, allow switch off?
+- allow switch off of auto-verify?
 - fail if verify called with no expectations? set expectation - expects(:blah).never to ensure method not called
-- fail if attempt to verify stub??
 - maybe use blank_slate as mocha parent class to allow mocking of standard object methods?
 - more jmock style stuff - e.g. return values on consecutive calls, labels/required order, more sophisticated param matching?
 - stubs should only return a fixed value - no blocks allowed for return values and no parameter expectations allowed?

data/lib/auto_mocha.rb

@@ -1 +1,2 @@
+require 'mocha'
 require 'auto_mocha/auto_mock'

data/lib/mocha.rb

@@ -1 +1,6 @@
-require 'mocha/mock'
+require 'smart_test_case'
+require 'mocha/auto_verify'
+
+class Test::Unit::TestCase
+  include AutoVerify unless ancestors.include?(AutoVerify)
+end

data/lib/mocha/auto_verify.rb

@@ -0,0 +1,41 @@
+require 'mocha/mock'
+
+module AutoVerify
+  
+  def self.included(base)
+    base.add_teardown_method(:teardown_mocks)
+  end
+
+  def mocks
+    @mocks ||= []
+  end
+  
+  def reset_mocks
+    @mocks = nil
+  end
+
+  def mock(expectations = {})
+    mock = Mocha::Mock.new
+    expectations.each do |method, result|
+      mock.expects(method).returns(result)
+    end
+    mocks << mock
+    mock
+  end
+  
+  def stub(expectations = {})
+    mock = Mocha::Mock.new
+    expectations.each do |method, result|
+      mock.stubs(method).returns(result)
+    end
+    mocks << mock
+    mock
+  end
+
+  def teardown_mocks
+    mocks.each { |mock| mock.verify }
+    reset_mocks
+  end
+  
+end
+

data/lib/smart_test_case.rb

@@ -0,0 +1,5 @@
+require 'smart_test_case/multiple_setup_and_teardown'
+
+class Test::Unit::TestCase
+  include MultipleSetupAndTeardown unless ancestors.include?(MultipleSetupAndTeardown)
+end

data/lib/smart_test_case/multiple_setup_and_teardown.rb

@@ -0,0 +1,115 @@
+module MultipleSetupAndTeardown
+  
+  def self.included(base)
+
+    base.class_eval do
+  
+      def self.method_added(symbol)
+        # disable until later
+      end
+
+      if method_defined?(:setup) then
+        alias_method :setup_original, :setup
+        define_method(:setup_new) do
+          begin
+            setup_original
+          ensure
+            setup_mocha
+          end
+        end
+      else
+        define_method(:setup_new) do
+          setup_mocha
+        end
+      end
+      alias_method :setup, :setup_new
+
+      if method_defined?(:teardown) then
+        alias_method :teardown_original, :teardown
+        define_method(:teardown_new) do
+          begin
+            teardown_mocha
+          ensure
+            teardown_original
+          end
+        end
+      else
+        define_method(:teardown_new) do
+          teardown_mocha
+        end
+      end
+      alias_method :teardown, :teardown_new
+
+      def self.method_added(method)
+        case method
+        when :setup
+          unless method_defined?(:setup_added)
+            alias_method :setup_added, :setup
+            define_method(:setup) do
+              begin
+                setup_new
+              ensure
+                setup_added
+              end
+            end
+          end
+        when :teardown
+          unless method_defined?(:teardown_added)
+            alias_method :teardown_added, :teardown
+            define_method(:teardown) do
+              begin
+                teardown_added
+              ensure
+                teardown_new
+              end
+            end
+          end
+        end
+      end
+
+      class << self
+
+        def setup_methods
+          @setup_methods ||= []
+        end
+
+        def teardown_methods
+          @teardown_methods ||= []
+        end
+
+        def add_setup_method(symbol)
+          setup_methods << symbol
+        end
+
+        def add_teardown_method(symbol)
+          teardown_methods << symbol
+        end
+
+        private
+
+        def inherited_with_setup_and_teardown_methods(child)
+          inherited_without_setup_and_teardown_methods(child) if respond_to?(:inherited_without_setup_and_teardown_methods, true)
+          child.instance_variable_set('@setup_methods', setup_methods.dup)
+          child.instance_variable_set('@teardown_methods', teardown_methods.dup)
+        end
+
+        if respond_to?(:inherited, true)
+          alias_method :inherited_without_setup_and_teardown_methods, :inherited
+        end
+        alias_method :inherited, :inherited_with_setup_and_teardown_methods
+
+      end
+
+      def setup_mocha
+        self.class.class_eval { setup_methods }.each { |symbol| send(symbol) }
+      end
+
+      def teardown_mocha
+        self.class.class_eval { teardown_methods }.reverse.each { |symbol| send(symbol) }
+      end
+
+    end
+
+  end
+
+end

data/lib/stubba.rb

@@ -1,2 +1,7 @@
-require 'stubba/test_case'
 require 'stubba/object'
+require 'smart_test_case'
+require 'stubba/setup_and_teardown'
+
+class Test::Unit::TestCase
+  include SetupAndTeardown unless ancestors.include?(SetupAndTeardown)
+end

data/lib/stubba/{stubba.rb → central.rb}

@@ -1,6 +1,6 @@
 module Stubba
   
-  class Stubba
+  class Central
   
     attr_accessor :stubba_methods
   

data/lib/stubba/setup_and_teardown.rb

@@ -0,0 +1,19 @@
+require 'stubba/central'
+
+module SetupAndTeardown
+  
+  def self.included(base)
+    base.add_setup_method(:setup_stubs)
+    base.add_teardown_method(:teardown_stubs)
+  end
+  
+  def setup_stubs
+    $stubba = Stubba::Central.new
+  end
+  
+  def teardown_stubs
+    $stubba.unstub_all if $stubba
+    $stubba = nil
+  end
+
+end

data/test/active_record_test_case.rb

@@ -0,0 +1,36 @@
+module ActiveRecordTestCase
+
+  def setup_with_fixtures
+    methods_called << :setup_with_fixtures
+  end
+
+  alias_method :setup, :setup_with_fixtures
+
+  def teardown_with_fixtures
+    methods_called << :teardown_with_fixtures
+  end
+
+  alias_method :teardown, :teardown_with_fixtures
+
+  def self.method_added(method)
+    case method.to_s
+    when 'setup'
+      unless method_defined?(:setup_without_fixtures)
+        alias_method :setup_without_fixtures, :setup
+        define_method(:setup) do
+          setup_with_fixtures
+          setup_without_fixtures
+        end
+      end
+    when 'teardown'
+      unless method_defined?(:teardown_without_fixtures)
+        alias_method :teardown_without_fixtures, :teardown
+        define_method(:teardown) do
+          teardown_without_fixtures
+          teardown_with_fixtures
+        end
+      end
+    end
+  end
+
+end