spy 0.0.1

data/spec/spy/precise_counts_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+
+module RSpec
+  module Mocks
+    describe "PreciseCounts" do
+      before(:each) do
+        @double = double("test double")
+      end
+
+      it "fails when exactly n times method is called less than n times" do
+        @double.should_receive(:do_something).exactly(3).times
+        @double.do_something
+        @double.do_something
+        expect {
+          @double.rspec_verify
+        }.to raise_error(RSpec::Mocks::MockExpectationError)
+      end
+
+      it "fails fast when exactly n times method is called more than n times" do
+        @double.should_receive(:do_something).exactly(3).times
+        @double.do_something
+        @double.do_something
+        @double.do_something
+        expect {
+          @double.do_something
+        }.to raise_error(RSpec::Mocks::MockExpectationError)
+      end
+
+      it "fails when exactly n times method is never called" do
+        @double.should_receive(:do_something).exactly(3).times
+        expect {
+          @double.rspec_verify
+        }.to raise_error(RSpec::Mocks::MockExpectationError)
+      end
+
+      it "passes if exactly n times method is called exactly n times" do
+        @double.should_receive(:do_something).exactly(3).times
+        @double.do_something
+        @double.do_something
+        @double.do_something
+        @double.rspec_verify
+      end
+
+      it "returns the value given by a block when the exactly once method is called" do
+        @double.should_receive(:to_s).exactly(:once) { "testing" }
+        expect(@double.to_s).to eq "testing"
+        @double.rspec_verify
+      end
+
+      it "passes mutiple calls with different args" do
+        @double.should_receive(:do_something).once.with(1)
+        @double.should_receive(:do_something).once.with(2)
+        @double.do_something(1)
+        @double.do_something(2)
+        @double.rspec_verify
+      end
+
+      it "passes multiple calls with different args and counts" do
+        @double.should_receive(:do_something).twice.with(1)
+        @double.should_receive(:do_something).once.with(2)
+        @double.do_something(1)
+        @double.do_something(2)
+        @double.do_something(1)
+        @double.rspec_verify
+      end
+    end
+  end
+end

data/spec/spy/serialization_spec.rb

@@ -0,0 +1,110 @@
+require 'spec_helper'
+
+module RSpec
+  module Mocks
+    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...
+            hide_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
+          end
+        end
+      end
+
+      let(:serializable_object) { RSpec::Mocks::SerializableObject.new(7, "something") }
+
+      def set_stub
+        Spy.on(serializable_object, :bazz => 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
+
+        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
+      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_stub
+          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
+
+      describe "an object that has its own mock_proxy instance variable" do
+        let(:serializable_object) { RSpec::Mocks::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
+end

data/spec/spy/stash_spec.rb

@@ -0,0 +1,54 @@
+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
+        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
+
+        klass.rspec_reset
+        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
+
+        klass.should_receive(:alternate_new)
+        expect(klass.alternate_new).to be_nil
+
+        klass.rspec_verify
+
+        klass.rspec_reset
+        expect(klass.alternate_new).to be_an_instance_of(klass)
+      end
+    end
+  end
+end

data/spec/spy/stub_implementation_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+module RSpec
+  module Mocks
+    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 }
+          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}
+          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}
+          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
+        Spy.stub(obj, :foo)
+        Spy.off(obj, :foo)
+        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.stub(parent, :new)
+        Spy.stub(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

@@ -0,0 +1,85 @@
+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.stub" do
+        it "returns declared value when message is received" do
+          Spy.stub(@instance, :msg).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)
+        expect(@instance).to respond_to(:msg)
+      end
+
+      it "instructs a class object to respond_to the message" do
+        Spy.stub(@class, :msg)
+        expect(@class).to respond_to(:msg)
+      end
+
+      it "handles multiple stubbed methods" do
+        Spy.stub(@instance, :msg1 => 1, :msg2 => 2)
+        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)
+        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)
+        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)
+        expect { @stub.something }.to throw_symbol(:up)
+      end
+
+      it "throws with argument when told to" do
+        Spy.stub(@stub, :something).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)
+        expect(@stub.existing_instance_method).to eq :updated_stub_value
+      end
+    end
+  end
+end

data/spec/spy/stubbed_message_expectations_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe "expection set on previously stubbed method" do
+  it "fails if message is not received after expectation is set" do
+    double = double(:msg => nil)
+    double.msg
+    double.should_receive(:msg)
+    expect { double.rspec_verify }.to raise_error(RSpec::Mocks::MockExpectationError)
+  end
+
+  it "outputs arguments of similar calls" do
+    double = double('double', :foo => true)
+    double.should_receive(:foo).with('first')
+    double.foo('second')
+    double.foo('third')
+    expect {
+      double.rspec_verify
+    }.to raise_error(%Q|Double "double" received :foo with unexpected arguments\n  expected: ("first")\n       got: ("second"), ("third")|)
+    double.rspec_reset
+  end
+
+  context "with argument constraint on stub" do
+    it "matches any args if no arg constraint set on expectation" do
+      double = double("mock")
+      Spy.on(double, :foo).with(3).and_return("stub")
+      double.should_receive(:foo).at_least(:once).and_return("expectation")
+      double.foo
+      double.rspec_verify
+    end
+
+    it "matches specific args set on expectation" do
+      double = double("mock")
+      Spy.on(double, :foo).with(3).and_return("stub")
+      double.should_receive(:foo).at_least(:once).with(4).and_return("expectation")
+      double.foo(4)
+      double.rspec_verify
+    end
+
+    it "fails if expectation's arg constraint is not met" do
+      double = double("mock")
+      Spy.on(double, :foo).with(3).and_return("stub")
+      double.should_receive(:foo).at_least(:once).with(4).and_return("expectation")
+      double.foo(3)
+      expect { double.rspec_verify }.to raise_error(/expected: \(4\)\s+got: \(3\)/)
+    end
+  end
+end

data/spec/spy/test_double_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+module RSpec
+  module Mocks
+    describe TestDouble do
+      before(:all) do
+        Module.class_eval do
+          private
+          def use; end
+        end
+      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 '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
+
+      it 'stubs the methods passed in the stubs hash' do
+        double = Module.new do
+          TestDouble.extend_onto(self, "MyDouble", :a => 5, :b => 10)
+        end
+
+        expect(double.a).to eq(5)
+        expect(double.b).to eq(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
+
+      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
+end
+