spy 1.0.1 → 1.0.5

data/spec/spy/passing_argument_matchers_spec.rb

@@ -1,140 +0,0 @@
-require 'spec_helper'
-
-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
-end

data/spec/spy/serialization_spec.rb

@@ -1,116 +0,0 @@
-require 'spec_helper'
-require 'yaml'
-require 'psych'
-require 'syck'
-
-module Spy
-  describe "serialization" do
-
-    class SerializableObject < Struct.new(:foo, :bar); end
-
-    class SerializableMockProxy
-      attr_reader :mock_proxy
-
-      def initialize(mock_proxy)
-        @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
-    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)
-
-        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) { SerializableObject.new(7, "something") }
-
-    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
-        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
-        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
-                            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
-        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_spy
-        expect(serializable_object).not_to respond_to(:to_yaml)
-      end
-    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) { 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
-    end
-  end
-end

data/spec/spy/stash_spec.rb

@@ -1,47 +0,0 @@
-require 'spec_helper'
-
-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
-      spy = Spy.on(klass, :foo)
-      klass.foo(:bazbar)
-      expect(spy).to have_been_called
-      Spy.off(klass, :foo)
-
-      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
-      end
-    end
-
-    it "restores the original aliased public method" do
-      klass = Class.new do
-        class << self
-          alias alternate_new new
-        end
-      end
-
-      spy = Spy.on(klass, :alternate_new)
-      expect(klass.alternate_new).to be_nil
-      expect(spy).to have_been_called
-
-      Spy.off(klass, :alternate_new)
-      expect(klass.alternate_new).to be_an_instance_of(klass)
-    end
-  end
-end

data/spec/spy/stub_implementation_spec.rb

@@ -1,64 +0,0 @@
-require 'spec_helper'
-
-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
-          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
-          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
-          Subroutine.new(obj, :foo).hook.and_return {|*given| given.first}
-          expect(obj.foo(:bar)).to eq :bar
-        end
-      end
-    end
-
-
-    describe "unstub implementation" do
-      it "replaces the stubbed method with the original method" do
-        obj = Object.new
-        def obj.foo; :original; end
-        Subroutine.new(obj, :foo).hook.unhook
-        expect(obj.foo).to eq :original
-      end
-
-      it "restores the correct implementations when stubbed and unstubbed on a parent and child class" do
-        parent = Class.new
-        child  = Class.new(parent)
-
-        Spy.on(parent, :new)
-        Spy.on(child, :new)
-        Spy.off(parent, :new)
-        Spy.off(child, :new)
-
-        expect(parent.new).to be_an_instance_of parent
-        expect(child.new).to be_an_instance_of child
-      end
-
-      it "raises a MockExpectationError if the method has not been stubbed" do
-        obj = Object.new
-        expect {
-          Spy.off(obj, :foo)
-        }.to raise_error
-      end
-    end
-  end
-end

data/spec/spy/stub_spec.rb

@@ -1,79 +0,0 @@
-require 'spec_helper'
-
-module RSpec
-  module Mocks
-    describe "A method stub" do
-      before(:each) do
-        @class = Class.new do
-          class << self
-            def existing_class_method
-              existing_private_class_method
-            end
-
-            private
-            def existing_private_class_method
-              :original_value
-            end
-          end
-
-          def existing_instance_method
-            existing_private_instance_method
-          end
-
-          private
-          def existing_private_instance_method
-            :original_value
-          end
-        end
-        @instance = @class.new
-        @stub = Object.new
-      end
-
-      describe "using Spy::Subroutine.new" do
-        it "returns declared value when message is received" do
-          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::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::Subroutine.new(@class, :msg).hook(force: true)
-        expect(@class).to respond_to(:msg)
-      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
-        @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 = 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::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::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::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
-  end
-end

data/spec/spy/to_ary_spec.rb

@@ -1,40 +0,0 @@
-require "spec_helper"
-
-describe "a double receiving to_ary" do
-  shared_examples "to_ary" do
-    it "returns nil" do
-      expect do
-        expect(obj.to_ary).to be_nil
-      end.to raise_error(NoMethodError)
-    end
-
-    it "doesn't respond" do
-      expect(obj).not_to respond_to(:to_ary)
-    end
-
-    it "can be overridden with a stub" do
-      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::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 = Spy.double('foo')
-      expect([obj].flatten).to eq([obj])
-    end
-  end
-
-  context "double as_null_object" do
-    let(:obj) { Spy.double('obj').as_null_object }
-    include_examples "to_ary"
-  end
-
-  context "double without as_null_object" do
-    let(:obj) { Spy.double('obj') }
-    include_examples "to_ary"
-  end
-end