crispy 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a5a304875b84ee789d83ba6420f4b57a2cd769d3
-  data.tar.gz: 50dddf1394a740c51c7a15dbfd5d4bd3227388b8
+  metadata.gz: 906a71958302bc1652930a6e9f1c5aa237eaa233
+  data.tar.gz: 27951041fba2e5b62fb3d78d3b26311455ac5863
 SHA512:
-  metadata.gz: 469caadde79084134b26358634de2830d156233e938b4ad2c1a21dd6653d0bd50d019530e6c5ad80bcf9b5e59526b135572bc8939b5d160b2f4a3f10129d79d8
-  data.tar.gz: 902018025f544c073758117e5072896cb7dbf5b6cbc2a41f52b6116036a485a24ff23090e36718d94fdabe0ca7b9a27c21fa18db2bf61be6e255247029c2c58d
+  metadata.gz: 569d2a0881f1f684974e70ed3e50c11d73038d1b07a29964521d6d50e6beaad11e3943e2b53455d9140707cc635f5b0e617fd4907608a919c59f990b833695c7
+  data.tar.gz: 4b8dee5f09c25f3494b22ce3cf9a2f511489fb8d1ef70d430abf8e6b9eae99ae1aadb0c2add730c6037bdc32cbf41032a09f19b42912eb247780d05a5e0ba334

data/.travis.yml

@@ -4,8 +4,8 @@ install:
   - bundle
 rvm:
   - ruby-head
-  - 2.2.0-preview1
-  - 2.1.3
+  - 2.2.0
+  - 2.1.5
   - 2.0.0
 script:
   - CODECLIMATE_REPO_TOKEN=fe75ea4329c1e131ef79de66f8ba2f605fa2fd352bbbd61fed5024cb6eaaba73 bundle exec rubydoctest README.md
@@ -22,4 +22,3 @@ addons:
 matrix:
   allow_failures:
     - rvm: ruby-head
-    - rvm: 2.2.0-preview1

data/ChangeLog.md

@@ -1,3 +1,14 @@
+# 0.3.0 (2014.12.31)
+
+- New Feature: Add stub feature to `ClassSpy`. [#23](https://github.com/igrep/crispy/pull/23)
+- New Feature: Now double is automatically spied without `spy_into`. [#21](https://github.com/igrep/crispy/pull/21)
+- Fix Bug: now `spy_into` replaces all stubber's methods with given stub spec when reinitialize a spy.[0f91579decbe27e6b05bec4b779dd1c3ede24380](https://github.com/igrep/crispy/commit/0f91579decbe27e6b05bec4b779dd1c3ede24380)
+- Fix Bug: reset spy log when `spy_into`-ing an already spied object. e.g. Class.[#20](https://github.com/igrep/crispy/pull/20)
+- New Feature: `spied?`. [#18](https://github.com/igrep/crispy/pull/18)
+- Refactor many internal classes and tests. [#21](https://github.com/igrep/crispy/pull/21) [#22](https://github.com/igrep/crispy/pull/22) [#23](https://github.com/igrep/crispy/pull/23) [#24](https://github.com/igrep/crispy/pull/24)
+- Loose required minitest's version.
+- Minor document enhancements.
+
 # 0.2.0 (2014.11.1)
 
 - New Feature: `stub_const`. [#11](https://github.com/igrep/crispy/pull/11)

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2014 Yamamoto Yuji
+Copyright (c) 2014 Yuji Yamamoto
 
 MIT License
 

data/README.md

@@ -9,7 +9,7 @@ Test Spy for Any Object in Ruby.
 
 ## Features
 
-- Test spy for any object by using `prepend` (Sorry, it runs by Ruby 2.0 or higher!)
+- Test spy for **ANY** object by using `prepend` (Sorry, it runs by Ruby 2.0 or higher!)
 - Extremely flexible query for received messages with `received_messages` method.
     - By using Array and Enumerable's methods, you never have to remember the complex API and tons of the argument matchers in RSpec anymore!
 - Makes mocks obsolete so you don't have to be worried about where to put the expectations (i.e. *before or after the subject method*).
@@ -42,8 +42,9 @@ doctest_require: './test/doctest-fixtures/your_cool_class.rb'
 >> include Crispy # import spy, spy_into and any other functions from Crispy namespace.
 
 >> object = YourCoolClass.new
->> spy = spy_into object
+>> spy_into object # sneak into your object to spy.
 
+# Use your object as usual.
 >> object.your_cool_method 1, 2, 3
 >> object.your_method_without_argument
 >> object.your_lovely_method 'great', 'arguments'
@@ -101,7 +102,7 @@ Each argument is compared by `==` method.
 #### Get more detailed log
 
 You can check arbitrary received methods with the familliar Array's (and of course including Enumerable's!) methods such as `any?`, `all`, `first`, `[]`, `index`.
-Because `spy(object).received_messages` returns an array of `CrispyReceivedMessage` instances.
+Because `spy(object).received_messages` returns an array of `CrispyReceivedMessage` instances.  
 **You don't have to remember the tons of matchers for received arguments any more!!**
 
 ```ruby
@@ -118,6 +119,31 @@ Because `spy(object).received_messages` returns an array of `CrispyReceivedMessa
 => true
 ```
 
+### Stub Methods of a Spy
+
+```ruby
+>> spy(object).stub(:your_cool_method, 'Awesome!')
+>> object.your_cool_method
+=> "Awesome!"
+
+>> spy(object).stub(your_lovely_method: 'I love this method!', your_finalizer: 'Finalized!')
+>> object.your_lovely_method
+=> "I love this method!"
+>> object.your_finalizer
+=> "Finalized!"
+```
+
+Of cource stubbed methods are spied as well.
+
+```ruby
+>> spy(object).received? :your_cool_method
+=> true
+
+# `spy(object)` keeps its spied log of a method even after stubbing the method.
+>> spy(object).count_received :your_lovely_method
+=> 3
+```
+
 ### Spy on Instances of a Class
 
 ```ruby
@@ -161,7 +187,7 @@ In addition, you can check which instance calles a method as well as its argumen
 => true
 ```
 
-Note that `spy_of_instances` stops to spy after called methods with `with_receiver` (or `with_receiver?`) prefix.
+Note that `spy_of_instances` stops spying after called methods with `with_receiver` (or `with_receiver?`) prefix.
 This is to prevent the spy from unexpectedly logging methods used to compare its receiver (such as `==`).
 
 ```ruby
@@ -175,35 +201,36 @@ This is to prevent the spy from unexpectedly logging methods used to compare its
 >> # Perhaps you don't want to log methods in test code.
 >> instance.some_method_for_testing
 >> spy_of_instances(YourCoolClass::Again).received? :some_method_for_testing
->> false
+=> false
 ```
 
 If you want to restart spying, use `restart` method literally.
 
 ```ruby
->> spy_into_instances(YourCoolClass::Again).restart
+>> spy_of_instances(YourCoolClass::Again).restart
 
 >> instance.some_method_for_testing
 >> spy_of_instances(YourCoolClass::Again).received? :some_method_for_testing
->> true
+=> true
 ```
 
-### Stub Methods of a Spy
+### Stub Methods of Instances of a Class
 
 ```ruby
->> spy(object).stub(:your_cool_method, 'Awesome!')
->> object.your_cool_method
-=> "Awesome!"
+>> spy_of_instances(YourCoolClass).stub(your_lovely_method: 'Even more lovely!', your_cool_method: 'much cooler!')
 
->> spy(object).stub(your_lovely_method: 'I love this method!', your_finalizer: 'Finalized!')
->> object.your_lovely_method
-=> "I love this method!"
->> object.your_finalizer
-=> "Finalized!"
+>> instance1.your_lovely_method
+=> "Even more lovely!"
+>> instance2.your_cool_method
+=> "much cooler!"
 ```
 
 ### Stub Methods of a Double
 
+Double can call Spy's method directly.
+You do NOT need to write code such as `spy(your_double).stub(...)`.  
+Just `your_double.stub(...)`.
+
 ```ruby
 >> your_awesome_double = double('your awesome double', nice!: '+1!', sexy?: true)
 >> your_awesome_double.nice!
@@ -216,6 +243,18 @@ If you want to restart spying, use `restart` method literally.
 => "can be stubbed."
 ```
 
+### Spy on a Double
+
+A double is spied without `spy_into`-ing.  
+And as `double.stub(...)`, Double can also call Spy's method such as `received?`
+
+```ruby
+>> your_awesome_double.received? :nice!
+=> true
+>> your_awesome_double.count_received :another_method
+=> 1
+```
+
 ### Stub Constants
 
 Specify the **fully qualified name of the constant** instead of the constant itself.

data/crispy.gemspec

@@ -22,7 +22,7 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "bundler", "~> 1.7"
   spec.add_development_dependency "rake"
-  spec.add_development_dependency "minitest", "~> 5.4"
+  spec.add_development_dependency "minitest", "~> 5"
   spec.add_development_dependency "pry"
   spec.add_development_dependency "byebug"
   spec.add_development_dependency "rubydoctest"

data/lib/crispy/crispy_internal/class_spy.rb

@@ -1,29 +1,26 @@
 require 'crispy/crispy_received_message_with_receiver'
-require 'crispy/crispy_internal/spy_mixin'
-require 'crispy/crispy_internal/with_stubber'
+require 'crispy/crispy_internal/spy_base'
 
 module Crispy
   module CrispyInternal
-    class ClassSpy < ::Module
-      include SpyMixin
-      #include WithStubber
+    class ClassSpy < SpyBase
 
       @registry = {}
 
-      def initialize klass#, stubs_map = {}
-        spy = self
-        super() do
-          define_method(:__CRISPY_CLASS_SPY__) { spy }
-        end
-
+      def initialize klass, stubs_map = {}
         @received_messages_with_receiver = []
-        initialize_spy
 
-        #initialize_stubber stubs_map
-        #prepend_stubber klass
+        super
 
-        prepend_features klass
-        self.class.register spy: spy, of_class: klass
+        self.class.register spy: self, of_class: klass
+      end
+
+      def self.of_target klass
+        @registry[klass]
+      end
+
+      def target_to_class target_class
+        target_class
       end
 
       def received_messages
@@ -63,42 +60,16 @@ module Crispy
         @received_messages_with_receiver.clear
       end
 
-      def append_received_message_with_receiver receiver, method_name, *arguments, &attached_block
-        if @spying
-          @received_messages_with_receiver <<
-            ::Crispy::CrispyReceivedMessageWithReceiver.new(receiver, method_name, *arguments, &attached_block)
-        end
-      end
-
-      def define_wrapper method_name
-        define_method method_name do|*arguments, &attached_block|
-          __CRISPY_CLASS_SPY__.append_received_message_with_receiver self, method_name, *arguments, &attached_block
-
-          super(*arguments, &attached_block)
-        end
-        method_name
-      end
-      private :define_wrapper
-
-      def self.new klass#, stubs_map = {}
-        spy = self.of_class(klass)
-        if spy
-          spy.restart
-          spy.erase_log
-          spy
-        else
-          super
-        end
+      def append_received_message receiver, method_name, *arguments, &attached_block
+        @received_messages_with_receiver <<
+          ::Crispy::CrispyReceivedMessageWithReceiver.new(receiver, method_name, *arguments, &attached_block)
       end
+      private :append_received_message
 
       def self.register(spy: nil, of_class: nil)
         @registry[of_class] = spy
       end
 
-      def self.of_class(klass)
-        @registry[klass]
-      end
-
     end
   end
 end

data/lib/crispy/crispy_internal/double.rb

@@ -1,23 +1,31 @@
-require 'crispy/crispy_internal/with_stubber'
-
 module Crispy
   module CrispyInternal
     class Double
-      include WithStubber
 
       def initialize name_or_stubs_map = nil, stubs_map = {}
         if name_or_stubs_map.is_a? ::Hash
           @name = ''.freeze
-          initialize_stubber(name_or_stubs_map)
+          @spy = ::Crispy.spy_into(self, name_or_stubs_map)
         else
           @name = name_or_stubs_map
-          initialize_stubber(stubs_map)
+          @spy = ::Crispy.spy_into(self, stubs_map)
         end
-        singleton_class =
-          class << self
-            self
+      end
+
+      def stub *arguments, &definition
+        @spy.stub(*arguments, &definition)
+      end
+
+      def received_messages
+        @spy.received_messages
+      end
+
+      SpyBase::COMMON_RECEIVED_MESSAGE_METHODS_DEFINITION.each_key do|method_name|
+        binding.eval(<<-END, __FILE__, (__LINE__ + 1))
+          def #{method_name} received_method_name, *received_arguments, &received_block
+            @spy.#{method_name} received_method_name, *received_arguments, &received_block
           end
-        prepend_stubber singleton_class
+        END
       end
 
     end

data/lib/crispy/crispy_internal/spy.rb

@@ -1,54 +1,41 @@
 require 'crispy/crispy_received_message'
-require 'crispy/crispy_internal/spy_mixin'
-require 'crispy/crispy_internal/with_stubber'
+require 'crispy/crispy_internal/spy_base'
 
 module Crispy
   module CrispyInternal
-    class Spy < ::Module
-      include SpyMixin
-      include WithStubber
+    class Spy < SpyBase
 
       attr_reader :received_messages
 
       def initialize target, stubs_map = {}
-        super() do
-          spy = self
+        spy = self
+        module_eval do
           define_method(:__CRISPY_SPY__) { spy }
         end
 
         @received_messages = []
-        initialize_spy
-
-        singleton_class =
-          class << target
-            self
-          end
-        initialize_stubber stubs_map
-        prepend_stubber singleton_class
+        super
+      end
 
-        prepend_features singleton_class
+      def target_to_class target
+        class << target
+          self
+        end
       end
 
       def erase_log
         @received_messages.clear
       end
 
-      def append_received_message method_name, *arguments, &attached_block
-        if @spying
-          @received_messages <<
-            ::Crispy::CrispyReceivedMessage.new(method_name, *arguments, &attached_block)
-        end
+      def self.of_target target
+        (defined? target.__CRISPY_SPY__) && target.__CRISPY_SPY__
       end
 
-      def define_wrapper method_name
-        define_method method_name do|*arguments, &attached_block|
-          __CRISPY_SPY__.append_received_message(method_name, *arguments, &attached_block)
-
-          super(*arguments, &attached_block)
-        end
-        method_name
+      def append_received_message receiver, method_name, *arguments, &attached_block
+        @received_messages <<
+          ::Crispy::CrispyReceivedMessage.new(method_name, *arguments, &attached_block)
       end
-      private :define_wrapper
+      private :append_received_message
 
     end
   end

data/lib/crispy/crispy_internal/spy_base.rb

@@ -0,0 +1,157 @@
+require 'crispy/crispy_received_message'
+
+module Crispy
+  module CrispyInternal
+    class SpyBase < ::Module
+
+      public :remove_method
+
+      BLACK_LISTED_METHODS = [
+        :__CRISPY_SPY__,
+      ]
+
+      def initialize target, stubs_map = {}
+        prepend_features target_to_class(target)
+
+        @stubbed_methods = []
+        stub stubs_map
+
+        @spying = true
+      end
+
+      def self.new target, stubs_map = {}
+        spy = self.of_target(target)
+        if spy
+          spy.restart
+          spy.erase_log
+          spy.reinitialize_stubber stubs_map
+          spy
+        else
+          super
+        end
+      end
+
+      def self.of_target target
+        raise NotImplementedError
+      end
+
+      def target_to_class target
+        raise NotImplementedError
+      end
+
+      def received_messages
+        raise NotImplementedError
+      end
+
+      def erase_log
+        raise NotImplementedError
+      end
+
+      def append_received_message receiver, method_name, *arguments, &attached_block
+        raise NotImplementedError
+      end
+
+      def stop
+        @spying = false
+      end
+
+      def restart
+        @spying = true
+      end
+
+      def define_wrapper method_name
+        spy = self
+        define_method method_name do|*arguments, &attached_block|
+          spy.append_received_message_when_spying(self, method_name, *arguments, &attached_block)
+
+          super(*arguments, &attached_block)
+        end
+        method_name
+      end
+      private :define_wrapper
+
+      def append_received_message_when_spying receiver, method_name, *arguments, &attached_block
+        if @spying
+          append_received_message receiver, method_name, *arguments, &attached_block
+        end
+      end
+
+      COMMON_RECEIVED_MESSAGE_METHODS_DEFINITION = {
+        'received?'      => 'include? %s',
+        'received_once?' => 'one? {|self_thing| self_thing == %s }',
+        'count_received' => 'count %s',
+      }
+
+      COMMON_RECEIVED_MESSAGE_METHODS_DEFINITION.each do|method_name, core_definition|
+        binding.eval(<<-END, __FILE__, (__LINE__ + 1))
+          def #{method_name} received_method_name, *received_arguments, &received_block
+            assert_symbol! received_method_name
+            if received_arguments.empty? and received_block.nil?
+              received_messages.map(&:method_name).#{sprintf(core_definition, 'received_method_name')}
+            else
+              received_message = ::Crispy::CrispyReceivedMessage.new(
+                received_method_name, *received_arguments, &received_block
+              )
+              received_messages.#{sprintf(core_definition, 'received_message')}
+            end
+          end
+        END
+      end
+
+      def stub method_name_or_hash, returned_value = nil, &definition
+        case method_name_or_hash
+        when Hash
+          hash = method_name_or_hash
+          hash.each do|method_name, value|
+            stub method_name, value
+          end
+        when ::Symbol, ::String
+          @stubbed_methods << method_name_or_hash
+
+          self.module_exec method_name_or_hash do|method_name|
+            spy = self
+
+            # remove methods already defined (maybe by define_wrapper) to avoid warning.
+            remove_method method_name if public_method_defined? method_name
+
+            # TODO: should not ignore arguments?
+            define_method(method_name) do|*arguments, &block|
+              spy.append_received_message_when_spying self, method_name, *arguments, &block
+              returned_value
+            end
+          end
+        end
+        self
+      end
+
+      def reinitialize_stubber stubs_map = {}
+        remove_method(*@stubbed_methods)
+        @stubbed_methods.clear
+        stub stubs_map
+      end
+
+      def prepend_features klass
+        super
+
+        klass.public_instance_methods.each do|method_name|
+          next if method_name == :__CRISPY_SPY__
+          self.module_eval { define_wrapper(method_name) }
+        end
+        klass.protected_instance_methods.each do|method_name|
+          self.module_eval { protected define_wrapper(method_name) }
+        end
+        klass.private_instance_methods.each do|method_name|
+          self.module_eval { private define_wrapper(method_name) }
+        end
+      end
+      private :prepend_features
+
+      def assert_symbol! maybe_symbol
+        unless maybe_symbol.respond_to?(:to_sym) && maybe_symbol.to_sym.instance_of?(::Symbol)
+          raise TypeError, "TypeError: no implicit conversion from #{maybe_symbol.inspect} to symbol"
+        end
+      end
+
+    end
+  end
+end

data/lib/crispy/crispy_received_message.rb

@@ -17,14 +17,14 @@ module Crispy
 
     def == other
       @method_name == other.method_name &&
-      @arguments == other.arguments &&
-      @attached_block == other.attached_block
+      @arguments == other.arguments # &&
+      # @attached_block == other.attached_block
     end
 
     CLASS_NAME = self.name
 
     def to_s
-      "#<#{CLASS_NAME}[#{(@method_name).inspect}, *#{@arguments.inspect}]>"
+      "#<#{CLASS_NAME}[#{@method_name.inspect}, *#{@arguments.inspect}]>"
     end
 
     alias inspect to_s

data/lib/crispy/version.rb

@@ -1,3 +1,3 @@
 module Crispy
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

data/lib/crispy.rb

@@ -18,8 +18,8 @@ module Crispy
   end
 
   # Make and returns a Crispy::ClassSpy's instance to spy all instances of a class.
-  def spy_into_instances klass#, stubs_map = {}
-    ::Crispy::CrispyInternal::ClassSpy.new klass
+  def spy_into_instances klass, stubs_map = {}
+    ::Crispy::CrispyInternal::ClassSpy.new klass, stubs_map
   end
 
   def spy object
@@ -27,7 +27,7 @@ module Crispy
   end
 
   def spy_of_instances klass
-    ::Crispy::CrispyInternal::ClassSpy.of_class(klass)
+    ::Crispy::CrispyInternal::ClassSpy.of_target(klass)
   end
 
   def stub_const full_const_name, value
@@ -35,4 +35,8 @@ module Crispy
     ::Crispy::CrispyInternal::ConstChanger.save full_const_name, saved_value
   end
 
+  def spied? object
+    defined? object.__CRISPY_SPY__
+  end
+
 end

data/test/test_crispy.rb

@@ -7,6 +7,20 @@ require 'minitest/autorun'
 class TestCrispy < MiniTest::Test
   include ::Crispy
 
+  module CommonSpyTests
+
+    def test_spy_is_also_returned_by_spy_into_method
+      assert_same @subject, @returned_spy
+    end
+
+    def test_spy_raises_error_given_non_symbol_as_method_name
+      assert_raises(::TypeError){ @subject.received?(nil) }
+      assert_raises(::TypeError){ @subject.received_once?(nil) }
+      assert_raises(::TypeError){ @subject.count_received(nil) }
+    end
+
+  end
+
   # Inherit BasicObject because it has fewer meta-programming methods than Object
   class ObjectClass < BasicObject
 
@@ -25,10 +39,13 @@ class TestCrispy < MiniTest::Test
     def baz
     end
     def method_to_stub1
-      fail "Not stubbed actually! The test fails."
+      'method to stub 1 (before stubbed)'
     end
     def method_to_stub2
-      fail "Not stubbed actually! The test fails."
+      'method to stub 2 (before stubbed)'
+    end
+    def method_to_stub3
+      'method to stub 3 (before stubbed)'
     end
 
     def private_foo a
@@ -36,6 +53,43 @@ class TestCrispy < MiniTest::Test
     end
     private :private_foo
 
+    def self.hoge a, b, c
+      private_foo a
+      [a, b, c]
+    end
+    def self.foo
+      123
+    end
+
+    def self.stubbed_method1
+      'before stubbed 1'
+    end
+    def self.stubbed_method2
+      'before stubbed 2'
+    end
+    def self.stubbed_method3
+      'before stubbed 3'
+    end
+
+    def self.private_foo a
+      :private_foo
+    end
+    private_class_method :private_foo
+
+  end
+
+  class TestCrispySpied < TestCrispy
+
+    def test_spied_object_is_spied
+      spied_object = Object.new
+      spy_into spied_object
+      assert spied?(spied_object)
+    end
+
+    def test_non_spied_object_is_not_spied
+      assert not(spied?(Object.new))
+    end
+
   end
 
   class TestCrispyStubConst < TestCrispy
@@ -58,6 +112,7 @@ class TestCrispy < MiniTest::Test
   end
 
   class TestCrispySpyInto < TestCrispy
+    include CommonSpyTests
 
     def setup
       @object = ObjectClass.new
@@ -134,14 +189,41 @@ class TestCrispy < MiniTest::Test
       assert_equal(:stubbed2, @object.method_to_stub2)
     end
 
-    def test_spy_is_also_returned_by_spy_into_method
-      assert_same @subject, @returned_spy
+  end
+
+  class TestCrispySpyIntoClass < TestCrispy
+
+    def setup
+      spy_into ObjectClass, stubbed_method1: 1, stubbed_method2: 2
+
+      ObjectClass.hoge 1, 2, 3
+      ObjectClass.foo
+      ObjectClass.hoge 3, 4, 5
+
+      @subject = spy(ObjectClass)
     end
 
-    def test_spy_raises_error_given_non_symbol_as_method_name
-      assert_raises(::TypeError){ @subject.received_once?(nil) }
-      assert_raises(::TypeError){ @subject.received_once?(nil) }
-      assert_raises(::TypeError){ @subject.count_received(nil) }
+    def test_spy_logs_received_messages_not_twice_by_spy_into_twice
+      setup
+
+      assert_equal(
+        [
+          CrispyReceivedMessage[:hoge, 1, 2, 3],
+          CrispyReceivedMessage[:private_foo, 1],
+          CrispyReceivedMessage[:foo],
+          CrispyReceivedMessage[:hoge, 3, 4, 5],
+          CrispyReceivedMessage[:private_foo, 3],
+        ],
+        @subject.received_messages
+      )
+    end
+
+    def test_spy_overrides_stubbed_methods
+      spy_into ObjectClass, stubbed_method2: 'xx', stubbed_method3: 'xxx'
+
+      assert_equal 'before stubbed 1', ObjectClass.stubbed_method1
+      assert_equal 'xx'              , ObjectClass.stubbed_method2
+      assert_equal 'xxx'             , ObjectClass.stubbed_method3
     end
 
   end
@@ -154,7 +236,7 @@ class TestCrispy < MiniTest::Test
 
     def setup
       @returned_spy = spy_into_instances(
-        object_class#, method_to_stub1: :stubbed_instance_method1, method_to_stub2: :stubbed_instance_method2
+        object_class, method_to_stub1: :stubbed_instance_method1, method_to_stub2: :stubbed_instance_method2
       )
 
       @subject = spy_of_instances(object_class)
@@ -173,7 +255,30 @@ class TestCrispy < MiniTest::Test
       CrispyWorld.reset
     end
 
+    module CommonClassSpyTests
+
+      def test_spy_changes_stubbed_method
+        @object_instances.each do|object|
+          assert_equal(:stubbed_instance_method1, object.method_to_stub1)
+          assert_equal(:stubbed_instance_method2, object.method_to_stub2)
+        end
+      end
+
+      def test_spy_overrides_stubbed_methods
+        spy_into_instances object_class, method_to_stub2: 'xx', method_to_stub3: 'xxx'
+
+        @object_instances.each do|object|
+          assert_equal 'method to stub 1 (before stubbed)', object.method_to_stub1
+          assert_equal 'xx'                               , object.method_to_stub2
+          assert_equal 'xxx'                              , object.method_to_stub3
+        end
+      end
+
+    end
+
     class TestReceivedMessage < self
+      include CommonSpyTests
+      include CommonClassSpyTests
 
       def object_class
         ObjectClass
@@ -246,15 +351,10 @@ class TestCrispy < MiniTest::Test
         assert_equal(2, @subject.count_received(:bar))
       end
 
-      def test_spy_raises_error_given_non_symbol_as_method_name
-        assert_raises(::TypeError){ @subject.received_once?(nil) }
-        assert_raises(::TypeError){ @subject.received_once?(nil) }
-        assert_raises(::TypeError){ @subject.count_received(nil) }
-      end
-
     end
 
     class TestReceivedMessageWithReceiver < self
+      include CommonClassSpyTests
 
       def object_class
         ObjectClassNonBasic
@@ -275,10 +375,13 @@ class TestCrispy < MiniTest::Test
         def baz
         end
         def method_to_stub1
-          fail "Not stubbed actually! The test fails."
+          'method to stub 1 (before stubbed)'
         end
         def method_to_stub2
-          fail "Not stubbed actually! The test fails."
+          'method to stub 2 (before stubbed)'
+        end
+        def method_to_stub3
+          'method to stub 3 (before stubbed)'
         end
 
         def private_foo a
@@ -436,9 +539,9 @@ class TestCrispy < MiniTest::Test
       end
 
       def test_spy_raises_error_given_non_symbol_as_method_name
-        assert_raises(::TypeError){ @subject.received_once?(@object_instances[0], nil) }
-        assert_raises(::TypeError){ @subject.received_once?(@object_instances[0], nil) }
-        assert_raises(::TypeError){ @subject.count_received(@object_instances[0], nil) }
+        assert_raises(::TypeError){ @subject.received_with_receiver?(@object_instances[0], nil) }
+        assert_raises(::TypeError){ @subject.received_once_with_receiver?(@object_instances[0], nil) }
+        assert_raises(::TypeError){ @subject.count_received_with_receiver(@object_instances[0], nil) }
       end
 
     end
@@ -446,6 +549,7 @@ class TestCrispy < MiniTest::Test
   end
 
   class TestCrispyDouble < TestCrispy
+
     def setup
       @expected_hoge = Object.new
       @expected_foo  = Object.new
@@ -472,6 +576,32 @@ class TestCrispy < MiniTest::Test
       assert_same @expected_baz, @actual_baz
     end
 
+    def test_double_can_be_spied
+      assert spied? @double
+
+      assert_same @double.received_messages, spy(@double).received_messages
+
+      assert @double.received?(:hoge)
+      assert @double.received_once?(:hoge, :with, :any, :arguments)
+      assert not(@double.received?(:hoge, 0, 0, 0))
+      assert not(@double.received_once?(:hoge, 0, 0, 0))
+      assert not(@double.received_once?(:hoge))
+      assert_equal 0, @double.count_received(:hoge, 0, 0, 0)
+      assert_equal 1, @double.count_received(:hoge, :with, :any, :arguments)
+      assert_equal 2, @double.count_received(:hoge)
+
+      assert @double.received?(:bar)
+      assert @double.received_once?(:bar)
+
+      assert @double.received_once?(:foo)
+      assert @double.received?(:foo)
+      assert_equal 1, @double.count_received(:foo)
+
+      assert not(@double.received?(:non_used_method))
+      assert not(@double.received_once?(:non_used_method))
+      assert_equal 0, @double.count_received(:non_used_method)
+    end
+
   end
 
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: crispy
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Yamamoto Yuji
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-02 00:00:00.000000000 Z
+date: 2014-12-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -44,14 +44,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.4'
+        version: '5'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.4'
+        version: '5'
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
@@ -116,9 +116,7 @@ files:
 - lib/crispy/crispy_internal/const_changer.rb
 - lib/crispy/crispy_internal/double.rb
 - lib/crispy/crispy_internal/spy.rb
-- lib/crispy/crispy_internal/spy_mixin.rb
-- lib/crispy/crispy_internal/stubber.rb
-- lib/crispy/crispy_internal/with_stubber.rb
+- lib/crispy/crispy_internal/spy_base.rb
 - lib/crispy/crispy_received_message.rb
 - lib/crispy/crispy_received_message_with_receiver.rb
 - lib/crispy/crispy_world.rb
@@ -146,7 +144,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: Test spy for any object.

data/lib/crispy/crispy_internal/spy_mixin.rb

@@ -1,83 +0,0 @@
-require 'crispy/crispy_received_message'
-
-module Crispy
-  module CrispyInternal
-    module SpyMixin
-
-      BLACK_LISTED_METHODS = [
-        :__CRISPY_CLASS_SPY__,
-        :__CRISPY_SPY__,
-      ]
-
-      def received_messages
-        raise NotImplementedError
-      end
-
-      def erase_log
-        raise NotImplementedError
-      end
-
-      def stop
-        @spying = false
-      end
-
-      def restart
-        @spying = true
-      end
-
-      COMMON_RECEIVED_MESSAGE_METHODS_DEFINITION = {
-        'received?'      => 'include? %s',
-        'received_once?' => 'one? {|self_thing| self_thing == %s }',
-        'count_received' => 'count %s',
-      }
-
-      COMMON_RECEIVED_MESSAGE_METHODS_DEFINITION.each do|method_name, core_definition|
-        binding.eval(<<-END, __FILE__, (__LINE__ + 1))
-          def #{method_name} received_method_name, *received_arguments, &received_block
-            assert_symbol! received_method_name
-            if received_arguments.empty? and received_block.nil?
-              received_messages.map(&:method_name).#{sprintf(core_definition, 'received_method_name')}
-            else
-              received_message = ::Crispy::CrispyReceivedMessage.new(
-                received_method_name, *received_arguments, &received_block
-              )
-              received_messages.#{sprintf(core_definition, 'received_message')}
-            end
-          end
-        END
-      end
-
-      def prepend_features klass
-        super
-
-        without_black_listed_methods(klass.public_instance_methods).each do|method_name|
-          self.module_eval { define_wrapper(method_name) }
-        end
-        klass.protected_instance_methods.each do|method_name|
-          self.module_eval { protected define_wrapper(method_name) }
-        end
-        klass.private_instance_methods.each do|method_name|
-          self.module_eval { private define_wrapper(method_name) }
-        end
-      end
-      private :prepend_features
-
-      def without_black_listed_methods method_names
-        method_names.reject {|method_name| BLACK_LISTED_METHODS.include? method_name }
-      end
-      private :without_black_listed_methods
-
-      def initialize_spy
-        @spying = true
-      end
-      private :initialize_spy
-
-      def assert_symbol! maybe_symbol
-        unless maybe_symbol.respond_to?(:to_sym) && maybe_symbol.to_sym.instance_of?(::Symbol)
-          raise TypeError, "TypeError: no implicit conversion from #{maybe_symbol.inspect} to symbol"
-        end
-      end
-
-    end
-  end
-end

data/lib/crispy/crispy_internal/stubber.rb

@@ -1,31 +0,0 @@
-module Crispy
-  module CrispyInternal
-    class Stubber < Module
-      public :prepend_features
-
-      def initialize stubs_map = {}
-        super()
-        stub stubs_map
-      end
-
-      NOT_SPECIFIED = ::Object.new
-
-      def stub method_name_or_hash, returned_value = NOT_SPECIFIED, &definition
-        case method_name_or_hash
-        when Hash
-          hash = method_name_or_hash
-          hash.each do|method_name, value|
-            stub method_name, value
-          end
-        when ::Symbol, ::String
-          self.module_exec method_name_or_hash do|method_name|
-            # TODO: should not ignore arguments?
-            define_method(method_name) {|*_arguments| returned_value }
-          end
-        end
-        self
-      end
-
-    end
-  end
-end

data/lib/crispy/crispy_internal/with_stubber.rb

@@ -1,24 +0,0 @@
-require 'crispy/crispy_internal/stubber'
-
-module Crispy
-  module CrispyInternal
-    module WithStubber
-
-      def initialize_stubber stubs_map = {}
-        @__CRISPY_STUBBER__ = Stubber.new(stubs_map)
-      end
-      private :initialize_stubber
-
-      def prepend_stubber klass
-        @__CRISPY_STUBBER__.prepend_features klass
-      end
-      private :prepend_stubber
-
-      def stub *arguments, &definition
-        @__CRISPY_STUBBER__.stub(*arguments, &definition)
-        self
-      end
-
-    end
-  end
-end