rr 1.1.1 → 3.0.0

data/spec/suites/rspec_2/support/mixins/mock_definition_creator_helpers.rb

@@ -0,0 +1,45 @@
+module MockDefinitionCreatorHelpers
+  include DoubleDefinitionCreatorHelpers
+
+  def expect_that_double_can_be_defined_without_block
+    _, _, return_value =
+      build_object_with_doubled_method_which_is_called('value')
+    expect(return_value).to eq nil
+  end
+
+  def expect_that_double_sets_implementation(&block)
+    _, _, return_value =
+      build_object_with_doubled_method_which_is_called('old value', -> { 'new value' }, &block)
+    expect(return_value).to eq 'new value'
+  end
+
+  def expect_that_double_sets_implementation_and_resets(&block)
+    object, method_name, return_value =
+      build_object_with_doubled_method_which_is_reset_and_called('old value', -> { 'new value' }, &block)
+
+    if methods_being_doubled_exist_already?
+      # This doesn't work quite yet - see btakita#44
+      #expect(object).not_to respond_to(method_name)
+    else
+      expect(return_value).to eq 'old value'
+    end
+  end
+
+  def expect_that_double_sets_value(&block)
+    _, _, return_value =
+      build_object_with_doubled_method_which_is_called('old value', 'new value', &block)
+    expect(return_value).to eq 'new value'
+  end
+
+  def expect_that_double_sets_value_and_resets(&block)
+    _, _, return_value =
+      build_object_with_doubled_method_which_is_reset_and_called('old value', 'new value', &block)
+
+    if methods_being_doubled_exist_already?
+      # This doesn't work quite yet - see btakita#44
+      #expect(object).not_to respond_to(method_name)
+    else
+      expect(return_value).to eq 'old value'
+    end
+  end
+end

data/spec/suites/rspec_2/support/mixins/proxy_definition_creator_helpers.rb

@@ -0,0 +1,33 @@
+module ProxyDefinitionCreatorHelpers
+  include DoubleDefinitionCreatorHelpers
+
+  def expect_that_double_can_be_defined_without_block
+    _, _, return_value =
+      build_object_with_doubled_method_which_is_called('value', nil)
+    expect(return_value).to eq 'value'
+  end
+
+  def expect_that_double_sets_implementation(&block)
+    _, _, return_value =
+      build_object_with_doubled_method_which_is_called('value', ->(v) { v.upcase }, &block)
+    expect(return_value).to eq 'VALUE'
+  end
+
+  def expect_that_double_sets_implementation_and_resets(&block)
+    _, _, return_value =
+      build_object_with_doubled_method_which_is_reset_and_called('value', ->(v) { v.upcase }, &block)
+    expect(return_value).to eq 'value'
+  end
+
+  def expect_that_double_sets_value(&block)
+    _, _, return_value =
+      build_object_with_doubled_method_which_is_called('old value', 'new value', &block)
+    expect(return_value).to eq 'new value'
+  end
+
+  def expect_that_double_sets_value_and_resets(&block)
+    _, _, return_value =
+      build_object_with_doubled_method_which_is_reset_and_called('old value', 'new value', &block)
+    expect(return_value).to eq 'old value'
+  end
+end

data/spec/suites/rspec_2/support/mixins/stub_creator_helpers.rb

@@ -0,0 +1,43 @@
+module StubDefinitionCreatorHelpers
+  def expect_that_double_can_be_defined_without_block
+    _, _, return_value =
+      build_object_with_doubled_method_which_is_called('value', nil)
+    expect(return_value).to eq nil
+  end
+
+  def expect_that_double_sets_implementation(&block)
+    _, _, return_value =
+      build_object_with_doubled_method_which_is_called('old value', -> { 'new value' }, &block)
+    expect(return_value).to eq 'new value'
+  end
+
+  def expect_that_double_sets_implementation_and_resets(&block)
+    object, method_name, return_value =
+      build_object_with_doubled_method_which_is_reset_and_called('old value', -> { 'new value' }, &block)
+
+    if methods_being_doubled_exist_already?
+      # This doesn't work quite yet - see btakita#44
+      #expect(object).not_to respond_to(method_name)
+    else
+      expect(return_value).to eq 'old value'
+    end
+  end
+
+  def expect_that_double_sets_value(&block)
+    _, _, return_value =
+      build_object_with_doubled_method_which_is_called('old value', 'new value', &block)
+    expect(return_value).to eq 'new value'
+  end
+
+  def expect_that_double_sets_value_and_resets(&block)
+    _, _, return_value =
+      build_object_with_doubled_method_which_is_reset_and_called('old value', 'new value', &block)
+
+    if methods_being_doubled_exist_already?
+      # This doesn't work quite yet - see btakita#44
+      #expect(object).not_to respond_to(method_name)
+    else
+      expect(return_value).to eq 'old value'
+    end
+  end
+end

data/spec/suites/rspec_2/support/mixins/stub_definition_creator_helpers.rb

@@ -0,0 +1,45 @@
+module StubDefinitionCreatorHelpers
+  include DoubleDefinitionCreatorHelpers
+
+  def expect_that_double_can_be_defined_without_block
+    _, _, return_value =
+      build_object_with_doubled_method_which_is_called('value', nil)
+    expect(return_value).to eq nil
+  end
+
+  def expect_that_double_sets_implementation(&block)
+    _, _, return_value =
+      build_object_with_doubled_method_which_is_called('old value', -> { 'new value' }, &block)
+    expect(return_value).to eq 'new value'
+  end
+
+  def expect_that_double_sets_implementation_and_resets(&block)
+    object, method_name, return_value =
+      build_object_with_doubled_method_which_is_reset_and_called('old value', -> { 'new value' }, &block)
+
+    if methods_being_doubled_exist_already?
+      # This doesn't work quite yet - see btakita#44
+      #expect(object).not_to respond_to(method_name)
+    else
+      expect(return_value).to eq 'old value'
+    end
+  end
+
+  def expect_that_double_sets_value(&block)
+    _, _, return_value =
+      build_object_with_doubled_method_which_is_called('old value', 'new value', &block)
+    expect(return_value).to eq 'new value'
+  end
+
+  def expect_that_double_sets_value_and_resets(&block)
+    _, _, return_value =
+      build_object_with_doubled_method_which_is_reset_and_called('old value', 'new value', &block)
+
+    if methods_being_doubled_exist_already?
+      # This doesn't work quite yet - see btakita#44
+      #expect(object).not_to respond_to(method_name)
+    else
+      expect(return_value).to eq 'old value'
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+shared_context 'using 1 of 2 ways to define a mock with an argument expectation with a never-called qualifier' do
+  include DoubleDefinitionCreatorHelpers
+
+  it "works as long as the invocation never occurs" do
+    build_object_with_possible_methods(some_method: lambda {|arg| }) do |subject|
+      double_creator = double_definition_creator_for(subject)
+      define_double_with_argument_expectation(double_creator, :some_method, 1).never
+    end
+  end
+
+  it "works as long as the invocation never occurs even if other invocations occur" do
+    object = build_object_with_possible_methods(some_method: lambda {|arg| }) do |subject|
+      double_creator = double_definition_creator_for(subject)
+      define_double_with_argument_expectation(double_creator, :some_method, 1).never
+    end
+    stub(object).some_method.with_any_args
+    object.some_method(2)
+  end
+
+  specify "TimesCalledError is raised as soon as the invocation occurs" do
+    object = build_object_with_possible_methods(some_method: lambda {|arg| }) do |subject|
+      double_creator = double_definition_creator_for(subject)
+      define_double_with_argument_expectation(double_creator, :some_method, 1).never
+    end
+    expect { object.some_method(1) }.to raise_error(RR::Errors::TimesCalledError)
+    RR.reset
+  end
+
+  specify "nothing happens upon being reset" do
+    object = build_object_with_possible_methods(some_method: lambda {|arg| }) do |subject|
+      double_creator = double_definition_creator_for(subject)
+      define_double_with_argument_expectation(double_creator, :some_method, 1).never
+    end
+    RR.reset
+    expect {
+      call_possible_method_on(object, :some_method, 1)
+    }.not_to raise_error
+  end
+end

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

@@ -0,0 +1,50 @@
+shared_context 'using 1 of 2 ways to define a mock with an argument expectation with a times-called qualifier' do
+  include DoubleDefinitionCreatorHelpers
+
+  context 'upon verification after the invocation occurs too few times' do
+    specify "TimesCalledError is raised" do
+      object = build_object_with_possible_methods(some_method: ->(arg) {}) do |subject|
+        double_creator = double_definition_creator_for(subject)
+        define_double_with_argument_expectation(double_creator, :some_method, 1).times(2)
+      end
+      call_possible_method_on(object, :some_method, 1)
+      expect { RR.verify }.to raise_error(RR::Errors::TimesCalledError)
+    end
+
+    specify "nothing happens upon reset" do
+      object = build_object_with_possible_methods(some_method: ->(arg) {}) do |subject|
+        double_creator = double_definition_creator_for(subject)
+        define_double_with_argument_expectation(double_creator, :some_method, 1).times(2)
+      end
+      RR.reset
+      call_possible_method_on(object, :some_method, 1)
+      expect { RR.verify }.not_to raise_error
+    end
+  end
+
+  context 'the moment the invocation occurs one too many times' do
+    specify "TimesCalledError is raised" do
+      object = build_object_with_possible_methods(some_method: ->(arg) {}) do |subject|
+        double_creator = double_definition_creator_for(subject)
+        define_double_with_argument_expectation(double_creator, :some_method, 1).times(2)
+      end
+      call_possible_method_on(object, :some_method, 1)
+      call_possible_method_on(object, :some_method, 1)
+      expect { object.some_method(1) }.to raise_error(RR::Errors::TimesCalledError)
+      RR.reset
+    end
+
+    specify "nothing happens upon reset" do
+      object = build_object_with_possible_methods(some_method: ->(arg) {}) do |subject|
+        double_creator = double_definition_creator_for(subject)
+        define_double_with_argument_expectation(double_creator, :some_method, 1).times(2)
+      end
+      RR.reset
+      call_possible_method_on(object, :some_method, 1)
+      call_possible_method_on(object, :some_method, 1)
+      expect {
+        call_possible_method_on(object, :some_method, 1)
+      }.not_to raise_error
+    end
+  end
+end

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