simple_mock 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 1.9.2
+  - 1.9.3

data/Gemfile

@@ -0,0 +1,3 @@
+source :rubygems
+
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2012 Tate Johnson <tate@tatey.com>
+
+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/README.md

@@ -0,0 +1,80 @@
+# SimpleMock
+
+[![Build Status](https://secure.travis-ci.org/tatey/simple_mock.png?branch=master)](http://travis-ci.org/tatey/simple_mock)
+
+A fast, tiny (81 lines) hybrid mocking library. Mix classical mocking with real objects. There's no monkey patching `Object` or copying. Real objects are completely untainted. The interface is 100% compatible with [MiniTest::Mock](https://github.com/seattlerb/minitest) so there is nothing new to learn. SimpleMock's one and only dependancy is Ruby 1.9.2 or greater.
+
+## Installation
+
+Add this to your project's Gemfile and run `$ bundle`.
+
+``` ruby
+gem 'simple_mock', :group => :test
+```
+
+SimpleMock is isolated so there is no need to set require to false.
+
+## Usage
+
+### Classical Mocking
+
+A new SimpleMock object behaves identically to MiniTest::Mock.
+
+``` ruby
+mock_model = SimpleMock.new
+mock_model.expect :valid?, true
+
+mock_model.valid? # => true
+
+mock_model.verify # => true
+```
+
+### Hybrid Mocking
+
+Pass an object to mix expectations with the real object's original behaviour.
+
+``` ruby
+class Post < ActiveRecord::Base
+  validates :title, :presence => true
+end
+
+real_model = Post.new
+mock_model = SimpleMock.new real_model
+mock_model.expect :valid?, true
+
+mock_model.valid? # => true
+mock_model.create # => true
+
+mock_model.verify # => true
+```
+
+This is done with delegation, avoiding monkey patching and copying. The real object is completely untainted.
+
+``` ruby
+mock_model.valid  # => true
+real_model.valid? # => false
+
+real_model.object_id == mock_model.__getobj__.object_id # => true
+```
+
+More documentation is available at [rubydoc.info](http://rubydoc.info/gems/simple_mock/frames).
+
+## Caveats
+
+Like MiniTest::Mock, `#expect` and `#verify` are reserved methods. Expectations should not be defined on real objects which implement these methods. As an alternative, consider creating an anonymous class which inherits from SimpleDelegator.
+
+``` ruby
+mock_class = Class.new SimpleDelegator do
+  def verify *args
+    true
+  end
+end
+mock_instance = mock_class.new MyRealClass.new
+mock_instance.verify # => true
+```
+
+SimpleMock does something similar to this under the hood.
+
+## Copyright
+
+Copyright © 2012 Tate Johnson. SimpleMock is released under the MIT license. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,10 @@
+require 'bundler/gem_tasks'
+require 'bundler/setup'
+require 'rake/testtask'
+
+Rake::TestTask.new :test do |test|
+  test.libs << 'test'
+  test.pattern = 'test/**/*_test.rb'
+end
+
+task :default => :test

data/lib/simple_mock.rb

@@ -0,0 +1,37 @@
+require 'delegate'
+require 'forwardable'
+require 'minitest/mock'
+
+require 'simple_mock/mock_delegator'
+require 'simple_mock/tracer'
+require 'simple_mock/version'
+
+module SimpleMock
+
+  # Returns a mock instance. For classicial mocking, call +new+ without
+  # an argument.
+  #
+  #   mock = SimpleMock.new
+  #   mock.expect :meaning_of_life, 42
+  #   mock.meaning_of_life # => 42
+  #   mock.verify # => true
+  #
+  # For hybrid mocking call +new+ with an +object+ argument. Hybrid mocking
+  # mixes expectations with real objects.
+  #
+  #  mock = SimpleMock.new Array.new
+  #  mock.expect :meaning_of_life, 42
+  #  mock.meaning_of_life # => 42
+  #  mock.push(1) # => [1]
+  #  mock.verify # => true
+  #
+  # +MiniTest::Mock+ and +SimpleMock::MockDelegator+ have a 100% compatible API
+  # making no difference to the consumer.
+  def self.new object = nil
+    if object.nil?
+      MiniTest::Mock.new
+    else
+      MockDelegator.new object
+    end
+  end
+end

data/lib/simple_mock/mock_delegator.rb

@@ -0,0 +1,44 @@
+module SimpleMock
+  class MockDelegator < SimpleDelegator
+    extend Forwardable
+
+    attr_accessor :__tracer
+    delegate :verify => :__tracer
+
+    def initialize object
+      super
+      self.__tracer = Tracer.new
+    end
+
+    # Expect that method +name+ is called, optionally with +args+, and returns
+    # +retval+.
+    #
+    #   mock.expect :meaning_of_life, 42
+    #   mock.meaning_of_life # => 42
+    #
+    #   mock.expect :do_something_with, true, [some_obj, true]
+    #   mock.do_something_with some_obj, true # => true
+    #
+    # +args+ is compared to the expected args using case equality (ie, the
+    # '===' method), allowing for less specific expectations.
+    #
+    #   mock.expect :uses_any_string, true, [String]
+    #   mock.uses_any_string 'foo' # => true
+    #   mock.verify  # => true
+    #
+    #   mock.expect :uses_one_string, true, ['foo']
+    #   mock.uses_one_string 'bar' # => true
+    #   mock.verify  # => raises MockExpectationError
+    def expect name, retval, args = []
+      method_definition = Module.new do
+        define_method name do |*args, &block|
+          __tracer.assert name, args
+          retval
+        end
+      end
+      extend method_definition
+      __tracer.register name, args
+      self
+    end
+  end
+end

data/lib/simple_mock/tracer.rb

@@ -0,0 +1,36 @@
+module SimpleMock
+  class Tracer
+    attr_accessor :actual_calls, :expected_calls
+
+    def initialize
+      self.actual_calls   = {}
+      self.expected_calls = {}
+    end
+
+    def assert name, actual_args = []
+      expected_args = expected_calls[name]
+      unless expected_args.size == actual_args.size
+        raise ArgumentError, "mocked method #{name.inspect} expects #{expected_args.size} arguments, got #{actual_args.size}"
+      end
+      unless expected_args.zip(actual_args).all? { |e, a| e === a || e == a }
+        raise MockExpectationError, "mocked method #{name.inspect} called with unexpected arguments #{actual_args.inspect}"
+      end
+      actual_calls[name] = true
+    end
+
+    def register name, args = []
+      expected_calls[name] = args
+    end
+
+    # Verify that all methods were called as expected. Raises
+    # +MockExpectationError+ if not called as expected.
+    def verify
+      differences = expected_calls.keys - actual_calls.keys
+      if differences.any?
+        raise MockExpectationError, "expected #{differences.first.inspect}"
+      else
+        true
+      end
+    end
+  end
+end

data/lib/simple_mock/version.rb

@@ -0,0 +1,3 @@
+module SimpleMock
+  VERSION = '0.0.1'
+end

data/simple_mock.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "simple_mock/version"
+
+Gem::Specification.new do |s|
+  s.name        = "simple_mock"
+  s.version     = SimpleMock::VERSION
+  s.authors     = ["Tate Johnson"]
+  s.email       = ["tate@tatey.com"]
+  s.homepage    = 'https://github.com/tatey/simple_mock'
+  s.summary     = %q{A fast, tiny hybrid mocking library.}
+  s.description = %q{A fast, tiny hybrid mocking library. Mix classical mocking with real objects. There's no monkey patching `Object` or copying objects. Real objects are completely untainted.}
+
+  s.rubyforge_project = "simple_mock"
+
+  s.required_ruby_version = '>= 1.9.2'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency 'rake'
+end

data/test/helper.rb

@@ -0,0 +1,4 @@
+require 'minitest/autorun'
+require 'simple_mock'
+
+include SimpleMock

data/test/unit/mock_delegator_test.rb

@@ -0,0 +1,62 @@
+require 'helper'
+
+class MockDelegatorTest < MiniTest::Unit::TestCase
+  def test_initialize_sets_delegate
+    object    = Object.new
+    delegator = MockDelegator.new object
+    assert_equal object, delegator.__getobj__
+  end
+
+  def test_expect_returns_self
+    object    = Object.new
+    delegator = MockDelegator.new object
+    assert_equal delegator, delegator.expect(:pop, 1)
+  end
+
+  def test_expect_defines_method_returning_value
+    array = Array.new
+    delegator = MockDelegator.new array
+    delegator.expect :pop, 1
+    assert_equal 1, delegator.pop
+  end
+
+  def test_expect_defines_method_with_argument_returning_value
+    array = Array.new
+    delegator = MockDelegator.new array
+    delegator.expect :push, [1, 2], [Fixnum]
+    assert_equal [1, 2], delegator.push(2)
+  end
+
+  def test_expect_calls_register_on_tracer
+    tracer = MiniTest::Mock.new
+    tracer.expect :register, true, [:plus_one, []]
+    delegator = MockDelegator.new Object.new
+    delegator.__tracer = tracer
+    delegator.expect :plus_one, 2
+    assert tracer.verify
+  end
+
+  def test_verify_is_forwarded_to_tracer
+    tracer = Class.new { define_method(:verify) { true } }.new
+    delegator = MockDelegator.new Object.new
+    delegator.__tracer = tracer
+    assert_equal true, delegator.verify
+  end
+
+  def test_method_is_forwarded_to_delegate
+    array = Array.new
+    delegator = MockDelegator.new array
+    assert delegator.respond_to?(:push)
+    assert_equal [1], delegator.push(1)
+  end
+
+  def test_method_calls_assert_on_tracer
+    tracer = MockDelegator.new Tracer.new
+    tracer.expect :assert, true, [:plus_one, []]
+    delegator = MockDelegator.new Object.new
+    delegator.__tracer = tracer
+    delegator.expect :plus_one, 2
+    delegator.plus_one
+    assert tracer.verify
+  end
+end

data/test/unit/simple_mock_test.rb

@@ -0,0 +1,11 @@
+require 'helper'
+
+class SimpleMockTest < MiniTest::Unit::TestCase
+  def test_new_without_argument_returns_minitest_mock
+    assert_match 'MiniTest::Mock', SimpleMock.new.inspect
+  end
+
+  def test_new_with_argument_returns_mock_delegator
+    assert_instance_of SimpleMock::MockDelegator, SimpleMock.new(Object.new)
+  end
+end

data/test/unit/tracer_test.rb

@@ -0,0 +1,43 @@
+require 'helper'
+
+class TracerTest < MiniTest::Unit::TestCase
+  def setup
+    @tracer = Tracer.new
+  end
+
+  def test_register_stores_expected_method_and_arguments
+    @tracer.register :plus_one, [Fixnum]
+    assert_equal [Fixnum], @tracer.expected_calls[:plus_one]
+  end
+
+  def test_assert_returns_true_when_methods_are_called_as_expected
+    @tracer.register :plus_one, [Fixnum]
+    assert @tracer.assert(:plus_one, [1])
+    assert @tracer.actual_calls[:plus_one]
+  end
+
+  def test_assert_raises_when_methods_are_called_with_wrong_number_of_arguments
+    @tracer.register :plus_one, [Fixnum, Fixnum]
+    e = assert_raises(ArgumentError) { @tracer.assert :plus_one, [1] }
+    assert_equal 'mocked method :plus_one expects 2 arguments, got 1', e.message
+  end
+
+  def test_assert_raises_when_methods_are_called_with_wrong_arguments
+    @tracer.register :plus_one, [Fixnum]
+    e = assert_raises(MockExpectationError) { @tracer.assert :plus_one, [String.new] }
+    assert_equal 'mocked method :plus_one called with unexpected arguments [""]', e.message
+  end
+
+  def test_verify_returns_true_when_methods_are_called_as_expected
+    @tracer.expected_calls = {:plus_one => [Fixnum]}
+    @tracer.actual_calls   = {:plus_one => true}
+    assert @tracer.verify
+  end
+
+  def test_verify_raises_when_expected_methods_are_not_called
+    @tracer.expected_calls = {:plus_one => [Fixnum]}
+    @tracer.actual_calls   = {:plus_two => true}
+    e = assert_raises(MockExpectationError) { @tracer.verify }
+    assert_equal 'expected :plus_one', e.message
+  end
+end

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification
+name: simple_mock
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Tate Johnson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-02-19 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &70324357134640 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70324357134640
+description: A fast, tiny hybrid mocking library. Mix classical mocking with real
+  objects. There's no monkey patching `Object` or copying objects. Real objects are
+  completely untainted.
+email:
+- tate@tatey.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/simple_mock.rb
+- lib/simple_mock/mock_delegator.rb
+- lib/simple_mock/tracer.rb
+- lib/simple_mock/version.rb
+- simple_mock.gemspec
+- test/helper.rb
+- test/unit/mock_delegator_test.rb
+- test/unit/simple_mock_test.rb
+- test/unit/tracer_test.rb
+homepage: https://github.com/tatey/simple_mock
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -790596087642070463
+requirements: []
+rubyforge_project: simple_mock
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: A fast, tiny hybrid mocking library.
+test_files:
+- test/helper.rb
+- test/unit/mock_delegator_test.rb
+- test/unit/simple_mock_test.rb
+- test/unit/tracer_test.rb