spy 0.1.0 → 0.2.1

data/spec/spy/mutate_const_spec.rb

@@ -29,8 +29,12 @@ module Spy
     end
 
     def on_const(const_name)
-      parent_const = recursive_const_get("Object::" + const_name.sub(/(::)?[^:]+\z/, ''))
-      Spy.on_const(parent_const, const_name.split('::').last.to_sym)
+      if const_name.include? "::"
+      args = [recursive_const_get("Object::" + const_name.sub(/(::)?[^:]+\z/, '')), const_name.split('::').last.to_sym]
+      else
+        args = [const_name.to_sym]
+      end
+      Spy.get_const(*args) || Spy.on_const(*args)
     end
 
     def stub_const(const_name, value)
@@ -172,17 +176,9 @@ module Spy
         it_behaves_like "unloaded constant hiding", "TestClass::Hash"
 
         it 'does not hide the top-level constant' do
-          top_level_hash = ::Hash
-
-          hide_const("TestClass::Hash")
-          expect(::Hash).to equal(top_level_hash)
-        end
-
-        it 'does not affect the ability to access the top-level constant from nested contexts', :silence_warnings do
-          top_level_hash = ::Hash
-
-          hide_const("TestClass::Hash")
-          expect(TestClass::Hash).to equal(top_level_hash)
+          expect {
+            hide_const("TestClass::Hash")
+          }.to raise_error
         end
       end
 
@@ -318,14 +314,6 @@ module Spy
         it_behaves_like "loaded constant stubbing", "TestClass::Nested"
       end
 
-      context 'for a loaded constant prefixed with ::' do
-        it_behaves_like 'loaded constant stubbing', "::TestClass"
-      end
-
-      context 'for an unloaded constant prefixed with ::' do
-        it_behaves_like 'unloaded constant stubbing', "::SomeUndefinedConst"
-      end
-
       context 'for an unloaded constant with nested name that matches a top-level constant' do
         it_behaves_like "unloaded constant stubbing", "TestClass::Hash"
       end
@@ -338,28 +326,6 @@ module Spy
         it_behaves_like "unloaded constant stubbing", "X"
       end
 
-      context 'for an unloaded nested constant' do
-        it_behaves_like "unloaded constant stubbing", "X::Y"
-
-        it 'removes the root constant when rspec clears its mocks' do
-          expect(defined?(X)).to be_false
-          stub_const("X::Y", 7)
-          reset_rspec_mocks
-          expect(defined?(X)).to be_false
-        end
-      end
-
-      context 'for an unloaded deeply nested constant' do
-        it_behaves_like "unloaded constant stubbing", "X::Y::Z"
-
-        it 'removes the root constant when rspec clears its mocks' do
-          expect(defined?(X)).to be_false
-          stub_const("X::Y::Z", 7)
-          reset_rspec_mocks
-          expect(defined?(X)).to be_false
-        end
-      end
-
       context 'for an unloaded constant nested within a loaded constant' do
         it_behaves_like "unloaded constant stubbing", "TestClass::X"
 
@@ -402,8 +368,12 @@ module Spy
     end
 
     def on_const(const_name)
-      parent_const = recursive_const_get("Object::" + const_name.sub(/(::)?[^:]+\z/, ''))
-      Spy.on_const(parent_const, const_name.split('::').last.to_sym)
+      if const_name.include? "::"
+      args = [recursive_const_get("Object::" + const_name.sub(/(::)?[^:]+\z/, '')), const_name.split('::').last.to_sym]
+      else
+        args = [const_name.to_sym]
+      end
+      Spy.get_const(*args) || Spy.on_const(*args)
     end
 
     def stub_const(const_name, value)
@@ -415,8 +385,12 @@ module Spy
     end
 
     def original(const_name)
-      parent_const = recursive_const_get("Object::" + const_name.sub(/(::)?[^:]+\z/, ''))
-      Spy.get_const(parent_const, const_name.split('::').last.to_sym)
+      if const_name.include? "::"
+      args = [recursive_const_get("Object::" + const_name.sub(/(::)?[^:]+\z/, '')), const_name.split('::').last.to_sym]
+      else
+        args = [const_name.to_sym]
+      end
+      Spy.get_const(*args)
     end
 
     describe ".original" do
@@ -425,8 +399,6 @@ module Spy
 
         it("exposes its name")                    { expect(const.name).to eq("TestClass::M") }
         it("indicates it was previously defined") { expect(const).to be_previously_defined }
-        it("indicates it has not been mutated")   { expect(const).not_to be_mutated }
-        it("indicates it has not been stubbed")   { expect(const).not_to be_stubbed }
         it("indicates it has not been hidden")    { expect(const).not_to be_hidden }
         it("exposes its original value")          { expect(const.original_value).to eq(:m) }
       end
@@ -437,8 +409,6 @@ module Spy
 
         it("exposes its name")                    { expect(const.name).to eq("TestClass::M") }
         it("indicates it was previously defined") { expect(const).to be_previously_defined }
-        it("indicates it has been mutated")       { expect(const).to be_mutated }
-        it("indicates it has been stubbed")       { expect(const).to be_stubbed }
         it("indicates it has not been hidden")    { expect(const).not_to be_hidden }
         it("exposes its original value")          { expect(const.original_value).to eq(:m) }
       end
@@ -449,8 +419,6 @@ module Spy
 
         it("exposes its name")                        { expect(const.name).to eq("TestClass::Undefined") }
         it("indicates it was not previously defined") { expect(const).not_to be_previously_defined }
-        it("indicates it has been mutated")           { expect(const).to be_mutated }
-        it("indicates it has been stubbed")           { expect(const).to be_stubbed }
         it("indicates it has not been hidden")        { expect(const).not_to be_hidden }
         it("returns nil for the original value")      { expect(const.original_value).to be_nil }
       end
@@ -460,8 +428,6 @@ module Spy
 
         it("exposes its name")                        { expect(const.name).to eq("TestClass::Undefined") }
         it("indicates it was not previously defined") { expect(const).not_to be_previously_defined }
-        it("indicates it has not been mutated")       { expect(const).not_to be_mutated }
-        it("indicates it has not been stubbed")       { expect(const).not_to be_stubbed }
         it("indicates it has not been hidden")        { expect(const).not_to be_hidden }
         it("returns nil for the original value")      { expect(const.original_value).to be_nil }
       end
@@ -473,8 +439,6 @@ module Spy
 
         it("exposes its name")                    { expect(const.name).to eq("TestClass::M") }
         it("indicates it was previously defined") { expect(const).to be_previously_defined }
-        it("indicates it has been mutated")       { expect(const).to be_mutated }
-        it("indicates it has been stubbed")       { expect(const).to be_stubbed }
         it("indicates it has not been hidden")    { expect(const).not_to be_hidden }
         it("exposes its original value")          { expect(const.original_value).to eq(:m) }
       end
@@ -486,8 +450,6 @@ module Spy
 
         it("exposes its name")                        { expect(const.name).to eq("TestClass::Undefined") }
         it("indicates it was not previously defined") { expect(const).not_to be_previously_defined }
-        it("indicates it has been mutated")           { expect(const).to be_mutated }
-        it("indicates it has been stubbed")           { expect(const).to be_stubbed }
         it("indicates it has not been hidden")        { expect(const).not_to be_hidden }
         it("returns nil for the original value")      { expect(const.original_value).to be_nil }
       end
@@ -498,8 +460,6 @@ module Spy
 
         it("exposes its name")                    { expect(const.name).to eq("TestClass::M") }
         it("indicates it was previously defined") { expect(const).to be_previously_defined }
-        it("indicates it has been mutated")       { expect(const).to be_mutated }
-        it("indicates it has not been stubbed")   { expect(const).not_to be_stubbed }
         it("indicates it has been hidden")        { expect(const).to be_hidden }
         it("exposes its original value")          { expect(const.original_value).to eq(:m) }
       end
@@ -511,8 +471,6 @@ module Spy
 
         it("exposes its name")                    { expect(const.name).to eq("TestClass::M") }
         it("indicates it was previously defined") { expect(const).to be_previously_defined }
-        it("indicates it has been mutated")       { expect(const).to be_mutated }
-        it("indicates it has not been stubbed")   { expect(const).not_to be_stubbed }
         it("indicates it has been hidden")        { expect(const).to be_hidden }
         it("exposes its original value")          { expect(const.original_value).to eq(:m) }
       end

data/spec/spy/null_object_mock_spec.rb

@@ -4,7 +4,7 @@ module RSpec
   module Mocks
     describe "a double _not_ acting as a null object" do
       before(:each) do
-        @double = double('non-null object')
+        @double = Spy.double('non-null object')
       end
 
       it "says it does not respond to messages it doesn't understand" do
@@ -17,19 +17,13 @@ module RSpec
       end
 
       it "raises an error when interpolated in a string as an integer" do
-        # Not sure why, but 1.9.2 (but not JRuby --1.9) raises a different
-        # error than 1.8.7 and 1.9.3...
-        expected_error = (RUBY_VERSION == '1.9.2' && RUBY_PLATFORM !~ /java/) ?
-                         RSpec::Mocks::MockExpectationError :
-                         TypeError
-
-        expect { "%i" % @double }.to raise_error(expected_error)
+        expect { "%i" % @double }.to raise_error(TypeError)
       end
     end
 
     describe "a double acting as a null object" do
       before(:each) do
-        @double = double('null object').as_null_object
+        @double = Spy.double('null object').as_null_object
       end
 
       it "says it responds to everything" do
@@ -42,43 +36,21 @@ module RSpec
       end
 
       it "allows explicit expectation" do
-        @double.should_receive(:something)
+        spy = Spy.on(@double, :something)
         @double.something
+        expect(spy).to have_been_called
       end
 
       it 'continues to return self from an explicit expectation' do
-        @double.should_receive(:bar)
+        spy = Spy.on(@double, :bar)
         expect(@double.foo.bar).to be(@double)
+        expect(spy).to have_been_called
       end
 
       it 'returns an explicitly stubbed value from an expectation with no implementation' do
-        Spy.on(@double, :foo => "bar")
-        @double.should_receive(:foo)
+        spy = Spy.on(@double, :foo => "bar")
         expect(@double.foo).to eq("bar")
-      end
-
-      it "fails verification when explicit exception not met" do
-        expect {
-          @double.should_receive(:something)
-          @double.rspec_verify
-        }.to raise_error(RSpec::Mocks::MockExpectationError)
-      end
-
-      it "ignores unexpected methods" do
-        @double.random_call("a", "d", "c")
-        @double.rspec_verify
-      end
-
-      it "allows expected message with different args first" do
-        @double.should_receive(:message).with(:expected_arg)
-        @double.message(:unexpected_arg)
-        @double.message(:expected_arg)
-      end
-
-      it "allows expected message with different args second" do
-        @double.should_receive(:message).with(:expected_arg)
-        @double.message(:expected_arg)
-        @double.message(:unexpected_arg)
+        expect(spy).to have_been_called
       end
 
       it "can be interpolated in a string as an integer" do
@@ -92,14 +64,14 @@ module RSpec
 
     describe "#as_null_object" do
       it "sets the object to null_object" do
-        obj = double('anything').as_null_object
+        obj = Spy.double('anything').as_null_object
         expect(obj).to be_null_object
       end
     end
 
     describe "#null_object?" do
       it "defaults to false" do
-        obj = double('anything')
+        obj = Spy.double('anything')
         expect(obj).not_to be_null_object
       end
     end

data/spec/spy/partial_mock_spec.rb

@@ -26,72 +26,13 @@ module Spy
       expect(spy).to have_been_called
     end
 
-    it "should_receive mocks out the method" do
-      stub(object, :foobar).with(:test_param).and_return(1)
-      expect(object.foobar(:test_param)).to equal(1)
-    end
-
-    it "should_receive handles a hash" do
-      stub(object, :foobar).with(:key => "value").and_return(1)
-      expect(object.foobar(:key => "value")).to equal(1)
-    end
-
-    it "should_receive handles an inner hash" do
-      hash = {:a => {:key => "value"}}
-      object.should_receive(:foobar).with(:key => "value").and_return(1)
-      expect(object.foobar(hash[:a])).to equal(1)
-    end
-
-    it "should_receive returns a message expectation" do
-      expect(object.should_receive(:foobar)).to be_kind_of(RSpec::Mocks::MessageExpectation)
-      object.foobar
-    end
-
-    it "should_receive verifies method was called" do
-      object.should_receive(:foobar).with(:test_param).and_return(1)
-      expect {
-        object.rspec_verify
-      }.to raise_error(RSpec::Mocks::MockExpectationError)
-    end
-
-    it "should_receive also takes a String argument" do
-      object.should_receive('foobar')
-      object.foobar
-    end
-
-    it "should_not_receive also takes a String argument" do
-      object.should_not_receive('foobar')
-      expect {
-        object.foobar
-      }.to raise_error(RSpec::Mocks::MockExpectationError)
-    end
-
     it "uses reports nil in the error message" do
       allow_message_expectations_on_nil
 
       _nil = nil
-      _nil.should_receive(:foobar)
-      expect {
-        _nil.rspec_verify
-      }.to raise_error(
-        RSpec::Mocks::MockExpectationError,
-        %Q|(nil).foobar(any args)\n    expected: 1 time\n    received: 0 times|
-      )
-    end
-
-    it "includes the class name in the error when mocking a class method that is called an extra time with the wrong args" do
-      klass = Class.new do
-        def self.inspect
-          "MyClass"
-        end
-      end
-
-      klass.should_receive(:bar).with(1)
-      klass.bar(1)
-
-      expect {
-        klass.bar(2)
-      }.to raise_error(RSpec::Mocks::MockExpectationError, /MyClass/)
+      spy = stub(_nil, :foobar)
+      _nil.foobar
+      expect(spy).to have_been_called
     end
   end
 

data/spec/spy/stash_spec.rb

@@ -1,54 +1,47 @@
 require 'spec_helper'
 
-module RSpec
-  module Mocks
-
-    describe "only stashing the original method" do
-      let(:klass) do
-        Class.new do
-          def self.foo(arg)
-            :original_value
-          end
+module Spy
+  describe "only stashing the original method" do
+    let(:klass) do
+      Class.new do
+        def self.foo(arg)
+          :original_value
         end
       end
+    end
 
-      it "keeps the original method intact after multiple expectations are added on the same method" do
-        klass.should_receive(:foo).with(:fizbaz).and_return(:wowwow)
-        klass.should_receive(:foo).with(:bazbar).and_return(:okay)
-
-        klass.foo(:fizbaz)
-        klass.foo(:bazbar)
-        klass.rspec_verify
+    it "keeps the original method intact after multiple expectations are added on the same method" do
+      spy = Spy.on(klass, :foo)
+      klass.foo(:bazbar)
+      expect(spy).to have_been_called
+      Spy.off(klass, :foo)
 
-        klass.rspec_reset
-        expect(klass.foo(:yeah)).to equal(:original_value)
-      end
+      expect(klass.foo(:yeah)).to equal(:original_value)
     end
+  end
 
-    describe "when a class method is aliased on a subclass and the method is mocked" do
-      let(:klass) do
-        Class.new do
-          class << self
-            alias alternate_new new
-          end
+  describe "when a class method is aliased on a subclass and the method is mocked" do
+    let(:klass) do
+      Class.new do
+        class << self
+          alias alternate_new new
         end
       end
+    end
 
-      it "restores the original aliased public method" do
-        klass = Class.new do
-          class << self
-            alias alternate_new new
-          end
+    it "restores the original aliased public method" do
+      klass = Class.new do
+        class << self
+          alias alternate_new new
         end
+      end
 
-        klass.should_receive(:alternate_new)
-        expect(klass.alternate_new).to be_nil
-
-        klass.rspec_verify
+      spy = Spy.on(klass, :alternate_new)
+      expect(klass.alternate_new).to be_nil
+      expect(spy).to have_been_called
 
-        klass.rspec_reset
-        expect(klass.alternate_new).to be_an_instance_of(klass)
-      end
+      Spy.off(klass, :alternate_new)
+      expect(klass.alternate_new).to be_an_instance_of(klass)
     end
   end
 end

data/spec/spy/stub_spec.rb

@@ -46,12 +46,6 @@ module RSpec
         expect(@class).to respond_to(:msg)
       end
 
-      it "handles multiple stubbed methods" do
-        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::Subroutine.new(@instance, :method_that_yields).hook(force: true).and_yield(:yielded_obj)
         current_value = :value_before

data/spec/spy/to_ary_spec.rb

@@ -13,28 +13,28 @@ describe "a double receiving to_ary" do
     end
 
     it "can be overridden with a stub" do
-      Spy.on(obj, :to_ary) { :non_nil_value }
+      Spy::Subroutine.new(obj, :to_ary).hook(force: true).and_return(:non_nil_value)
       expect(obj.to_ary).to be(:non_nil_value)
     end
 
     it "responds when overriden" do
-      Spy.on(obj, :to_ary) { :non_nil_value }
+      Spy::Subroutine.new(obj, :to_ary).hook(force: true).and_return(:non_nil_value)
       expect(obj).to respond_to(:to_ary)
     end
 
     it "supports Array#flatten" do
-      obj = double('foo')
+      obj = Spy.double('foo')
       expect([obj].flatten).to eq([obj])
     end
   end
 
   context "double as_null_object" do
-    let(:obj) { double('obj').as_null_object }
+    let(:obj) { Spy.double('obj').as_null_object }
     include_examples "to_ary"
   end
 
   context "double without as_null_object" do
-    let(:obj) { double('obj') }
+    let(:obj) { Spy.double('obj') }
     include_examples "to_ary"
   end
 end