rr 0.4.10 → 0.6.0

data/lib/rr/double_definition_builder.rb

@@ -1,44 +0,0 @@
-module RR
-  class DoubleDefinitionBuilder #:nodoc:
-    attr_reader :definition
-
-    def initialize(definition, args, handler)
-      @definition = definition
-      @args = args
-      @handler = handler
-    end
-    
-    def mock
-      @definition.with(*@args).once
-    end
-
-    def stub
-      @definition.any_number_of_times
-      permissive_argument
-    end
-
-    def dont_allow
-      @definition.never
-      permissive_argument
-      reimplementation
-    end
-
-    def permissive_argument
-      if @args.empty?
-        @definition.with_any_args
-      else
-        @definition.with(*@args)
-      end
-    end
-
-    def reimplementation
-      @definition.returns(&@handler)
-    end
-    
-    def proxy
-      @definition.after_call_block_callback_strategy
-      @definition.proxy
-      @definition.after_call(&@handler) if @handler
-    end
-  end
-end

data/lib/rr/double_definition_creator.rb

@@ -1,156 +0,0 @@
-module RR
-  class DoubleDefinitionCreator # :nodoc
-    NO_SUBJECT_ARG = Object.new
-
-    include Space::Reader
-    include Errors
-
-    def initialize
-      @core_strategy = nil
-      @using_proxy_strategy = false
-      @using_instance_of_strategy = nil
-    end
-    
-    def mock(subject=NO_SUBJECT_ARG, method_name=nil, &definition) # :nodoc
-      add_strategy(subject, method_name, definition) do
-        set_core_strategy :mock
-      end
-    end
-
-    def stub(subject=NO_SUBJECT_ARG, method_name=nil, &definition) # :nodoc
-      add_strategy(subject, method_name, definition) do
-        set_core_strategy :stub
-      end
-    end
-
-    def dont_allow(subject=NO_SUBJECT_ARG, method_name=nil, &definition) # :nodoc
-      add_strategy(subject, method_name, definition) do
-        set_core_strategy :dont_allow
-      end
-    end
-    alias_method :do_not_allow, :dont_allow
-    alias_method :dont_call, :dont_allow
-    alias_method :do_not_call, :dont_allow
-
-    def proxy(subject=NO_SUBJECT_ARG, method_name=nil, &definition) # :nodoc
-      add_strategy(subject, method_name, definition) do
-        proxy_when_dont_allow_error if @core_strategy == :dont_allow
-        @using_proxy_strategy = true
-      end
-    end
-    alias_method :probe, :proxy
-
-    def instance_of(subject=NO_SUBJECT_ARG, method_name=nil, &definition) # :nodoc
-      if subject != NO_SUBJECT_ARG && !subject.is_a?(Class)
-        raise ArgumentError, "instance_of only accepts class objects" unless subject.is_a?(Class)
-      end
-      add_strategy(subject, method_name, definition) do
-        @using_instance_of_strategy = true
-        return self if subject === NO_SUBJECT_ARG
-      end
-    end
-
-    def create(subject, method_name, *args, &handler)
-      @args = args
-      @handler = handler
-      if @using_instance_of_strategy
-        setup_doubles_for_class_instances(subject, method_name)
-      else
-        setup_double(subject, method_name)
-      end
-      transform
-      @definition
-    end
-    
-    protected
-    def add_strategy(subject, method_name, definition)
-      if method_name && definition
-        raise ArgumentError, "Cannot pass in a method name and a block"
-      end
-      yield
-      if subject.__id__ === NO_SUBJECT_ARG.__id__
-        self
-      elsif method_name
-        create subject, method_name, &definition
-      else
-        DoubleDefinitionCreatorProxy.new(self, subject, &definition)
-      end
-    end
-
-    def set_core_strategy(strategy)
-      verify_no_core_strategy
-      @core_strategy = strategy
-      proxy_when_dont_allow_error if strategy == :dont_allow && @using_proxy_strategy
-    end
-
-    def setup_double(subject, method_name)
-      @double_injection = space.double_injection(subject, method_name)
-      @double = Double.new(@double_injection)
-      @definition = @double.definition
-    end
-
-    def setup_doubles_for_class_instances(subject, method_name)
-      class_double = space.double_injection(subject, :new)
-      class_double = Double.new(class_double)
-
-      instance_method_name = method_name
-
-      @definition = DoubleDefinition.new
-      class_handler = lambda do |return_value|
-        double_injection = space.double_injection(return_value, instance_method_name)
-        Double.new(double_injection, @definition)
-        return_value
-      end
-
-      builder = DoubleDefinitionBuilder.new(
-        class_double.definition,
-        [],
-        class_handler
-      )
-      builder.stub
-      builder.proxy
-    end
-
-    def transform
-      builder = DoubleDefinitionBuilder.new(@definition, @args, @handler)
-
-      verify_strategy
-      builder.__send__(@core_strategy)
-
-      if @using_proxy_strategy
-        builder.proxy
-      else
-        builder.reimplementation
-      end
-    end
-
-    def verify_no_core_strategy
-      strategy_already_defined_error if @core_strategy
-    end
-
-    def strategy_already_defined_error
-      raise(
-        DoubleDefinitionError,
-        "This Double already has a #{@core_strategy} strategy"
-      )
-    end
-
-    def verify_strategy
-      no_strategy_error unless @core_strategy
-    end
-
-    def no_strategy_error
-      raise(
-        DoubleDefinitionError,
-        "This Double has no strategy"
-      )
-    end
-
-    def proxy_when_dont_allow_error
-      raise(
-        DoubleDefinitionError,
-        "Doubles cannot be proxied when using dont_allow strategy"
-      )
-    end
-  end
-end

data/lib/rr/double_definition_creator_proxy.rb

@@ -1,20 +0,0 @@
-module RR
-  class DoubleDefinitionCreatorProxy
-    def initialize(creator, object, &block) #:nodoc:
-      @creator = creator
-      @object = object
-      class << self
-        instance_methods.each do |m|
-          unless m =~ /^_/ || m.to_s == 'object_id'
-            undef_method m
-          end
-        end
-
-        def method_missing(method_name, *args, &block)
-          @creator.create(@object, method_name, *args, &block)
-        end
-      end
-      yield(self) if block_given?
-    end
-  end
-end

data/spec/rr/double/double_injection_bind_spec.rb

@@ -1,105 +0,0 @@
-require "spec/spec_helper"
-
-module RR
-  describe DoubleInjection, "#bind with an existing method" do
-    before do
-      @object = Object.new
-      @method_name = :foobar
-      def @object.foobar;
-        :original_foobar;
-      end
-      @original_method = @object.method(@method_name)
-      @object.methods.should include(@method_name.to_s)
-      @double_injection = DoubleInjection.new(@object, @method_name)
-    end
-
-    it "overrides the original method with the double_injection's dispatching methods" do
-      @object.respond_to?(:__rr__foobar).should == false
-      @double_injection.bind
-      @object.respond_to?(:__rr__foobar).should == true
-
-      rr_foobar_called = false
-      (class << @object; self; end).class_eval do
-        define_method :__rr__foobar do
-          rr_foobar_called = true
-        end
-      end
-
-      rr_foobar_called.should == false
-      @object.foobar
-      rr_foobar_called.should == true
-    end
-
-    it "stores original method in __rr__original_method_name" do
-      @double_injection.bind
-      @object.respond_to?(:__rr__original_foobar).should == true
-      @object.method(:__rr__original_foobar).should == @original_method
-    end
-  end
-
-  describe DoubleInjection, "#bind without an existing method" do
-    before do
-      @object = Object.new
-      @method_name = :foobar
-      @object.methods.should_not include(@method_name.to_s)
-      @double_injection = DoubleInjection.new(@object, @method_name)
-    end
-
-    it "creates a new method with the double_injection's dispatching methods" do
-      @object.respond_to?(:__rr__foobar).should == false
-      @double_injection.bind
-      @object.respond_to?(:__rr__foobar).should == true
-
-      rr_foobar_called = false
-      (class << @object; self; end).class_eval do
-        define_method :__rr__foobar do
-          rr_foobar_called = true
-        end
-      end
-
-      rr_foobar_called.should == false
-      @object.foobar
-      rr_foobar_called.should == true
-    end
-
-    it "does not create method __rr__original_method_name" do
-      @double_injection.bind
-      @object.respond_to?(:__rr__original_foobar).should == false
-    end
-  end
-
-  describe DoubleInjection, "#bind with ==" do
-    before do
-      @object = Object.new
-      @method_name = :'=='
-      @object.should respond_to(@method_name)
-      @original_method = @object.method(@method_name)
-      @object.methods.should include(@method_name.to_s)
-      @double_injection = DoubleInjection.new(@object, @method_name)
-    end
-
-    it "overrides the original method with the double_injection's dispatching methods" do
-      @object.respond_to?(:"__rr__#{@method_name}").should == false
-      @double_injection.bind
-      @object.respond_to?(:"__rr__#{@method_name}").should == true
-
-      override_called = false
-      method_name = @method_name
-      (class << @object; self; end).class_eval do
-        define_method :"__rr__#{method_name}" do
-          override_called = true
-        end
-      end
-
-      override_called.should == false
-      @object == 1
-      override_called.should == true
-    end
-
-    it "stores original method in __rr__original_method_name" do
-      @double_injection.bind
-      @object.respond_to?(:"__rr__original_#{@method_name}").should == true
-      @object.method(:"__rr__original_#{@method_name}").should == @original_method
-    end
-  end
-end

data/spec/rr/double/double_injection_dispatching_spec.rb

@@ -1,228 +0,0 @@
-require "spec/spec_helper"
-
-module RR
-  describe DoubleInjection do
-    before do
-      @space = Space.new
-      @object = Object.new
-      @object.methods.should_not include(method_name.to_s)
-      @double_injection = @space.double_injection(@object, method_name)
-    end
-
-    describe "normal methods" do
-      def method_name
-        :foobar
-      end
-
-      describe "where the double takes a block" do
-        it "executes the block" do
-          method_fixture = Object.new
-          class << method_fixture
-            def method_with_block(a, b)
-              yield(a, b)
-            end
-          end
-          double = Double.new(@double_injection)
-          double.with(1, 2).implemented_by(method_fixture.method(:method_with_block))
-          @object.foobar(1, 2) {|a, b| [b, a]}.should == [2, 1]
-        end
-      end
-
-      describe "where there are no doubles with duplicate ArgumentExpectations" do
-        it "dispatches to Double that have an exact match" do
-          double1_with_exact_match = Double.new(@double_injection)
-          double1_with_exact_match.with(:exact_match_1).returns {:return_1}
-          double_with_no_match = Double.new(@double_injection)
-          double_with_no_match.with("nothing that matches").returns {:no_match}
-          double2_with_exact_match = Double.new(@double_injection)
-          double2_with_exact_match.with(:exact_match_2).returns {:return_2}
-
-          @object.foobar(:exact_match_1).should == :return_1
-          @object.foobar(:exact_match_2).should == :return_2
-        end
-
-        it "dispatches to Double that have a wildcard match" do
-          double_with_wildcard_match = Double.new(@double_injection)
-          double_with_wildcard_match.with_any_args.returns {:wild_card_value}
-          double_with_no_match = Double.new(@double_injection)
-          double_with_no_match.with("nothing that matches").returns {:no_match}
-
-          @object.foobar(:wildcard_match_1).should == :wild_card_value
-          @object.foobar(:wildcard_match_2, 3).should == :wild_card_value
-        end
-      end
-
-      describe "where there are doubles" do
-        it "raises DoubleNotFoundError error when arguments do not match a double" do
-          double_1 = Double.new(@double_injection)
-          double_1.with(1, 2)
-
-          double_2 = Double.new(@double_injection)
-          double_2.with(3)
-
-          error = nil
-          begin
-            @object.foobar(:arg1, :arg2)
-            viotated "Error should have been raised"
-          rescue Errors::DoubleNotFoundError => e
-            error = e
-          end
-          error.message.should include("On object #<Object")
-          expected_double_message_part = "unexpected method invocation in the next line followed by the expected invocations\n" <<
-            "  foobar(:arg1, :arg2)\n"
-            "- foobar(1, 2)\n" <<
-            "- foobar(3)"
-          error.message.should include(expected_double_message_part)
-        end
-      end
-
-      describe "where there are Doubles with NonTerminal TimesCalledMatchers" do
-        it "dispatches to Double with exact match" do
-          double = double(1, 2) {:return_value}
-          @object.foobar(1, 2).should == :return_value
-        end
-
-        it "matches to the last Double that was registered with an exact match" do
-          double_1 = double(1, 2) {:value_1}
-          double_2 = double(1, 2) {:value_2}
-
-          @object.foobar(1, 2).should == :value_2
-        end
-
-        it "dispatches to Double with wildcard match" do
-          double = double(anything) {:return_value}
-          @object.foobar(:dont_care).should == :return_value
-        end
-
-        it "matches to the last Double that was registered with a wildcard match" do
-          double_1 = double(anything) {:value_1}
-          double_2 = double(anything) {:value_2}
-
-          @object.foobar(:dont_care).should == :value_2
-        end
-
-        it "matches to Double with exact match Double even when a Double with wildcard match was registered later" do
-          exact_double_registered_first = double(1, 2) {:exact_first}
-          wildcard_double_registered_last = double(anything, anything) {:wildcard_last}
-
-          @object.foobar(1, 2).should == :exact_first
-        end
-
-        def double(*arguments, &return_value)
-          double = Double.new(@double_injection)
-          double.with(*arguments).any_number_of_times.returns(&return_value)
-          double.should_not be_terminal
-          double
-        end
-      end
-
-      describe "where there are Terminal Doubles with duplicate Exact Match ArgumentExpectations" do
-        it "dispatches to Double that have an exact match" do
-          double1_with_exact_match = double(:exact_match) {:return_1}
-
-          @object.foobar(:exact_match).should == :return_1
-        end
-
-        it "dispatches to the first Double that have an exact match" do
-          double1_with_exact_match = double(:exact_match) {:return_1}
-          double2_with_exact_match = double(:exact_match) {:return_2}
-
-          @object.foobar(:exact_match).should == :return_1
-        end
-
-        it "dispatches the second Double with an exact match
-          when the first double's Times Called expectation is satisfied" do
-          double1_with_exact_match = double(:exact_match) {:return_1}
-          double2_with_exact_match = double(:exact_match) {:return_2}
-
-          @object.foobar(:exact_match)
-          @object.foobar(:exact_match).should == :return_2
-        end
-
-        it "raises TimesCalledError when all of the doubles Times Called expectation is satisfied" do
-          double1_with_exact_match = double(:exact_match) {:return_1}
-          double2_with_exact_match = double(:exact_match) {:return_2}
-
-          @object.foobar(:exact_match)
-          @object.foobar(:exact_match)
-          lambda do
-            @object.foobar(:exact_match)
-          end.should raise_error(Errors::TimesCalledError)
-        end
-
-        def double(*arguments, &return_value)
-          double = Double.new(@double_injection)
-          double.with(*arguments).once.returns(&return_value)
-          double.should be_terminal
-          double
-        end
-      end
-
-      describe "where there are doubles with duplicate Wildcard Match ArgumentExpectations" do
-        it "dispatches to Double that have a wildcard match" do
-          double_1 = double {:return_1}
-
-          @object.foobar(:anything).should == :return_1
-        end
-
-        it "dispatches to the first Double that has a wildcard match" do
-          double_1 = double {:return_1}
-          double_2 = double {:return_2}
-
-          @object.foobar(:anything).should == :return_1
-        end
-
-        it "dispatches the second Double with a wildcard match
-          when the first double's Times Called expectation is satisfied" do
-          double_1 = double {:return_1}
-          double_2 = double {:return_2}
-
-          @object.foobar(:anything)
-          @object.foobar(:anything).should == :return_2
-        end
-
-        it "raises TimesCalledError when all of the doubles Times Called expectation is satisfied" do
-          double_1 = double {:return_1}
-          double_2 = double {:return_2}
-
-          @object.foobar(:anything)
-          @object.foobar(:anything)
-          lambda do
-            @object.foobar(:anything)
-          end.should raise_error(Errors::TimesCalledError)
-        end
-
-        def double(&return_value)
-          double = Double.new(@double_injection)
-          double.with_any_args.once.returns(&return_value)
-          double.should be_terminal
-          double
-        end
-      end
-    end
-
-    describe "method names with !" do
-      def method_name
-        :foobar!
-      end
-
-      it "executes the block" do
-        double = Double.new(@double_injection)
-        double.with(1, 2) {:return_value}
-        @object.foobar!(1, 2).should == :return_value
-      end
-    end
-
-    describe "method names with ?" do
-      def method_name
-        :foobar?
-      end
-
-      it "executes the block" do
-        double = Double.new(@double_injection)
-        double.with(1, 2) {:return_value}
-        @object.foobar?(1, 2).should == :return_value
-      end
-    end
-  end
-end