rr 1.1.2 → 1.2.0

data/spec/suites/rspec_2/functional/stub_strong_spec.rb

@@ -0,0 +1,15 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+permutations =
+  %w(stub strong).permutation.map { |parts| parts.join('.') } +
+  %w(strong)
+
+permutations.each do |permutation|
+  describe permutation, is_strong: true do
+    include_context 'stub + strong'
+
+    define_method(:double_definition_creator_for) do |object, &block|
+      eval(permutation + '(object, &block)')
+    end
+  end
+end

data/spec/suites/rspec_2/helper.rb

@@ -24,5 +24,5 @@ RSpec.configure do |c|
   c.order = :random
 end
 
-Dir[ File.expand_path('../shared/*.rb', __FILE__) ].each {|fn| require fn }
-Dir[ File.expand_path('../support/**/*.rb', __FILE__) ].each {|fn| require fn }
+Dir[ File.expand_path('../shared/*.rb', __FILE__) ].sort.each {|fn| require fn }
+Dir[ File.expand_path('../support/**/*.rb', __FILE__) ].sort.each {|fn| require fn }

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

@@ -0,0 +1,173 @@
+module DoubleDefinitionCreatorHelpers
+  module ClassMethods
+    def methods_being_doubled_exist_already?
+      metadata[:methods_exist] || supports_proxying? || supports_mocking?
+    end
+
+    def type_of_methods_being_tested
+      metadata[:method_type]
+    end
+
+    def supports_proxying?
+      metadata[:is_proxy]
+    end
+
+    def supports_instance_of?
+      metadata[:is_instance_of]
+    end
+
+    def supports_mocking?
+      metadata[:is_mock]
+    end
+
+    def supports_strong?
+      metadata[:is_strong]
+    end
+
+    def supports_dont_allow?
+      metadata[:is_dont_allow]
+    end
+  end
+
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  def build_object_with_possible_methods(methods = {}, actually_add_methods = methods_being_doubled_exist_already?)
+    subject =
+      if type_of_methods_being_tested == :class
+        Class.new
+      else
+        Object.new
+      end
+
+    if actually_add_methods
+      if supports_instance_of?
+        add_methods_to_class(subject, methods)
+      else
+        add_methods_to_class(subject.singleton_class, methods)
+      end
+    end
+
+    object =
+      if type_of_methods_being_tested == :class && supports_instance_of?
+        subject.new
+      else
+        subject
+      end
+
+    if block_given?
+      yield subject, object
+    end
+
+    object
+  end
+
+  def build_object_with_methods(methods = {}, &block)
+    build_object_with_possible_methods(methods, true, &block)
+  end
+  alias_method :build_object, :build_object_with_methods
+
+  def add_methods_to_class(klass, methods)
+    klass.class_eval do
+      methods.each do |method_name, implementation|
+        implementation ||= ->(*args) { }
+        define_method(method_name, &implementation)
+      end
+    end
+  end
+
+  def expect_method_to_have_value_or_be_absent(return_value, object, method_name, *args, &block)
+    if methods_being_doubled_exist_already?
+      expect(object.__send__(method_name, *args, &block)).to eq return_value
+    else
+      expect_method_to_not_exist(object, method_name)
+    end
+  end
+
+  def expect_method_to_not_exist(object, method_name)
+    expect { object.method_name }.to raise_error(NoMethodError)
+    # Commenting this out for now since this is broken.
+    # See: btakita/rr #43
+    #expect(object).not_to respond_to(method_name)
+  end
+
+  def build_object_with_doubled_method_which_is_called(original_value, new_value=nil, opts={}, &define_double)
+    method_name = :some_method
+
+    object = build_object_with_methods(method_name => -> { original_value }) do |subject|
+      double_creator = double_definition_creator_for(subject)
+
+      if define_double
+        define_double.call(double_creator, method_name, new_value)
+      else
+        double_creator.__send__(method_name)
+      end
+    end
+
+    if opts[:before_method_call]
+      opts[:before_method_call].call
+    end
+
+    return_value = object.__send__(method_name)
+    [object, method_name, return_value]
+  end
+
+  def build_object_with_doubled_method_which_is_reset_and_called(original_value, new_value, opts={})
+    opts = opts.merge(before_method_call: -> { RR.reset })
+    build_object_with_doubled_method_which_is_called(original_value, new_value, opts)
+  end
+
+  def call_possible_method_on(object, method_name, *args, &block)
+    object.__send__(method_name, *args, &block)
+  rescue NoMethodError
+  end
+
+  def expect_call_to_return_or_raise_times_called_error(return_value, object, method_name, *args, &block)
+    if supports_dont_allow?
+      expect { object.__send__(method_name, *args, &block) }.
+        to raise_error(RR::Errors::TimesCalledError)
+    else
+      expect(object.__send__(method_name, *args, &block)).to eq return_value
+    end
+  end
+
+  def call_method_rescuing_times_called_error(object, method_name, *args, &block)
+    if supports_dont_allow?
+      begin
+        object.__send__(method_name, *args, &block)
+      rescue RR::Errors::TimesCalledError
+      end
+    else
+      object.__send__(method_name, *args, &block)
+    end
+  end
+
+  def methods_being_doubled_exist_already?
+    self.class.methods_being_doubled_exist_already?
+  end
+
+  def type_of_methods_being_tested
+    self.class.type_of_methods_being_tested
+  end
+
+  def supports_proxying?
+    self.class.supports_proxying?
+  end
+
+  def supports_instance_of?
+    self.class.supports_instance_of?
+  end
+
+  def supports_mocking?
+    self.class.supports_mocking?
+  end
+
+  def supports_strong?
+    self.class.supports_strong?
+  end
+
+  def supports_dont_allow?
+    self.class.supports_dont_allow?
+  end
+end

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