rr 1.1.1.rc1 → 1.1.1

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

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

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

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

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

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

@@ -1,446 +0,0 @@
-require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
-
-module RR
-  module DoubleDefinitions
-    describe DoubleDefinitionCreate do
-      subject { Object.new }
-
-      attr_reader :double_definition_create, :strategy_method_name
-
-      include_examples "Swapped Space"
-
-      before(:each) do
-        @double_definition_create = DoubleDefinitionCreate.new
-      end
-
-      describe "#root_subject" do
-        it "returns #subject" do
-          double_definition_create.stub(subject).foobar
-          expect(double_definition_create.root_subject).to eq subject
-        end
-      end
-
-      describe "StrategySetupMethods" do
-        describe "normal strategy definitions" do
-          def call_strategy(*args, &block)
-            double_definition_create.__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 self" do
-                expect(call_strategy).to equal double_definition_create
-              end
-            end
-
-            context "when passed a subject and a method_name argument" do
-              it "creates a mock Double for method" do
-                double_definition = double_definition_create.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 self" do
-                expect(call_strategy).to equal double_definition_create
-              end
-            end
-
-            context "when passed subject and a method_name argument" do
-              it "creates a stub Double for method when passed a method_name argument" do
-                double_definition = double_definition_create.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 self" do
-                expect(call_strategy).to equal double_definition_create
-              end
-            end
-
-            context "when passed a subject and a method_name argument_expectation" do
-              it "creates a mock Double for method" do
-                double_definition = double_definition_create.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)
-            double_definition_create.__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
-                double_definition_create.mock!(:foobar)
-                expect(double_definition_create.verification_strategy.class).to eq Strategies::Verification::Mock
-                expect { RR.verify }.to raise_error(::RR::Errors::TimesCalledError)
-              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
-                double_definition_create.stub!(:foobar)
-                expect(double_definition_create.verification_strategy.class).to eq 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
-                double_definition_create.dont_allow!(:foobar)
-                expect(double_definition_create.verification_strategy.class).to eq Strategies::Verification::DontAllow
-              end
-            end
-          end
-        end
-
-        describe "#stub.proxy" do
-          before do
-            class << subject
-              def foobar(*args)
-                :original_foobar
-              end
-            end
-          end
-
-          context "when passed a method_name argument" do
-            it "creates a proxy Double for method" do
-              double_definition = double_definition_create.stub.proxy(subject, :foobar).after_call {: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 "#instance_of" do
-          context "when not passed a class" do
-            it "raises an ArgumentError" do
-              expect {
-                double_definition_create.instance_of(Object.new).foobar
-              }.to raise_error(ArgumentError, "instance_of only accepts class objects")
-            end
-          end
-
-          context "when passed a method_name argument" do
-            it "creates a proxy Double for method" do
-              klass = Class.new
-              double_definition = double_definition_create.stub.instance_of(klass, :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(klass.new.foobar).to eq :baz
-            end
-          end
-        end
-
-        describe "#instance_of.mock" do
-          before do
-            @klass = Class.new
-          end
-
-#          context "when passed no arguments" do
-#            it "returns a DoubleDefinitiondouble_definition_create" do
-#              expect(instance_of.instance_of).to be_instance_of(DoubleDefinitionCreate)
-#            end
-#          end
-
-          context "when passed a method_name argument" do
-            it "creates a instance_of Double for method" do
-              double_definition = instance_of.mock(@klass, :foobar)
-              double_definition.with(1, 2) {: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 [1, 2]
-
-              expect(@klass.new.foobar(1, 2)).to eq :baz
-            end
-          end
-        end
-      end
-
-      describe "StrategyExecutionMethods" do
-        describe "#create" do
-          context "when #verification_strategy is a Mock" do
-            context "when #implementation_strategy is a Reimplementation" do
-              before do
-                double_definition_create.mock(subject)
-              end
-
-              it "sets expectation on the #subject that it will be sent the method_name once with the passed-in arguments" do
-                mock(subject).foobar(1, 2)
-                subject.foobar(1, 2)
-                expect { subject.foobar(1, 2) }.to raise_error(RR::Errors::TimesCalledError)
-                expect { RR.verify }.to raise_error(RR::Errors::TimesCalledError)
-              end
-
-              describe "#subject.method_name being called" do
-                it "returns the return value of the Double#returns block" do
-                  double_definition_create.call(:foobar, 1, 2) {:baz}
-                  expect(subject.foobar(1, 2)).to eq :baz
-                end
-              end
-            end
-
-            context "when #implementation_strategy is a Proxy" do
-              before do
-                double_definition_create.mock
-                double_definition_create.proxy(subject)
-              end
-
-              it "sets expectation on the #subject that it will be sent the method_name once with the passed-in arguments" do
-                def subject.foobar(*args)
-                  :baz
-                end
-                mock(subject).foobar(1, 2)
-
-                subject.foobar(1, 2)
-                expect { subject.foobar(1, 2) }.to raise_error(RR::Errors::TimesCalledError)
-                expect { RR.verify }.to raise_error(RR::Errors::TimesCalledError)
-              end
-
-              describe "#subject.method_name being called" do
-                it "calls the original method" do
-                  original_method_called = false
-                  (class << subject; self; end).class_eval do
-                    define_method(:foobar) do |*args|
-                      original_method_called = true
-                    end
-                  end
-                  double_definition_create.call(:foobar, 1, 2)
-                  subject.foobar(1, 2)
-                  expect(original_method_called).to be_true
-                end
-
-                context "when not passed a block" do
-                  it "returns the value of the original method" do
-                    def subject.foobar(*args)
-                      :baz;
-                    end
-                    double_definition_create.call(:foobar, 1, 2)
-                    expect(subject.foobar(1, 2)).to eq :baz
-                  end
-                end
-
-                context "when passed a block" do
-                  attr_reader :real_value
-                  before do
-                    @real_value = real_value = Object.new
-                    (class << subject; self; end).class_eval do
-                      define_method(:foobar) {|arg1, arg2| real_value}
-                    end
-                  end
-
-                  it "calls the block with the return value of the original method" do
-                    double_definition_create.call(:foobar, 1, 2) do |value|
-                      mock(value).a_method {99}
-                      value
-                    end
-                    subject.foobar(1, 2)
-                    expect(real_value.a_method).to eq 99
-                  end
-
-                  it "returns the return value of the block" do
-                    double_definition_create.call(:foobar, 1, 2) do |value|
-                      :something_else
-                    end
-                    expect(subject.foobar(1, 2)).to eq :something_else
-                  end
-                end
-              end
-            end
-          end
-
-          context "when #verification_strategy is a Stub" do
-            context "when #implementation_strategy is a Reimplementation" do
-              before do
-                double_definition_create.stub(subject)
-              end
-
-              context "when not passed a block" do
-                it "returns nil" do
-                  double_definition_create.call(:foobar)
-                  expect(subject.foobar).to be_nil
-                end
-              end
-
-              context "when passed a block" do
-                describe "#subject.method_name being called" do
-                  it "returns the return value of the block" do
-                    double_definition_create.call(:foobar) {:baz}
-                    expect(subject.foobar).to eq :baz
-                  end
-                end
-              end
-
-              context "when not passed args" do
-                describe "#subject.method_name being called with any arguments" do
-                  it "invokes the implementation of the Stub" do
-                    double_definition_create.call(:foobar) {:baz}
-                    expect(subject.foobar(1, 2)).to eq :baz
-                    expect(subject.foobar()).to eq :baz
-                    expect(subject.foobar([])).to eq :baz
-                  end
-                end
-              end
-
-              context "when passed args" do
-                describe "#subject.method_name being called with the passed-in arguments" do
-                  it "invokes the implementation of the Stub" do
-                    double_definition_create.call(:foobar, 1, 2) {:baz}
-                    expect(subject.foobar(1, 2)).to eq :baz
-                  end
-                end
-
-                describe "#subject.method_name being called with different arguments" do
-                  it "raises a DoubleNotFoundError" do
-                    double_definition_create.call(:foobar, 1, 2) {:baz}
-                    expect {
-                      subject.foobar
-                    }.to raise_error(RR::Errors::DoubleNotFoundError)
-                  end
-                end
-              end
-            end
-
-            context "when #implementation_strategy is a Proxy" do
-              before do
-                def subject.foobar(*args)
-                  :original_return_value
-                end
-                double_definition_create.stub
-                double_definition_create.proxy(subject)
-              end
-
-              context "when not passed a block" do
-                describe "#subject.method_name being called" do
-                  it "invokes the original implementanion" do
-                    double_definition_create.call(:foobar)
-                    expect(subject.foobar).to eq :original_return_value
-                  end
-                end
-              end
-
-              context "when passed a block" do
-                describe "#subject.method_name being called" do
-                  it "invokes the original implementanion and invokes the block with the return value of the original implementanion" do
-                    passed_in_value = nil
-                    double_definition_create.call(:foobar) do |original_return_value|
-                      passed_in_value = original_return_value
-                    end
-                    subject.foobar
-                    expect(passed_in_value).to eq :original_return_value
-                  end
-
-                  it "returns the return value of the block" do
-                    double_definition_create.call(:foobar) do |original_return_value|
-                      :new_return_value
-                    end
-                    expect(subject.foobar).to eq :new_return_value
-                  end
-                end
-              end
-
-              context "when passed args" do
-                describe "#subject.method_name being called with the passed-in arguments" do
-                  it "invokes the implementation of the Stub" do
-                    double_definition_create.call(:foobar, 1, 2) {:baz}
-                    expect(subject.foobar(1, 2)).to eq :baz
-                  end
-                end
-
-                describe "#subject.method_name being called with different arguments" do
-                  it "raises a DoubleNotFoundError" do
-                    double_definition_create.call(:foobar, 1, 2) {:baz}
-                    expect {
-                      subject.foobar
-                    }.to raise_error(RR::Errors::DoubleNotFoundError)
-                  end
-                end
-              end
-            end
-          end
-
-          context "when #verification_strategy is a DontAllow" do
-            before do
-              double_definition_create.dont_allow(subject)
-            end
-
-            context "when not passed args" do
-              describe "#subject.method_name being called with any arguments" do
-                it "raises a TimesCalledError" do
-                  double_definition_create.call(:foobar)
-                  expect { subject.foobar }.to raise_error(RR::Errors::TimesCalledError)
-                  expect { subject.foobar(1, 2) }.to raise_error(RR::Errors::TimesCalledError)
-                end
-              end
-            end
-
-            context "when passed args" do
-              describe "#subject.method_name being called with the passed-in arguments" do
-                it "raises a TimesCalledError" do
-                  double_definition_create.call(:foobar, 1, 2)
-                  expect { subject.foobar(1, 2) }.to raise_error(RR::Errors::TimesCalledError)
-                end
-              end
-
-              describe "#subject.method_name being called with different arguments" do
-                it "raises a DoubleNotFoundError" do
-                  double_definition_create.call(:foobar, 1, 2)
-                  expect { subject.foobar() }.to raise_error(RR::Errors::DoubleNotFoundError)
-                end
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end