rr 1.1.1.rc1 → 1.1.1

data/spec/suites/rspec_2/unit/adapters/rr_methods/double_creators_spec.rb

@@ -1,135 +0,0 @@
-require File.expand_path("#{File.dirname(__FILE__)}/../../../spec_helper")
-
-module RR
-  module Adapters
-    describe RRMethods do
-      subject { Object.new }
-
-      after(:each) do
-        RR.reset
-      end
-
-      describe "normal strategy definitions" do
-        attr_reader :strategy_method_name
-
-        def call_strategy(*args, &block)
-          __send__(strategy_method_name, *args, &block)
-        end
-
-        describe "#mock" do
-          before do
-            @strategy_method_name = :mock
-          end
-
-          context "when passing no args" do
-            it "returns a DoubleDefinitionCreate" do
-              expect(call_strategy.class).to eq RR::DoubleDefinitions::DoubleDefinitionCreate
-            end
-          end
-
-          context "when passed a method_name argument" do
-            it "creates a mock Double for method" do
-              double_definition = mock(subject, :foobar).returns {:baz}
-              expect(double_definition.times_matcher).to eq RR::TimesCalledMatchers::IntegerMatcher.new(1)
-              expect(double_definition.argument_expectation.class).to eq RR::Expectations::ArgumentEqualityExpectation
-              expect(double_definition.argument_expectation.expected_arguments).to eq []
-              expect(subject.foobar).to eq :baz
-            end
-          end
-        end
-
-        describe "#stub" do
-          before do
-            @strategy_method_name = :stub
-          end
-
-          context "when passing no args" do
-            it "returns a DoubleDefinitionCreate" do
-              expect(call_strategy.class).to eq RR::DoubleDefinitions::DoubleDefinitionCreate
-            end
-          end
-
-          context "when passed a method_name argument" do
-            it "creates a stub Double for method when passed a method_name argument" do
-              double_definition = stub(subject, :foobar).returns {:baz}
-              expect(double_definition.times_matcher).to eq RR::TimesCalledMatchers::AnyTimesMatcher.new
-              expect(double_definition.argument_expectation.class).to eq RR::Expectations::AnyArgumentExpectation
-              expect(subject.foobar).to eq :baz
-            end
-          end
-        end
-
-        describe "#dont_allow" do
-          before do
-            @strategy_method_name = :dont_allow
-          end
-
-          context "when passing no args" do
-            it "returns a DoubleDefinitionCreate" do
-              expect(call_strategy.class).to eq RR::DoubleDefinitions::DoubleDefinitionCreate
-            end
-          end
-
-          context "when passed a method_name argument_expectation" do
-            it "creates a mock Double for method" do
-              double_definition = dont_allow(subject, :foobar)
-              expect(double_definition.times_matcher).to eq RR::TimesCalledMatchers::NeverMatcher.new
-              expect(double_definition.argument_expectation.class).to eq RR::Expectations::AnyArgumentExpectation
-
-              expect {
-                subject.foobar
-              }.to raise_error(RR::Errors::TimesCalledError)
-              RR.reset
-            end
-          end
-        end
-      end
-
-      describe "! strategy definitions" do
-        attr_reader :strategy_method_name
-        def call_strategy(*args, &definition_eval_block)
-          __send__(strategy_method_name, *args, &definition_eval_block)
-        end
-
-        describe "#mock!" do
-          before do
-            @strategy_method_name = :mock!
-          end
-
-          context "when passed a method_name argument" do
-            it "sets #verification_strategy to Mock" do
-              proxy = mock!(:foobar)
-              expect(proxy.double_definition_create.verification_strategy.class).to eq RR::DoubleDefinitions::Strategies::Verification::Mock
-            end
-          end
-        end
-
-        describe "#stub!" do
-          before do
-            @strategy_method_name = :stub!
-          end
-
-          context "when passed a method_name argument" do
-            it "sets #verification_strategy to Stub" do
-              proxy = stub!(:foobar)
-              expect(proxy.double_definition_create.verification_strategy.class).to eq RR::DoubleDefinitions::Strategies::Verification::Stub
-            end
-          end
-        end
-
-        describe "#dont_allow!" do
-          before do
-            @strategy_method_name = :dont_allow!
-          end
-
-          context "when passed a method_name argument" do
-            it "sets #verification_strategy to DontAllow" do
-              proxy = dont_allow!(:foobar)
-              expect(proxy.double_definition_create.verification_strategy.class).to eq RR::DoubleDefinitions::Strategies::Verification::DontAllow
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/spec/suites/rspec_2/unit/adapters/rr_methods/space_spec.rb

@@ -1,101 +0,0 @@
-require File.expand_path("#{File.dirname(__FILE__)}/../../../spec_helper")
-
-module RR
-  module Adapters
-    describe RRMethods do
-      attr_reader :space, :subject_1, :subject_2, :method_name
-
-      include_examples "Swapped Space"
-
-      include RR::Adapters::RRMethods
-
-      before do
-        @subject_1 = Object.new
-        @subject_2 = Object.new
-        @method_name = :foobar
-      end
-
-      describe "#verify" do
-        it "aliases #rr_verify" do
-          expect(RRMethods.instance_method("verify")).to eq RRMethods.instance_method("rr_verify")
-        end
-      end
-
-      describe "#rr_verify" do
-        it "verifies and deletes the double_injections" do
-          double_1 = ::RR::Injections::DoubleInjection.find_or_create_by_subject(subject_1, method_name)
-          double_1_verify_calls = 0
-          double_1_reset_calls = 0
-          (
-          class << double_1;
-            self;
-          end).class_eval do
-            define_method(:verify) do ||
-              double_1_verify_calls += 1
-            end
-            define_method(:reset) do ||
-              double_1_reset_calls += 1
-            end
-          end
-          double_2 = ::RR::Injections::DoubleInjection.find_or_create_by_subject(subject_2, method_name)
-          double_2_verify_calls = 0
-          double_2_reset_calls = 0
-          ( class << double_2; self; end).class_eval do
-            define_method(:verify) do ||
-              double_2_verify_calls += 1
-            end
-            define_method(:reset) do ||
-              double_2_reset_calls += 1
-            end
-          end
-
-          rr_verify
-          expect(double_1_verify_calls).to eq 1
-          expect(double_2_verify_calls).to eq 1
-          expect(double_1_reset_calls).to eq 1
-          expect(double_1_reset_calls).to eq 1
-        end
-      end
-
-      describe "#reset" do
-        it "aliases #rr_reset" do
-          expect(RRMethods.instance_method("reset")).to eq RRMethods.instance_method("rr_reset")
-        end
-      end
-
-      describe "#rr_reset" do
-        it "removes the ordered doubles" do
-          mock(subject_1).foobar1.ordered
-          mock(subject_2).foobar2.ordered
-
-          ::RR::Injections::DoubleInjection.instances.should_not be_empty
-
-          rr_reset
-          ::RR::Injections::DoubleInjection.instances
-          expect(::RR::Injections::DoubleInjection.instances).to be_empty
-        end
-
-        it "resets all double_injections" do
-          double_1 = ::RR::Injections::DoubleInjection.find_or_create_by_subject(subject_1, method_name)
-          double_1_reset_calls = 0
-          ( class << double_1; self; end).class_eval do
-            define_method(:reset) do ||
-              double_1_reset_calls += 1
-            end
-          end
-          double_2 = ::RR::Injections::DoubleInjection.find_or_create_by_subject(subject_2, method_name)
-          double_2_reset_calls = 0
-          ( class << double_2; self; end).class_eval do
-            define_method(:reset) do ||
-              double_2_reset_calls += 1
-            end
-          end
-
-          rr_reset
-          expect(double_1_reset_calls).to eq 1
-          expect(double_2_reset_calls).to eq 1
-        end
-      end
-    end
-  end
-end

data/spec/suites/rspec_2/unit/adapters/rr_methods/wildcard_matchers_spec.rb

@@ -1,69 +0,0 @@
-require File.expand_path("#{File.dirname(__FILE__)}/../../../spec_helper")
-
-module RR
-  module Adapters
-    describe RRMethods do
-      include RR::Adapters::RRMethods
-
-      describe "#anything" do
-        it "returns an Anything matcher" do
-          expect(anything).to eq RR::WildcardMatchers::Anything.new
-        end
-
-        it "rr_anything returns an Anything matcher" do
-          expect(rr_anything).to eq RR::WildcardMatchers::Anything.new
-        end
-      end
-
-      describe "#is_a" do
-        it "returns an IsA matcher" do
-          expect(is_a(Integer)).to eq RR::WildcardMatchers::IsA.new(Integer)
-        end
-
-        it "rr_is_a returns an IsA matcher" do
-          expect(rr_is_a(Integer)).to eq RR::WildcardMatchers::IsA.new(Integer)
-        end
-      end
-
-      describe "#numeric" do
-        it "returns an Numeric matcher" do
-          expect(numeric).to eq RR::WildcardMatchers::Numeric.new
-        end
-
-        it "rr_numeric returns an Numeric matcher" do
-          expect(rr_numeric).to eq RR::WildcardMatchers::Numeric.new
-        end
-      end
-
-      describe "#boolean" do
-        it "returns an Boolean matcher" do
-          expect(boolean).to eq RR::WildcardMatchers::Boolean.new
-        end
-
-        it "rr_boolean returns an Boolean matcher" do
-          expect(rr_boolean).to eq RR::WildcardMatchers::Boolean.new
-        end
-      end
-
-      describe "#duck_type" do
-        it "returns a DuckType matcher" do
-          expect(duck_type(:one, :two)).to eq RR::WildcardMatchers::DuckType.new(:one, :two)
-        end
-
-        it "rr_duck_type returns a DuckType matcher" do
-          expect(rr_duck_type(:one, :two)).to eq RR::WildcardMatchers::DuckType.new(:one, :two)
-        end
-      end
-    end
-
-    describe "#any_times" do
-      it "returns an AnyTimesMatcher" do
-        expect(any_times).to eq RR::TimesCalledMatchers::AnyTimesMatcher.new
-      end
-
-      it "rr_any_times returns an AnyTimesMatcher" do
-        expect(rr_any_times).to eq RR::TimesCalledMatchers::AnyTimesMatcher.new
-      end
-    end
-  end
-end

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

@@ -1,39 +0,0 @@
-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

@@ -1,81 +0,0 @@
-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

@@ -1,55 +0,0 @@
-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