spy 0.0.1

data/lib/spy/double.rb

@@ -0,0 +1,11 @@
+class Spy
+  class Double
+    def initialize(name, *args)
+      @name = name
+
+      if args.size > 0
+        Spy.on(self,*args)
+      end
+    end
+  end
+end

data/lib/spy/dsl.rb

@@ -0,0 +1,7 @@
+class Spy
+  module Dsl
+    def spy
+      Spy
+    end
+  end
+end

data/lib/spy/version.rb

@@ -0,0 +1,3 @@
+class Spy
+  VERSION = "0.0.1"
+end

data/spec/spec_helper.rb

@@ -0,0 +1,39 @@
+require "rspec/autorun"
+require "spy"
+require "pry"
+require "pry-nav"
+
+RSpec::Matchers.define :include_method do |expected|
+  match do |actual|
+    actual.map { |m| m.to_s }.include?(expected.to_s)
+  end
+end
+
+RSpec.configure do |config|
+  config.color_enabled = true
+  config.order = :random
+  config.run_all_when_everything_filtered = true
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.filter_run_including :focus
+  config.filter_run_excluding :broken => true
+
+
+  config.expect_with :rspec do |expectations|
+    expectations.syntax = :expect
+  end
+
+  old_verbose = nil
+  config.before(:each, :silence_warnings) do
+    old_verbose = $VERBOSE
+    $VERBOSE = nil
+  end
+
+  config.after(:each, :silence_warnings) do
+    $VERBOSE = old_verbose
+  end
+
+  config.after(:each) do
+    Spy.teardown
+  end
+end
+

data/spec/spy/and_call_original_spec.rb

@@ -0,0 +1,152 @@
+require 'spec_helper'
+
+describe "and_call_through" do
+  context "on a partial mock object" do
+    let(:klass) do
+      Class.new do
+        def meth_1
+          :original
+        end
+
+        def meth_2(x)
+          yield x, :additional_yielded_arg
+        end
+
+        def self.new_instance
+          new
+        end
+      end
+    end
+
+    let(:instance) { klass.new }
+
+    it 'passes the received message through to the original method' do
+      spy = Spy.on(instance, :meth_1).and_call_through
+      expect(instance.meth_1).to eq(:original)
+      expect(spy).to have_been_called
+    end
+
+    it 'passes args and blocks through to the original method' do
+      spy = Spy.on(instance, :meth_2).and_call_through
+      value = instance.meth_2(:submitted_arg) { |a, b| [a, b] }
+      expect(value).to eq([:submitted_arg, :additional_yielded_arg])
+      expect(spy).to have_been_called
+    end
+
+    it 'works for singleton methods' do
+      def instance.foo; :bar; end
+      spy = Spy.on(instance, :foo).and_call_through
+      expect(instance.foo).to eq(:bar)
+      expect(spy).to have_been_called
+    end
+
+    it 'works for methods added through an extended module' do
+      instance.extend Module.new { def foo; :bar; end }
+      spy = Spy.on(instance, :foo).and_call_through
+      expect(instance.foo).to eq(:bar)
+      expect(spy).to have_been_called
+    end
+
+    it "works for method added through an extended module onto a class's ancestor" do
+      sub_sub_klass = Class.new(Class.new(klass))
+      klass.extend Module.new { def foo; :bar; end }
+      spy = Spy.on(sub_sub_klass, :foo).and_call_through
+      expect(sub_sub_klass.foo).to eq(:bar)
+      expect(spy).to have_been_called
+    end
+
+    it "finds the method on the most direct ancestor even if the method " +
+       "is available on more distant ancestors" do
+      klass.extend Module.new { def foo; :klass_bar; end }
+      sub_klass = Class.new(klass)
+      sub_klass.extend Module.new { def foo; :sub_klass_bar; end }
+      spy = Spy.on(sub_klass, :foo).and_call_through
+      expect(sub_klass.foo).to eq(:sub_klass_bar)
+      expect(spy).to have_been_called
+    end
+
+    it 'works for class methods defined on a superclass' do
+      subclass = Class.new(klass)
+      spy = Spy.on(subclass, :new_instance).and_call_through
+      expect(subclass.new_instance).to be_a(subclass)
+      expect(spy).to have_been_called
+    end
+
+    it 'works for class methods defined on a grandparent class' do
+      sub_subclass = Class.new(Class.new(klass))
+      spy = Spy.on(sub_subclass, :new_instance).and_call_through
+      expect(sub_subclass.new_instance).to be_a(sub_subclass)
+      expect(spy).to have_been_called
+    end
+
+    it 'works for class methods defined on the Class class' do
+      spy = Spy.on(klass, :new).and_call_through
+      expect(klass.new).to be_an_instance_of(klass)
+      expect(spy).to have_been_called
+    end
+
+    it "works for instance methods defined on the object's class's superclass" do
+      subclass = Class.new(klass)
+      inst = subclass.new
+      spy = Spy.on(inst, :meth_1).and_call_through
+      expect(inst.meth_1).to eq(:original)
+      expect(spy).to have_been_called
+    end
+
+    it 'works for aliased methods' do
+      klass = Class.new do
+        class << self
+          alias alternate_new new
+        end
+      end
+
+      spy = Spy.on(klass, :alternate_new).and_call_through
+      expect(klass.alternate_new).to be_an_instance_of(klass)
+      expect(spy).to have_been_called
+    end
+
+    context 'on an object that defines method_missing' do
+      before do
+        klass.class_eval do
+          def respond_to_missing?(name, _)
+            if name.to_s == "greet_jack"
+              true
+            else
+              super
+            end
+          end
+
+          def method_missing(name, *args)
+            if name.to_s == "greet_jack"
+              "Hello, jack"
+            else
+              super
+            end
+          end
+        end
+      end
+
+      it 'works when the method_missing definition handles the message' do
+        spy = Spy.on(instance, :greet_jack).and_call_through
+        expect(instance.greet_jack).to eq("Hello, jack")
+        expect(spy).to have_been_called
+      end
+
+      it 'raises an error on invocation if method_missing does not handle the message' do
+        Spy.new(instance, :not_a_handled_message).hook(force: true).and_call_through
+
+        # Note: it should raise a NoMethodError (and usually does), but
+        # due to a weird rspec-expectations issue (see #183) it sometimes
+        # raises a `NameError` when a `be_xxx` predicate matcher has been
+        # recently used. `NameError` is the superclass of `NoMethodError`
+        # so this example will pass regardless.
+        # If/when we solve the rspec-expectations issue, this can (and should)
+        # be changed to `NoMethodError`.
+        expect {
+          instance.not_a_handled_message
+        }.to raise_error(NameError, /not_a_handled_message/)
+      end
+    end
+  end
+end
+

data/spec/spy/and_yield_spec.rb

@@ -0,0 +1,114 @@
+require 'spec_helper'
+
+describe RSpec::Mocks::Mock do
+
+  let(:obj) { double }
+
+  describe "#and_yield" do
+    context "with eval context as block argument" do
+
+      it "evaluates the supplied block as it is read" do
+        evaluated = false
+        Spy.on(obj, :method_that_accepts_a_block).and_yield do |eval_context|
+          evaluated = true
+        end
+        expect(evaluated).to be_true
+      end
+
+      it "passes an eval context object to the supplied block" do
+        Spy.on(obj, :method_that_accepts_a_block).and_yield do |eval_context|
+          expect(eval_context).not_to be_nil
+        end
+      end
+
+      it "evaluates the block passed to the stubbed method in the context of the supplied eval context" do
+        expected_eval_context = nil
+        actual_eval_context = nil
+
+        Spy.on(obj, :method_that_accepts_a_block).and_yield do |eval_context|
+          expected_eval_context = eval_context
+        end
+
+        obj.method_that_accepts_a_block do
+          actual_eval_context = self
+        end
+
+        expect(actual_eval_context).to equal(expected_eval_context)
+      end
+
+      context "and no yielded arguments" do
+
+        it "passes when expectations set on the eval context are met" do
+          configured_eval_context = nil
+          Spy.on(obj, :method_that_accepts_a_block).and_yield do |eval_context|
+            configured_eval_context = eval_context
+            configured_eval_context.should_receive(:foo)
+          end
+
+          obj.method_that_accepts_a_block do
+            foo
+          end
+
+          configured_eval_context.rspec_verify
+        end
+
+        it "fails when expectations set on the eval context are not met" do
+          configured_eval_context = nil
+          Spy.on(obj, :method_that_accepts_a_block).and_yield do |eval_context|
+            configured_eval_context = eval_context
+            configured_eval_context.should_receive(:foo)
+          end
+
+          obj.method_that_accepts_a_block do
+            # foo is not called here
+          end
+
+          expect { configured_eval_context.rspec_verify }.to raise_error(RSpec::Mocks::MockExpectationError)
+        end
+
+      end
+
+      context "and yielded arguments" do
+
+        it "passes when expectations set on the eval context and yielded arguments are met" do
+          configured_eval_context = nil
+          yielded_arg = Object.new
+          Spy.on(obj, :method_that_accepts_a_block).and_yield(yielded_arg) do |eval_context|
+            configured_eval_context = eval_context
+            configured_eval_context.should_receive(:foo)
+            yielded_arg.should_receive(:bar)
+          end
+
+          obj.method_that_accepts_a_block do |obj|
+            obj.bar
+            foo
+          end
+
+          configured_eval_context.rspec_verify
+          yielded_arg.rspec_verify
+        end
+
+        it "fails when expectations set on the eval context and yielded arguments are not met" do
+          configured_eval_context = nil
+          yielded_arg = Object.new
+          Spy.on(obj, :method_that_accepts_a_block).and_yield(yielded_arg) do |eval_context|
+            configured_eval_context = eval_context
+            configured_eval_context.should_receive(:foo)
+            yielded_arg.should_receive(:bar)
+          end
+
+          obj.method_that_accepts_a_block do |obj|
+            # obj.bar is not called here
+            # foo is not called here
+          end
+
+          expect { configured_eval_context.rspec_verify }.to raise_error(RSpec::Mocks::MockExpectationError)
+          expect { yielded_arg.rspec_verify }.to raise_error(RSpec::Mocks::MockExpectationError)
+        end
+
+      end
+
+    end
+  end
+end
+

data/spec/spy/bug_report_10260_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+describe "An RSpec Mock" do
+  it "hides internals in its inspect representation" do
+    m = double('cup')
+    expect(m.inspect).to match /#<RSpec::Mocks::Mock:0x[a-f0-9.]+ @name="cup">/
+  end
+end

data/spec/spy/bug_report_10263_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe "Double" do
+  let(:test_double) { double }
+
+  specify "when one example has an expectation inside the block passed to should_receive" do
+    Spy.stub(test_double, :msg).and_return do |arg|
+      expect(arg).to be_true #this call exposes the problem
+    end
+    begin
+      test_double.msg(false)
+    rescue Exception
+    end
+  end
+
+  specify "then the next example should behave as expected instead of saying" do
+    test_double_spy = Spy.stub(test_double, :foobar)
+    test_double.foobar
+    expect(test_double_spy).to have_been_called
+    test_double.foobar
+    expect(test_double_spy.calls.count).to equal(2)
+  end
+end
+

data/spec/spy/bug_report_496_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+module BugReport496
+  describe "a message expectation on a base class object" do
+    class BaseClass
+    end
+
+    class SubClass < BaseClass
+    end
+
+    it "is received" do
+      new_spy = Spy.on(BaseClass, :new)
+      SubClass.new
+      expect(new_spy.calls.count).to equal(1)
+    end
+  end
+end
+

data/spec/spy/bug_report_600_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+module BugReport600
+  describe "stubbing a class method" do
+    class ExampleClass
+      def self.method_that_uses_define_method
+        define_method "defined_method" do |attributes|
+          load_address(address, attributes)
+        end
+      end
+    end
+
+    it "works" do
+      define_method_spy = Spy.on(ExampleClass, :define_method)
+      ExampleClass.method_that_uses_define_method
+
+      expect(define_method_spy).to have_been_called_with("defined_method")
+    end
+
+    it "restores the original method" do
+      ExampleClass.method_that_uses_define_method
+    end
+  end
+end

data/spec/spy/bug_report_7611_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+module Bug7611
+  describe "A Partial Mock" do
+    class Foo; end
+    class Bar < Foo; end
+
+    it "respects subclasses" do
+      Spy.on(Foo, :new).and_return(Object.new)
+    end
+
+    it "should" do
+      expect(Bar.new.class).to eq Bar
+    end
+  end
+end

data/spec/spy/bug_report_8165_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe "An object where respond_to? is true and does not have method" do
+  # When should_receive(message) is sent to any object, the Proxy sends
+  # respond_to?(message) to that object to see if the method should be proxied.
+  #
+  # If respond_to? itself is proxied, then when the Proxy sends respond_to?
+  # to the object, the proxy is invoked and responds yes (if so set in the spec).
+  # When the object does NOT actually respond to `message`, an exception is thrown
+  # when trying to proxy it.
+  #
+  # The fix was to keep track of whether `respond_to?` had been proxied and, if
+  # so, call the munged copy of `respond_to?` on the object.
+
+  it "does not raise an exception for Object" do
+    obj = Object.new
+    obj.should_receive(:respond_to?).with(:foobar).and_return(true)
+    obj.should_receive(:foobar).and_return(:baz)
+    expect(obj.respond_to?(:foobar)).to be_true
+    expect(obj.foobar).to eq :baz
+  end
+
+  it "does not raise an exception for mock" do
+    obj = double("obj")
+    obj.should_receive(:respond_to?).with(:foobar).and_return(true)
+    obj.should_receive(:foobar).and_return(:baz)
+    expect(obj.respond_to?(:foobar)).to be_true
+    expect(obj.foobar).to eq :baz
+  end
+
+end