rr 0.1.0

data/lib/rr/expectations/wildcard_matchers/anything.rb

@@ -0,0 +1,15 @@
+module RR
+  module Expectations
+    module WildcardMatchers
+      class Anything
+        def wildcard_match?(other)
+          true
+        end
+
+        def ==(other)
+          other.is_a?(self.class)
+        end
+      end
+    end
+  end
+end

data/lib/rr/expectations/wildcard_matchers/boolean.rb

@@ -0,0 +1,20 @@
+module RR
+  module Expectations
+    module WildcardMatchers
+      class Boolean
+        def wildcard_match?(other)
+          self == other || is_a_boolean?(other)
+        end
+
+        def ==(other)
+          other.is_a?(self.class)
+        end
+
+        protected
+        def is_a_boolean?(subject)
+          subject.is_a?(TrueClass) || subject.is_a?(FalseClass)
+        end
+      end
+    end
+  end
+end

data/lib/rr/expectations/wildcard_matchers/duck_type.rb

@@ -0,0 +1,26 @@
+module RR
+  module Expectations
+    module WildcardMatchers
+      class DuckType
+        attr_accessor :required_methods
+
+        def initialize(*required_methods)
+          @required_methods = required_methods
+        end
+
+        def wildcard_match?(other)
+          return true if self == other
+          required_methods.each do |m|
+            return false unless other.respond_to?(m)
+          end
+          return true
+        end
+
+        def ==(other)
+          return false unless other.is_a?(self.class)
+          self.required_methods == other.required_methods
+        end
+      end
+    end
+  end
+end

data/lib/rr/expectations/wildcard_matchers/is_a.rb

@@ -0,0 +1,22 @@
+module RR
+  module Expectations
+    module WildcardMatchers
+      class IsA
+        attr_reader :klass
+        
+        def initialize(klass)
+          @klass = klass
+        end
+        
+        def wildcard_match?(other)
+          self == other || other.is_a?(klass)
+        end
+
+        def ==(other)
+          return false unless other.is_a?(self.class)
+          self.klass == other.klass
+        end
+      end
+    end
+  end
+end

data/lib/rr/expectations/wildcard_matchers/numeric.rb

@@ -0,0 +1,11 @@
+module RR
+  module Expectations
+    module WildcardMatchers
+      class Numeric < IsA
+        def initialize
+          @klass = ::Numeric
+        end
+      end
+    end
+  end
+end

data/lib/rr/expectations/wildcard_matchers/range.rb

@@ -0,0 +1,7 @@
+class Range
+  def wildcard_match?(other)
+    return true if self == other
+    return false unless other.is_a?(Numeric)
+    self.include?(other)
+  end
+end

data/lib/rr/expectations/wildcard_matchers/regexp.rb

@@ -0,0 +1,7 @@
+class Regexp
+  def wildcard_match?(other)
+    return true if self == other
+    return false unless other.is_a?(String)
+    (other =~ self) ? true : false
+  end
+end

data/lib/rr/extensions/double_methods.rb

@@ -0,0 +1,81 @@
+module RR
+module Extensions
+  module DoubleMethods
+    # Sets up a MockCreator that generates a Double Scenario that
+    # acts like a mock.
+    #   mock(object).method_name(arg1, arg2) {return_value}
+    def mock(subject, &definition)
+      RR::Space.instance.create_mock_creator(subject, &definition)
+    end
+
+    # Sets up a StubCreator that generates a Double Scenario that
+    # acts like a stub.
+    #   stub(object).method_name {return_value}
+    def stub(subject, &definition)
+      RR::Space.instance.create_stub_creator(subject, &definition)
+    end
+
+    # Sets up a ProbeCreator that generates a Double Scenario that
+    # acts like a probe.
+    #   probe(controller.template).render(:partial => "my/socks")
+    def probe(subject, &definition)
+      RR::Space.instance.create_probe_creator(subject, &definition)
+    end
+
+    # Sets up a DoNotAllowCreator that generates a Double Scenario that
+    # expects never to be called.
+    #   do_not_allow(object).method_name
+    def do_not_allow(subject, &definition)
+      RR::Space.instance.create_do_not_allow_creator(subject, &definition)
+    end
+    alias_method :dont_allow, :do_not_allow
+
+    # Sets up an Anything wildcard ArgumentEqualityExpectation
+    # that succeeds when passed any argument.
+    #   mock(object).method_name(anything) {return_value}
+    #   object.method_name("an arbitrary value") # passes
+    def anything
+      RR::Expectations::WildcardMatchers::Anything.new
+    end
+
+    # Sets up an IsA wildcard ArgumentEqualityExpectation
+    # that succeeds when passed an argument of a certain type.
+    #   mock(object).method_name(is_a(String)) {return_value}
+    #   object.method_name("A String") # passes
+    def is_a(klass)
+      RR::Expectations::WildcardMatchers::IsA.new(klass)
+    end
+
+    # Sets up an Numeric wildcard ArgumentEqualityExpectation
+    # that succeeds when passed an argument that is ::Numeric.
+    #   mock(object).method_name(numeric) {return_value}
+    #   object.method_name(99) # passes
+    def numeric
+      RR::Expectations::WildcardMatchers::Numeric.new
+    end
+
+    # Sets up an Boolean wildcard ArgumentEqualityExpectation
+    # that succeeds when passed an argument that is a ::Boolean.
+    #   mock(object).method_name(boolean) {return_value}
+    #   object.method_name(false) # passes
+    def boolean
+      RR::Expectations::WildcardMatchers::Boolean.new
+    end
+
+    # Sets up a DuckType wildcard ArgumentEqualityExpectation
+    # that succeeds when passed the argument implements the methods.
+    #   arg = Object.new
+    #   def arg.foo; end
+    #   def arg.bar; end
+    #   mock(object).method_name(duck_type(:foo, :bar)) {return_value}
+    #   object.method_name(arg) # passes
+    def duck_type(*args)
+      RR::Expectations::WildcardMatchers::DuckType.new(*args)
+    end
+
+    instance_methods.each do |name|
+      alias_method "rr_#{name}", name
+    end
+  end
+end
+end

data/lib/rr/mock_creator.rb

@@ -0,0 +1,32 @@
+module RR
+  # RR::MockCreator uses RR::MockCreator#method_missing to create
+  # a Scenario that acts like a mock.
+  #
+  # The following example mocks method_name with arg1 and arg2
+  # returning return_value.
+  #
+  #   mock(subject).method_name(arg1, arg2) { return_value }
+  #
+  # The MockCreator also supports a block sytnax.
+  #
+  #    mock(subject) do |m|
+  #      m.method_name(arg1, arg2) { return_value }
+  #    end
+  class MockCreator
+    instance_methods.each { |m| undef_method m unless m =~ /^__/ }
+    
+    def initialize(space, subject)
+      @space = space
+      @subject = subject
+      yield(self) if block_given?
+    end
+
+    protected
+    def method_missing(method_name, *args, &returns)
+      double = @space.create_double(@subject, method_name)
+      scenario = @space.create_scenario(double)
+      scenario.with(*args).once.returns(&returns)
+      scenario
+    end
+  end
+end

data/lib/rr/probe_creator.rb

@@ -0,0 +1,31 @@
+module RR
+  # RR::ProbeCreator uses RR::ProbeCreator#method_missing to create
+  # a Scenario that acts like a probe.
+  #
+  # The following example probes method_name with arg1 and arg2
+  # returning return_value.
+  #
+  #   probe(subject).method_name(arg1, arg2) { return_value }
+  #
+  # The ProbeCreator also supports a block sytnax.
+  #
+  #    probe(subject) do |m|
+  #      m.method_name(arg1, arg2) { return_value }
+  #    end
+  class ProbeCreator
+    instance_methods.each { |m| undef_method m unless m =~ /^__/ }
+    
+    def initialize(space, subject)
+      @space = space
+      @subject = subject
+      yield(self) if block_given?
+    end
+
+    protected
+    def method_missing(method_name, *args, &returns)
+      double = @space.create_double(@subject, method_name)
+      scenario = @space.create_scenario(double)
+      scenario.with(*args).once.implemented_by(double.original_method)
+    end
+  end
+end

data/lib/rr/scenario.rb

@@ -0,0 +1,184 @@
+module RR
+  # RR::Scenario is the use case for a method call.
+  # It has the ArgumentEqualityExpectation, TimesCalledExpectation,
+  # and the implementation.
+  class Scenario
+    attr_reader :times_called, :argument_expectation, :times_called_expectation
+
+    def initialize(space)
+      @space = space
+      @implementation = nil
+      @argument_expectation = nil
+      @times_called_expectation = nil
+      @times_called = 0
+    end
+
+    # Scenario#with creates an ArgumentEqualityExpectation for the
+    # Scenario. it takes a list of expected arguments.
+    #
+    # Passing in a block sets the return value.
+    #
+    #   mock(subject).method_name.with(1, 2) {:return_value}
+    def with(*args, &returns)
+      @argument_expectation = Expectations::ArgumentEqualityExpectation.new(*args)
+      returns(&returns) if returns
+      self
+    end
+
+    # Scenario#with_any_args creates an AnyArgumentEqualityExpectation
+    # for the Scenario.
+    #
+    # Passing in a block sets the return value.
+    #
+    #   mock(subject).method_name.with_any_args {:return_value}
+    def with_any_args(&returns)
+      @argument_expectation = Expectations::AnyArgumentExpectation.new
+      returns(&returns) if returns
+      self
+    end
+
+    # Scenario#with_no_args creates an ArgumentEqualityExpectation with
+    # no arguments for the Scenario.
+    #
+    # Passing in a block sets the return value.
+    #
+    #   mock(subject).method_name.with_no_args {:return_value}
+    def with_no_args(&returns)
+      @argument_expectation = Expectations::ArgumentEqualityExpectation.new()
+      returns(&returns) if returns
+      self
+    end
+
+    # Scenario#never creates an TimesCalledExpectation of 0.
+    #
+    # This method does not accept a block because it will never be called.
+    #
+    #   mock(subject).method_name.never
+    def never
+      @times_called_expectation = Expectations::TimesCalledExpectation.new(0)
+      self
+    end
+
+    # Scenario#once creates an TimesCalledExpectation of 1.
+    #
+    # Passing in a block sets the return value.
+    #
+    #   mock(subject).method_name.once {:return_value}
+    def once(&returns)
+      @times_called_expectation = Expectations::TimesCalledExpectation.new(1)
+      returns(&returns) if returns
+      self
+    end
+
+    # Scenario#twice creates an TimesCalledExpectation of 2.
+    #
+    # Passing in a block sets the return value.
+    #
+    #   mock(subject).method_name.twice {:return_value}
+    def twice(&returns)
+      @times_called_expectation = Expectations::TimesCalledExpectation.new(2)
+      returns(&returns) if returns
+      self
+    end
+
+    # Scenario#twice creates an TimesCalledExpectation of the passed
+    # in number.
+    #
+    # Passing in a block sets the return value.
+    #
+    #   mock(subject).method_name.times(4) {:return_value}
+    def times(number, &returns)
+      @times_called_expectation = Expectations::TimesCalledExpectation.new(number)
+      returns(&returns) if returns
+      self
+    end
+
+    # Scenario#ordered sets the Scenario to have an ordered
+    # expectation.
+    #
+    # Passing in a block sets the return value.
+    #
+    #   mock(subject).method_name.ordered {return_value}
+    def ordered(&returns)
+      @ordered = true
+      @space.ordered_scenarios << self unless @space.ordered_scenarios.include?(self)
+      returns(&returns) if returns
+      self
+    end
+
+    # Scenario#ordered? returns true when the Scenario is ordered.
+    #
+    #   mock(subject).method_name.ordered?
+    def ordered?
+      @ordered
+    end
+
+    # Scenario#returns causes Scenario to return the return value of
+    # the passed in block.
+    def returns(&implementation)
+      implemented_by implementation
+    end
+
+    # Scenario#implemented_by sets the implementation of the Scenario.
+    # This method takes a Proc or a Method. Passing in a Method allows
+    # the Scenario to accept blocks.
+    #
+    #   obj = Object.new
+    #   def obj.foobar
+    #     yield(1)
+    #   end
+    #   mock(obj).method_name.implemented_by(obj.method(:foobar))
+    def implemented_by(implementation)
+      @implementation = implementation
+      self
+    end
+
+    # Scenario#call calls the Scenario's implementation. The return
+    # value of the implementation is returned.
+    #
+    # A TimesCalledExpectationError is raised when the times called
+    # exceeds the expected TimesCalledExpectation.
+    def call(*args, &block)
+      @times_called_expectation.verify_input if @times_called_expectation
+      @space.verify_ordered_scenario(self) if ordered?
+      return nil unless @implementation
+
+      if @implementation.is_a?(Method)
+        return @implementation.call(*args, &block)
+      else
+        args << block if block
+        return @implementation.call(*args)
+      end
+    end
+
+    # Scenario#exact_match? returns true when the passed in arguments
+    # exactly match the ArgumentEqualityExpectation arguments.
+    def exact_match?(*arguments)
+      return false unless @argument_expectation 
+      @argument_expectation.exact_match?(*arguments)
+    end
+
+    # Scenario#wildcard_match? returns true when the passed in arguments
+    # wildcard match the ArgumentEqualityExpectation arguments.
+    def wildcard_match?(*arguments)
+      return false unless @argument_expectation
+      @argument_expectation.wildcard_match?(*arguments)
+    end
+
+    # Scenario#times_called_verified? returns true when the
+    # TimesCalledExpectation is satisfied.
+    def times_called_verified?
+      return false unless @times_called_expectation
+      @times_called_expectation.verify
+    end
+
+    # Scenario#verify verifies the the TimesCalledExpectation
+    # is satisfied for this scenario. A TimesCalledExpectationError
+    # is raised if the TimesCalledExpectation is not met.
+    def verify
+      return true unless @times_called_expectation
+      @times_called_expectation.verify!
+      true
+    end
+  end
+end