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