google-geo 1.0 → 2.0

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

@@ -0,0 +1,34 @@
+class ExecutionPoint
+  
+  attr_reader :backtrace
+
+  def self.current
+    new(caller)
+  end
+  
+  def initialize(backtrace)
+    @backtrace = backtrace
+  end
+  
+  def file_name
+    /\A(.*?):\d+/.match(@backtrace.first)[1]
+  end
+  
+  def line_number
+    Integer(/\A.*?:(\d+)/.match(@backtrace.first)[1])
+  end
+
+  def ==(other)
+    return false unless other.is_a?(ExecutionPoint)
+    (file_name == other.file_name) and (line_number == other.line_number)
+  end
+  
+  def to_s
+    "file: #{file_name} line: #{line_number}"
+  end
+  
+  def inspect
+    to_s
+  end
+  
+end

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

@@ -0,0 +1,18 @@
+require 'mocha/metaclass'
+
+class Object
+  
+  def define_instance_method(method_symbol, &block)
+    __metaclass__.send(:define_method, method_symbol, block)
+  end
+
+  def replace_instance_method(method_symbol, &block)
+    raise "Cannot replace #{method_symbol} as #{self} does not respond to it." unless self.respond_to?(method_symbol)
+    define_instance_method(method_symbol, &block)
+  end
+
+  def define_instance_accessor(*symbols)
+    symbols.each { |symbol| __metaclass__.send(:attr_accessor, symbol) }
+  end
+
+end

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

@@ -0,0 +1,124 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper")
+require 'method_definer'
+require 'mocha/mock'
+require 'mocha/any_instance_method'
+
+class AnyInstanceMethodTest < Test::Unit::TestCase
+  
+  include Mocha
+  
+  def test_should_hide_original_method
+    klass = Class.new { def method_x; end }
+    method = AnyInstanceMethod.new(klass, :method_x)
+    hidden_method_x = method.hidden_method.to_sym
+    
+    method.hide_original_method
+    
+    assert klass.method_defined?(hidden_method_x)
+  end
+  
+  def test_should_not_hide_original_method_if_it_is_not_defined
+    klass = Class.new
+    method = AnyInstanceMethod.new(klass, :method_x)
+    hidden_method_x = method.hidden_method.to_sym
+    
+    method.hide_original_method
+    
+    assert_equal false, klass.method_defined?(hidden_method_x)
+  end
+  
+  def test_should_define_a_new_method
+    klass = Class.new { def method_x; end } 
+    method = AnyInstanceMethod.new(klass, :method_x)
+    mocha = Mock.new
+    mocha.expects(:method_x).with(:param1, :param2).returns(:result)
+    any_instance = Object.new
+    any_instance.define_instance_method(:mocha) { mocha }
+    klass.define_instance_method(:any_instance) { any_instance }
+    
+    method.define_new_method
+
+    instance = klass.new
+    result = instance.method_x(:param1, :param2)
+        
+    assert_equal :result, result
+    mocha.verify
+  end
+
+  def test_should_restore_original_method
+    klass = Class.new { def method_x; end }
+    method = AnyInstanceMethod.new(klass, :method_x)
+    hidden_method_x = method.hidden_method.to_sym
+    klass.send(:define_method, hidden_method_x, Proc.new { :original_result }) 
+    
+    method.restore_original_method
+    
+    instance = klass.new
+    assert_equal :original_result, instance.method_x 
+    assert !klass.method_defined?(hidden_method_x)
+  end
+
+  def test_should_not_restore_original_method_if_hidden_method_not_defined
+    klass = Class.new { def method_x; :new_result; end }
+    method = AnyInstanceMethod.new(klass, :method_x)
+    
+    method.restore_original_method
+    
+    instance = klass.new
+    assert_equal :new_result, instance.method_x 
+  end
+
+  def test_should_call_remove_new_method
+    klass = Class.new { def method_x; end }
+    any_instance = Mock.new
+    any_instance.stubs(:reset_mocha)
+    klass.define_instance_method(:any_instance) { any_instance }
+    method = AnyInstanceMethod.new(klass, :method_x)
+    method.replace_instance_method(:restore_original_method) { }
+    method.define_instance_accessor(:remove_called)
+    method.replace_instance_method(:remove_new_method) { self.remove_called = true }
+    
+    method.unstub
+    
+    assert method.remove_called
+  end
+
+  def test_should_call_restore_original_method
+    klass = Class.new { def method_x; end }
+    any_instance = Mock.new
+    any_instance.stubs(:reset_mocha)
+    klass.define_instance_method(:any_instance) { any_instance }
+    method = AnyInstanceMethod.new(klass, :method_x)
+    method.replace_instance_method(:remove_new_method) { }
+    method.define_instance_accessor(:restore_called)
+    method.replace_instance_method(:restore_original_method) { self.restore_called = true }
+    
+    method.unstub
+    
+    assert method.restore_called
+  end
+
+  def test_should_call_reset_mocha
+    klass = Class.new { def method_x; end }
+    any_instance = Class.new { attr_accessor :mocha_was_reset; def reset_mocha; self.mocha_was_reset = true; end }.new
+    klass.define_instance_method(:any_instance) { any_instance }
+    method = AnyInstanceMethod.new(klass, :method_x)
+    method.replace_instance_method(:remove_new_method) { }
+    method.replace_instance_method(:restore_original_method) { }
+    
+    method.unstub
+
+    assert any_instance.mocha_was_reset
+  end
+
+  def test_should_return_any_instance_mocha_for_stubbee
+    mocha = Object.new
+    any_instance = Object.new
+    any_instance.define_instance_method(:mocha) { mocha }
+    stubbee = Class.new
+    stubbee.define_instance_method(:any_instance) { any_instance }
+    method = AnyInstanceMethod.new(stubbee, :method_name)
+    assert_equal stubbee.any_instance.mocha, method.mock
+  end
+
+end

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

@@ -0,0 +1,163 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper")
+require 'mocha/auto_verify'
+require 'method_definer'
+
+class AutoVerifyTest < Test::Unit::TestCase
+  
+  attr_reader :test_case
+  
+  def setup
+    @test_case = Object.new
+    class << test_case
+      def self.add_teardown_method(symbol); end
+      include Mocha::AutoVerify
+    end
+  end
+  
+  def test_should_add_mock_type_expectations
+    test_case.define_instance_accessor(:expectation_type, :expectations)
+    test_case.define_instance_method(:build_mock_with_expectations) do |expectation_type, expectations|
+      self.expectation_type = expectation_type
+      self.expectations = expectations
+    end
+    expectations = { :method1 => :value1, :method2 => :value2 }
+    
+    test_case.mock(expectations)
+    
+    assert_equal :expects, test_case.expectation_type
+    assert_equal expectations, test_case.expectations
+  end
+  
+  def test_should_add_stub_type_expectations
+    test_case.define_instance_accessor(:expectation_type, :expectations)
+    test_case.define_instance_method(:build_mock_with_expectations) do |expectation_type, expectations|
+      self.expectation_type = expectation_type
+      self.expectations = expectations
+    end
+    expectations = { :method1 => :value1, :method2 => :value2 }
+    
+    test_case.stub(expectations)
+    
+    assert_equal :stubs, test_case.expectation_type
+    assert_equal expectations, test_case.expectations
+  end
+  
+  def test_should_add_greedy_stub_type_expectations
+    test_case.define_instance_accessor(:expectation_type, :expectations)
+    test_case.define_instance_method(:build_mock_with_expectations) do |expectation_type, expectations|
+      self.expectation_type = expectation_type
+      self.expectations = expectations
+    end
+    expectations = { :method1 => :value1, :method2 => :value2 }
+    
+    test_case.stub_everything(expectations)
+    
+    assert_equal :stub_everything, test_case.expectation_type
+    assert_equal expectations, test_case.expectations
+  end
+  
+  def test_should_build_mock
+    mock = test_case.build_mock_with_expectations
+    assert mock.is_a?(Mocha::Mock)
+  end
+  
+  def test_should_add_expectation_to_mock
+    mock = test_case.build_mock_with_expectations(:expects, :expected_method => 'return_value')
+    assert_equal 'return_value', mock.expected_method
+  end
+  
+  def test_should_build_stub
+    stub = test_case.build_mock_with_expectations(:stubs)
+    assert stub.is_a?(Mocha::Mock)
+  end
+  
+  def test_should_add_expectation_to_stub
+    stub = test_case.build_mock_with_expectations(:stubs, :stubbed_method => 'return_value')
+    assert_equal 'return_value', stub.stubbed_method
+  end
+  
+  def test_should_build_greedy_stub
+    greedy_stub = test_case.build_mock_with_expectations(:stub_everything)
+    assert greedy_stub.stub_everything
+  end
+  
+  def test_should_add_expectations_to_greedy_stub
+    greedy_mock = test_case.build_mock_with_expectations(:stub_everything, :stubbed_method => 'return_value')
+    assert_equal 'return_value', greedy_mock.stubbed_method
+  end
+  
+  def test_should_build_new_mock_each_time
+    assert_not_equal test_case.build_mock_with_expectations, test_case.build_mock_with_expectations
+  end
+  
+  def test_should_store_each_new_mock
+    expected = Array.new(3) { test_case.build_mock_with_expectations }
+    assert_equal expected, test_case.mocks
+  end
+  
+  def test_should_verify_each_mock
+    mocks = Array.new(3) do
+      mock = Object.new
+      mock.define_instance_accessor(:verify_called)
+      mock.define_instance_method(:verify) { self.verify_called = true }
+      mock
+    end
+    test_case.replace_instance_method(:mocks)  { mocks }
+    test_case.verify_mocks
+    assert mocks.all? { |mock| mock.verify_called }
+  end
+  
+  def test_should_yield_to_block_for_each_assertion
+    mock_class = Class.new do
+      def verify(&block); yield; end
+    end
+    mock = mock_class.new
+    test_case.replace_instance_method(:mocks)  { [mock] }
+    yielded = false
+    test_case.verify_mocks { yielded = true }
+    assert yielded
+  end
+  
+  def test_should_reset_mocks_on_teardown
+    mock = Class.new { define_method(:verify) {} }.new
+    test_case.mocks << mock
+    test_case.teardown_mocks
+    assert test_case.mocks.empty?
+  end
+  
+  def test_should_stub_everything
+    mock = test_case.stub_everything
+    assert_equal true, mock.stub_everything
+  end
+  
+  def test_should_add_mock_to_mocks
+    mock = test_case.mock
+    assert_equal [mock], test_case.mocks
+  end
+  
+  def test_should_add_stub_to_mocks
+    stub = test_case.stub
+    assert_equal [stub], test_case.mocks
+  end
+  
+  def test_should_add_greedy_stub_to_mocks
+    greedy_stub = test_case.stub_everything
+    assert_equal [greedy_stub], test_case.mocks
+  end
+  
+  def test_should_create_mock_with_name
+    mock = test_case.mock('named_mock')
+    assert_equal '#<Mock:named_mock>', mock.mocha_inspect
+  end
+  
+  def test_should_create_stub_with_name
+    stub = test_case.stub('named_stub')
+    assert_equal '#<Mock:named_stub>', stub.mocha_inspect
+  end
+  
+  def test_should_create_greedy_stub_with_name
+    greedy_stub = test_case.stub_everything('named_greedy_stub')
+    assert_equal '#<Mock:named_greedy_stub>', greedy_stub.mocha_inspect
+  end
+  
+end

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

@@ -0,0 +1,124 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper")
+
+require 'mocha/central'
+require 'mocha/mock'
+require 'method_definer'
+
+class CentralTest < Test::Unit::TestCase
+  
+  include Mocha
+  
+  def test_should_start_with_empty_stubba_methods
+    stubba = Central.new
+    
+    assert_equal [], stubba.stubba_methods
+  end
+  
+  def test_should_stub_method_if_not_already_stubbed
+    method = Mock.new
+    method.expects(:stub)
+    stubba = Central.new
+    
+    stubba.stub(method)
+    
+    method.verify
+  end
+  
+  def test_should_not_stub_method_if_already_stubbed
+    method = Mock.new
+    method.expects(:stub).times(0)
+    stubba = Central.new
+    stubba_methods = Mock.new
+    stubba_methods.stubs(:include?).with(method).returns(true)
+    stubba.stubba_methods = stubba_methods
+    
+    stubba.stub(method)
+    
+    method.verify
+  end
+  
+  def test_should_record_method
+    method = Mock.new
+    method.expects(:stub)
+    stubba = Central.new
+    
+    stubba.stub(method)
+    
+    assert_equal [method], stubba.stubba_methods
+  end
+  
+  def test_should_unstub_all_methods
+    stubba = Central.new
+    method_1 = Mock.new
+    method_1.expects(:unstub)
+    method_2 = Mock.new
+    method_2.expects(:unstub)
+    stubba.stubba_methods = [method_1, method_2]
+
+    stubba.unstub_all
+    
+    assert_equal [], stubba.stubba_methods
+    method_1.verify
+    method_2.verify
+  end
+  
+  def test_should_collect_mocks_from_all_methods
+    method_1 = Mock.new
+    method_1.stubs(:mock).returns(:mock_1)
+
+    method_2 = Mock.new
+    method_2.stubs(:mock).returns(:mock_2)
+
+    stubba = Central.new
+    stubba.stubba_methods = [method_1, method_2]
+    
+    assert_equal 2, stubba.unique_mocks.size
+    assert stubba.unique_mocks.include?(:mock_1)
+    assert stubba.unique_mocks.include?(:mock_2)
+  end
+
+  def test_should_return_unique_mochas
+    method_1 = Mock.new
+    method_1.stubs(:mock).returns(:mock_1)
+
+    method_2 = Mock.new
+    method_2.stubs(:mock).returns(:mock_1)
+
+    stubba = Central.new
+    stubba.stubba_methods = [method_1, method_2]
+    
+    assert_equal [:mock_1], stubba.unique_mocks
+  end
+  
+  def test_should_call_verify_on_all_unique_mocks
+    mock_class = Class.new do
+      attr_accessor :verify_called
+      def verify
+        self.verify_called = true
+      end
+    end
+    mocks = [mock_class.new, mock_class.new]
+    stubba = Central.new
+    stubba.replace_instance_method(:unique_mocks) { mocks }
+    
+    stubba.verify_all
+    
+    assert mocks.all? { |mock| mock.verify_called }
+  end
+
+  def test_should_call_verify_on_all_unique_mochas
+    mock_class = Class.new do
+      def verify(&block)
+        yield if block_given?
+      end
+    end
+    stubba = Central.new
+    stubba.replace_instance_method(:unique_mocks) { [mock_class.new] }
+    yielded = false
+    
+    stubba.verify_all { yielded = true }
+    
+    assert yielded
+  end
+
+end