spy 0.2.4 → 0.2.5

data/.travis.yml

@@ -1,5 +1,11 @@
 language: ruby
 rvm:
-  - "1.9.3"
-  - "2.0.0"
+  - 1.9.3
+  - 2.0.0
   - jruby-19mode
+  - ruby-head
+  - rbx-19mode
+matrix:
+  allow_failures:
+      - rvm: ruby-head
+      - rvm: rbx-19mode

data/README.md

@@ -1,4 +1,8 @@
-# Spy [![Build Status](https://travis-ci.org/ryanong/spy.png?branch=master)](https://travis-ci.org/ryanong/spy) [![Gem Version](https://badge.fury.io/rb/spy.png)](http://badge.fury.io/rb/spy)
+# Spy
+[![Gem Version](https://badge.fury.io/rb/spy.png)](http://badge.fury.io/rb/spy)
+[![Build Status](https://travis-ci.org/ryanong/spy.png?branch=master)](https://travis-ci.org/ryanong/spy)
+[![Coverage Status](https://coveralls.io/repos/ryanong/spy/badge.png?branch=master)](https://coveralls.io/r/ryanong/spy)
+
 
 [Docs](http://rdoc.info/gems/spy/frames)
 
@@ -40,6 +44,7 @@ Fail faster, code faster.
 * #with is not supported
   * you can usually just check the call logs.
   * if you do need to use this. It is probably a code smell. You either need to abstract your method more or add separate tests.
+* you use `mock_model` and `stub_model` (I want to impliment this soon)
 
 ## Installation
 
@@ -75,7 +80,7 @@ Spy will raise an error if you try to stub on a method that doesn't exist.
 You can force the creation of a stub on method that didn't exist but it really isn't suggested.
 
 ```ruby
-Spy.new(book, :flamethrower).hook(force:true).and_return("burnninante")
+Spy::Subroutine.new(book, :flamethrower).hook(force:true).and_return("burnninante")
 ```
 
 You can also stub instance methods of Classes and Modules. This is equivalent to
@@ -176,6 +181,19 @@ In `test_helper.rb`
 ```ruby
 require "spy"
 MiniTest::TestCase.add_teardown_hook { Spy.teardown }
+
+
+class TestBook < MiniTest::Unit::TestCase
+  def test_title
+    book = book.new
+    title_spy = spy.on(book, title)
+    book.title
+    book.title
+
+    assert title_spy.has_been_called?
+    assert_equal 2, title_spy.calls.count
+  end
+end
 ```
 
 ### Rspec
@@ -189,6 +207,18 @@ RSpec.configure do |c|
   c.after { Spy.teardown  }
   c.mock_with :absolutely_nothing # this is completely optional.
 end
+
+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
 ```
 
 ### Test::Unit

data/lib/spy/agency.rb

@@ -10,7 +10,6 @@ module Spy
       clear!
     end
 
-
     # given a spy ID it will return the associated spy
     # @param id [Integer] spy object id
     # @return [Nil, Subroutine, Constant, Double]
@@ -22,11 +21,12 @@ module Spy
     # @param spy [Subroutine, Constant, Double]
     # @return [spy]
     def recruit(spy)
+      raise AlreadyStubbedError if @spies[spy.object_id]
       case spy
       when Subroutine,  Constant, Double
         @spies[spy.object_id] = spy
       else
-        raise "Not a spy"
+        raise ArgumentError, "#{spy}, was not a spy"
       end
     end
 
@@ -34,11 +34,12 @@ module Spy
     # @param spy [Subroutine, Constant, Double]
     # @return [spy]
     def retire(spy)
+      raise NoSpyError unless @spies[spy.object_id]
       case spy
       when Subroutine,  Constant, Double
         @spies.delete(spy.object_id)
       else
-        raise "Not a spy"
+        raise ArgumentError, "#{spy}, was not a spy"
       end
     end
 
@@ -50,7 +51,7 @@ module Spy
       when Subroutine,  Constant, Double
         @spies.has_key?(spy.object_id)
       else
-        raise "Not a spy"
+        raise ArgumentError, "#{spy}, was not a spy"
       end
     end
 

data/lib/spy/constant.rb

@@ -16,8 +16,8 @@ module Spy
     # @param base_module [Module] the module this spy should be on
     # @param constant_name [Symbol] the constant this spy is watching
     def initialize(base_module, constant_name)
-      raise "#{base_module.inspect} is not a kind of Module" unless base_module.is_a? Module
-      raise "#{constant_name.inspect} is not a kind of Symbol" unless constant_name.is_a? Symbol
+      raise ArgumentError, "#{base_module.inspect} is not a kind of Module" unless base_module.is_a? Module
+      raise ArgumentError, "#{constant_name.inspect} is not a kind of Symbol" unless constant_name.is_a? Symbol
       @base_module, @constant_name = base_module, constant_name.to_sym
       @original_value = @new_value = @previously_defined = nil
     end
@@ -97,7 +97,7 @@ module Spy
     end
 
     class << self
-      # creates a new constant spy and hooks the constant
+      # finds existing spy or creates a new constant spy and hooks the constant
       # @return [Constant]
       def on(base_module, constant_name)
         new(base_module, constant_name).hook
@@ -107,7 +107,9 @@ module Spy
       # from the module
       # @return [Constant]
       def off(base_module, constant_name)
-        get(base_module, constant_name).unhook
+        spy = get(base_module, constant_name)
+        raise NoSpyError, "#{constant_name} was not spied on #{base_module}" unless spy
+        spy.unhook
       end
 
       # retrieves the spy for given constnat and module or returns nil
@@ -115,7 +117,7 @@ module Spy
       def get(base_module, constant_name)
         nest = Nest.get(base_module)
         if nest
-          nest.hooked_constants[constant_name]
+          nest.get(constant_name)
         end
       end
     end

data/lib/spy/exceptions.rb

@@ -0,0 +1,33 @@
+module Spy
+  class Error < StandardError; end
+
+  class AlreadyStubbedError < Error
+    def message
+      "Spy is already stubbed."
+    end
+  end
+
+  class AlreadyHookedError < Error
+    def message
+      "Spy is already hooked."
+    end
+  end
+
+  class NotHookedError < Error
+    def message
+      "Spy was not hooked."
+    end
+  end
+
+  class NeverHookedError < Error
+    def message
+      "Spy was never hooked."
+    end
+  end
+
+  class NoSpyError < Error
+    def message
+      "Spy could not be found"
+    end
+  end
+end

data/lib/spy/nest.rb

@@ -5,26 +5,26 @@ module Spy
     # @!attribute [r] base_module
     #   @return [Module] The module that the Nest is managing
     #
-    # @!attribute [r] hooked_constants
+    # @!attribute [r] constant_spies
     #   @return [Hash<Symbol, Constant>] The module that the Nest is managing
 
 
-    attr_reader :base_module, :hooked_constants
+    attr_reader :base_module
 
     def initialize(base_module)
-      raise "#{base_module} is not a kind of Module" unless base_module.is_a?(Module)
+      raise ArgumentError, "#{base_module} is not a kind of Module" unless base_module.is_a?(Module)
       @base_module = base_module
-      @hooked_constants = {}
+      @constant_spies = {}
     end
 
     # records that the spy is hooked
     # @param spy [Constant]
     # @return [self]
     def add(spy)
-      if @hooked_constants[spy.constant_name]
-        raise "#{spy.constant_name} has already been stubbed"
+      if @constant_spies[spy.constant_name]
+        raise AlreadyStubbedError, "#{spy.constant_name} has already been stubbed"
       else
-        @hooked_constants[spy.constant_name] = spy
+        @constant_spies[spy.constant_name] = spy
       end
       self
     end
@@ -33,19 +33,32 @@ module Spy
     # @param spy [Constant]
     # @return [self]
     def remove(spy)
-      if @hooked_constants[spy.constant_name] == spy
-        @hooked_constants.delete(spy.constant_name)
+      if @constant_spies[spy.constant_name] == spy
+        @constant_spies.delete(spy.constant_name)
       else
-        raise "#{spy.constant_name} was never added"
+        raise NoSpyError, "#{spy.constant_name} was not stubbed on #{base_module.name}"
       end
       self
     end
 
+    # returns a spy if the constant was added
+    # @param constant_name [Symbol]
+    # @return [Constant, nil]
+    def get(constant_name)
+      @constant_spies[constant_name]
+    end
+
     # checks to see if a given constant is hooked
     # @param constant_name [Symbol]
     # @return [Boolean]
     def hooked?(constant_name)
-      !!@hooked_constants[constant_name]
+      !!get(constant_name)
+    end
+
+    # list all the constants that are being stubbed
+    # @return [Array]
+    def hooked_constants
+      @constant_spies.keys
     end
 
     class << self
@@ -56,7 +69,6 @@ module Spy
         all[base_module.name]
       end
 
-
       # retrieves the nest for a given module or creates it
       # @param base_module [Module]
       # @return [Nest]

data/lib/spy/subroutine.rb

@@ -40,7 +40,7 @@ module Spy
     # @option opts [Symbol<:public, :protected, :private>] visibility overrides visibility with whatever method is given
     # @return [self]
     def hook(opts = {})
-      raise "#{base_object} method '#{method_name}' has already been hooked" if hooked?
+      raise AlreadyHookedError, "#{base_object} method '#{method_name}' has already been hooked" if self.class.get(base_object, method_name, singleton_method)
 
       @hook_opts = opts
       @original_method_visibility = method_visibility_of(method_name)
@@ -66,7 +66,7 @@ module Spy
     # unhooks method from object
     # @return [self]
     def unhook
-      raise "'#{method_name}' method has not been hooked" unless hooked?
+      raise NeverHookedError, "'#{method_name}' method has not been hooked" unless hooked?
 
       if original_method && method_owner == original_method.owner
         method_owner.send(:define_method, method_name, original_method)
@@ -111,7 +111,7 @@ module Spy
         if value.is_a?(Hash) && value.has_key?(:force)
           @do_not_check_plan_arity = !!value[:force]
         elsif !value.nil?
-          raise ArgumentError.new("value and block conflict. Choose one")
+          raise ArgumentError, "value and block conflict. Choose one"
         end
 
         @plan = Proc.new
@@ -184,7 +184,7 @@ module Spy
     # if the method was called it will return true
     # @return [Boolean]
     def has_been_called?
-      raise "was never hooked" unless @was_hooked
+      raise NeverHookedError unless @was_hooked
       calls.size > 0
     end
 
@@ -192,7 +192,7 @@ module Spy
     # @param args Arguments that should have been sent to the method
     # @return [Boolean]
     def has_been_called_with?(*args)
-      raise "was never hooked" unless @was_hooked
+      raise NeverHookedError unless @was_hooked
       calls.any? do |call_log|
         call_log.args == args
       end
@@ -305,7 +305,23 @@ module Spy
     end
 
     class << self
-      # retrieve the method spy from an object
+
+      # retrieve the method spy from an object or create a new one
+      # @param base_object
+      # @param method_name [Symbol]
+      # @param singleton_method [Boolean] this a singleton method or a instance method?
+      # @return [Array<Subroutine>]
+      def on(base_object, method_name, singleton_method = true)
+        new(base_object, method_name, singleton_method).hook
+      end
+
+      def off(base_object, method_name, singleton_method = true)
+        spy = get(base_object, method_name, singleton_method = true)
+        raise NoSpyError, "#{method_name} was not spied on #{base_object}" unless spy
+        spy.unhook
+      end
+
+      # retrieve the method spy from an object or return nil
       # @param base_object
       # @param method_name [Symbol]
       # @param singleton_method [Boolean] this a singleton method or a instance method?

data/lib/spy/version.rb

@@ -1,3 +1,3 @@
 module Spy
-  VERSION = "0.2.4"
+  VERSION = "0.2.5"
 end

data/lib/spy.rb

@@ -3,6 +3,7 @@ require "spy/agency"
 require "spy/call_log"
 require "spy/constant"
 require "spy/double"
+require "spy/exceptions"
 require "spy/nest"
 require "spy/subroutine"
 require "spy/version"
@@ -32,7 +33,7 @@ module Spy
         if spy
           spy.unhook
         else
-          raise "#{spy.inspect} was not found to be hooked"
+          raise NoSpyError, "#{method_name} was not hooked on #{base_object.inspect}."
         end
       end
 
@@ -54,7 +55,7 @@ module Spy
         if spy
           spy.unhook
         else
-          raise "#{spy.inspect} was not found to be hooked"
+          raise NoSpyError, "#{method_name} was not hooked on #{base_object.inspect}."
         end
       end
 
@@ -79,7 +80,7 @@ module Spy
             Constant.on(base_module, name).and_return(result)
           end
         else
-          raise ArgumentError.new "#{constant_name.class} is an invalid input, #on only accepts Symbol, and Hash"
+          raise ArgumentError, "#{constant_name.class} is an invalid input, #on only accepts Symbol, and Hash"
         end
       end.flatten
 
@@ -98,7 +99,7 @@ module Spy
 
       spies = constant_names.map do |constant_name|
         unless constant_name.is_a?(Symbol)
-          raise ArgumentError.new "#{constant_name.class} is an invalid input, #on only accepts Symbol, and Hash"
+          raise ArgumentError, "#{constant_name.class} is an invalid input, #on only accepts Symbol, and Hash"
         end
         Constant.off(base_module, constant_name)
       end
@@ -148,16 +149,16 @@ module Spy
 
     private
 
-    def create_and_hook_spy(base_object, method_name, singleton_method = true, hook_opts = {})
+    def create_and_hook_spy(base_object, method_name, singleton_method = true)
       case method_name
       when String, Symbol
-        Subroutine.new(base_object, method_name, singleton_method).hook(hook_opts)
+        Subroutine.on(base_object, method_name, singleton_method)
       when Hash
         method_name.map do |name, result|
-          create_and_hook_spy(base_object, name, singleton_method, hook_opts).and_return(result)
+          Subroutine.on(base_object, name, singleton_method).and_return(result)
         end
       else
-        raise ArgumentError.new "#{method_name.class} is an invalid input, #on only accepts String, Symbol, and Hash"
+        raise ArgumentError, "#{method_name.class} is an invalid input, #on only accepts String, Symbol, and Hash"
       end
     end
   end

data/spec/spy/any_instance_spec.rb

@@ -444,7 +444,7 @@ module Spy
 
     context 'when used in conjunction with a `dup`' do
       it "doesn't cause an infinite loop" do
-        Object.any_instance.stub(:some_method)
+        Spy::Subroutine.new(Object, :some_method, false).hook(force: true)
         o = Object.new
         o.some_method
         expect { o.dup.some_method }.to_not raise_error(SystemStackError)
@@ -454,7 +454,7 @@ module Spy
         klass = Class.new do
           undef_method :dup
         end
-        klass.any_instance
+        Spy::Subroutine.new(Object, :some_method, false).hook(force: true)
       end
 
       it "doesn't fail when dup accepts parameters" do
@@ -463,7 +463,7 @@ module Spy
           end
         end
 
-        klass.any_instance
+        Spy::Subroutine.new(Object, :some_method, false).hook(force: true)
 
         expect { klass.new.dup('Dup dup dup') }.to_not raise_error(ArgumentError)
       end

data/spy.gemspec

@@ -23,4 +23,5 @@ Gem::Specification.new do |gem|
   gem.add_development_dependency('minitest', '>= 4.5.0')
   gem.add_development_dependency('rspec-core')
   gem.add_development_dependency('rspec-expectations')
+  gem.add_development_dependency('coveralls')
 end

data/test/spy/test_subroutine.rb

@@ -226,8 +226,15 @@ module Spy
     def test_spy_get_can_retrieve_a_spy
       pen_write_spy = spy_on(@pen, :write).and_return(:hello)
       assert_equal :hello, @pen.write(:world)
-      assert_equal pen_write_spy, Subroutine.get(@pen, :write)
       assert Subroutine.get(@pen, :write).has_been_called?
+      assert_same pen_write_spy, Subroutine.get(@pen, :write)
+    end
+
+    def test_spy_hook_raises_an_error_on_an_already_hooked_method
+      spy_on(@pen, :write)
+      assert_raises AlreadyHookedError do
+        spy_on(@pen, :write)
+      end
     end
   end
 end

data/test/test_helper.rb

@@ -2,6 +2,8 @@ require 'bundler/setup'
 require 'minitest/autorun'
 require 'pry'
 require 'pry-nav'
+require 'coveralls'
+Coveralls.wear!
 
 require 'spy'
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: spy
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.2.5
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-02-28 00:00:00.000000000 Z
+date: 2013-03-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pry
@@ -91,6 +91,22 @@ dependencies:
     - - ! '>='
       - !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
   method's existence and arity.
 email:
@@ -112,6 +128,7 @@ files:
 - lib/spy/constant.rb
 - lib/spy/core_ext/marshal.rb
 - lib/spy/double.rb
+- lib/spy/exceptions.rb
 - lib/spy/nest.rb
 - lib/spy/subroutine.rb
 - lib/spy/version.rb