rr 1.1.1 → 3.0.0

data/spec/suites/rspec_2/support/shared_examples/double_definition_creators/comparing_arity.rb

@@ -0,0 +1,63 @@
+shared_examples_for 'comparing the arity between the method and double definition' do
+  it "succeeds if both have no arity" do
+    object = build_object_with_methods(some_method: -> {}) do |subject|
+      double_creator = double_definition_creator_for(subject)
+      double_creator.some_method
+    end
+    object.some_method
+  end
+
+  it "fails if the former has no arity and the latter does" do
+    build_object_with_methods(some_method: -> {}) do |subject|
+      double_creator = double_definition_creator_for(subject)
+      expect { double_creator.some_method(1) }.to \
+        raise_error(RR::Errors::SubjectHasDifferentArityError)
+    end
+  end
+
+  it "fails if the former has arity but the latter doesn't" do
+    build_object_with_methods(some_method: ->(arg) {}) do |subject|
+      double_creator = double_definition_creator_for(subject)
+      expect { double_creator.some_method }.to \
+        raise_error(RR::Errors::SubjectHasDifferentArityError)
+    end
+  end
+
+  it "succeeds if both have a finite number of arguments" do
+    object = build_object_with_methods(some_method: ->(arg) {}) do |subject|
+      double_creator = double_definition_creator_for(subject)
+      double_creator.some_method(1)
+    end
+    object.some_method(1)
+  end
+
+  it "succeeds if both have a variable number of arguments" do
+    object = build_object_with_methods(some_method: ->(*args) {}) do |subject|
+      double_creator = double_definition_creator_for(subject)
+      double_creator.some_method(1)
+      double_creator.some_method(1, 2, 3)
+      double_creator.some_method(1, 2)
+    end
+    object.some_method(1)
+    object.some_method(1, 2)
+    object.some_method(1, 2, 3)
+  end
+
+  it "succeeds if both have finite and variable number of arguments" do
+    object = build_object_with_methods(some_method: ->(arg1, arg2, *rest) {}) do |subject|
+      double_creator = double_definition_creator_for(subject)
+      double_creator.some_method(1, 2)
+      double_creator.some_method(1, 2, 3)
+    end
+    object.some_method(1, 2)
+    object.some_method(1, 2, 3)
+  end
+
+  it "fails if the finite arguments are not matched before the variable arguments" do
+    build_object_with_methods(some_method: ->(arg1, arg2, *rest) {}) do |subject|
+      double_creator = double_definition_creator_for(subject)
+      expect { double_creator.some_method(1) }.to \
+        raise_error(RR::Errors::SubjectHasDifferentArityError)
+    end
+  end
+end

data/spec/suites/rspec_2/support/shared_examples/double_definition_creators/object_is_proxy.rb

@@ -0,0 +1,43 @@
+# btakita/rr issue #24
+# this happens when defining a double on an ActiveRecord association object
+shared_examples_for 'defining a method double on an object which is a proxy for another object' do
+  include DoubleDefinitionCreatorHelpers
+
+  it "places the double on the proxy object and not the target object by mistake" do
+    target_object = build_object_with_possible_methods(some_method: -> { 'existing value' })
+    proxy_object = proxy_object_class.new(target_object)
+    expect(proxy_object.methods).to match_array(target_object.methods)
+    double_definition_creator_for(proxy_object).some_method { 'value' }
+    expect(proxy_object.some_method).to eq 'value'
+  end
+
+  it "resets the double correctly" do
+    target_object = build_object_with_possible_methods(some_method: -> { 'existing value' })
+    proxy_object = proxy_object_class.new(target_object)
+    expect(proxy_object.methods).to match_array(target_object.methods)
+    double_definition_creator_for(proxy_object).some_method { 'value' }
+    RR.reset
+    expect_method_to_have_value_or_be_absent('existing value', proxy_object, :some_method)
+  end
+
+  def proxy_object_class
+    Class.new do
+      # This matches what AssociationProxy was like as of Rails 2
+      instance_methods.each do |m|
+        undef_method m unless m.to_s =~ /^(?:nil\?|send|object_id|to_a)$|^__|^respond_to|proxy_/
+      end
+
+      def initialize(target)
+        @target = target
+      end
+
+      def method_missing(name, *args, &block)
+        if @target.respond_to?(name)
+          @target.__send__(name, *args, &block)
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/spec/suites/rspec_2/support/shared_examples/double_definition_creators/sequential_invocations.rb

@@ -0,0 +1,26 @@
+shared_examples_for 'defining a method double for sequential invocations of that method using #ordered/#then' do
+  include DoubleDefinitionCreatorHelpers
+
+  it "works" do
+    object = build_object_with_possible_methods(some_method: -> {}) do |subject|
+      double_creator = double_definition_creator_for(subject)
+      double_creator.some_method { 'value 1' }.twice.ordered
+      double_creator.some_method { 'value 2' }.once.ordered
+    end
+
+    expect(object.some_method).to eq 'value 1'
+    expect(object.some_method).to eq 'value 1'
+    expect(object.some_method).to eq 'value 2'
+  end
+
+  it "works when using #then instead of #ordered" do
+    object = build_object_with_possible_methods(some_method: -> {}) do |subject|
+      double_definition_creator_for(subject).
+        some_method { 'value 1' }.once.then.
+        some_method { 'value 2' }.once
+    end
+
+    expect(object.some_method).to eq 'value 1'
+    expect(object.some_method).to eq 'value 2'
+  end
+end

data/spec/suites/rspec_2/support/shared_examples/double_definition_creators/setting_implementation.rb

@@ -0,0 +1,51 @@
+shared_examples_for 'defining a method double that sets the implementation of that method' do
+  include DoubleDefinitionCreatorHelpers
+
+  it "works when not given a block" do
+    expect_that_double_can_be_defined_without_block
+  end
+
+  context 'by giving a block' do
+    it "replaces the implementation with the block" do
+      expect_that_double_sets_implementation do |double_creator, method_name, block|
+        double_creator.__send__(method_name, &block)
+      end
+    end
+
+    it "resets the double correctly" do
+      expect_that_double_sets_implementation_and_resets do |double_creator, method_name, block|
+        double_creator.__send__(method_name, &block)
+      end
+    end
+  end
+
+  context 'by using #returns' do
+    context 'with a block' do
+      it "replaces the implementation with the block" do
+        expect_that_double_sets_implementation do |double_creator, method_name, block|
+          double_creator.__send__(method_name).returns(&block)
+        end
+      end
+
+      it "resets the double correctly" do
+        expect_that_double_sets_implementation_and_resets do |double_creator, method_name, block|
+          double_creator.__send__(method_name).returns(&block)
+        end
+      end
+    end
+
+    context 'with a straight argument' do
+      it "makes the method return the argument" do
+        expect_that_double_sets_value do |double_creator, method_name, value|
+          double_creator.__send__(method_name).returns(value)
+        end
+      end
+
+      it "resets the double correctly" do
+        expect_that_double_sets_value_and_resets do |double, method_name, value|
+          double_creator.__send__(method_name).returns(value)
+        end
+      end
+    end
+  end
+end

data/spec/suites/rspec_2/support/shared_examples/double_definition_creators/yields.rb

@@ -0,0 +1,81 @@
+shared_examples_for 'defining a method double qualified with #yields' do
+  include DoubleDefinitionCreatorHelpers
+
+  context 'without arguments' do
+    it "inserts a yield that passes no arguments" do
+      object = build_object_with_possible_methods(some_method: -> {}) do |subject|
+        double_definition_creator_for(subject).some_method.yields
+      end
+      x = 0
+      object.some_method { x = 1 }
+      expect(x).to eq 1
+    end
+
+    it "does not affect setting the implementation otherwise" do
+      object = build_object_with_possible_methods(some_method: -> { 'existing value' }) do |subject|
+        double_definition_creator_for(subject).some_method { 'value' }.yields
+      end
+      expect(object.some_method { }).to eq 'value'
+    end
+
+    it "also lets you set the implementation in preference to #returns" do
+      object = build_object_with_possible_methods(some_method: -> { 'existing value' }) do |subject|
+        double_definition_creator_for(subject).some_method.yields { 'value' }
+      end
+      expect(object.some_method { }).to eq 'value'
+    end
+
+    it "is reset correctly" do
+      object = build_object_with_possible_methods(some_method: -> {}) do |subject|
+        double_definition_creator_for(subject).some_method.yields
+      end
+      RR.reset
+      x = 0
+      if methods_being_doubled_exist_already?
+        object.some_method { x = 1 }
+        expect(x).to eq 0
+      else
+        expect_method_to_not_exist(object, :some_method)
+      end
+    end
+  end
+
+  context 'with arguments' do
+    it "inserts a yield that passes those arguments" do
+      object = build_object_with_possible_methods(some_method: -> {}) do |subject|
+        double_definition_creator_for(subject).some_method.yields(1)
+      end
+      x = 0
+      object.some_method {|a| x = a }
+      expect(x).to eq 1
+    end
+
+    it "does not affect setting the implementation otherwise" do
+      object = build_object_with_possible_methods(some_method: -> { 'existing value' }) do |subject|
+        double_definition_creator_for(subject).some_method { 'value' }.yields(1)
+      end
+      expect(object.some_method { }).to eq 'value'
+    end
+
+    it "also lets you set the implementation in preference to #returns" do
+      object = build_object_with_possible_methods(some_method: -> { 'existing value' }) do |subject|
+        double_definition_creator_for(subject).some_method.yields(1) { 'value' }
+      end
+      expect(object.some_method { }).to eq 'value'
+    end
+
+    it "is reset correctly" do
+      object = build_object_with_possible_methods(some_method: -> {}) do |subject|
+        double_definition_creator_for(subject).some_method.yields(1)
+      end
+      RR.reset
+      if methods_being_doubled_exist_already?
+        x = 0
+        object.some_method {|a| x = a }
+        expect(x).to eq 0
+      else
+        expect_method_to_not_exist(object, :some_method)
+      end
+    end
+  end
+end

data/spec/suites/rspec_2/support/shared_examples/space.rb

@@ -0,0 +1,13 @@
+shared_examples_for "Swapped Space" do
+  attr_reader :space, :original_space
+
+  before do
+    @original_space = RR::Space.instance
+    RR::Space.instance = RR::Space.new
+    @space = RR::Space.instance
+  end
+
+  after do
+    RR::Space.instance = @original_space
+  end
+end

data/spec/suites/rspec_2/support/shared_examples/times_called_expectation.rb

@@ -0,0 +1,9 @@
+shared_examples_for "RR::Expectations::TimesCalledExpectation" do
+  include_examples "Swapped Space"
+
+  subject { Object.new }
+
+  def raises_expectation_error(&block)
+    expect { block.call }.to raise_error(RR::Errors::TimesCalledError)
+  end
+end

data/spec/suites/rspec_2/unit/core_ext/array_spec.rb

@@ -0,0 +1,39 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+describe Array do
+  include WildcardMatcherMatchers
+
+  describe '#wildcard_match?' do
+    context 'when this Array has items that respond to #wildcard_match?' do
+      subject { [hash_including({:foo => 'bar'})] }
+
+      it "returns true if all items in the given Array wildcard-match corresponding items in this Array" do
+        should wildcard_match([{:foo => 'bar', :baz => 'quux'}])
+      end
+
+      it "returns true if any items in the given Array do not wildcard-match corresponding items in this Array" do
+        should_not wildcard_match([{:foo => 'bat', :baz => 'quux'}])
+      end
+    end
+
+    context 'when this Array has items that do not respond to #wildcard_match?' do
+      subject { [:a_symbol] }
+
+      it "returns true if all items in the given Array equal-match corresponding items in this Array" do
+        should wildcard_match([:a_symbol])
+      end
+
+      it "returns true if any items in the given Array do not equal-match corresponding items in this Array" do
+        should_not wildcard_match([:another_symbol])
+      end
+    end
+
+    context 'when not given an Array' do
+      subject { [{:foo => 'bar'}] }
+
+      it "returns false" do
+        should_not wildcard_match(:something_else)
+      end
+    end
+  end
+end

data/spec/suites/rspec_2/unit/core_ext/enumerable_spec.rb

@@ -0,0 +1,53 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+describe Enumerable do
+  include WildcardMatcherMatchers
+
+  let(:klass) {
+    Class.new do
+      include Enumerable
+
+      def initialize(*items)
+        @arr = items
+      end
+
+      def each(&block)
+        @arr.each(&block)
+      end
+    end
+  }
+
+  describe '#wildcard_match?' do
+    context 'when this Enumerable has items that respond to #wildcard_match?' do
+      subject { klass.new(hash_including({:foo => 'bar'})) }
+
+      it "returns true if all items in the given Enumerable wildcard-match corresponding items in this Enumerable" do
+        should wildcard_match([{:foo => 'bar', :baz => 'quux'}])
+      end
+
+      it "returns true if any items in the given Enumerable do not wildcard-match corresponding items in this Enumerable" do
+        should_not wildcard_match([{:foo => 'bat', :baz => 'quux'}])
+      end
+    end
+
+    context 'when this Enumerable has items that do not respond to #wildcard_match?' do
+      subject { klass.new(:a_symbol) }
+
+      it "returns true if all items in the given Enumerable equal-match corresponding items in this Enumerable" do
+        should wildcard_match([:a_symbol])
+      end
+
+      it "returns true if any items in the given Enumerable do not equal-match corresponding items in this Enumerable" do
+        should_not wildcard_match([:another_symbol])
+      end
+    end
+
+    context 'when not given an Enumerable' do
+      subject { klass.new({:foo => 'bar'}) }
+
+      it "returns false" do
+        should_not wildcard_match(:something_else)
+      end
+    end
+  end
+end

data/spec/suites/rspec_2/unit/core_ext/hash_spec.rb

@@ -0,0 +1,55 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+describe Hash do
+  include WildcardMatcherMatchers
+
+  describe '#wildcard_match?' do
+    context 'when this Hash has keys that respond to #wildcard_match?' do
+      subject { {is_a(Symbol) => 'x'} }
+
+      it "returns true if all keys in the given Hash wildcard-match the corresponding keys in this Hash" do
+        should wildcard_match({:foo => 'x'})
+      end
+
+      it "returns true if any keys in the given Hash do not wildcard-match the corresponding keys in this Hash" do
+        should_not wildcard_match({'foo' => 'x'})
+      end
+    end
+
+    context 'when this Hash has values that respond to #wildcard_match?' do
+      subject { {'x' => is_a(Symbol)} }
+
+      it "returns true if all values in the given Hash wildcard-match the corresponding values in this Hash" do
+        should wildcard_match({'x' => :foo})
+      end
+
+      it "returns false if any values in the given Hash do not wildcard-match the corresponding values in this Hash" do
+        should_not wildcard_match({'x' => 'foo'})
+      end
+    end
+
+    context 'when this Hash does not have keys or values that respond to #wildcard_match?' do
+      subject { {:x => :y} }
+
+      it "returns true if all pairs in the given Hash wildcard-match the corresponding values in this Hash" do
+        should wildcard_match({:x => :y})
+      end
+
+      it "returns false if any keys do not equal-match corresponding items in the subject" do
+        should_not wildcard_match({:z => :y})
+      end
+
+      it "returns false if any values do not equal-match corresponding items in the subject" do
+        should_not wildcard_match({:x => :z})
+      end
+    end
+
+    context 'when not given a Hash' do
+      subject { {:foo => 'bar'} }
+
+      it "returns false" do
+        should_not wildcard_match(:something_else)
+      end
+    end
+  end
+end