rr 1.1.1 → 1.1.2.rc1

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,81 @@
+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
+
+    if RUBY_VERSION =~ /^1.8/
+      context 'when the Enumerable is a String' do
+        subject { 'foo' }
+
+        it "returns true if the String is exactly equal to the given String" do
+          should wildcard_match('foo')
+        end
+
+        it "returns false if the string is not exactly equal to the given String" do
+          should_not wildcard_match('bar')
+        end
+
+        context 'whose #== method has been proxied' do
+          before do
+            @r1 = 'x'
+            @r2 = 'y'
+            mock.proxy(@r1) == @r1
+            mock.proxy(@r1) == @r2
+          end
+
+          it "doesn't blow up with a recursive loop error" do
+            @r1 == @r1
+            @r1 == @r2
+          end
+        end
+      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

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

@@ -0,0 +1,41 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
+
+describe Range do
+  include WildcardMatcherMatchers
+
+  describe '#wildcard_match?' do
+    subject { 1..5 }
+
+    it "returns true when given Range is exactly equal to this Range" do
+      should wildcard_match(1..5)
+    end
+
+    it "returns true when given number falls within the range" do
+      should wildcard_match(3)
+    end
+
+    it "returns false when given number falls outside the range" do
+      should_not wildcard_match(8)
+    end
+  end
+
+  describe '#==' do
+    subject { 1..5 }
+
+    it "returns true when given Range is exactly equal to this Range" do
+      should equal_match(1..5)
+    end
+
+    it "returns false when given Range is not exactly equal to this Range" do
+      should_not equal_match(3..5)
+    end
+
+    it "returns false even when given an object that wildcard matches this Range" do
+      should_not equal_match(3)
+    end
+
+    it "returns false when given object isn't even a Range" do
+      should_not equal_match(:something_else)
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+describe Regexp do
+  include WildcardMatcherMatchers
+
+  describe '#wildcard_match?' do
+    subject { /foo/ }
+
+    it "returns true when given Regexp is exactly equal to this Regexp" do
+      should wildcard_match(/foo/)
+    end
+
+    it "returns true if given string matches the regexp" do
+      should wildcard_match('foobarbaz')
+    end
+
+    it "returns false if given string does not match the regexp" do
+      should_not wildcard_match('aslkj')
+    end
+  end
+
+  describe '#==' do
+    subject { /foo/ }
+
+    it "returns true when given Regexp is exactly equal to this Regexp" do
+      should equal_match(/foo/)
+    end
+
+    it "returns false when given Regexp is not exactly equal to this Regexp" do
+      should_not equal_match(/alkj/)
+    end
+
+    it "returns false even when given an object that wildcard matches this Regexp" do
+      should_not equal_match('foobarbaz')
+    end
+
+    it "returns false when not even given a Regexp" do
+      should_not equal_match(:something_else)
+    end
+  end
+end

data/spec/suites/rspec_2/unit/double_definitions/child_double_definition_create_spec.rb

@@ -0,0 +1,114 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
+
+module RR
+  module DoubleDefinitions
+    describe ChildDoubleDefinitionCreate do
+      attr_reader :parent_subject, :parent_double_definition_create, :parent_double_definition, :child_double_definition_create
+
+      include_examples "Swapped Space"
+
+      before(:each) do
+        @parent_subject = Object.new
+        @parent_double_definition_create = DoubleDefinitionCreate.new
+        @parent_double_definition = DoubleDefinition.new(parent_double_definition_create)
+        @child_double_definition_create = ChildDoubleDefinitionCreate.new(parent_double_definition)
+      end
+
+      describe "#root_subject" do
+        it "returns the #parent_double_definition.root_subject" do
+          child_subject = Object.new
+          parent_double_definition_create.stub(parent_subject)
+          child_double_definition_create.stub(child_subject)
+          expect(child_double_definition_create.root_subject).to eq parent_subject
+        end
+      end
+
+      describe "Strategies::Verification definitions" do
+        describe "methods without !" do
+          attr_reader :child_subject
+          before do
+            @child_subject = Object.new
+          end
+
+          describe "#mock" do
+            context "when passed a subject" do
+              it "sets #parent_double_definition.implementation to a Proc returning the passed-in subject" do
+                expect(parent_double_definition.implementation).to be_nil
+                child_double_definition_create.mock(child_subject)
+                expect(parent_double_definition.implementation.call).to eq child_subject
+              end
+            end
+          end
+
+          describe "#stub" do
+            context "when passed a subject" do
+              it "sets #parent_double_definition.implementation to a Proc returning the passed-in subject" do
+                expect(parent_double_definition.implementation).to be_nil
+                child_double_definition_create.stub(child_subject)
+                expect(parent_double_definition.implementation.call).to eq child_subject
+              end
+            end
+          end
+
+          describe "#dont_allow" do
+            context "when passed a subject" do
+              it "sets #parent_double_definition.implementation to a Proc returning the passed-in subject" do
+                expect(parent_double_definition.implementation).to be_nil
+                child_double_definition_create.dont_allow(child_subject)
+                expect(parent_double_definition.implementation.call).to eq child_subject
+              end
+            end
+          end
+        end
+
+        describe "methods with !" do
+          describe "#mock!" do
+            it "sets #parent_double_definition.implementation to a Proc returning the #subject" do
+              expect(parent_double_definition.implementation).to be_nil
+              child_subject = child_double_definition_create.mock!.__double_definition_create__.subject
+              expect(parent_double_definition.implementation.call).to eq child_subject
+            end
+          end
+
+          describe "#stub!" do
+            it "sets #parent_double_definition.implementation to a Proc returning the #subject" do
+              expect(parent_double_definition.implementation).to be_nil
+              child_subject = child_double_definition_create.stub!.__double_definition_create__.subject
+              expect(parent_double_definition.implementation.call).to eq child_subject
+            end
+          end
+
+          describe "#dont_allow!" do
+            it "sets #parent_double_definition.implementation to a Proc returning the #subject" do
+              expect(parent_double_definition.implementation).to be_nil
+              child_subject = child_double_definition_create.dont_allow!.__double_definition_create__.subject
+              expect(parent_double_definition.implementation.call).to eq child_subject
+            end
+          end
+        end
+      end
+
+      describe "Strategies::DoubleInjection definitions" do
+        describe "methods without !" do
+          describe "#instance_of" do
+            it "raises a NoMethodError" do
+              expect {
+                child_double_definition_create.instance_of
+              }.to raise_error(NoMethodError)
+            end
+          end
+        end
+
+        describe "methods with !" do
+          describe "#instance_of!" do
+            it "raises a NoMethodError" do
+              expect {
+                child_double_definition_create.instance_of!
+              }.to raise_error(NoMethodError)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/suites/rspec_2/unit/double_definitions/double_definition_create_blank_slate_spec.rb

@@ -0,0 +1,93 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
+
+module RR
+  module DoubleDefinitions
+    describe DoubleDefinitionCreateBlankSlate do
+      attr_reader :double_definition_create, :blank_slate
+
+      include_examples "Swapped Space"
+
+      subject { Object.new }
+
+      before(:each) do
+        @double_definition_create = DoubleDefinitionCreate.new
+        double_definition_create.mock(subject)
+      end
+
+      describe ".new" do
+        it "does not undefine object_id" do
+          blank_slate = DoubleDefinitionCreateBlankSlate.new(double_definition_create)
+          expect(blank_slate.object_id.class).to eq Fixnum
+        end
+
+        context "without block" do
+          before do
+            @blank_slate = DoubleDefinitionCreateBlankSlate.new(double_definition_create)
+          end
+
+          it "clears out all methods from proxy" do
+            expect(stub(subject).i_should_be_a_double).to be_instance_of(DoubleDefinition)
+          end
+        end
+
+        context "when passed a block" do
+          context "when the block has an arity of 1" do
+            attr_reader :passed_in_argument
+            before do
+              passed_in_argument = nil
+              stub(subject) do |b|
+                passed_in_argument = b
+                b.foobar(1, 2) {:one_two}
+                b.foobar(1) {:one}
+                b.foobar.with_any_args {:default}
+                b.baz() {:baz_result}
+              end
+              @passed_in_argument = passed_in_argument
+            end
+
+            it "creates double_injections" do
+              expect(subject.foobar(1, 2)).to eq :one_two
+              expect(subject.foobar(1)).to eq :one
+              expect(subject.foobar(:something)).to eq :default
+              expect(subject.baz).to eq :baz_result
+            end
+
+            it "passes the self into the block" do
+              expect(passed_in_argument.__double_definition_create__).to be_instance_of(
+                ::RR::DoubleDefinitions::DoubleDefinitionCreate
+              )
+            end
+          end
+
+          context "when the block has an arity of 0" do
+            attr_reader :self_value
+            before do
+              self_value = nil
+              stub(subject) do ||
+                self_value = self
+                foobar(1, 2) {:one_two}
+                foobar(1) {:one}
+                foobar.with_any_args {:default}
+                baz() {:baz_result}
+              end
+              @self_value = self_value
+            end
+
+            it "creates double_injections" do
+              expect(subject.foobar(1, 2)).to eq :one_two
+              expect(subject.foobar(1)).to eq :one
+              expect(subject.foobar(:something)).to eq :default
+              expect(subject.baz).to eq :baz_result
+            end
+
+            it "evaluates the block with the context of self" do
+              expect(self_value.__double_definition_create__).to be_instance_of(
+                ::RR::DoubleDefinitions::DoubleDefinitionCreate
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end