rr 1.1.2 → 1.2.0

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

@@ -0,0 +1,131 @@
+shared_context 'using 1 of 2 ways to define a method double with an argument expectation without any qualifiers' do
+  include DoubleDefinitionCreatorHelpers
+
+  it "defines the double just for that specific invocation" do
+    object = build_object_with_possible_methods(some_method: ->(*args) { 'value' }) do |subject|
+      double_creator = double_definition_creator_for(subject)
+      double = define_double_with_argument_expectation(double_creator, :some_method, 1)
+      double.returns { 'bar' }
+    end
+    expect_call_to_return_or_raise_times_called_error('bar', object, :some_method, 1)
+  end
+
+  if supports_dont_allow?
+
+    context 'upon verification after the invocation occurs too few times' do
+      specify "no error is raised if the method is never called at all" do
+        build_object_with_possible_methods(some_method: ->(*args) {}) do |subject|
+          double_creator = double_definition_creator_for(subject)
+          define_double_with_argument_expectation(double_creator, :some_method, 1)
+        end
+        expect { RR.verify }.not_to raise_error
+      end
+    end
+
+    context 'the moment an unknown invocation occurs' do
+      specify "DoubleNotFoundError is raised" do
+        object = build_object_with_possible_methods(some_method: ->(*args) {}) do |subject|
+          double_creator = double_definition_creator_for(subject)
+          define_double_with_argument_expectation(double_creator, :some_method, 1)
+        end
+        expect { object.some_method }.to raise_error(RR::Errors::DoubleNotFoundError)
+        RR.reset
+      end
+
+      it "is reset correctly" do
+        object = build_object_with_possible_methods(some_method: ->(*args) {}) do |subject|
+          double_creator = double_definition_creator_for(subject)
+          define_double_with_argument_expectation(double_creator, :some_method, 1)
+        end
+        RR.reset
+        expect {
+          call_possible_method_on(object, :some_method)
+        }.not_to raise_error
+      end
+    end
+
+  elsif supports_mocking?
+
+    context 'upon verification after the invocation occurs too few times' do
+      specify "TimesCalledError is raised at the verify step if the method is never called at all" do
+        build_object_with_possible_methods(some_method: ->(*args) {}) do |subject|
+          double_creator = double_definition_creator_for(subject)
+          define_double_with_argument_expectation(double_creator, :some_method, 1)
+        end
+        expect { RR.verify }.to raise_error(RR::Errors::TimesCalledError)
+      end
+
+      specify "nothing happens upon being reset" do
+        build_object_with_possible_methods(some_method: ->(*args) {}) do |subject|
+          double_creator = double_definition_creator_for(subject)
+          define_double_with_argument_expectation(double_creator, :some_method, 1)
+        end
+        RR.reset
+        expect { RR.verify }.not_to raise_error
+      end
+    end
+
+    context 'the moment an unknown invocation occurs' do
+      specify "DoubleNotFoundError is raised" do
+        object = build_object_with_possible_methods(some_method: ->(*args) {}) do |subject|
+          double_creator = double_definition_creator_for(subject)
+          define_double_with_argument_expectation(double_creator, :some_method, 1)
+        end
+        expect { object.some_method }.to raise_error(RR::Errors::DoubleNotFoundError)
+        RR.reset
+      end
+
+      specify "is reset correctly" do
+        object = build_object_with_possible_methods(some_method: ->(*args) {}) do |subject|
+          double_creator = double_definition_creator_for(subject)
+          define_double_with_argument_expectation(double_creator, :some_method, 1)
+        end
+        RR.reset
+        expect {
+          call_possible_method_on(object, :some_method, 1)
+        }.not_to raise_error
+      end
+    end
+
+  else
+
+    it "resets the double correctly" do
+      object = build_object_with_possible_methods(some_method: ->(*args) { 'existing value' }) do |subject, object|
+        expect_method_to_have_value_or_be_absent('existing value', object, :some_method, 1)
+        double_creator = double_definition_creator_for(subject)
+        double = define_double_with_argument_expectation(double_creator, :some_method, 1)
+        double.returns { 'new value' }
+      end
+      RR.reset
+      expect_method_to_have_value_or_be_absent('existing value', object, :some_method, 1)
+    end
+
+    it "raises DoubleNotFoundError the moment the method is called but not with the specified arguments" do
+      object = build_object_with_possible_methods(some_method: ->(*args) {}) do |subject|
+        double_creator = double_definition_creator_for(subject)
+        define_double_with_argument_expectation(double_creator, :some_method, 1)
+      end
+      expect { object.some_method }.to raise_error(RR::Errors::DoubleNotFoundError)
+      RR.reset
+    end
+
+  end
+
+  unless supports_dont_allow?
+    it "lets you define a catch-all double by defining a stub without arguments" do
+      object = build_object_with_possible_methods(some_method: ->(*args) {}) do |subject|
+        double_creator =
+          if supports_instance_of?
+            stub.instance_of(subject)
+          else
+            stub(subject)
+          end
+        double_creator.some_method
+        double_creator = double_definition_creator_for(subject)
+        define_double_with_argument_expectation(double_creator, :some_method, 1)
+      end
+      object.some_method(1)
+      object.some_method(2)  # shouldn't raise an error
+    end
+  end
+end

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

@@ -0,0 +1,148 @@
+shared_context 'tests for a double definition creator method that supports dont_allow' do
+  include DoubleDefinitionCreatorHelpers
+
+  specify "TimesCalledError is raised as soon as the method is called" do
+    object = build_object_with_possible_methods(some_method: -> {}) do |subject|
+      dont_allow(subject).some_method
+    end
+    expect { object.some_method }.to raise_error(RR::Errors::TimesCalledError)
+  end
+
+  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'
+
+      specify "no error is raised if the method is never called at all" do
+        build_object_with_possible_methods(some_method: -> {}) do |subject|
+          double_creator = double_definition_creator_for(subject)
+          define_double_with_argument_expectation(double_creator, :some_method, 1)
+        end
+      end
+
+      specify "a DoubleNotFoundError is raised if the method is called but not with the specified arguments" do
+        object = build_object_with_possible_methods(some_method: -> {}) do |subject|
+          double_creator = double_definition_creator_for(subject)
+          define_double_with_argument_expectation(double_creator, :some_method, 1)
+        end
+        expect { object.some_method }.to raise_error(RR::Errors::DoubleNotFoundError)
+      end
+
+      specify "a TimesCalledError is raised the moment the method is called with the specified arguments" do
+        object = build_object_with_possible_methods(some_method: -> {}) do |subject|
+          double_creator = double_definition_creator_for(subject)
+          define_double_with_argument_expectation(double_creator, :some_method, 1)
+        end
+        expect { object.some_method(1) }.to raise_error(RR::Errors::TimesCalledError)
+      end
+
+      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'
+
+        specify "no error is raised if the method is never called at all" do
+          build_object_with_possible_methods(some_method: -> {}) do |subject|
+            double_creator = double_definition_creator_for(subject)
+            define_double_with_argument_expectation(double_creator, :some_method, 1)
+          end
+        end
+
+        specify "a DoubleNotFoundError is raised if the method is called but not with the specified arguments" do
+          object = build_object_with_possible_methods(some_method: -> {}) do |subject|
+            double_creator = double_definition_creator_for(subject)
+            define_double_with_argument_expectation(double_creator, :some_method, 1)
+          end
+          expect { object.some_method }.to raise_error(RR::Errors::DoubleNotFoundError)
+        end
+
+        specify "a TimesCalledError is raised the moment the method is called with the specified arguments" do
+          object = build_object_with_possible_methods(some_method: -> {}) do |subject|
+            double_creator = double_definition_creator_for(subject)
+            define_double_with_argument_expectation(double_creator, :some_method, 1)
+          end
+          expect { object.some_method(1) }.to raise_error(RR::Errors::TimesCalledError)
+        end
+
+        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 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_call_to_return_or_raise_times_called_error('value', object, :==, :whatever)
+    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' }
+      expect(child_class.some_method).to eq 'existing value'
+    end
+  end
+end

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