surrogate 0.1.0

data/spec/defining_api_methods_spec.rb

@@ -0,0 +1,295 @@
+require 'spec_helper'
+
+describe 'define' do
+  describe 'in the block' do
+    it 'is an api method for the class' do
+      pristine_klass = Class.new do
+        Surrogate.endow self do
+          define(:find) { 123 }
+        end
+      end
+
+      klass1 = pristine_klass.reprise
+      klass1.should_not have_been_told_to :find
+      klass1.find(1).should == 123
+      klass1.should have_been_told_to(:find).with(1)
+    end
+  end
+
+
+  describe 'out of the block' do
+    let(:mocked_class) { Surrogate.endow Class.new }
+    let(:instance)     { mocked_class.new }
+
+    it 'is an api method for the instance' do
+      mocked_class.define(:book) { 'book' }
+      instance.book.should == 'book'
+    end
+
+    describe 'declaring the behaviour' do
+      describe 'for verbs' do
+        before     { mocked_class.define :wink }
+
+        describe 'will_<api_method>' do
+          it 'overrides the default value for the api method' do
+            mock1 = mocked_class.new
+            mock2 = mocked_class.new
+            mock1.will_wink :quickly
+            mock2.will_wink :slowly
+            mock1.wink.should == :quickly
+            mock2.wink.should == :slowly
+            mock1.wink.should == :quickly
+          end
+
+          it 'returns the object' do
+            instance = mocked_class.new
+            instance.will_wink(:quickly).should equal instance
+          end
+        end
+
+        describe 'will_<api_method> with multiple arguments' do
+          it 'returns the object' do
+            instance = mocked_class.new
+            instance.will_wink(1, 2, 3).should equal instance
+          end
+
+          context 'it creates a queue of things to find then returns to normal behaviour' do
+            specify 'when there is no default block' do
+              mock = mocked_class.new
+              mock.will_wink :quickly, :slowly
+              mock.wink.should == :quickly
+              mock.wink.should == :slowly
+              expect { mock.wink }.to raise_error Surrogate::UnpreparedMethodError
+            end
+
+            specify 'when there is a default block' do
+              mocked_class = Surrogate.endow(Class.new)
+              mocked_class.define(:connect) { :default }
+              mock = mocked_class.new
+              mock.will_connect 1, 2
+              mock.connect.should == 1
+              mock.connect.should == 2
+              mock.connect.should == :default
+            end
+          end
+        end
+      end
+
+
+      describe 'for nouns' do
+        before { mocked_class.define :age }
+
+        describe 'will_have_<api_method>' do
+          it 'defines will_have_<api_method> which overrides the default block' do
+            mock1 = mocked_class.new
+            mock2 = mocked_class.new
+            mock1.will_have_age 12
+            mock2.will_have_age 34
+            mock1.age.should == 12
+            mock2.age.should == 34
+            mock1.age.should == 12
+          end
+
+          it 'returns the object' do
+            instance = mocked_class.new
+            instance.will_have_age(123).should equal instance
+          end
+        end
+
+        describe 'wil_have_<api_method> with multiple arguments' do
+          it 'returns the object' do
+            instance = mocked_class.new
+            instance.will_have_age(1,2,3).should equal instance
+          end
+
+          context 'it creates a queue of things to find then returns to normal behaviour' do
+            specify 'when there is no default block' do
+              mock = mocked_class.new
+              mock.will_have_age 12, 34
+              mock.age.should == 12
+              mock.age.should == 34
+              expect { mock.age }.to raise_error Surrogate::UnpreparedMethodError
+            end
+
+            specify 'when there is a default block' do
+              mocked_class = Surrogate.endow(Class.new)
+              mocked_class.define(:name) { 'default' }
+              mock = mocked_class.new
+              mock.will_have_name 'a', 'b'
+              mock.name.should == 'a'
+              mock.name.should == 'b'
+              mock.name.should == 'default'
+            end
+          end
+        end
+      end
+    end
+
+
+
+    context 'the api method' do
+      it 'takes any number of arguments' do
+        mocked_class.define(:meth) { 1 }
+        mocked_class.new.meth.should == 1
+        mocked_class.new.meth(1).should == 1
+        mocked_class.new.meth(1, 2).should == 1
+      end
+
+      it 'raises an UnpreparedMethodError when it has no default block' do
+        mocked_class.define :meth
+        expect { mocked_class.new.meth }.to raise_error(Surrogate::UnpreparedMethodError, /meth/)
+      end
+
+      it 'considers ivars of the same name to be its default' do
+        mocked_class.define :meth
+        mocked = mocked_class.new
+        mocked.instance_variable_set :@meth, 123
+        mocked.meth.should == 123
+      end
+
+      it 'reverts to the default block if invoked and having no ivar' do
+        mocked_class.define(:meth) { 123 }
+        mocked = mocked_class.new
+        mocked.instance_variable_get(:@meth).should be_nil
+        mocked.meth.should == 123
+      end
+
+      describe 'initialization' do
+        specify 'api methods can be an initialize method' do
+          mocked_class.define(:initialize) { @abc = 123 }
+          mocked_class.new.instance_variable_get(:@abc).should == 123
+        end
+
+        specify 'initialize exsits even if error is raised' do
+          mocked_class.define(:initialize) { raise "simulate runtime error" }
+          expect { mocked_class.new }.to raise_error(RuntimeError, /simulate/)
+          expect { mocked_class.new }.to raise_error(RuntimeError, /simulate/)
+        end
+
+        specify 'receives args' do
+          mocked_class.define(:initialize) { |num1, num2| @num = num1 + num2 }
+          mocked_class.new(25, 75).instance_variable_get(:@num).should == 100
+        end
+
+        specify 'even works with inheritance' do
+          superclass = Class.new
+          superclass.send(:define_method, :initialize) { @a = 1 }
+          subclass = Class.new superclass
+          mocked_subclass = Surrogate.endow Class.new subclass
+          mocked_subclass.define :abc
+          mocked_subclass.new.instance_variable_get(:@a).should == 1
+        end
+
+        context 'when not an api method' do
+          it 'respects arity (this is probably 1.9.3 only)' do
+            expect { mocked_class.new(1) }.to raise_error ArgumentError, 'wrong number of arguments(1 for 0)'
+          end
+
+          specify 'recorded regardless of when initialize is defined in relation to mock' do
+            klass = Class.new do
+              Surrogate.endow self
+              def initialize(a)
+                @a = a
+              end
+            end
+            klass.new(1).should have_been_initialized_with 1
+            klass.new(1).instance_variable_get(:@a).should == 1
+
+            klass = Class.new do
+              def initialize(a)
+                @a = a
+              end
+              Surrogate.endow self
+            end
+            klass.new(1).should have_been_initialized_with 1
+            klass.new(1).instance_variable_get(:@a).should == 1
+          end
+        end
+      end
+
+      describe 'it takes a block whos return value will be used as the default' do
+        specify 'the block is instance evaled' do
+          mocked_class.define(:meth) { self }
+          instance = mocked_class.new
+          instance.meth.should equal instance
+        end
+
+        specify 'arguments passed to the method will be passed to the block' do
+          mocked_class.define(:meth) { |*args| args }
+          instance = mocked_class.new
+          instance.meth(1).should == [1]
+          instance.meth(1, 2).should == [1, 2]
+        end
+      end
+
+      it 'remembers what it was invoked with' do
+        mocked_class.define(:meth) { nil }
+        mock = mocked_class.new
+        mock.meth 1
+        mock.meth 1, 2
+        mock.meth [1, 2]
+        mock.invocations(:meth).should == [
+          [1],
+          [1, 2],
+          [[1, 2]],
+        ]
+      end
+
+      it 'raises an error if asked about invocations for api methods it does not know' do
+        mocked_class.define :meth1
+        mocked_class.define :meth2
+        mock = mocked_class.new
+        expect { mock.invocations(:meth1) }.to_not raise_error
+        expect { mock.invocations(:meth3) }.to raise_error Surrogate::UnknownMethod, /doesn't know "meth3", only knows "initialize", "meth1", "meth2"/
+      end
+    end
+  end
+
+
+  describe 'reprise' do
+    it 'a repetition or further performance of the klass' do
+      pristine_klass = Class.new do
+        Surrogate.endow self do
+          define(:find) { 123 }
+          define(:bind) { 'abc' }
+        end
+        define(:peat)   { true }
+        define(:repeat) { 321 }
+      end
+
+      klass1 = pristine_klass.reprise
+      klass1.should_not have_been_told_to :find
+      klass1.find(1).should == 123
+      klass1.should have_been_told_to(:find).with(1)
+      klass1.bind.should == 'abc'
+
+      klass2 = pristine_klass.reprise
+      klass2.will_find 456
+      klass2.find(2).should == 456
+      klass1.find.should == 123
+
+      klass1.should have_been_told_to(:find).with(1)
+      klass2.should have_been_told_to(:find).with(2)
+      klass1.should_not have_been_told_to(:find).with(2)
+      klass2.should_not have_been_told_to(:find).with(1)
+
+      klass1.new.peat.should == true
+      klass1.new.repeat.should == 321
+    end
+
+    it 'is a subclass of the reprised class' do
+      superclass = Surrogate.endow Class.new
+      superclass.reprise.new.should be_a_kind_of superclass
+    end
+  end
+
+  describe '#api_method_names' do
+    it 'returns the names of the api methods as symbols' do
+      mocked_class = Class.new do
+        Surrogate.endow self
+        define :abc
+      end
+      mocked_class.api_method_names.should == [:abc]
+    end
+  end
+end

data/spec/rspec/have_been_asked_for_its_spec.rb

@@ -0,0 +1,143 @@
+require 'spec_helper'
+
+describe 'RSpec matchers', 'have_been_asked_for_its' do
+  let(:mocked_class) { Surrogate.endow Class.new }
+  let(:instance) { mocked_class.new }
+
+  describe 'default use case' do
+    before { mocked_class.define :name, default: 'Ayaan' }
+
+    example 'passes if has been invoked at least once' do
+      instance.should_not have_been_asked_for_its :name
+      instance.name
+      instance.should have_been_asked_for_its :name
+      instance.name
+      instance.should have_been_asked_for_its :name
+    end
+
+    example 'failure message for should' do
+      expect { instance.should have_been_asked_for_its :name }.to \
+        raise_error(RSpec::Expectations::ExpectationNotMetError, /was never asked for its name/)
+    end
+
+    example 'failure message for should not' do
+      instance.name
+      expect { instance.should_not have_been_asked_for_its :name }.to \
+        raise_error(RSpec::Expectations::ExpectationNotMetError, /shouldn't have been asked for its name, but was asked 1 time/)
+
+      instance.name
+      expect { instance.should_not have_been_asked_for_its :name }.to \
+        raise_error(RSpec::Expectations::ExpectationNotMetError, /shouldn't have been asked for its name, but was asked 2 times/)
+    end
+  end
+
+
+  describe 'specifying which arguments it should have been invoked with' do
+    before { mocked_class.define :size, default: nil }
+
+    example 'default use case' do
+      instance.should_not have_been_asked_for_its(:size).with(1, 2, 3)
+      instance.size 1, 2
+      instance.should_not have_been_asked_for_its(:size).with(1, 2, 3)
+      instance.size 1, 2, 3
+      instance.should have_been_asked_for_its(:size).with(1, 2, 3)
+    end
+
+    example 'failure message for should' do
+      expect { instance.should have_been_asked_for_its(:size).with(1, '2') }.to \
+        raise_error(RSpec::Expectations::ExpectationNotMetError, /should have been asked for its size with `1, "2"', but was never asked/)
+
+      instance.size 3
+      instance.size 4, '5'
+      expect { instance.should have_been_asked_for_its(:size).with(1, '2') }.to \
+        raise_error(RSpec::Expectations::ExpectationNotMetError, /should have been asked for its size with `1, "2"', but got `3', `4, "5"'/)
+    end
+
+    example 'failure message for should not' do
+      instance.size 1, '2'
+      expect { instance.should_not have_been_asked_for_its(:size).with(1, '2') }.to \
+        raise_error(RSpec::Expectations::ExpectationNotMetError, /should not have been asked for its size with `1, "2"'/)
+    end
+
+    describe 'integration with rspec argument_matchers' do
+      it 'works with no_args' do
+        instance.should_not have_been_asked_for_its(:size).with(no_args)
+        instance.size(1)
+        instance.should_not have_been_asked_for_its(:size).with(no_args)
+        instance.size
+        instance.should have_been_asked_for_its(:size).with(no_args)
+      end
+    end
+  end
+
+
+  describe 'specifying number of times invoked' do
+    before { mocked_class.define :value, default: nil }
+
+    example 'default use case' do
+      instance.should have_been_asked_for_its(:value).times(0)
+      instance.value
+      instance.should have_been_asked_for_its(:value).times(1)
+      instance.value
+      instance.should have_been_asked_for_its(:value).times(2)
+    end
+
+    example 'failure message for should' do
+      expect { instance.should have_been_asked_for_its(:value).times(1) }.to \
+        raise_error(RSpec::Expectations::ExpectationNotMetError, /should have been asked for its value 1 time, but was asked 0 times/)
+
+      instance.value
+      expect { instance.should have_been_asked_for_its(:value).times(2) }.to \
+        raise_error(RSpec::Expectations::ExpectationNotMetError, /should have been asked for its value 2 times, but was asked 1 time/)
+    end
+
+    example 'failure message for should not' do
+      expect { instance.should_not have_been_asked_for_its(:value).times(0) }.to \
+        raise_error(RSpec::Expectations::ExpectationNotMetError, /shouldn't have been asked for its value 0 times, but was/)
+
+      instance.value
+      expect { instance.should_not have_been_asked_for_its(:value).times(1) }.to \
+        raise_error(RSpec::Expectations::ExpectationNotMetError, /shouldn't have been asked for its value 1 time, but was/)
+    end
+  end
+
+  describe 'conjunction of with(args) and times(n)' do
+    before { mocked_class.define :value, default: nil }
+
+    example 'default use case' do
+      instance.should have_been_asked_for_its(:value).times(0).with(1, '2')
+      instance.should_not have_been_asked_for_its(:value).times(1).with(1, '2')
+      instance.value
+      instance.should have_been_asked_for_its(:value).times(0).with(1, '2')
+      instance.should_not have_been_asked_for_its(:value).times(1).with(1, '2')
+      instance.value 1, '2'
+      instance.should have_been_asked_for_its(:value).times(1).with(1, '2')
+      instance.value 1, '2' # correct one
+      instance.value 1, '3'
+      instance.value 2, '2'
+      instance.value 1, '2', 3
+      instance.should have_been_asked_for_its(:value).times(2).with(1, '2')
+      instance.should have_been_asked_for_its(:value).with(1, '2').times(2)
+    end
+
+    example 'failure message for should' do
+      expect { instance.should have_been_asked_for_its(:value).times(1).with(1, '2') }.to \
+        raise_error(RSpec::Expectations::ExpectationNotMetError, /should have been asked for its value 1 time with `1, "2"', but was never asked/)
+
+      instance.value 1, '2'
+      expect { instance.should have_been_asked_for_its(:value).times(0).with(1, '2') }.to \
+        raise_error(RSpec::Expectations::ExpectationNotMetError, /should have been asked for its value 0 times with `1, "2"', but was asked 1 time/)
+
+      instance.value 1, '2'
+      expect { instance.should have_been_asked_for_its(:value).times(1).with(1, '2') }.to \
+        raise_error(RSpec::Expectations::ExpectationNotMetError, /should have been asked for its value 1 time with `1, "2"', but was asked 2 times/)
+    end
+
+    example 'failure message for should not' do
+      instance.value 1, '2'
+      instance.value 1, '2'
+      expect { instance.should_not have_been_asked_for_its(:value).times(2).with(1, '2') }.to \
+        raise_error(RSpec::Expectations::ExpectationNotMetError, /should not have been asked for its value 2 times with `1, "2"'/)
+    end
+  end
+end

data/spec/rspec/have_been_initialized_with_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe 'RSpec matchers', 'have_been_initialized_with' do
+  let(:mocked_class) { Surrogate.endow Class.new }
+  before { mocked_class.module_eval { def initialize(*) end } } # b/c 1.9.3 will have arity issues otherwise
+
+  it 'is the same as have_been_told_to(:initialize).with(...)' do
+    mocked_class.new.should have_been_initialized_with no_args
+    mocked_class.new.should_not have_been_initialized_with(1)
+    mocked_class.new(1).should have_been_initialized_with 1
+    mocked_class.new(1, '2').should have_been_initialized_with 1, '2'
+  end
+
+  def failure_message_for
+    yield
+  rescue RSpec::Expectations::ExpectationNotMetError
+    $!.message
+  end
+
+  example 'failure message for should' do
+    failure_message_for { mocked_class.new("1").should have_been_initialized_with 2 }.should ==
+      failure_message_for { mocked_class.new("1").should have_been_told_to(:initialize).with(2) }
+  end
+
+  example 'failure message for should not' do
+    failure_message_for { mocked_class.new("1").should_not have_been_initialized_with('1') }.should ==
+      failure_message_for { mocked_class.new("1").should_not have_been_told_to(:initialize).with('1') }
+  end
+end

data/spec/rspec/have_been_told_to_spec.rb

@@ -0,0 +1,133 @@
+require 'spec_helper'
+
+describe 'RSpec matchers', 'have_been_told_to' do
+  let(:mocked_class) { Surrogate.endow Class.new }
+  let(:instance) { mocked_class.new }
+
+  describe 'default use case' do
+    before { mocked_class.define :kick, default: [] }
+
+    example 'passes if has been invoked at least once' do
+      instance.should_not have_been_told_to :kick
+      instance.kick
+      instance.should have_been_told_to :kick
+      instance.kick
+      instance.should have_been_told_to :kick
+    end
+
+    example 'failure message for should' do
+      expect { instance.should have_been_told_to :kick }.to \
+        raise_error(RSpec::Expectations::ExpectationNotMetError, /was never told to kick/)
+    end
+
+    example 'failure message for should not' do
+      instance.kick
+      expect { instance.should_not have_been_told_to :kick }.to \
+        raise_error(RSpec::Expectations::ExpectationNotMetError, /shouldn't have been told to kick, but was told to kick 1 time/)
+
+      instance.kick
+      expect { instance.should_not have_been_told_to :kick }.to \
+        raise_error(RSpec::Expectations::ExpectationNotMetError, /shouldn't have been told to kick, but was told to kick 2 times/)
+    end
+  end
+
+
+  describe 'specifying which arguments it should have been invoked with' do
+    before { mocked_class.define :smile, default: nil }
+
+    example 'default use case' do
+      instance.should_not have_been_told_to(:smile).with(1, 2, 3)
+      instance.smile 1, 2
+      instance.should_not have_been_told_to(:smile).with(1, 2, 3)
+      instance.smile 1, 2, 3
+      instance.should have_been_told_to(:smile).with(1, 2, 3)
+    end
+
+    example 'failure message for should' do
+      expect { instance.should have_been_told_to(:smile).with(1, '2') }.to \
+        raise_error(RSpec::Expectations::ExpectationNotMetError, /should have been told to smile with `1, "2"', but was never told to/)
+
+      instance.smile 3
+      instance.smile 4, '5'
+      expect { instance.should have_been_told_to(:smile).with(1, '2') }.to \
+        raise_error(RSpec::Expectations::ExpectationNotMetError, /should have been told to smile with `1, "2"', but got `3', `4, "5"'/)
+    end
+
+    example 'failure message for should not' do
+      instance.smile 1, '2'
+      expect { instance.should_not have_been_told_to(:smile).with(1, '2') }.to \
+        raise_error(RSpec::Expectations::ExpectationNotMetError, /should not have been told to smile with `1, "2"'/)
+    end
+  end
+
+
+  describe 'specifying number of times invoked' do
+    before { mocked_class.define :wink, default: nil }
+
+    example 'default use case' do
+      instance.should have_been_told_to(:wink).times(0)
+      instance.wink
+      instance.should have_been_told_to(:wink).times(1)
+      instance.wink
+      instance.should have_been_told_to(:wink).times(2)
+    end
+
+    example 'failure message for should' do
+      expect { instance.should have_been_told_to(:wink).times(1) }.to \
+        raise_error(RSpec::Expectations::ExpectationNotMetError, /should have been told to wink 1 time but was told to wink 0 times/)
+
+      instance.wink
+      expect { instance.should have_been_told_to(:wink).times(2) }.to \
+        raise_error(RSpec::Expectations::ExpectationNotMetError, /should have been told to wink 2 times but was told to wink 1 time/)
+    end
+
+    example 'failure message for should not' do
+      expect { instance.should_not have_been_told_to(:wink).times(0) }.to \
+        raise_error(RSpec::Expectations::ExpectationNotMetError, /shouldn't have been told to wink 0 times, but was/)
+
+      instance.wink
+      expect { instance.should_not have_been_told_to(:wink).times(1) }.to \
+        raise_error(RSpec::Expectations::ExpectationNotMetError, /shouldn't have been told to wink 1 time, but was/)
+    end
+  end
+
+  describe 'conjunction of with(args) and times(n)' do
+    before { mocked_class.define :wink, default: nil }
+
+    example 'default use case' do
+      instance.should have_been_told_to(:wink).times(0).with(1, '2')
+      instance.should_not have_been_told_to(:wink).times(1).with(1, '2')
+      instance.wink
+      instance.should have_been_told_to(:wink).times(0).with(1, '2')
+      instance.should_not have_been_told_to(:wink).times(1).with(1, '2')
+      instance.wink 1, '2'
+      instance.should have_been_told_to(:wink).times(1).with(1, '2')
+      instance.wink 1, '2' # correct one
+      instance.wink 1, '3'
+      instance.wink 2, '2'
+      instance.wink 1, '2', 3
+      instance.should have_been_told_to(:wink).times(2).with(1, '2')
+      instance.should have_been_told_to(:wink).with(1, '2').times(2)
+    end
+
+    example 'failure message for should' do
+      expect { instance.should have_been_told_to(:wink).times(1).with(1, '2') }.to \
+        raise_error(RSpec::Expectations::ExpectationNotMetError, /should have been told to wink 1 time with `1, "2"', but was never told to/)
+
+      instance.wink 1, '2'
+      expect { instance.should have_been_told_to(:wink).times(0).with(1, '2') }.to \
+        raise_error(RSpec::Expectations::ExpectationNotMetError, /should have been told to wink 0 times with `1, "2"', but got it 1 time/)
+
+      instance.wink 1, '2'
+      expect { instance.should have_been_told_to(:wink).times(1).with(1, '2') }.to \
+        raise_error(RSpec::Expectations::ExpectationNotMetError, /should have been told to wink 1 time with `1, "2"', but got it 2 times/)
+    end
+
+    example 'failure message for should not' do
+      instance.wink 1, '2'
+      instance.wink 1, '2'
+      expect { instance.should_not have_been_told_to(:wink).times(2).with(1, '2') }.to \
+        raise_error(RSpec::Expectations::ExpectationNotMetError, /should not have been told to wink 2 times with `1, "2"'/)
+    end
+  end
+end

data/spec/rspec/messages_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+messages_for = Surrogate::RSpec::MessagesFor
+
+describe messages_for, 'argument inspection' do
+
+  describe 'individual argument inspection inspection' do
+    it 'inspects non RSpec matchers as their default inspection' do
+      messages_for.inspect_argument("1").should == '"1"'
+      messages_for.inspect_argument(1).should == "1"
+      messages_for.inspect_argument([/a/]).should == "[/a/]"
+    end
+
+    it 'inspects no_args matcher' do
+      messages_for.inspect_argument(no_args).should == 'no_args'
+    end
+  end
+
+
+  describe 'multiple argument inspection' do
+    it "wraps individual arguments in `'" do
+      messages_for.inspect_arguments([/a/]).should == "`/a/'"
+    end
+
+    it "joins arguments with commas" do
+      messages_for.inspect_arguments(['x', no_args]).should == "`\"x\", no_args'"
+    end
+
+    it 'returns no_args when the array is empty' do
+      messages_for.inspect_arguments([]).should == "`no_args'"
+    end
+  end
+end