rr 1.1.2 → 3.0.2

data/spec/suites/rspec_2/support/shared_contexts/double_definition_creators/stub_instance_of.rb

@@ -0,0 +1,32 @@
+shared_context 'stub + instance_of' do
+  include StubDefinitionCreatorHelpers
+
+  context 'where subject is a class', method_type: :class do
+    context 'where methods being doubled already exist', methods_exist: true do
+      include_context 'tests for a double definition creator method that supports stubbing'
+
+      it "lets you stub methods which are called in #initialize" do
+        klass = Class.new do
+          def initialize; method_run_in_initialize; end
+          def method_run_in_initialize; end
+        end
+        method_double_called = false
+        double_creator = double_definition_creator_for(klass)
+        double_creator.method_run_in_initialize { method_double_called = true }
+        klass.new
+        expect(method_double_called).to eq true
+      end
+    end
+
+    context 'where methods being doubled do not already exist', methods_exist: false do
+      include_context 'tests for a double definition creator method that supports stubbing'
+    end
+  end
+
+  context 'where subject is an instance of a class', method_type: :instance do
+    it "doesn't work" do
+      double_creator = double_definition_creator_for(Object.new)
+      expect { double_creator.some_method }.to raise_error(ArgumentError)
+    end
+  end
+end

data/spec/suites/rspec_2/support/shared_contexts/double_definition_creators/stub_instance_of_strong.rb

@@ -0,0 +1,39 @@
+shared_context 'stub + instance_of + strong' do
+  include StubDefinitionCreatorHelpers
+
+  context 'where subject is a class', method_type: :class do
+    context 'where methods being doubled already exist', methods_exist: true do
+      include_context 'tests for a double definition creator method that supports stubbing'
+
+      it_behaves_like 'comparing the arity between the method and double definition'
+
+      it "lets you stub methods which are called in #initialize" do
+        klass = Class.new do
+          def initialize; method_run_in_initialize; end
+          def method_run_in_initialize; end
+        end
+        method_double_called = false
+        double_creator = double_definition_creator_for(klass)
+        double_creator.method_run_in_initialize { method_double_called = true }
+        klass.new
+        expect(method_double_called).to eq true
+      end
+    end
+
+    context 'where methods being doubled do not already exist', methods_exist: false do
+      it "doesn't work" do
+        klass = Class.new
+        double_creator = double_definition_creator_for(klass)
+        expect { double_creator.some_method }.to \
+          raise_error(RR::Errors::SubjectDoesNotImplementMethodError)
+      end
+    end
+  end
+
+  context 'where subject is an instance of a class', method_type: :instance do
+    it "doesn't work" do
+      double_creator = double_definition_creator_for(Object.new)
+      expect { double_creator.some_method }.to raise_error(ArgumentError)
+    end
+  end
+end

data/spec/suites/rspec_2/support/shared_contexts/double_definition_creators/stub_proxy.rb

@@ -0,0 +1,11 @@
+shared_context 'stub + proxy' do
+  include ProxyDefinitionCreatorHelpers
+
+  context 'against instance methods', method_type: :instance do
+    include_context 'tests for a double definition creator method that supports stubbing'
+  end
+
+  context 'against class methods', method_type: :class do
+    include_context 'tests for a double definition creator method that supports stubbing'
+  end
+end

data/spec/suites/rspec_2/support/shared_contexts/double_definition_creators/stub_strong.rb

@@ -0,0 +1,37 @@
+shared_context 'stub + strong' do
+  include StubDefinitionCreatorHelpers
+
+  context 'against instance methods', method_type: :instance do
+    context 'that exist', methods_exist: true do
+      include_context 'tests for a double definition creator method that supports stubbing'
+
+      it_behaves_like 'comparing the arity between the method and double definition'
+    end
+
+    context 'that do not exist', methods_exist: false do
+      it "doesn't work" do
+        object = Object.new
+        double_creator = double_definition_creator_for(object)
+        expect { double_creator.some_method }.to \
+          raise_error(RR::Errors::SubjectDoesNotImplementMethodError)
+      end
+    end
+  end
+
+  context 'against class methods', method_type: :class do
+    context 'that exist', methods_exist: true do
+      include_context 'tests for a double definition creator method that supports stubbing'
+
+      it_behaves_like 'comparing the arity between the method and double definition'
+    end
+
+    context 'that do not exist', methods_exist: false do
+      it "doesn't work" do
+        klass = Class.new
+        double_creator = double_definition_creator_for(klass)
+        expect { double_creator.some_method }.to \
+          raise_error(RR::Errors::SubjectDoesNotImplementMethodError)
+      end
+    end
+  end
+end

data/spec/suites/rspec_2/support/shared_contexts/double_definition_creators/stubbing.rb

@@ -0,0 +1,57 @@
+shared_context 'tests for a double definition creator method that supports stubbing' do
+  include DoubleDefinitionCreatorHelpers
+
+  it_behaves_like 'defining a method double that sets the implementation of that method'
+
+  context 'defining a method double with an argument expectation' do
+    context 'by passing arguments to the double definition directly' do
+      include_context 'using 1 of 2 ways to define a method double with an argument expectation without any qualifiers'
+
+      def define_double_with_argument_expectation(double_creator, method_name, *args)
+        double_creator.__send__(method_name, *args)
+      end
+    end
+
+    # https://github.com/rr/rr/issues/23
+    unless supports_strong?
+      context 'by using #with and arguments' do
+        include_context 'using 1 of 2 ways to define a method double with an argument expectation without any qualifiers'
+
+        def define_double_with_argument_expectation(double_creator, method_name, *args)
+          double_creator.__send__(method_name).with(*args)
+        end
+      end
+    end
+  end
+
+  it_behaves_like 'defining a method double qualified with #yields'
+  it_behaves_like 'defining method doubles using the block form of the double definition creator'
+  it_behaves_like 'defining a method double for sequential invocations of that method using #ordered/#then'
+  it_behaves_like 'an object which has a method double wrapped in an array and flattened'
+
+  if supports_proxying? && !supports_instance_of?
+    it_behaves_like 'defining a method double on an object which is a proxy for another object'
+  end
+
+  if methods_being_doubled_exist_already?
+    it "lets you double operator methods as well as normal ones" do
+      object = build_object do |subject|
+        double_definition_creator_for(subject).==(anything) { 'value' }
+      end
+      expect(object == :whatever).to eq 'value'
+    end
+  end
+
+  if type_of_methods_being_tested == :class && methods_being_doubled_exist_already? && !supports_instance_of?
+    it "in a parent class doesn't affect child classes" do
+      parent_class = Class.new do
+        def self.some_method; 'existing value'; end
+      end
+      child_class = Class.new(parent_class)
+      double_creator = double_definition_creator_for(parent_class)
+      double_creator.some_method { 'value' }
+      parent_class.some_method
+      expect(child_class.some_method).to eq 'existing value'
+    end
+  end
+end

data/spec/suites/rspec_2/support/shared_examples/double_definition_creators/array_flatten_bug.rb

@@ -0,0 +1,35 @@
+# btakita/rr issue #44
+shared_examples_for 'an object which has a method double wrapped in an array and flattened' do
+  include DoubleDefinitionCreatorHelpers
+
+  it "does not raise an error" do
+    object = build_object_with_possible_methods(some_method: -> {}) do |subject|
+      double_definition_creator_for(subject).some_method
+    end
+    # force RR to define method_missing
+    call_method_rescuing_times_called_error(object, :some_method)
+    expect([object].flatten).to eq [object]
+  end
+
+  it "honors a #to_ary that already exists" do
+    object = build_object_with_possible_methods(some_method: -> {}) do |subject, object|
+      (class << object; self; end).class_eval do
+        def to_ary; []; end
+      end
+      double_definition_creator_for(subject).some_method
+    end
+    # force RR to define method_missing
+    call_method_rescuing_times_called_error(object, :some_method)
+    expect([object].flatten).to eq []
+  end
+
+  it "is reset correctly" do
+    object = build_object_with_possible_methods(some_method: -> {}) do |subject|
+      double_definition_creator_for(subject).some_method
+    end
+    # force RR to define method_missing
+    call_method_rescuing_times_called_error(object, :some_method)
+    RR.reset
+    expect([object].flatten).to eq [object]
+  end
+end

data/spec/suites/rspec_2/support/shared_examples/double_definition_creators/block_form.rb

@@ -0,0 +1,31 @@
+shared_examples_for 'defining method doubles using the block form of the double definition creator' do
+  include DoubleDefinitionCreatorHelpers
+
+  it "allows multiple methods to be doubled" do
+    object = build_object_with_possible_methods(
+      some_method: -> { 'existing value 1' },
+      another_method: -> { 'existing value 2' }
+    ) do |subject|
+      double_definition_creator_for(subject) do
+        some_method { 'value 1' }
+        another_method { 'value 2' }
+      end
+    end
+    expect_call_to_return_or_raise_times_called_error('value 1', object, :some_method)
+    expect_call_to_return_or_raise_times_called_error('value 2', object, :another_method)
+  end
+
+  it "yields rather than using instance_eval if a block argument is given" do
+    object = build_object_with_possible_methods(
+      some_method: -> { 'existing value 1' },
+      another_method: -> { 'existing value 2' }
+    ) do |subject|
+      double_definition_creator_for(subject) do |double_creator|
+        double_creator.some_method { 'value 1' }
+        double_creator.another_method { 'value 2' }
+      end
+    end
+    expect_call_to_return_or_raise_times_called_error('value 1', object, :some_method)
+    expect_call_to_return_or_raise_times_called_error('value 2', object, :another_method)
+  end
+end

data/spec/suites/rspec_2/support/shared_examples/double_definition_creators/comparing_arity.rb

@@ -0,0 +1,63 @@
+shared_examples_for 'comparing the arity between the method and double definition' do
+  it "succeeds if both have no arity" do
+    object = build_object_with_methods(some_method: -> {}) do |subject|
+      double_creator = double_definition_creator_for(subject)
+      double_creator.some_method
+    end
+    object.some_method
+  end
+
+  it "fails if the former has no arity and the latter does" do
+    build_object_with_methods(some_method: -> {}) do |subject|
+      double_creator = double_definition_creator_for(subject)
+      expect { double_creator.some_method(1) }.to \
+        raise_error(RR::Errors::SubjectHasDifferentArityError)
+    end
+  end
+
+  it "fails if the former has arity but the latter doesn't" do
+    build_object_with_methods(some_method: ->(arg) {}) do |subject|
+      double_creator = double_definition_creator_for(subject)
+      expect { double_creator.some_method }.to \
+        raise_error(RR::Errors::SubjectHasDifferentArityError)
+    end
+  end
+
+  it "succeeds if both have a finite number of arguments" do
+    object = build_object_with_methods(some_method: ->(arg) {}) do |subject|
+      double_creator = double_definition_creator_for(subject)
+      double_creator.some_method(1)
+    end
+    object.some_method(1)
+  end
+
+  it "succeeds if both have a variable number of arguments" do
+    object = build_object_with_methods(some_method: ->(*args) {}) do |subject|
+      double_creator = double_definition_creator_for(subject)
+      double_creator.some_method(1)
+      double_creator.some_method(1, 2, 3)
+      double_creator.some_method(1, 2)
+    end
+    object.some_method(1)
+    object.some_method(1, 2)
+    object.some_method(1, 2, 3)
+  end
+
+  it "succeeds if both have finite and variable number of arguments" do
+    object = build_object_with_methods(some_method: ->(arg1, arg2, *rest) {}) do |subject|
+      double_creator = double_definition_creator_for(subject)
+      double_creator.some_method(1, 2)
+      double_creator.some_method(1, 2, 3)
+    end
+    object.some_method(1, 2)
+    object.some_method(1, 2, 3)
+  end
+
+  it "fails if the finite arguments are not matched before the variable arguments" do
+    build_object_with_methods(some_method: ->(arg1, arg2, *rest) {}) do |subject|
+      double_creator = double_definition_creator_for(subject)
+      expect { double_creator.some_method(1) }.to \
+        raise_error(RR::Errors::SubjectHasDifferentArityError)
+    end
+  end
+end

data/spec/suites/rspec_2/support/shared_examples/double_definition_creators/object_is_proxy.rb

@@ -0,0 +1,43 @@
+# btakita/rr issue #24
+# this happens when defining a double on an ActiveRecord association object
+shared_examples_for 'defining a method double on an object which is a proxy for another object' do
+  include DoubleDefinitionCreatorHelpers
+
+  it "places the double on the proxy object and not the target object by mistake" do
+    target_object = build_object_with_possible_methods(some_method: -> { 'existing value' })
+    proxy_object = proxy_object_class.new(target_object)
+    expect(proxy_object.methods).to match_array(target_object.methods)
+    double_definition_creator_for(proxy_object).some_method { 'value' }
+    expect(proxy_object.some_method).to eq 'value'
+  end
+
+  it "resets the double correctly" do
+    target_object = build_object_with_possible_methods(some_method: -> { 'existing value' })
+    proxy_object = proxy_object_class.new(target_object)
+    expect(proxy_object.methods).to match_array(target_object.methods)
+    double_definition_creator_for(proxy_object).some_method { 'value' }
+    RR.reset
+    expect_method_to_have_value_or_be_absent('existing value', proxy_object, :some_method)
+  end
+
+  def proxy_object_class
+    Class.new do
+      # This matches what AssociationProxy was like as of Rails 2
+      instance_methods.each do |m|
+        undef_method m unless m.to_s =~ /^(?:nil\?|send|object_id|to_a)$|^__|^respond_to|proxy_/
+      end
+
+      def initialize(target)
+        @target = target
+      end
+
+      def method_missing(name, *args, &block)
+        if @target.respond_to?(name)
+          @target.__send__(name, *args, &block)
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/spec/suites/rspec_2/support/shared_examples/double_definition_creators/sequential_invocations.rb

@@ -0,0 +1,26 @@
+shared_examples_for 'defining a method double for sequential invocations of that method using #ordered/#then' do
+  include DoubleDefinitionCreatorHelpers
+
+  it "works" do
+    object = build_object_with_possible_methods(some_method: -> {}) do |subject|
+      double_creator = double_definition_creator_for(subject)
+      double_creator.some_method { 'value 1' }.twice.ordered
+      double_creator.some_method { 'value 2' }.once.ordered
+    end
+
+    expect(object.some_method).to eq 'value 1'
+    expect(object.some_method).to eq 'value 1'
+    expect(object.some_method).to eq 'value 2'
+  end
+
+  it "works when using #then instead of #ordered" do
+    object = build_object_with_possible_methods(some_method: -> {}) do |subject|
+      double_definition_creator_for(subject).
+        some_method { 'value 1' }.once.then.
+        some_method { 'value 2' }.once
+    end
+
+    expect(object.some_method).to eq 'value 1'
+    expect(object.some_method).to eq 'value 2'
+  end
+end

data/spec/suites/rspec_2/support/shared_examples/double_definition_creators/setting_implementation.rb

@@ -0,0 +1,51 @@
+shared_examples_for 'defining a method double that sets the implementation of that method' do
+  include DoubleDefinitionCreatorHelpers
+
+  it "works when not given a block" do
+    expect_that_double_can_be_defined_without_block
+  end
+
+  context 'by giving a block' do
+    it "replaces the implementation with the block" do
+      expect_that_double_sets_implementation do |double_creator, method_name, block|
+        double_creator.__send__(method_name, &block)
+      end
+    end
+
+    it "resets the double correctly" do
+      expect_that_double_sets_implementation_and_resets do |double_creator, method_name, block|
+        double_creator.__send__(method_name, &block)
+      end
+    end
+  end
+
+  context 'by using #returns' do
+    context 'with a block' do
+      it "replaces the implementation with the block" do
+        expect_that_double_sets_implementation do |double_creator, method_name, block|
+          double_creator.__send__(method_name).returns(&block)
+        end
+      end
+
+      it "resets the double correctly" do
+        expect_that_double_sets_implementation_and_resets do |double_creator, method_name, block|
+          double_creator.__send__(method_name).returns(&block)
+        end
+      end
+    end
+
+    context 'with a straight argument' do
+      it "makes the method return the argument" do
+        expect_that_double_sets_value do |double_creator, method_name, value|
+          double_creator.__send__(method_name).returns(value)
+        end
+      end
+
+      it "resets the double correctly" do
+        expect_that_double_sets_value_and_resets do |double, method_name, value|
+          double_creator.__send__(method_name).returns(value)
+        end
+      end
+    end
+  end
+end

data/spec/suites/rspec_2/support/shared_examples/double_definition_creators/yields.rb

@@ -0,0 +1,81 @@
+shared_examples_for 'defining a method double qualified with #yields' do
+  include DoubleDefinitionCreatorHelpers
+
+  context 'without arguments' do
+    it "inserts a yield that passes no arguments" do
+      object = build_object_with_possible_methods(some_method: -> {}) do |subject|
+        double_definition_creator_for(subject).some_method.yields
+      end
+      x = 0
+      object.some_method { x = 1 }
+      expect(x).to eq 1
+    end
+
+    it "does not affect setting the implementation otherwise" do
+      object = build_object_with_possible_methods(some_method: -> { 'existing value' }) do |subject|
+        double_definition_creator_for(subject).some_method { 'value' }.yields
+      end
+      expect(object.some_method { }).to eq 'value'
+    end
+
+    it "also lets you set the implementation in preference to #returns" do
+      object = build_object_with_possible_methods(some_method: -> { 'existing value' }) do |subject|
+        double_definition_creator_for(subject).some_method.yields { 'value' }
+      end
+      expect(object.some_method { }).to eq 'value'
+    end
+
+    it "is reset correctly" do
+      object = build_object_with_possible_methods(some_method: -> {}) do |subject|
+        double_definition_creator_for(subject).some_method.yields
+      end
+      RR.reset
+      x = 0
+      if methods_being_doubled_exist_already?
+        object.some_method { x = 1 }
+        expect(x).to eq 0
+      else
+        expect_method_to_not_exist(object, :some_method)
+      end
+    end
+  end
+
+  context 'with arguments' do
+    it "inserts a yield that passes those arguments" do
+      object = build_object_with_possible_methods(some_method: -> {}) do |subject|
+        double_definition_creator_for(subject).some_method.yields(1)
+      end
+      x = 0
+      object.some_method {|a| x = a }
+      expect(x).to eq 1
+    end
+
+    it "does not affect setting the implementation otherwise" do
+      object = build_object_with_possible_methods(some_method: -> { 'existing value' }) do |subject|
+        double_definition_creator_for(subject).some_method { 'value' }.yields(1)
+      end
+      expect(object.some_method { }).to eq 'value'
+    end
+
+    it "also lets you set the implementation in preference to #returns" do
+      object = build_object_with_possible_methods(some_method: -> { 'existing value' }) do |subject|
+        double_definition_creator_for(subject).some_method.yields(1) { 'value' }
+      end
+      expect(object.some_method { }).to eq 'value'
+    end
+
+    it "is reset correctly" do
+      object = build_object_with_possible_methods(some_method: -> {}) do |subject|
+        double_definition_creator_for(subject).some_method.yields(1)
+      end
+      RR.reset
+      if methods_being_doubled_exist_already?
+        x = 0
+        object.some_method {|a| x = a }
+        expect(x).to eq 0
+      else
+        expect_method_to_not_exist(object, :some_method)
+      end
+    end
+  end
+end