spy 0.0.1 → 0.1.0

data/spec/spy/partial_mock_spec.rb

@@ -1,196 +1,140 @@
 require 'spec_helper'
 
-module RSpec
-  module Mocks
-    describe "using a Partial Mock," do
-      let(:object) { Object.new }
-
-      it "names the class in the failure message" do
-        object.should_receive(:foo)
-        expect do
-          object.rspec_verify
-        end.to raise_error(RSpec::Mocks::MockExpectationError, /\(#<Object:.*>\).foo/)
-      end
-
-      it "names the class in the failure message when expectation is on class" do
-        Object.should_receive(:foo)
-        expect {
-          Object.rspec_verify
-        }.to raise_error(RSpec::Mocks::MockExpectationError, /<Object \(class\)>/)
-      end
-
-      it "does not conflict with @options in the object" do
-        object.instance_eval { @options = Object.new }
-        object.should_receive(:blah)
-        object.blah
-      end
-
-      it "should_not_receive mocks out the method" do
-        object.should_not_receive(:fuhbar)
-        expect {
-          object.fuhbar
-        }.to raise_error(
-          RSpec::Mocks::MockExpectationError,
-          /expected\: 0 times\n    received\: 1 time/
-        )
-      end
+module Spy
+  describe "using a Partial Mock," do
 
-      it "should_not_receive returns a negative message expectation" do
-        expect(object.should_not_receive(:foobar)).to be_kind_of(RSpec::Mocks::NegativeMessageExpectation)
-      end
-
-      it "should_receive mocks out the method" do
-        object.should_receive(:foobar).with(:test_param).and_return(1)
-        expect(object.foobar(:test_param)).to equal(1)
-      end
+    def stub(object, method_name)
+      Spy::Subroutine.new(object, method_name).hook(force: true)
+    end
 
-      it "should_receive handles a hash" do
-        object.should_receive(:foobar).with(:key => "value").and_return(1)
-        expect(object.foobar(:key => "value")).to equal(1)
-      end
+    let(:object) { Object.new }
 
-      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 "names the class in the failure message" do
+      spy = stub(object, :foo)
+      expect(spy).to_not have_been_called
+    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 "names the class in the failure message when expectation is on class" do
+      spy = stub(Object, :foo)
+      expect(spy).to_not have_been_called
+    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 "does not conflict with @options in the object" do
+      object.instance_eval { @options = Object.new }
+      spy = stub(object, :blah)
+      object.blah
+      expect(spy).to have_been_called
+    end
 
-      it "should_receive also takes a String argument" do
-        object.should_receive('foobar')
-        object.foobar
-      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_not_receive also takes a String argument" do
-        object.should_not_receive('foobar')
-        expect {
-          object.foobar
-        }.to raise_error(RSpec::Mocks::MockExpectationError)
-      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 "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 "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 "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
+    it "should_receive returns a message expectation" do
+      expect(object.should_receive(:foobar)).to be_kind_of(RSpec::Mocks::MessageExpectation)
+      object.foobar
+    end
 
-        klass.should_receive(:bar).with(1)
-        klass.bar(1)
+    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
 
-        expect {
-          klass.bar(2)
-        }.to raise_error(RSpec::Mocks::MockExpectationError, /MyClass/)
-      end
+    it "should_receive also takes a String argument" do
+      object.should_receive('foobar')
+      object.foobar
     end
 
-    describe "Using a partial mock on a proxy object", :if => defined?(::BasicObject) do
-      let(:proxy_class) do
-        Class.new(::BasicObject) do
-          def initialize(target)
-            @target = target
-          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
 
-          def proxied?
-            true
-          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
 
-          def method_missing(*a)
-            @target.send(*a)
-          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
 
-      let(:instance) { proxy_class.new(Object.new) }
+      klass.should_receive(:bar).with(1)
+      klass.bar(1)
 
-      it 'works properly' do
-        instance.should_receive(:proxied?).and_return(false)
-        expect(instance).not_to be_proxied
-      end
+      expect {
+        klass.bar(2)
+      }.to raise_error(RSpec::Mocks::MockExpectationError, /MyClass/)
     end
+  end
 
-    describe "Partially mocking an object that defines ==, after another mock has been defined" do
-      before(:each) do
-        stub("existing mock", :foo => :foo)
-      end
-
-      let(:klass) do
-        Class.new do
-          attr_reader :val
-          def initialize(val)
-            @val = val
-          end
-
-          def ==(other)
-            @val == other.val
-          end
-        end
-      end
-
-      it "does not raise an error when stubbing the object" do
-        o = klass.new :foo
-        expect { Spy.on(o, :bar) }.not_to raise_error(NoMethodError)
-      end
+  describe "Method visibility when using partial mocks" do
+    def stub(o, method_name)
+      Spy.on(o, method_name)
     end
 
-    describe "Method visibility when using partial mocks" do
-      let(:klass) do
-        Class.new do
-          def public_method
-            private_method
-            protected_method
-          end
-          protected
-          def protected_method; end
-          private
-          def private_method; end
+    let(:klass) do
+      Class.new do
+        def public_method
+          private_method
+          protected_method
         end
+        protected
+        def protected_method; end
+        private
+        def private_method; end
       end
+    end
 
-      let(:object) { klass.new }
-
-      it 'keeps public methods public' do
-        object.should_receive(:public_method)
-        expect(object.public_methods).to include_method(:public_method)
-        object.public_method
-      end
+    let(:object) { klass.new }
 
-      it 'keeps private methods private' do
-        object.should_receive(:private_method)
-        expect(object.private_methods).to include_method(:private_method)
-        object.public_method
-      end
+    it 'keeps public methods public' do
+      spy = stub(object, :public_method)
+      expect(object.public_methods).to include_method(:public_method)
+      object.public_method
+      expect(spy).to have_been_called
+    end
 
-      it 'keeps protected methods protected' do
-        object.should_receive(:protected_method)
-        expect(object.protected_methods).to include_method(:protected_method)
-        object.public_method
-      end
+    it 'keeps private methods private' do
+      spy = stub(object, :private_method)
+      expect(object.private_methods).to include_method(:private_method)
+      object.public_method
+      expect(spy).to have_been_called
+    end
 
+    it 'keeps protected methods protected' do
+      spy = stub(object, :protected_method)
+      expect(object.protected_methods).to include_method(:protected_method)
+      object.public_method
+      expect(spy).to have_been_called
     end
+
   end
 end

data/spec/spy/passing_argument_matchers_spec.rb

@@ -1,141 +1,139 @@
 require 'spec_helper'
 
-module RSpec
-  module Mocks
-    describe Methods, :broken do
-      before(:each) do
-        @double = double('double')
-        Spy.on(Kernel, :warn)
-      end
-
-      after(:each) do
-        @double.rspec_verify
-      end
-
-      context "handling argument matchers" do
-        it "accepts true as boolean()" do
-          @double.should_receive(:random_call).with(boolean())
-          @double.random_call(true)
-        end
-
-        it "accepts false as boolean()" do
-          @double.should_receive(:random_call).with(boolean())
-          @double.random_call(false)
-        end
-
-        it "accepts fixnum as kind_of(Numeric)" do
-          @double.should_receive(:random_call).with(kind_of(Numeric))
-          @double.random_call(1)
-        end
-
-        it "accepts float as an_instance_of(Numeric)" do
-          @double.should_receive(:random_call).with(kind_of(Numeric))
-          @double.random_call(1.5)
-        end
-
-        it "accepts fixnum as instance_of(Fixnum)" do
-          @double.should_receive(:random_call).with(instance_of(Fixnum))
-          @double.random_call(1)
-        end
-
-        it "does NOT accept fixnum as instance_of(Numeric)" do
-          @double.should_not_receive(:random_call).with(instance_of(Numeric))
-          @double.random_call(1)
-        end
-
-        it "does NOT accept float as instance_of(Numeric)" do
-          @double.should_not_receive(:random_call).with(instance_of(Numeric))
-          @double.random_call(1.5)
-        end
-
-        it "accepts string as anything()" do
-          @double.should_receive(:random_call).with("a", anything(), "c")
-          @double.random_call("a", "whatever", "c")
-        end
-
-        it "matches duck type with one method" do
-          @double.should_receive(:random_call).with(duck_type(:length))
-          @double.random_call([])
-        end
-
-        it "matches duck type with two methods" do
-          @double.should_receive(:random_call).with(duck_type(:abs, :div))
-          @double.random_call(1)
-        end
-
-        it "matches no args against any_args()" do
-          @double.should_receive(:random_call).with(any_args)
-          @double.random_call()
-        end
-
-        it "matches one arg against any_args()" do
-          @double.should_receive(:random_call).with(any_args)
-          @double.random_call("a string")
-        end
-
-        it "matches no args against no_args()" do
-          @double.should_receive(:random_call).with(no_args)
-          @double.random_call()
-        end
-
-        it "matches hash with hash_including same hash" do
-          @double.should_receive(:random_call).with(hash_including(:a => 1))
-          @double.random_call(:a => 1)
-        end
-      end
-
-      context "handling block matchers" do
-        it "matches arguments against RSpec expectations" do
-          @double.should_receive(:random_call).with {|arg1, arg2, arr, *rest|
-            expect(arg1).to eq 5
-            expect(arg2).to have_at_least(3).characters
-            expect(arg2).to have_at_most(10).characters
-            expect(arr.map {|i| i * 2}).to eq [2,4,6]
-            expect(rest).to eq [:fee, "fi", 4]
-          }
-          @double.random_call 5, "hello", [1,2,3], :fee, "fi", 4
-        end
-
-        it "does not eval the block as the return value" do
-          eval_count = 0
-          @double.should_receive(:msg).with {|a| eval_count += 1}
-          @double.msg(:ignore)
-          expect(eval_count).to eq(1)
-        end
-      end
-
-      context "handling non-matcher arguments" do
-        it "matches non special symbol (can be removed when deprecated symbols are removed)" do
-          @double.should_receive(:random_call).with(:some_symbol)
-          @double.random_call(:some_symbol)
-        end
-
-        it "matches string against regexp" do
-          @double.should_receive(:random_call).with(/bcd/)
-          @double.random_call("abcde")
-        end
-
-        it "matches regexp against regexp" do
-          @double.should_receive(:random_call).with(/bcd/)
-          @double.random_call(/bcd/)
-        end
-
-        it "matches against a hash submitted and received by value" do
-          @double.should_receive(:random_call).with(:a => "a", :b => "b")
-          @double.random_call(:a => "a", :b => "b")
-        end
-
-        it "matches against a hash submitted by reference and received by value" do
-          opts = {:a => "a", :b => "b"}
-          @double.should_receive(:random_call).with(opts)
-          @double.random_call(:a => "a", :b => "b")
-        end
-
-        it "matches against a hash submitted by value and received by reference" do
-          opts = {:a => "a", :b => "b"}
-          @double.should_receive(:random_call).with(:a => "a", :b => "b")
-          @double.random_call(opts)
-        end
+module Spy
+  describe "Matchers", :broken do
+    before(:each) do
+      @double = double('double')
+      Spy.on(Kernel, :warn)
+    end
+
+    after(:each) do
+      @double.rspec_verify
+    end
+
+    context "handling argument matchers" do
+      it "accepts true as boolean()" do
+        @double.should_receive(:random_call).with(boolean())
+        @double.random_call(true)
+      end
+
+      it "accepts false as boolean()" do
+        @double.should_receive(:random_call).with(boolean())
+        @double.random_call(false)
+      end
+
+      it "accepts fixnum as kind_of(Numeric)" do
+        @double.should_receive(:random_call).with(kind_of(Numeric))
+        @double.random_call(1)
+      end
+
+      it "accepts float as an_instance_of(Numeric)" do
+        @double.should_receive(:random_call).with(kind_of(Numeric))
+        @double.random_call(1.5)
+      end
+
+      it "accepts fixnum as instance_of(Fixnum)" do
+        @double.should_receive(:random_call).with(instance_of(Fixnum))
+        @double.random_call(1)
+      end
+
+      it "does NOT accept fixnum as instance_of(Numeric)" do
+        @double.should_not_receive(:random_call).with(instance_of(Numeric))
+        @double.random_call(1)
+      end
+
+      it "does NOT accept float as instance_of(Numeric)" do
+        @double.should_not_receive(:random_call).with(instance_of(Numeric))
+        @double.random_call(1.5)
+      end
+
+      it "accepts string as anything()" do
+        @double.should_receive(:random_call).with("a", anything(), "c")
+        @double.random_call("a", "whatever", "c")
+      end
+
+      it "matches duck type with one method" do
+        @double.should_receive(:random_call).with(duck_type(:length))
+        @double.random_call([])
+      end
+
+      it "matches duck type with two methods" do
+        @double.should_receive(:random_call).with(duck_type(:abs, :div))
+        @double.random_call(1)
+      end
+
+      it "matches no args against any_args()" do
+        @double.should_receive(:random_call).with(any_args)
+        @double.random_call()
+      end
+
+      it "matches one arg against any_args()" do
+        @double.should_receive(:random_call).with(any_args)
+        @double.random_call("a string")
+      end
+
+      it "matches no args against no_args()" do
+        @double.should_receive(:random_call).with(no_args)
+        @double.random_call()
+      end
+
+      it "matches hash with hash_including same hash" do
+        @double.should_receive(:random_call).with(hash_including(:a => 1))
+        @double.random_call(:a => 1)
+      end
+    end
+
+    context "handling block matchers" do
+      it "matches arguments against RSpec expectations" do
+        @double.should_receive(:random_call).with {|arg1, arg2, arr, *rest|
+          expect(arg1).to eq 5
+          expect(arg2).to have_at_least(3).characters
+          expect(arg2).to have_at_most(10).characters
+          expect(arr.map {|i| i * 2}).to eq [2,4,6]
+          expect(rest).to eq [:fee, "fi", 4]
+        }
+        @double.random_call 5, "hello", [1,2,3], :fee, "fi", 4
+      end
+
+      it "does not eval the block as the return value" do
+        eval_count = 0
+        @double.should_receive(:msg).with {|a| eval_count += 1}
+        @double.msg(:ignore)
+        expect(eval_count).to eq(1)
+      end
+    end
+
+    context "handling non-matcher arguments" do
+      it "matches non special symbol (can be removed when deprecated symbols are removed)" do
+        @double.should_receive(:random_call).with(:some_symbol)
+        @double.random_call(:some_symbol)
+      end
+
+      it "matches string against regexp" do
+        @double.should_receive(:random_call).with(/bcd/)
+        @double.random_call("abcde")
+      end
+
+      it "matches regexp against regexp" do
+        @double.should_receive(:random_call).with(/bcd/)
+        @double.random_call(/bcd/)
+      end
+
+      it "matches against a hash submitted and received by value" do
+        @double.should_receive(:random_call).with(:a => "a", :b => "b")
+        @double.random_call(:a => "a", :b => "b")
+      end
+
+      it "matches against a hash submitted by reference and received by value" do
+        opts = {:a => "a", :b => "b"}
+        @double.should_receive(:random_call).with(opts)
+        @double.random_call(:a => "a", :b => "b")
+      end
+
+      it "matches against a hash submitted by value and received by reference" do
+        opts = {:a => "a", :b => "b"}
+        @double.should_receive(:random_call).with(:a => "a", :b => "b")
+        @double.random_call(opts)
       end
     end
   end