spy 0.0.1 → 0.1.0

data/spec/spy/serialization_spec.rb

@@ -1,109 +1,115 @@
 require 'spec_helper'
+require 'yaml'
+require 'psych'
+require 'syck'
 
-module RSpec
-  module Mocks
-    describe Serialization do
+module Spy
+  describe "serialization" do
 
-      class SerializableObject < Struct.new(:foo, :bar); end
+    class SerializableObject < Struct.new(:foo, :bar); end
 
-      class SerializableMockProxy
-        attr_reader :mock_proxy
+    class SerializableMockProxy
+      attr_reader :mock_proxy
 
-        def initialize(mock_proxy)
-          @mock_proxy = mock_proxy
-        end
+      def initialize(mock_proxy)
+        @mock_proxy = mock_proxy
+      end
 
-        def ==(other)
-          other.class == self.class && other.mock_proxy == mock_proxy
-        end
+      def ==(other)
+        other.class == self.class && other.mock_proxy == mock_proxy
       end
+    end
 
-      def self.with_yaml_loaded(&block)
-        context 'with YAML loaded' do
-          module_eval(&block)
-        end
+    def self.with_yaml_loaded(&block)
+      context 'with YAML loaded' do
+        module_eval(&block)
       end
+    end
 
-      def self.without_yaml_loaded(&block)
-        context 'without YAML loaded' do
-          before do
-            # We can't really unload yaml, but we can fake it here...
-            hide_const("YAML")
-            Struct.class_eval do
-              alias __old_to_yaml to_yaml
-              undef to_yaml
-            end
+    def self.without_yaml_loaded(&block)
+      context 'without YAML loaded' do
+        before do
+          # We can't really unload yaml, but we can fake it here...
+          @yaml = YAML
+          Object.send(:remove_const, "YAML")
+          Struct.class_eval do
+            alias __old_to_yaml to_yaml
+            undef to_yaml
           end
+        end
 
-          module_eval(&block)
+        module_eval(&block)
 
-          after do
-            Struct.class_eval do
-              alias to_yaml __old_to_yaml
-              undef __old_to_yaml
-            end
+        after do
+          Struct.class_eval do
+            alias to_yaml __old_to_yaml
+            undef __old_to_yaml
           end
+
+          Object.send(:const_set, "YAML", @yaml)
         end
       end
+    end
 
-      let(:serializable_object) { RSpec::Mocks::SerializableObject.new(7, "something") }
+    let(:serializable_object) { SerializableObject.new(7, "something") }
 
-      def set_stub
-        Spy.on(serializable_object, :bazz => 5)
-      end
+    def set_spy
+      Spy::Subroutine.new(serializable_object, :bazz).hook(force: true).and_return(5)
+    end
 
-      shared_examples_for 'normal YAML serialization' do
-        it 'serializes to yaml the same with and without stubbing, using #to_yaml' do
-          expect { set_stub }.to_not change { serializable_object.to_yaml }
-        end
+    shared_examples_for 'normal YAML serialization' do
+      it 'serializes to yaml the same with and without stubbing, using #to_yaml' do
+        set_spy
+        expect { Spy.get(serializable_object, :bazz) }.to_not change { serializable_object.to_yaml }
+      end
 
-        it 'serializes to yaml the same with and without stubbing, using YAML.dump' do
-          expect { set_stub }.to_not change { ::YAML.dump(serializable_object) }
-        end
+      it 'serializes to yaml the same with and without stubbing, using YAML.dump' do
+        set_spy
+        expect { Spy.get(serializable_object, :bazz) }.to_not change { ::YAML.dump(serializable_object) }
       end
+    end
 
-      with_yaml_loaded do
-        compiled_with_psych = begin
-          require 'psych'
-          true
-        rescue LoadError
-          false
+    with_yaml_loaded do
+      compiled_with_psych = begin
+                              require 'psych'
+                              true
+                            rescue LoadError
+                              false
+                            end
+
+      if compiled_with_psych
+        context 'using Syck as the YAML engine' do
+          before(:each) { ::YAML::ENGINE.yamler = 'syck' }
+          it_behaves_like 'normal YAML serialization'
         end
 
-        if compiled_with_psych
-          context 'using Syck as the YAML engine' do
-            before(:each) { ::YAML::ENGINE.yamler = 'syck' }
-            it_behaves_like 'normal YAML serialization'
-          end
-
-          context 'using Psych as the YAML engine' do
-            before(:each) { ::YAML::ENGINE.yamler = 'psych' }
-            it_behaves_like 'normal YAML serialization'
-          end
-        else
+        context 'using Psych as the YAML engine' do
+          before(:each) { ::YAML::ENGINE.yamler = 'psych' }
           it_behaves_like 'normal YAML serialization'
         end
+      else
+        it_behaves_like 'normal YAML serialization'
       end
+    end
 
-      without_yaml_loaded do
-        it 'does not add #to_yaml to the stubbed object' do
-          expect(serializable_object).not_to respond_to(:to_yaml)
-          set_stub
-          expect(serializable_object).not_to respond_to(:to_yaml)
-        end
+    without_yaml_loaded do
+      it 'does not add #to_yaml to the stubbed object' do
+        expect(serializable_object).not_to respond_to(:to_yaml)
+        set_spy
+        expect(serializable_object).not_to respond_to(:to_yaml)
       end
+    end
 
-      it 'marshals the same with and without stubbing' do
-        expect { set_stub }.to_not change { Marshal.dump(serializable_object) }
-      end
+    it 'marshals the same with and without stubbing' do
+      expect { Spy.get(serializable_object, :bazz) }.to_not change { Marshal.dump(serializable_object) }
+    end
 
-      describe "an object that has its own mock_proxy instance variable" do
-        let(:serializable_object) { RSpec::Mocks::SerializableMockProxy.new(:my_mock_proxy) }
+    describe "an object that has its own mock_proxy instance variable" do
+      let(:serializable_object) { SerializableMockProxy.new(:my_mock_proxy) }
 
-        it 'does not interfere with its marshalling' do
-          marshalled_copy = Marshal.load(Marshal.dump(serializable_object))
-          expect(marshalled_copy).to eq serializable_object
-        end
+      it 'does not interfere with its marshalling' do
+        marshalled_copy = Marshal.load(Marshal.dump(serializable_object))
+        expect(marshalled_copy).to eq serializable_object
       end
     end
   end

data/spec/spy/stub_implementation_spec.rb

@@ -1,28 +1,31 @@
 require 'spec_helper'
 
-module RSpec
-  module Mocks
+module Spy
+  describe Subroutine do
+    class Bar
+      def foo(given = nil)
+      end
+    end
+
+    let(:obj) { Bar.new }
     describe "stub implementation" do
       describe "with no args" do
         it "execs the block when called" do
-          obj = stub()
-          Spy.stub(obj, :foo).and_return { :bar }
+          Subroutine.new(obj, :foo).hook.and_return { :bar }
           expect(obj.foo).to eq :bar
         end
       end
 
       describe "with one arg" do
         it "execs the block with that arg when called" do
-          obj = stub()
-          Spy.stub(obj, :foo).and_return {|given| given}
+          Subroutine.new(obj, :foo).hook.and_return {|given| given}
           expect(obj.foo(:bar)).to eq :bar
         end
       end
 
       describe "with variable args" do
         it "execs the block when called" do
-          obj = stub()
-          Spy.stub(obj, :foo).and_return {|*given| given.first}
+          Subroutine.new(obj, :foo).hook.and_return {|*given| given.first}
           expect(obj.foo(:bar)).to eq :bar
         end
       end
@@ -33,8 +36,7 @@ module RSpec
       it "replaces the stubbed method with the original method" do
         obj = Object.new
         def obj.foo; :original; end
-        Spy.stub(obj, :foo)
-        Spy.off(obj, :foo)
+        Subroutine.new(obj, :foo).hook.unhook
         expect(obj.foo).to eq :original
       end
 
@@ -42,8 +44,8 @@ module RSpec
         parent = Class.new
         child  = Class.new(parent)
 
-        Spy.stub(parent, :new)
-        Spy.stub(child, :new)
+        Spy.on(parent, :new)
+        Spy.on(child, :new)
         Spy.off(parent, :new)
         Spy.off(child, :new)
 

data/spec/spy/stub_spec.rb

@@ -29,55 +29,55 @@ module RSpec
         @stub = Object.new
       end
 
-      describe "using Spy.stub" do
+      describe "using Spy::Subroutine.new" do
         it "returns declared value when message is received" do
-          Spy.stub(@instance, :msg).and_return(:return_value)
+          Spy::Subroutine.new(@instance, :msg).hook(force: true).and_return(:return_value)
           expect(@instance.msg).to equal(:return_value)
         end
       end
 
       it "instructs an instance to respond_to the message" do
-        Spy.stub(@instance, :msg)
+        Spy::Subroutine.new(@instance, :msg).hook(force: true)
         expect(@instance).to respond_to(:msg)
       end
 
       it "instructs a class object to respond_to the message" do
-        Spy.stub(@class, :msg)
+        Spy::Subroutine.new(@class, :msg).hook(force: true)
         expect(@class).to respond_to(:msg)
       end
 
       it "handles multiple stubbed methods" do
-        Spy.stub(@instance, :msg1 => 1, :msg2 => 2)
+        Spy::Subroutine.new(@instance, :msg1 => 1, :msg2 => 2).hook(force: true)
         expect(@instance.msg1).to eq(1)
         expect(@instance.msg2).to eq(2)
       end
 
       it "yields a specified object" do
-        Spy.stub(@instance, :method_that_yields).and_yield(:yielded_obj)
+        Spy::Subroutine.new(@instance, :method_that_yields).hook(force: true).and_yield(:yielded_obj)
         current_value = :value_before
         @instance.method_that_yields {|val| current_value = val}
         expect(current_value).to eq :yielded_obj
       end
 
       it "yields a specified object and return another specified object" do
-        yielded_obj = double("my mock")
-        Spy.stub(yielded_obj, :foo)
-        Spy.stub(@instance, :method_that_yields_and_returns).and_yield(yielded_obj).and_return(:baz)
+        yielded_obj = Spy.double("my mock")
+        Spy::Subroutine.new(yielded_obj, :foo).hook(force: true)
+        Spy::Subroutine.new(@instance, :method_that_yields_and_returns).hook(force: true).and_yield(yielded_obj).and_return(:baz)
         expect(@instance.method_that_yields_and_returns { |o| o.foo :bar }).to eq :baz
       end
 
       it "throws when told to" do
-        Spy.stub(@stub, :something).and_throw(:up)
+        Spy::Subroutine.new(@stub, :something).hook(force: true).and_throw(:up)
         expect { @stub.something }.to throw_symbol(:up)
       end
 
       it "throws with argument when told to" do
-        Spy.stub(@stub, :something).and_throw(:up, 'high')
+        Spy::Subroutine.new(@stub, :something).hook(force: true).and_throw(:up, 'high')
         expect { @stub.something }.to throw_symbol(:up, 'high')
       end
 
       it "overrides a pre-existing method" do
-        Spy.stub(@stub, :existing_instance_method).and_return(:updated_stub_value)
+        Spy::Subroutine.new(@stub, :existing_instance_method).hook(force: true).and_return(:updated_stub_value)
         expect(@stub.existing_instance_method).to eq :updated_stub_value
       end
     end

data/spec/spy/test_double_spec.rb

@@ -1,57 +1,54 @@
 require 'spec_helper'
 
-module RSpec
-  module Mocks
-    describe TestDouble do
-      before(:all) do
-        Module.class_eval do
-          private
-          def use; end
-        end
+module Spy
+  describe Double do
+    before(:all) do
+      Module.class_eval do
+        private
+        def use; end
       end
+    end
 
-      after(:all) do
-        Module.class_eval do
-          undef use
-        end
+    after(:all) do
+      Module.class_eval do
+        undef use
       end
+    end
 
-      it 'can be extended onto a module to make it a pure test double that can mock private methods' do
-        double = Module.new
-        Spy.on(double, :use)
-        expect { double.use }.to raise_error(/private method `use' called/)
-
-        double = Module.new { TestDouble.extend_onto(self) }
-        double.should_receive(:use).and_return(:ok)
-        expect(double.use).to be(:ok)
-      end
+    it 'can be extended onto a module to make it a pure test double that can mock private methods' do
+      double = Module.new
+      Spy.on(double, :use)
+      expect { double.use }.to raise_error(/private method `use' called/)
 
-      it 'sets the test double name when a name is passed' do
-        double = Module.new { TestDouble.extend_onto(self, "MyDouble") }
-        expect { double.foo }.to raise_error(/Mock "MyDouble" received/)
-      end
+      double = Module.new { TestDouble.extend_onto(self) }
+      double.should_receive(:use).and_return(:ok)
+      expect(double.use).to be(:ok)
+    end
 
-      it 'stubs the methods passed in the stubs hash' do
-        double = Module.new do
-          TestDouble.extend_onto(self, "MyDouble", :a => 5, :b => 10)
-        end
+    it 'sets the test double name when a name is passed' do
+      double = Module.new { TestDouble.extend_onto(self, "MyDouble") }
+      expect { double.foo }.to raise_error(/Mock "MyDouble" received/)
+    end
 
-        expect(double.a).to eq(5)
-        expect(double.b).to eq(10)
+    it 'stubs the methods passed in the stubs hash' do
+      double = Module.new do
+        TestDouble.extend_onto(self, "MyDouble", :a => 5, :b => 10)
       end
 
-      it 'indicates what type of test double it is in error messages' do
-        double = Module.new do
-          TestDouble.extend_onto(self, "A", :__declared_as => "ModuleMock")
-        end
-        expect { double.foo }.to raise_error(/ModuleMock "A"/)
-      end
+      expect(double.a).to eq(5)
+      expect(double.b).to eq(10)
+    end
 
-      it 'is declared as a mock by default' do
-        double = Module.new { TestDouble.extend_onto(self) }
-        expect { double.foo }.to raise_error(/Mock received/)
+    it 'indicates what type of test double it is in error messages' do
+      double = Module.new do
+        TestDouble.extend_onto(self, "A", :__declared_as => "ModuleMock")
       end
+      expect { double.foo }.to raise_error(/ModuleMock "A"/)
+    end
+
+    it 'is declared as a mock by default' do
+      double = Module.new { TestDouble.extend_onto(self) }
+      expect { double.foo }.to raise_error(/Mock received/)
     end
   end
 end
-

data/spy.gemspec

@@ -17,5 +17,6 @@ Gem::Specification.new do |gem|
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
   gem.add_development_dependency('minitest', '>= 4.5.0')
-  gem.add_development_dependency('rspec')
+  gem.add_development_dependency('rspec-core')
+  gem.add_development_dependency('rspec-expectations')
 end

data/test/integration/test_constant_spying.rb

@@ -0,0 +1,58 @@
+require 'test_helper'
+
+class TestConstantSpying < MiniTest::Unit::TestCase
+
+  class Foo
+    HELLO = "hello world"
+
+    def self.hello
+      HELLO
+    end
+
+    module Bar
+      def self.hello
+        HELLO
+      end
+    end
+  end
+
+  class ChildFoo < Foo
+    def self.hello
+      HELLO
+    end
+  end
+
+  def setup
+    Spy::Agency.instance.dissolve!
+  end
+
+  def test_spy_on_constant
+    assert_equal "hello world", Foo.hello
+
+    spy = Spy.on_const(Foo, :HELLO)
+    assert_equal nil, Foo.hello
+    spy.and_return("awesome")
+    assert_equal "awesome", Foo.hello
+
+    Spy.off_const(Foo, :HELLO)
+    assert_equal "hello world", Foo.hello
+
+    assert_equal "hello world", Foo::Bar.hello
+    spy = Spy.on_const(Foo, :HELLO)
+    assert_equal nil, Foo::Bar.hello
+    spy.and_return("awesome")
+    assert_equal "awesome", Foo::Bar.hello
+
+    Spy.off_const(Foo, :HELLO)
+    assert_equal "hello world", Foo::Bar.hello
+
+    assert_equal "hello world", ChildFoo.hello
+    spy = Spy.on_const(Foo, :HELLO)
+    assert_equal nil, ChildFoo.hello
+    spy.and_return("awesome")
+    assert_equal "awesome", ChildFoo.hello
+
+    Spy.off_const(Foo, :HELLO)
+    assert_equal "hello world", ChildFoo.hello
+  end
+end