google-geo 1.0 → 2.0

data/vendor/mocha-0.4.0/lib/mocha/mock.rb

@@ -0,0 +1,20 @@
+require 'mocha/mock_methods'
+
+module Mocha
+
+  class Mock
+    
+    include MockMethods
+
+    def initialize(stub_everything = false, name = nil)
+      @stub_everything = stub_everything
+      @mock_name = name
+    end
+
+    def mocha_inspect
+      @mock_name ? "#<Mock:#{@mock_name}>" : "#<Mock:0x#{__id__.to_s(16)}>"
+    end
+
+  end
+
+end

data/vendor/mocha-0.4.0/lib/mocha/mock_methods.rb

@@ -0,0 +1,122 @@
+require 'mocha/expectation'
+require 'mocha/metaclass'
+
+module Mocha
+  # Methods added to mock objects.
+  # These methods all return an expectation which can be further modified by methods on Mocha::Expectation.
+  module MockMethods
+    
+    # :stopdoc:
+    
+    attr_reader :stub_everything
+  
+    def expectations
+      @expectations ||= []
+    end
+
+    # :startdoc:
+
+    # :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 Mocha::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)
+    def expects(method_names, backtrace = nil)
+      method_names = method_names.is_a?(Hash) ? method_names : { method_names => nil }
+      method_names.each do |method_name, return_value|
+        expectations << Expectation.new(self, method_name, backtrace).returns(return_value)
+        self.__metaclass__.send(:undef_method, method_name) if self.__metaclass__.method_defined?(method_name)
+      end
+      expectations.last
+    end
+
+    alias_method :__expects__, :expects
+
+    # :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 Mocha::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)
+    def stubs(method_names, backtrace = nil)
+      method_names = method_names.is_a?(Hash) ? method_names : { method_names => nil }
+      method_names.each do |method_name, return_value|
+        expectations << Stub.new(self, method_name, backtrace).returns(return_value)
+        self.__metaclass__.send(:undef_method, method_name) if self.__metaclass__.method_defined?(method_name)
+      end
+      expectations.last
+    end
+    
+    alias_method :__stubs__, :stubs
+
+    # :stopdoc:
+
+    def method_missing(symbol, *arguments, &block)
+      matching_expectation = matching_expectation(symbol, *arguments)
+      if matching_expectation then
+        matching_expectation.invoke(&block)
+      elsif stub_everything then
+        return
+      else
+        begin
+          super_method_missing(symbol, *arguments, &block)
+    		rescue NoMethodError
+    			unexpected_method_called(symbol, *arguments)
+    		end
+  		end
+  	end
+  	
+  	def respond_to?(symbol)
+  	  expectations.any? { |expectation| expectation.method_name == symbol }
+	  end
+	
+  	def super_method_missing(symbol, *arguments, &block)
+  	  raise NoMethodError
+    end
+
+  	def unexpected_method_called(symbol, *arguments)
+      MissingExpectation.new(self, symbol).with(*arguments).verify
+    end
+	
+  	def matching_expectation(symbol, *arguments)
+      expectations.reverse.detect { |expectation| expectation.match?(symbol, *arguments) }
+    end
+  
+    def verify(&block)
+      expectations.each { |expectation| expectation.verify(&block) }
+    end
+  
+    # :startdoc:
+
+  end
+end

data/vendor/mocha-0.4.0/lib/mocha/object.rb

@@ -0,0 +1,100 @@
+require 'mocha/mock'
+require 'mocha/instance_method'
+require 'mocha/class_method'
+require 'mocha/any_instance_method'
+
+# Methods added all Objects.
+class Object
+  
+  def mocha # :nodoc:
+    @mocha ||= Mocha::Mock.new
+  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
+  def expects(symbol) 
+    method = stubba_method.new(stubba_object, symbol)
+    $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
+  def stubs(symbol) 
+    method = stubba_method.new(stubba_object, symbol)
+    $stubba.stub(method)
+    mocha.stubs(symbol, caller)
+  end
+  
+  def verify # :nodoc:
+    mocha.verify
+  end
+  
+end
+
+class Module # :nodoc:
+  
+  def stubba_method
+    Mocha::ClassMethod
+  end
+    
+end
+  
+class Class
+  
+  def stubba_method # :nodoc:
+    Mocha::ClassMethod
+  end
+
+  class AnyInstance # :nodoc:
+    
+    def initialize(klass)
+      @stubba_object = klass
+    end
+    
+    def stubba_method
+      Mocha::AnyInstanceMethod
+    end
+    
+    def stubba_object
+      @stubba_object
+    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/vendor/mocha-0.4.0/lib/mocha/pretty_parameters.rb

@@ -0,0 +1,28 @@
+require 'mocha/inspect'
+
+module Mocha
+
+  class PrettyParameters
+  
+    def initialize(params)
+      @params = params
+      @params_string = params.mocha_inspect
+    end
+  
+    def pretty
+      remove_outer_array_braces!
+      remove_outer_hash_braces!
+      @params_string
+    end
+  
+    def remove_outer_array_braces!
+      @params_string = @params_string.gsub(/^\[|\]$/, '')
+    end
+  
+    def remove_outer_hash_braces!
+      @params_string = @params_string.gsub(/^\{|\}$/, '') if @params.size == 1
+    end
+  
+  end
+  
+end

data/vendor/mocha-0.4.0/lib/mocha/setup_and_teardown.rb

@@ -0,0 +1,23 @@
+require 'mocha/central'
+
+module Mocha
+  
+  module SetupAndTeardown
+  
+    def setup_stubs
+      $stubba = Mocha::Central.new
+    end
+    
+    def verify_stubs
+      $stubba.verify_all { yield if block_given? } if $stubba
+    end
+  
+    def teardown_stubs
+      if $stubba then
+        $stubba.unstub_all
+        $stubba = nil
+      end
+    end
+
+  end
+end

data/vendor/mocha-0.4.0/lib/mocha/standalone.rb

@@ -0,0 +1,30 @@
+require 'mocha/auto_verify'
+require 'mocha/setup_and_teardown'
+
+module Mocha
+  
+  module Standalone
+    
+    include AutoVerify
+    include SetupAndTeardown
+    
+    def mocha_setup
+      setup_stubs
+    end
+    
+    def mocha_verify(&block)
+      verify_mocks(&block)
+      verify_stubs(&block)
+    end
+    
+    def mocha_teardown
+      begin
+        teardown_mocks
+      ensure
+        teardown_stubs
+      end
+    end
+    
+  end
+  
+end

data/vendor/mocha-0.4.0/lib/mocha/test_case_adapter.rb

@@ -0,0 +1,49 @@
+require 'mocha/expectation_error'
+
+module Mocha
+  
+  module TestCaseAdapter
+
+    def self.included(base)
+      base.class_eval do
+
+        alias_method :run_before_mocha_test_case_adapter, :run
+
+        def run(result)
+          yield(Test::Unit::TestCase::STARTED, name)
+          @_result = result
+          begin
+            mocha_setup
+            begin
+              setup
+              __send__(@method_name)
+              mocha_verify { add_assertion }
+            rescue Mocha::ExpectationError => e
+              add_failure(e.message, e.backtrace)
+            rescue Test::Unit::AssertionFailedError => e
+              add_failure(e.message, e.backtrace)
+            rescue StandardError, ScriptError
+              add_error($!)
+            ensure
+              begin
+                teardown
+              rescue Test::Unit::AssertionFailedError => e
+                add_failure(e.message, e.backtrace)
+              rescue StandardError, ScriptError
+                add_error($!)
+              end
+            end
+          ensure
+            mocha_teardown
+          end
+          result.add_run
+          yield(Test::Unit::TestCase::FINISHED, name)
+        end
+                
+      end
+      
+    end
+    
+  end
+  
+end

data/vendor/mocha-0.4.0/lib/mocha_standalone.rb

@@ -0,0 +1,2 @@
+require 'mocha/standalone'
+require 'mocha/object'

data/vendor/mocha-0.4.0/lib/stubba.rb

@@ -0,0 +1,2 @@
+# for backwards compatibility
+require 'mocha'

data/vendor/mocha-0.4.0/test/active_record_test_case.rb

@@ -0,0 +1,36 @@
+module ActiveRecordTestCase
+
+  def setup_with_fixtures
+    methods_called << :setup_with_fixtures
+  end
+
+  alias_method :setup, :setup_with_fixtures
+
+  def teardown_with_fixtures
+    methods_called << :teardown_with_fixtures
+  end
+
+  alias_method :teardown, :teardown_with_fixtures
+
+  def self.method_added(method)
+    case method.to_s
+    when 'setup'
+      unless method_defined?(:setup_without_fixtures)
+        alias_method :setup_without_fixtures, :setup
+        define_method(:setup) do
+          setup_with_fixtures
+          setup_without_fixtures
+        end
+      end
+    when 'teardown'
+      unless method_defined?(:teardown_without_fixtures)
+        alias_method :teardown_without_fixtures, :teardown
+        define_method(:teardown) do
+          teardown_without_fixtures
+          teardown_with_fixtures
+        end
+      end
+    end
+  end
+
+end

data/vendor/mocha-0.4.0/test/all_tests.rb

@@ -0,0 +1,75 @@
+require 'test/unit/ui/console/testrunner'
+
+require 'mocha/inspect_test'
+require 'mocha/pretty_parameters_test'
+require 'mocha/expectation_test'
+require 'mocha/infinite_range_test'
+require 'mocha/mock_methods_test'
+require 'mocha/mock_test'
+require 'mocha/auto_verify_test'
+
+require 'mocha/central_test'
+require 'mocha/class_method_test'
+require 'mocha/any_instance_method_test'
+require 'mocha/setup_and_teardown_test'
+require 'mocha/object_test'
+require 'mocha/metaclass_test'
+
+class UnitTests
+  
+  def self.suite
+    suite = Test::Unit::TestSuite.new('UnitTests')
+    suite << InspectTest.suite
+    suite << PrettyParametersTest.suite
+    suite << ExpectationTest.suite
+    suite << InfiniteRangeTest.suite
+    suite << MockMethodsTest.suite
+    suite << MockTest.suite
+    suite << AutoVerifyTest.suite
+    suite << CentralTest.suite
+    suite << ClassMethodTest.suite
+    suite << AnyInstanceMethodTest.suite
+    suite << SetupAndTeardownTest.suite
+    suite << ObjectTest.suite
+    suite << MetaclassTest.suite
+    suite
+  end
+  
+end
+
+Test::Unit::UI::Console::TestRunner.run(UnitTests)
+
+require 'mocha_test_result_integration_test'
+require 'stubba_test_result_integration_test'
+require 'stubba_integration_test'
+
+class IntegrationTests
+  
+  def self.suite
+    suite = Test::Unit::TestSuite.new('IntegrationTests')
+    suite << MochaTestResultIntegrationTest.suite
+    suite << StubbaTestResultIntegrationTest.suite
+    suite << StubbaIntegrationTest.suite
+  end
+  
+end
+
+Test::Unit::UI::Console::TestRunner.run(IntegrationTests)
+
+require 'mocha_acceptance_test'
+require 'stubba_acceptance_test'
+require 'standalone_acceptance_test'
+
+class AcceptanceTests
+  
+  def self.suite
+    suite = Test::Unit::TestSuite.new('AcceptanceTests')
+    suite << MochaAcceptanceTest.suite
+    suite << StubbaAcceptanceTest.suite
+    suite << StandaloneAcceptanceTest.suite
+    suite
+  end
+  
+end
+
+Test::Unit::UI::Console::TestRunner.run(AcceptanceTests)