thoughtbot-clearance 0.2.0 → 0.2.2

data/test/rails_root/vendor/gems/mocha-0.9.1/lib/mocha/mock.rb

@@ -0,0 +1,196 @@
+require 'mocha/expectation'
+require 'mocha/expectation_list'
+require 'mocha/metaclass'
+require 'mocha/names'
+require 'mocha/mockery'
+require 'mocha/method_matcher'
+require 'mocha/parameters_matcher'
+require 'mocha/unexpected_invocation'
+
+module Mocha # :nodoc:
+  
+  # Traditional mock object.
+  #
+  # Methods return an Expectation which can be further modified by methods on Expectation.
+  class Mock
+    
+    # :call-seq: expects(method_name) -> expectation
+    #            expects(method_names) -> last expectation
+    #
+    # Adds an expectation that a method identified by +method_name+ symbol must be called exactly once with any parameters.
+    # Returns the new expectation which can be further modified by methods on Expectation.
+    #   object = mock()
+    #   object.expects(:method1)
+    #   object.method1
+    #   # no error raised
+    #
+    #   object = mock()
+    #   object.expects(:method1)
+    #   # error raised, because method1 not called exactly once
+    # If +method_names+ is a +Hash+, an expectation will be set up for each entry using the key as +method_name+ and value as +return_value+.
+    #   object = mock()
+    #   object.expects(:method1 => :result1, :method2 => :result2)
+    #
+    #   # exactly equivalent to
+    #
+    #   object = mock()
+    #   object.expects(:method1).returns(:result1)
+    #   object.expects(:method2).returns(:result2)
+    #
+    # Aliased by <tt>\_\_expects\_\_</tt>
+    def expects(method_name_or_hash, backtrace = nil)
+      if method_name_or_hash.is_a?(Hash) then
+        method_name_or_hash.each do |method_name, return_value|
+          ensure_method_not_already_defined(method_name)
+          @expectations.add(Expectation.new(self, method_name, backtrace).returns(return_value))
+        end
+      else
+        ensure_method_not_already_defined(method_name_or_hash)
+        @expectations.add(Expectation.new(self, method_name_or_hash, backtrace))
+      end
+    end
+    
+    # :call-seq: stubs(method_name) -> expectation
+    #            stubs(method_names) -> last expectation
+    #
+    # Adds an expectation that a method identified by +method_name+ symbol may be called any number of times with any parameters.
+    # Returns the new expectation which can be further modified by methods on Expectation.
+    #   object = mock()
+    #   object.stubs(:method1)
+    #   object.method1
+    #   object.method1
+    #   # no error raised
+    # If +method_names+ is a +Hash+, an expectation will be set up for each entry using the key as +method_name+ and value as +return_value+.
+    #   object = mock()
+    #   object.stubs(:method1 => :result1, :method2 => :result2)
+    #
+    #   # exactly equivalent to
+    #
+    #   object = mock()
+    #   object.stubs(:method1).returns(:result1)
+    #   object.stubs(:method2).returns(:result2)
+    #
+    # Aliased by <tt>\_\_stubs\_\_</tt>
+    def stubs(method_name_or_hash, backtrace = nil)
+      if method_name_or_hash.is_a?(Hash) then
+        method_name_or_hash.each do |method_name, return_value|
+          ensure_method_not_already_defined(method_name)
+          @expectations.add(Expectation.new(self, method_name, backtrace).at_least(0).returns(return_value))
+        end
+      else
+        ensure_method_not_already_defined(method_name_or_hash)
+        @expectations.add(Expectation.new(self, method_name_or_hash, backtrace).at_least(0))
+      end
+    end
+    
+    # :call-seq: responds_like(responder) -> mock
+    #
+    # Constrains the +mock+ so that it can only expect or stub methods to which +responder+ responds. The constraint is only applied at method invocation time.
+    #
+    # A +NoMethodError+ will be raised if the +responder+ does not <tt>respond_to?</tt> a method invocation (even if the method has been expected or stubbed).
+    #
+    # The +mock+ will delegate its <tt>respond_to?</tt> method to the +responder+.
+    #   class Sheep
+    #     def chew(grass); end
+    #     def self.number_of_legs; end
+    #   end
+    #
+    #   sheep = mock('sheep')
+    #   sheep.expects(:chew)
+    #   sheep.expects(:foo)
+    #   sheep.respond_to?(:chew) # => true
+    #   sheep.respond_to?(:foo) # => true
+    #   sheep.chew
+    #   sheep.foo
+    #   # no error raised
+    #
+    #   sheep = mock('sheep')
+    #   sheep.responds_like(Sheep.new)
+    #   sheep.expects(:chew)
+    #   sheep.expects(:foo)
+    #   sheep.respond_to?(:chew) # => true
+    #   sheep.respond_to?(:foo) # => false
+    #   sheep.chew
+    #   sheep.foo # => raises NoMethodError exception
+    #
+    #   sheep_class = mock('sheep_class')
+    #   sheep_class.responds_like(Sheep)
+    #   sheep_class.stubs(:number_of_legs).returns(4)
+    #   sheep_class.expects(:foo)
+    #   sheep_class.respond_to?(:number_of_legs) # => true
+    #   sheep_class.respond_to?(:foo) # => false
+    #   assert_equal 4, sheep_class.number_of_legs
+    #   sheep_class.foo # => raises NoMethodError exception
+    #
+    # Aliased by +quacks_like+
+    def responds_like(object)
+      @responder = object
+      self
+    end
+    
+    # :stopdoc:
+    
+    def initialize(name = nil, &block)
+      @name = name || DefaultName.new(self)
+      @expectations = ExpectationList.new
+      @everything_stubbed = false
+      @responder = nil
+      instance_eval(&block) if block
+    end
+
+    attr_reader :everything_stubbed, :expectations
+
+    alias_method :__expects__, :expects
+
+    alias_method :__stubs__, :stubs
+    
+    alias_method :quacks_like, :responds_like
+
+    def stub_everything
+      @everything_stubbed = true
+    end
+    
+    def method_missing(symbol, *arguments, &block)
+      if @responder and not @responder.respond_to?(symbol)
+        raise NoMethodError, "undefined method `#{symbol}' for #{self.mocha_inspect} which responds like #{@responder.mocha_inspect}"
+      end
+      if matching_expectation_allowing_invocation = @expectations.match_allowing_invocation(symbol, *arguments)
+        matching_expectation_allowing_invocation.invoke(&block)
+      else
+        if (matching_expectation = @expectations.match(symbol, *arguments)) || (!matching_expectation && !@everything_stubbed)
+          message = UnexpectedInvocation.new(self, symbol, *arguments).to_s
+          message << Mockery.instance.mocha_inspect
+          raise ExpectationError.new(message, caller)
+        end
+      end
+    end
+    
+    def respond_to?(symbol)
+      if @responder then
+        @responder.respond_to?(symbol)
+      else
+        @expectations.matches_method?(symbol)
+      end
+    end
+    
+    def __verified__?(assertion_counter = nil)
+      @expectations.verified?(assertion_counter)
+    end
+    
+    def mocha_inspect
+      @name.mocha_inspect
+    end
+    
+    def inspect
+      mocha_inspect
+    end
+    
+    def ensure_method_not_already_defined(method_name)
+      self.__metaclass__.send(:undef_method, method_name) if self.__metaclass__.method_defined?(method_name)
+    end
+
+    # :startdoc:
+
+  end
+
+end

data/test/rails_root/vendor/gems/mocha-0.9.1/lib/mocha/mockery.rb

@@ -0,0 +1,181 @@
+require 'mocha/central'
+require 'mocha/mock'
+require 'mocha/names'
+require 'mocha/state_machine'
+require 'mocha/logger'
+require 'mocha/configuration'
+require 'mocha/stubbing_error'
+
+module Mocha
+  
+  class Mockery
+    
+    class << self
+      
+      def instance
+        @instance ||= new
+      end
+      
+      def reset_instance
+        @instance = nil
+      end
+      
+    end
+    
+    def named_mock(name, &block)
+      add_mock(Mock.new(Name.new(name), &block))
+    end
+    
+    def unnamed_mock(&block)
+      add_mock(Mock.new(&block))
+    end
+    
+    def mock_impersonating(object, &block)
+      add_mock(Mock.new(ImpersonatingName.new(object), &block))
+    end
+    
+    def mock_impersonating_any_instance_of(klass, &block)
+      add_mock(Mock.new(ImpersonatingAnyInstanceName.new(klass), &block))
+    end
+    
+    def new_state_machine(name)
+      add_state_machine(StateMachine.new(name))
+    end
+    
+    def verify(assertion_counter = nil)
+      unless mocks.all? { |mock| mock.__verified__?(assertion_counter) }
+        message = "not all expectations were satisfied\n#{mocha_inspect}"
+        if unsatisfied_expectations.empty?
+          backtrace = caller
+        else
+          backtrace = unsatisfied_expectations[0].backtrace
+        end
+        raise ExpectationError.new(message, backtrace)
+      end
+      expectations.each do |e|
+        unless Mocha::Configuration.allow?(:stubbing_method_unnecessarily)
+          unless e.used?
+            on_stubbing_method_unnecessarily(e)
+          end
+        end
+      end
+    end
+    
+    def teardown
+      stubba.unstub_all
+      reset
+    end
+    
+    def stubba
+      @stubba ||= Central.new
+    end
+    
+    def mocks
+      @mocks ||= []
+    end
+    
+    def state_machines
+      @state_machines ||= []
+    end
+    
+    def mocha_inspect
+      message = ""
+      message << "unsatisfied expectations:\n- #{unsatisfied_expectations.map { |e| e.mocha_inspect }.join("\n- ")}\n" unless unsatisfied_expectations.empty?
+      message << "satisfied expectations:\n- #{satisfied_expectations.map { |e| e.mocha_inspect }.join("\n- ")}\n" unless satisfied_expectations.empty?
+      message << "states:\n- #{state_machines.map { |sm| sm.mocha_inspect }.join("\n- ")}" unless state_machines.empty?
+      message
+    end
+    
+    def on_stubbing(object, method)
+      method = RUBY_VERSION < '1.9' ? method.to_s : method.to_sym
+      unless Mocha::Configuration.allow?(:stubbing_non_existent_method)
+        unless object.method_exists?(method, include_public_methods = true)
+          on_stubbing_non_existent_method(object, method)
+        end
+      end
+      unless Mocha::Configuration.allow?(:stubbing_non_public_method)
+        if object.method_exists?(method, include_public_methods = false)
+          on_stubbing_non_public_method(object, method)
+        end
+      end
+      unless Mocha::Configuration.allow?(:stubbing_method_on_non_mock_object)
+        on_stubbing_method_on_non_mock_object(object, method)
+      end
+    end
+    
+    def on_stubbing_non_existent_method(object, method)
+      if Mocha::Configuration.prevent?(:stubbing_non_existent_method)
+        raise StubbingError.new("stubbing non-existent method: #{object.mocha_inspect}.#{method}", caller)
+      end
+      if Mocha::Configuration.warn_when?(:stubbing_non_existent_method)
+        logger.warn "stubbing non-existent method: #{object.mocha_inspect}.#{method}"
+      end
+    end
+    
+    def on_stubbing_non_public_method(object, method)
+      if Mocha::Configuration.prevent?(:stubbing_non_public_method)
+        raise StubbingError.new("stubbing non-public method: #{object.mocha_inspect}.#{method}", caller)
+      end
+      if Mocha::Configuration.warn_when?(:stubbing_non_public_method)
+        logger.warn "stubbing non-public method: #{object.mocha_inspect}.#{method}"
+      end
+    end
+    
+    def on_stubbing_method_on_non_mock_object(object, method)
+      if Mocha::Configuration.prevent?(:stubbing_method_on_non_mock_object)
+        raise StubbingError.new("stubbing method on non-mock object: #{object.mocha_inspect}.#{method}", caller)
+      end
+      if Mocha::Configuration.warn_when?(:stubbing_method_on_non_mock_object)
+        logger.warn "stubbing method on non-mock object: #{object.mocha_inspect}.#{method}"
+      end
+    end
+    
+    def on_stubbing_method_unnecessarily(expectation)
+      if Mocha::Configuration.prevent?(:stubbing_method_unnecessarily)
+        raise StubbingError.new("stubbing method unnecessarily: #{expectation.method_signature}", expectation.backtrace)
+      end
+      if Mocha::Configuration.warn_when?(:stubbing_method_unnecessarily)
+        logger.warn "stubbing method unnecessarily: #{expectation.method_signature}"
+      end
+    end
+    
+    attr_writer :logger
+    
+    def logger
+      @logger ||= Logger.new($stderr)
+    end
+    
+    
+    private
+    
+    def expectations
+      mocks.map { |mock| mock.expectations.to_a }.flatten
+    end
+    
+    def unsatisfied_expectations
+      expectations.reject { |e| e.verified? }
+    end
+    
+    def satisfied_expectations
+      expectations.select { |e| e.verified? }
+    end
+    
+    def add_mock(mock)
+      mocks << mock
+      mock
+    end
+    
+    def add_state_machine(state_machine)
+      state_machines << state_machine
+      state_machine
+    end
+    
+    def reset
+      @stubba = nil
+      @mocks = nil
+      @state_machines = nil
+    end
+    
+  end
+  
+end

data/test/rails_root/vendor/gems/mocha-0.9.1/lib/mocha/module_method.rb

@@ -0,0 +1,16 @@
+require 'mocha/module_method'
+
+module Mocha
+
+  class ModuleMethod < ClassMethod
+
+    def method_exists?(method)
+      return true if stubbee.public_methods(false).include?(method)
+      return true if stubbee.protected_methods(false).include?(method)
+      return true if stubbee.private_methods(false).include?(method)
+      return false
+    end
+
+  end
+  
+end

data/test/rails_root/vendor/gems/mocha-0.9.1/lib/mocha/multiple_yields.rb

@@ -0,0 +1,20 @@
+module Mocha # :nodoc:
+  
+  class MultipleYields # :nodoc:
+    
+    attr_reader :parameter_groups
+    
+    def initialize(*parameter_groups)
+      @parameter_groups = parameter_groups
+    end
+    
+    def each
+      @parameter_groups.each do |parameter_group|
+        yield(parameter_group)
+      end
+    end
+    
+  end
+  
+end
+    

data/test/rails_root/vendor/gems/mocha-0.9.1/lib/mocha/names.rb

@@ -0,0 +1,53 @@
+module Mocha
+  
+  class ImpersonatingName
+    
+    def initialize(object)
+      @object = object
+    end
+    
+    def mocha_inspect
+      @object.mocha_inspect
+    end
+    
+  end
+  
+  class ImpersonatingAnyInstanceName
+    
+    def initialize(klass)
+      @klass = klass
+    end
+    
+    def mocha_inspect
+      "#<AnyInstance:#{@klass.mocha_inspect}>"
+    end
+    
+  end
+  
+  class Name
+    
+    def initialize(name)
+      @name = name
+    end
+    
+    def mocha_inspect
+      "#<Mock:#{@name}>"
+    end
+    
+  end
+  
+  class DefaultName
+    
+    def initialize(mock)
+      @mock = mock
+    end
+    
+    def mocha_inspect
+      address = @mock.__id__ * 2
+      address += 0x100000000 if address < 0
+      "#<Mock:0x#{'%x' % address}>"
+    end
+    
+  end
+  
+end

data/test/rails_root/vendor/gems/mocha-0.9.1/lib/mocha/no_yields.rb

@@ -0,0 +1,11 @@
+module Mocha # :nodoc:
+  
+  class NoYields # :nodoc:
+    
+    def each
+    end
+    
+  end
+  
+end
+    

data/test/rails_root/vendor/gems/mocha-0.9.1/lib/mocha/object.rb

@@ -0,0 +1,134 @@
+require 'mocha/mockery'
+require 'mocha/instance_method'
+require 'mocha/class_method'
+require 'mocha/module_method'
+require 'mocha/any_instance_method'
+
+# Methods added all objects to allow mocking and stubbing on real objects.
+#
+# Methods return a Mocha::Expectation which can be further modified by methods on Mocha::Expectation.
+class Object
+  
+  def mocha # :nodoc:
+    @mocha ||= Mocha::Mockery.instance.mock_impersonating(self)
+  end
+  
+  def reset_mocha # :nodoc:
+    @mocha = nil
+  end
+  
+  def stubba_method # :nodoc:
+    Mocha::InstanceMethod
+  end
+  
+  def stubba_object # :nodoc:
+    self
+  end
+  
+  # :call-seq: expects(symbol) -> expectation
+  #
+  # Adds an expectation that a method identified by +symbol+ must be called exactly once with any parameters.
+  # Returns the new expectation which can be further modified by methods on Mocha::Expectation.
+  #   product = Product.new
+  #   product.expects(:save).returns(true)
+  #   assert_equal false, product.save
+  #
+  # The original implementation of <tt>Product#save</tt> is replaced temporarily.
+  #
+  # The original implementation of <tt>Product#save</tt> is restored at the end of the test.
+  def expects(symbol)
+    mockery = Mocha::Mockery.instance
+    mockery.on_stubbing(self, symbol)
+    method = stubba_method.new(stubba_object, symbol)
+    mockery.stubba.stub(method)
+    mocha.expects(symbol, caller)
+  end
+  
+  # :call-seq: stubs(symbol) -> expectation
+  #
+  # Adds an expectation that a method identified by +symbol+ may be called any number of times with any parameters.
+  # Returns the new expectation which can be further modified by methods on Mocha::Expectation.
+  #   product = Product.new
+  #   product.stubs(:save).returns(true)
+  #   assert_equal false, product.save
+  #
+  # The original implementation of <tt>Product#save</tt> is replaced temporarily.
+  #
+  # The original implementation of <tt>Product#save</tt> is restored at the end of the test.
+  def stubs(symbol)
+    mockery = Mocha::Mockery.instance
+    mockery.on_stubbing(self, symbol)
+    method = stubba_method.new(stubba_object, symbol)
+    mockery.stubba.stub(method)
+    mocha.stubs(symbol, caller)
+  end
+  
+  def method_exists?(method, include_public_methods = true)
+    if include_public_methods
+      return true if public_methods(include_superclass_methods = true).include?(method)
+      return true if respond_to?(method)
+    end
+    return true if protected_methods(include_superclass_methods = true).include?(method)
+    return true if private_methods(include_superclass_methods = true).include?(method)
+    return false
+  end
+  
+end
+
+class Module # :nodoc:
+  
+  def stubba_method
+    Mocha::ModuleMethod
+  end
+    
+end
+  
+class Class
+  
+  def stubba_method # :nodoc:
+    Mocha::ClassMethod
+  end
+
+  class AnyInstance # :nodoc:
+    
+    def initialize(klass)
+      @stubba_object = klass
+    end
+    
+    def mocha
+      @mocha ||= Mocha::Mockery.instance.mock_impersonating_any_instance_of(@stubba_object)
+    end
+
+    def stubba_method
+      Mocha::AnyInstanceMethod
+    end
+    
+    def stubba_object
+      @stubba_object
+    end
+    
+    def method_exists?(method, include_public_methods = true)
+      if include_public_methods
+        return true if @stubba_object.public_instance_methods(include_superclass_methods = true).include?(method)
+      end
+      return true if @stubba_object.protected_instance_methods(include_superclass_methods = true).include?(method)
+      return true if @stubba_object.private_instance_methods(include_superclass_methods = true).include?(method)
+      return false
+    end
+    
+  end
+  
+  # :call-seq: any_instance -> mock object
+  #
+  # Returns a mock object which will detect calls to any instance of this class.
+  #   Product.any_instance.stubs(:save).returns(false)
+  #   product_1 = Product.new
+  #   assert_equal false, product_1.save
+  #   product_2 = Product.new
+  #   assert_equal false, product_2.save
+  def any_instance
+    @any_instance ||= AnyInstance.new(self)
+  end
+  
+end
+

data/test/rails_root/vendor/gems/mocha-0.9.1/lib/mocha/parameter_matchers/all_of.rb

@@ -0,0 +1,42 @@
+require 'mocha/parameter_matchers/base'
+
+module Mocha
+  
+  module ParameterMatchers
+
+    # :call-seq: all_of(*parameter_matchers) -> parameter_matcher
+    #
+    # Matches if all +parameter_matchers+ match.
+    #   object = mock()
+    #   object.expects(:method_1).with(all_of(includes(1), includes(3)))
+    #   object.method_1([1, 3])
+    #   # no error raised
+    #
+    #   object = mock()
+    #   object.expects(:method_1).with(all_of(includes(1), includes(3)))
+    #   object.method_1([1, 2])
+    #   # error raised, because method_1 was not called with object including 1 and 3
+    def all_of(*matchers)
+      AllOf.new(*matchers)
+    end
+    
+    class AllOf < Base # :nodoc:
+      
+      def initialize(*matchers)
+        @matchers = matchers
+      end
+    
+      def matches?(available_parameters)
+        parameter = available_parameters.shift
+        @matchers.all? { |matcher| matcher.to_matcher.matches?([parameter]) }
+      end
+      
+      def mocha_inspect
+        "all_of(#{@matchers.map { |matcher| matcher.mocha_inspect }.join(", ") })"
+      end
+      
+    end
+    
+  end
+  
+end

data/test/rails_root/vendor/gems/mocha-0.9.1/lib/mocha/parameter_matchers/any_of.rb

@@ -0,0 +1,47 @@
+require 'mocha/parameter_matchers/base'
+
+module Mocha
+  
+  module ParameterMatchers
+
+    # :call-seq: any_of(*parameter_matchers) -> parameter_matcher
+    #
+    # Matches if any +parameter_matchers+ match.
+    #   object = mock()
+    #   object.expects(:method_1).with(any_of(1, 3))
+    #   object.method_1(1)
+    #   # no error raised
+    #
+    #   object = mock()
+    #   object.expects(:method_1).with(any_of(1, 3))
+    #   object.method_1(3)
+    #   # no error raised
+    #
+    #   object = mock()
+    #   object.expects(:method_1).with(any_of(1, 3))
+    #   object.method_1(2)
+    #   # error raised, because method_1 was not called with 1 or 3
+    def any_of(*matchers)
+      AnyOf.new(*matchers)
+    end
+    
+    class AnyOf < Base # :nodoc:
+      
+      def initialize(*matchers)
+        @matchers = matchers
+      end
+    
+      def matches?(available_parameters)
+        parameter = available_parameters.shift
+        @matchers.any? { |matcher| matcher.to_matcher.matches?([parameter]) }
+      end
+      
+      def mocha_inspect
+        "any_of(#{@matchers.map { |matcher| matcher.mocha_inspect }.join(", ") })"
+      end
+      
+    end
+    
+  end
+  
+end