spy 0.3.1 → 0.4.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0b0de47cae4d5ee5cf4709bc537489dc137007b5
+  data.tar.gz: 4e6cff2b7b27e27c787ad93d5fb1af723f382739
+SHA512:
+  metadata.gz: fed5be1346e1c658363827797fd9a20b1241f33724c4af92b8f1616887967a3ff44ea51409ec027a8187b9b95db606cd361972cbed323c7bb4ebdbf5c734d8d1
+  data.tar.gz: 65ce3667c4665ef8a396d0e6ab3248d88d57eaedff2b6393865d661813b4253c63e213990fa0f3e8684c5e7b882e92db44dd74c1e2cd1a7483611d1239e968a7

data/.gitignore

@@ -1,6 +1,7 @@
 *.gem
 *.rbc
 *.sw*
+*.rbx
 .bundle
 .config
 .yardoc

data/README.md

@@ -101,7 +101,7 @@ when the method is not stubbed. Spy will not let you stub a method that wasn't
 on the mocked class. You can spy on the classes and call through to the original method.
 
 ```ruby
-book = Spy.mock(Book)
+book = Spy.mock(Book) # Must be a class
 Spy.on(book, first_name: "Neil", last_name: "Gaiman")
 Spy.on(book, :author).and_call_through
 book.author #=> "Neil Gaiman"
@@ -113,7 +113,7 @@ book.title #=> Spy::NeverHookedError: 'title' was never hooked on mock spy.
 To stub methods during instantiation just add arguments.
 
 ```ruby
-book = Spy.mock(book, :first_name, author: "Neil Gaiman")
+book = Spy.mock(Book, :first_name, author: "Neil Gaiman")
 ```
 
 ### Arbitrary Handling
@@ -139,7 +139,7 @@ end
 When you stub a method it returns a spy. A spy records what calls have been made to a given method.
 
 ```ruby
-validator = Spy.double("validator")
+validator = Spy.mock(Validator)
 validate_spy = Spy.on(validator, :validate)
 validate_spy.has_been_called? #=> false
 
@@ -181,26 +181,30 @@ first_call.result #=> "hello world"
 first_call.called_from #=> "file_name.rb:line_number"
 ```
 
-### MiniTest
+## Test Framework Integration
 
-In `test_helper.rb`
+### MiniTest/TestUnit
+
+in your `test_helper.rb` add this line after you include your framework
 
 ```ruby
-require "spy"
-MiniTest::TestCase.add_teardown_hook { Spy.teardown }
+require 'spy/integration'
+```
 
+In your test file
 
-class TestBook < MiniTest::Unit::TestCase
+```ruby
   def test_title
-    book = book.new
-    title_spy = spy.on(book, title)
+    book = Book.new
+    title_spy = Spy.on(book, title)
     book.title
     book.title
 
+    assert_received book, :title
+
     assert title_spy.has_been_called?
     assert_equal 2, title_spy.calls.count
   end
-end
 ```
 
 ### Rspec
@@ -209,34 +213,28 @@ In `spec_helper.rb`
 
 ```ruby
 require "rspec/autorun"
-require "spy"
+require "spy/integration"
 RSpec.configure do |c|
-  c.after { Spy.teardown  }
-  c.mock_with :absolutely_nothing # this is completely optional.
+  c.mock_with Spy::RspecAdapter
 end
+```
+
+In your test
 
+```ruby
 describe Book do
   it "title can be called" do
     book = book.new
-    title_spy = spy.on(book, title)
-    book.title
-    book.title
-
-    expect(title_spy).to have_been_called
-    expect(title_spy.calls.count).to eq(2)
-  end
-end
-```
+    page_spy = Spy.on(book, page)
+    book.page(1)
+    book.page(2)
 
-### Test::Unit
+    expect(book).to have_received(:page)
+    expect(book).to have_received(:page).with(1)
+    expect(book).to have_received(:page).with(2)
 
-```ruby
-require "spy"
-class Test::Unit::TestCase
-  def teardown
-    # if you don't add super to every teardown then you will have to add this
-    # line to every file.
-    Spy.teardown
+    expect(page_spy).to have_been_called
+    expect(page_spy.calls.count).to eq(2)
   end
 end
 ```

data/lib/spy.rb

@@ -1,9 +1,10 @@
+require "spy/exceptions"
 require "spy/core_ext/marshal"
 require "spy/agency"
+require "spy/api"
 require "spy/base"
 require "spy/call_log"
 require "spy/constant"
-require "spy/exceptions"
 require "spy/mock"
 require "spy/nest"
 require "spy/subroutine"
@@ -41,7 +42,11 @@ module Spy
       removed_spies.size > 1 ? removed_spies : removed_spies.first
     end
 
-    #
+    # stubs the instance method of a given Class so all instance methods of this
+    # class will have the given method stubbed
+    # @param base_class [Class] The class you wish to stub the instance methods of
+    # @param method_names *[Symbol, Hash]
+    # @return [Spy,Array<Spy>]
     def on_instance_method(base_class, *method_names)
       spies = method_names.map do |method_name|
         create_and_hook_spy(base_class, method_name, false)
@@ -50,13 +55,17 @@ module Spy
       spies.size > 1 ? spies : spies.first
     end
 
-    def off_instance_method(base_object, *method_names)
+    # remove the stub from given Class
+    # @param base_class [Class]
+    # @param method_names *[Symbol]
+    # @return [Spy]
+    def off_instance_method(base_class, *method_names)
       removed_spies = method_names.map do |method_name|
-        spy = Subroutine.get(base_object, method_name, false)
+        spy = Subroutine.get(base_class, method_name, false)
         if spy
           spy.unhook
         else
-          raise NoSpyError, "#{method_name} was not hooked on #{base_object.inspect}."
+          raise NoSpyError, "#{method_name} was not hooked on #{base_class.inspect}."
         end
       end
 
@@ -108,6 +117,10 @@ module Spy
       spies.size > 1 ? spies : spies.first
     end
 
+    # Create a mock object from a given class
+    # @param klass [Class] class you wish to mock
+    # @param stubs *[Symbol, Hash] methods you with to stub
+    # @return [Object]
     def mock(klass, *stubs)
       new_mock = Mock.new(klass).new
       if stubs.size > 0
@@ -116,6 +129,11 @@ module Spy
       new_mock
     end
 
+    # create a mock object from a given class with all the methods stubbed out
+    # and returning nil unless specified otherwise.
+    # @param klass [Class] class you wish to mock
+    # @param stubs *[Symbol, Hash] methods you with to stub
+    # @return [Object]
     def mock_all(klass, *stubs)
       mock_klass = Mock.new(klass)
       new_mock = mock_klass.new

data/lib/spy/agency.rb

@@ -68,7 +68,7 @@ module Spy
     private
 
     def check_spy!(spy)
-      raise ArgumentError, "#{spy}, was not a spy" unless spy.is_a?(Base) || spy.respond_to?(:_mock_class, true)
+      raise ArgumentError, "#{spy}, was not a spy" unless spy.is_a?(Base)
     end
   end
 end

data/lib/spy/api.rb

@@ -0,0 +1,72 @@
+module Spy
+  module API
+    DidNotReceiveError = Class.new(Spy::Error)
+
+    def assert_received(base_object, method_name)
+      assert Subroutine.get(base_object, method_name).has_been_called?,
+        "#{method_name} was not called on #{base_object.inspect}"
+    end
+
+    def assert_received_with(base_object, method_name, *args, &block)
+      assert Subroutine.get(base_object, method_name).has_been_called_with?(*args, &block),
+        "#{method_name} was not called on #{base_object.inspect} with #{args.inspect}"
+    end
+
+    def have_received(method_name)
+      HaveReceived.new(method_name)
+    end
+
+    class HaveReceived
+      attr_reader :method_name, :actual
+
+      def initialize(method_name)
+        @method_name = method_name
+        @with = nil
+      end
+
+      def matches?(actual)
+        @actual = actual
+        case @with
+        when Proc
+          spy.has_been_called_with?(&@with)
+        when Array
+          spy.has_been_called_with?(*@with)
+        else
+          spy.has_been_called?
+        end
+      end
+
+      def with(*args)
+        @with = block_given? ? Proc.new : args
+        self
+      end
+
+      def failure_message_for_should
+        "expected #{actual.inspect} to have received #{method_name.inspect}#{args_message}"
+      end
+
+      def failure_message_for_should_not
+        "expected #{actual.inspect} to not have received #{method_name.inspect}#{args_message}, but did"
+      end
+
+      def description
+        "to have received #{method_name.inspect}#{args_message}"
+      end
+
+      private
+
+      def args_message
+        case @with
+        when Array
+          " with #{@with.inspect}"
+        when Proc
+          " with given block"
+        end
+      end
+
+      def spy
+        @spy ||= Subroutine.get(@actual, @method_name)
+      end
+    end
+  end
+end

data/lib/spy/exceptions.rb

@@ -1,33 +1,8 @@
 module Spy
-  class Error < StandardError; end
-
-  class AlreadyStubbedError < Error
-    def to_s
-      @mesg || "Spy is already stubbed."
-    end
-  end
-
-  class AlreadyHookedError < Error
-    def to_s
-      @mesg || "Spy is already hooked."
-    end
-  end
-
-  class NotHookedError < Error
-    def to_s
-      @mesg || "Spy was not hooked."
-    end
-  end
-
-  class NeverHookedError < Error
-    def to_s
-      @mesg || "Spy was never hooked."
-    end
-  end
-
-  class NoSpyError < Error
-    def to_s
-      @mesg || "Spy could not be found"
-    end
-  end
+  Error = Class.new(StandardError)
+  AlreadyStubbedError = Class.new(Error)
+  AlreadyHookedError = Class.new(Error)
+  NotHookedError = Class.new(Error)
+  NeverHookedError = Class.new(Error)
+  NoSpyError = Class.new(Error)
 end

data/lib/spy/integration.rb

@@ -0,0 +1,42 @@
+require 'spy'
+
+module Spy
+  if defined?(::MiniTest::Unit::TestCase)
+    class MiniTestAdapter
+      include API
+      def after_teardown
+        super
+        Spy.teardown
+      end
+    end
+
+    ::MiniTest::Unit::TestCase.send(:include, MiniTestAdapter)
+  end
+
+  if defined?(::Test::Unit::TestCase) && !(defined?(::MiniTest::Unit::TestCase) && (::Test::Unit::TestCase < ::MiniTest::Unit::TestCase)) && !(defined?(::MiniTest::Spec) && (::Test::Unit::TestCase < ::MiniTest::Spec))
+
+    class TestUnitAdapter
+      include API
+      def self.included(mod)
+        mod.teardown :spy_teardown, :after => :append
+      end
+
+      def spy_teardown
+        Spy.teardown
+      end
+    end
+
+    ::Test::Unit::TestCase.send(:include, TestUnitAdapter)
+  end
+
+  class RspecAdapter
+    include API
+    def setup_mocks_for_rspec
+    end
+    def verify_mocks_for_rspec
+    end
+    def teardown_mocks_for_rspec
+      Spy.teardown
+    end
+  end
+end

data/lib/spy/mock.rb

@@ -12,35 +12,32 @@ module Spy
       Agency.instance.recruit(self)
     end
 
-    def is_a?(other)
-      self.class.ancestors.include?(other)
-    end
-
-    alias :kind_of? :is_a?
-
+    # the only method that doesn't work correctly of a mock if inherited. We
+    # overwite for compatibility.
+    # @param other [Class]
+    # @return [Boolean]
     def instance_of?(other)
       other == self.class
     end
 
+    # returns the original class method if the current method is a mock_method
+    # @param method_name [Symbol, String]
+    # @return [Method]
     def method(method_name)
       new_method = super
-      if new_method.parameters.size >= 1 &&
-        new_method.parameters.last.last == :mock_method
-
-        begin
-          _mock_class.send(:remove_method, method_name)
-          real_method = super
-        ensure
-          _mock_class.send(:define_method, method_name, new_method)
-        end
-
-        real_method
+      parameters = new_method.parameters
+      if parameters.size >= 1 && parameters.last.last == :mock_method
+        self.class.instance_method(method_name).bind(self)
       else
         new_method
       end
     end
 
     class << self
+      # This will create a new Mock class with all the instance methods of given
+      # klass mocked out.
+      # @param klass [Class]
+      # @return [Class]
       def new(klass)
         mock_klass = Class.new(klass)
         mock_klass.class_exec do
@@ -56,6 +53,8 @@ module Spy
         mock_klass
       end
 
+      private
+
       def included(mod)
         method_classes = classes_to_override_methods(mod)
 
@@ -65,13 +64,13 @@ module Spy
             mocked_methods << method_name
             args = args_for_method(mod.instance_method(method_name))
 
-            mod.class_eval <<-DEF_METHOD, __FILE__, __LINE__+1
+            mod.class_eval <<-DEF_METHOD, __FILE__, __LINE__ + 1
               def #{method_name}(#{args})
                 raise ::Spy::NeverHookedError, "'#{method_name}' was never hooked on mock spy."
               end
-
-              #{visibility} :#{method_name}
             DEF_METHOD
+
+            mod.send(visibility, method_name)
           end
         end
 
@@ -80,8 +79,6 @@ module Spy
         end
       end
 
-      private
-
       def classes_to_override_methods(mod)
         method_classes = mod.ancestors
         method_classes.shift
@@ -95,7 +92,7 @@ module Spy
 
       def get_inherited_methods(klass_ancestors, visibility)
         instance_methods = klass_ancestors.map do |klass|
-         klass.send("#{visibility}_instance_methods".to_sym, false)
+          klass.send("#{visibility}_instance_methods".to_sym, false)
         end
         instance_methods.flatten!
         instance_methods.uniq!
@@ -103,7 +100,8 @@ module Spy
       end
 
       def args_for_method(method)
-        args = method.parameters.map do |type,name|
+        args = method.parameters
+        args.map! do |type,name|
           name ||= :args
           case type
           when :req
@@ -113,7 +111,8 @@ module Spy
           when :rest
             "*#{name}"
           end
-        end.compact
+        end
+        args.compact!
         args << "&mock_method"
         args.join(",")
       end

data/lib/spy/subroutine.rb

@@ -193,9 +193,8 @@ module Spy
     # @return [Boolean]
     def has_been_called_with?(*args)
       raise NeverHookedError unless @was_hooked
-      calls.any? do |call_log|
-        call_log.args == args
-      end
+      match = block_given? ? Proc.new : proc { |call| call.args == args }
+      calls.any?(&match)
     end
 
     # invoke that the method has been called. You really shouldn't use this
@@ -331,7 +330,9 @@ module Spy
           if base_object.respond_to?(method_name, true)
             spied_method = base_object.method(method_name)
           end
-        elsif (base_object.instance_methods + base_object.private_instance_methods).include?(method_name)
+        elsif (base_object.public_instance_methods +
+               base_object.protected_instance_methods +
+               base_object.private_instance_methods).include?(method_name)
           spied_method = base_object.instance_method(method_name)
         end
 

data/lib/spy/version.rb

@@ -1,3 +1,3 @@
 module Spy
-  VERSION = "0.3.1"
+  VERSION = "0.4.0"
 end

data/test/integration/test_api.rb

@@ -0,0 +1,40 @@
+require 'test_helper'
+
+class TestApi < MiniTest::Unit::TestCase
+  include Spy::API
+
+  def setup
+    @pen = Pen.new
+    Spy.on(@pen, :write)
+  end
+
+  def test_assert_received
+    @pen.write(:hello)
+    assert_received(@pen, :write)
+  end
+
+  def test_assert_received_with
+    @pen.write(:world)
+    assert_received_with(@pen, :write, :world)
+    assert_received_with(@pen, :write) do |call|
+      call.args == [:world]
+    end
+  end
+
+  def test_have_received
+    @pen.write(:foo)
+    matcher = have_received(:write)
+    assert matcher.matches?(@pen)
+  end
+
+  def test_have_received_with
+    @pen.write(:bar)
+    matcher = have_received(:write).with(:bar)
+    assert matcher.matches?(@pen)
+
+    matcher = have_received(:write).with do |call|
+      call.args == [:bar]
+    end
+    assert matcher.matches?(@pen)
+  end
+end

data/test/spy/test_mock.rb

@@ -76,11 +76,13 @@ module Spy
       assert_equal pen_methods.sort, @pen_mock.mocked_methods.sort
     end
 
-    def test_base_class_methods_are_not_stubbed
-      (Object.instance_methods - [:tap, :pretty_print_inspect]).each do |method_name|
-        object_method = Object.instance_method(method_name)
-        if object_method.parameters == []
-          @pen.send(method_name)
+    buggy_methods = [:tap, :pretty_print_inspect]
+    methods_to_test = Object.instance_methods - buggy_methods
+    methods_to_test.each do |method_name|
+      object_method = Object.instance_method(method_name)
+      if object_method.arity == 0 || (RUBY_ENGINE != "jruby" && object_method.parameters == [])
+        define_method("test_base_class_method_#{method_name}_is_not_stubbed") do
+          @pen_mock.new.send(method_name)
         end
       end
     end

metadata

@@ -1,110 +1,97 @@
 --- !ruby/object:Gem::Specification
 name: spy
 version: !ruby/object:Gem::Version
-  version: 0.3.1
-  prerelease: 
+  version: 0.4.0
 platform: ruby
 authors:
 - Ryan Ong
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-13 00:00:00.000000000 Z
+date: 2013-05-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: pry-nav
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: 4.5.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: 4.5.0
 - !ruby/object:Gem::Dependency
   name: rspec-core
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec-expectations
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: coveralls
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 description: A simple modern mocking library that uses the spy pattern and checks
@@ -125,11 +112,13 @@ files:
 - Rakefile
 - lib/spy.rb
 - lib/spy/agency.rb
+- lib/spy/api.rb
 - lib/spy/base.rb
 - lib/spy/call_log.rb
 - lib/spy/constant.rb
 - lib/spy/core_ext/marshal.rb
 - lib/spy/exceptions.rb
+- lib/spy/integration.rb
 - lib/spy/mock.rb
 - lib/spy/nest.rb
 - lib/spy/subroutine.rb
@@ -151,6 +140,7 @@ files:
 - spec/spy/stub_spec.rb
 - spec/spy/to_ary_spec.rb
 - spy.gemspec
+- test/integration/test_api.rb
 - test/integration/test_constant_spying.rb
 - test/integration/test_instance_method.rb
 - test/integration/test_mocking.rb
@@ -162,27 +152,26 @@ files:
 homepage: https://github.com/ryanong/spy
 licenses:
 - MIT
+metadata: {}
 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.3
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 2.0.3
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Spy is a mocking library that was made for the modern age. It supports only
   1.9.3+. Spy by default will raise an error if you attempt to stub a method that
   doesn't exist or call the stubbed method with the wrong arity.
@@ -203,6 +192,7 @@ test_files:
 - spec/spy/stub_implementation_spec.rb
 - spec/spy/stub_spec.rb
 - spec/spy/to_ary_spec.rb
+- test/integration/test_api.rb
 - test/integration/test_constant_spying.rb
 - test/integration/test_instance_method.rb
 - test/integration/test_mocking.rb
@@ -211,4 +201,3 @@ test_files:
 - test/spy/test_subroutine.rb
 - test/support/pen.rb
 - test/test_helper.rb
-has_rdoc: