rr 1.1.1 → 3.0.0

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

@@ -0,0 +1,26 @@
+shared_context 'mock + instance_of' do
+  include MockDefinitionCreatorHelpers
+
+  context 'where subject is a class', method_type: :class do
+    include_context 'tests for a double definition creator method that supports mocking'
+
+    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 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/mock_instance_of_strong.rb

@@ -0,0 +1,28 @@
+shared_context 'mock + instance_of + strong' do
+  include MockDefinitionCreatorHelpers
+
+  context 'where subject is a class', method_type: :class 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 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/mock_proxy.rb

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

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

@@ -0,0 +1,37 @@
+shared_context 'mock + strong' do
+  include MockDefinitionCreatorHelpers
+
+  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 mocking'
+
+      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 mocking'
+
+      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/mocking.rb

@@ -0,0 +1,107 @@
+shared_context 'tests for a double definition creator method that supports mocking' do
+  include DoubleDefinitionCreatorHelpers
+
+  specify "TimesCalledError is raised at the verify step if the method is never called" do
+    build_object_with_possible_methods(some_method: -> {}) do |subject|
+      double_creator = double_definition_creator_for(subject)
+      double_creator.some_method
+    end
+    expect { RR.verify }.to raise_error(RR::Errors::TimesCalledError)
+  end
+
+  it_behaves_like 'defining a method double that sets the implementation of that method'
+
+  context 'defining a mock with an argument expectation with a times-called qualifier' do
+    context 'by passing arguments to the double definition directly' do
+      include_context 'using 1 of 2 ways to define a mock with an argument expectation with a times-called qualifier'
+
+      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 mock with an argument expectation with a times-called qualifier'
+
+        def define_double_with_argument_expectation(double_creator, method_name, *args)
+          double_creator.__send__(method_name).with(*args)
+        end
+      end
+    end
+  end
+
+  context 'defining a mock with an argument expectation with a never-called qualifier' do
+    context 'by passing arguments to the double definition directly' do
+      include_context 'using 1 of 2 ways to define a mock with an argument expectation with a never-called qualifier'
+
+      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 mock with an argument expectation with a never-called qualifier'
+
+        def define_double_with_argument_expectation(double_creator, method_name, *args)
+          double_creator.__send__(method_name).with(*args)
+        end
+      end
+    end
+  end
+
+  context 'defining a mock with an argument expectation without any qualifiers' 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_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