gsterndale-warrant 0.0.0 → 0.2.0

data/test/rails_root/vendor/gems/mocha-0.9.4/test/acceptance/stubbing_non_public_class_method_test.rb

@@ -0,0 +1,163 @@
+require File.join(File.dirname(__FILE__), "acceptance_test_helper")
+require 'mocha'
+
+class StubbingNonPublicClassMethodTest < Test::Unit::TestCase
+  
+  include AcceptanceTest
+  
+  def setup
+    setup_acceptance_test
+  end
+  
+  def teardown
+    teardown_acceptance_test
+  end
+  
+  def test_should_allow_stubbing_private_class_method
+    Mocha::Configuration.allow(:stubbing_non_public_method)
+    klass = Class.new do
+      class << self
+        def private_method; end
+        private :private_method
+      end
+    end
+    test_result = run_test do
+      klass.stubs(:private_method)
+    end
+    assert_passed(test_result)
+    assert !@logger.warnings.include?("stubbing non-public method: #{klass}.private_method")
+  end
+  
+  def test_should_allow_stubbing_protected_class_method
+    Mocha::Configuration.allow(:stubbing_non_public_method)
+    klass = Class.new do
+      class << self
+        def protected_method; end
+        protected :protected_method
+      end
+    end
+    test_result = run_test do
+      klass.stubs(:protected_method)
+    end
+    assert_passed(test_result)
+    assert !@logger.warnings.include?("stubbing non-public method: #{klass}.protected_method")
+  end
+  
+  def test_should_warn_when_stubbing_private_class_method
+    Mocha::Configuration.warn_when(:stubbing_non_public_method)
+    klass = Class.new do
+      class << self
+        def private_method; end
+        private :private_method
+      end
+    end
+    test_result = run_test do
+      klass.stubs(:private_method)
+    end
+    assert_passed(test_result)
+    assert @logger.warnings.include?("stubbing non-public method: #{klass}.private_method")
+  end
+  
+  def test_should_warn_when_stubbing_protected_class_method
+    Mocha::Configuration.warn_when(:stubbing_non_public_method)
+    klass = Class.new do
+      class << self
+        def protected_method; end
+        protected :protected_method
+      end
+    end
+    test_result = run_test do
+      klass.stubs(:protected_method)
+    end
+    assert_passed(test_result)
+    assert @logger.warnings.include?("stubbing non-public method: #{klass}.protected_method")
+  end
+  
+  def test_should_prevent_stubbing_private_class_method
+    Mocha::Configuration.prevent(:stubbing_non_public_method)
+    klass = Class.new do
+      class << self
+        def private_method; end
+        private :private_method
+      end
+    end
+    test_result = run_test do
+      klass.stubs(:private_method)
+    end
+    assert_failed(test_result)
+    assert test_result.error_messages.include?("Mocha::StubbingError: stubbing non-public method: #{klass}.private_method")
+  end
+  
+  def test_should_prevent_stubbing_protected_class_method
+    Mocha::Configuration.prevent(:stubbing_non_public_method)
+    klass = Class.new do
+      class << self
+        def protected_method; end
+        protected :protected_method
+      end
+    end
+    test_result = run_test do
+      klass.stubs(:protected_method)
+    end
+    assert_failed(test_result)
+    assert test_result.error_messages.include?("Mocha::StubbingError: stubbing non-public method: #{klass}.protected_method")
+  end
+  
+  def test_should_default_to_allow_stubbing_private_class_method
+    klass = Class.new do
+      class << self
+        def private_method; end
+        private :private_method
+      end
+    end
+    test_result = run_test do
+      klass.stubs(:private_method)
+    end
+    assert_passed(test_result)
+    assert !@logger.warnings.include?("stubbing non-public method: #{klass}.private_method")
+  end
+  
+  def test_should_default_to_allow_stubbing_protected_class_method
+    klass = Class.new do
+      class << self
+        def protected_method; end
+        protected :protected_method
+      end
+    end
+    test_result = run_test do
+      klass.stubs(:protected_method)
+    end
+    assert_passed(test_result)
+    assert !@logger.warnings.include?("stubbing non-public method: #{klass}.protected_method")
+  end
+  
+  def test_should_allow_stubbing_public_class_method
+    Mocha::Configuration.prevent(:stubbing_non_public_method)
+    klass = Class.new do
+      class << self
+        def public_method; end
+        public :public_method
+      end
+    end
+    test_result = run_test do
+      klass.stubs(:public_method)
+    end
+    assert_passed(test_result)
+  end
+
+  def test_should_allow_stubbing_method_to_which_class_responds
+    Mocha::Configuration.prevent(:stubbing_non_public_method)
+    klass = Class.new do
+      class << self
+        def respond_to?(method, include_private_methods = false)
+          (method == :method_to_which_class_responds)
+        end
+      end
+    end
+    test_result = run_test do
+      klass.stubs(:method_to_which_class_responds)
+    end
+    assert_passed(test_result)
+  end
+
+end

data/test/rails_root/vendor/gems/mocha-0.9.4/test/acceptance/stubbing_non_public_instance_method_test.rb

@@ -0,0 +1,143 @@
+require File.join(File.dirname(__FILE__), "acceptance_test_helper")
+require 'mocha'
+
+class StubbingNonPublicInstanceMethodTest < Test::Unit::TestCase
+  
+  include AcceptanceTest
+  
+  def setup
+    setup_acceptance_test
+  end
+  
+  def teardown
+    teardown_acceptance_test
+  end
+  
+  def test_should_allow_stubbing_private_instance_method
+    Mocha::Configuration.allow(:stubbing_non_public_method)
+    instance = Class.new do
+      def private_method; end
+      private :private_method
+    end.new
+    test_result = run_test do
+      instance.stubs(:private_method)
+    end
+    assert_passed(test_result)
+    assert !@logger.warnings.include?("stubbing non-public method: #{instance}.private_method")
+  end
+  
+  def test_should_allow_stubbing_protected_instance_method
+    Mocha::Configuration.allow(:stubbing_non_public_method)
+    instance = Class.new do
+      def protected_method; end
+      protected :protected_method
+    end.new
+    test_result = run_test do
+      instance.stubs(:protected_method)
+    end
+    assert_passed(test_result)
+    assert !@logger.warnings.include?("stubbing non-public method: #{instance}.protected_method")
+  end
+  
+  def test_should_warn_when_stubbing_private_instance_method
+    Mocha::Configuration.warn_when(:stubbing_non_public_method)
+    instance = Class.new do
+      def private_method; end
+      private :private_method
+    end.new
+    test_result = run_test do
+      instance.stubs(:private_method)
+    end
+    assert_passed(test_result)
+    assert @logger.warnings.include?("stubbing non-public method: #{instance}.private_method")
+  end
+  
+  def test_should_warn_when_stubbing_protected_instance_method
+    Mocha::Configuration.warn_when(:stubbing_non_public_method)
+    instance = Class.new do
+      def protected_method; end
+      protected :protected_method
+    end.new
+    test_result = run_test do
+      instance.stubs(:protected_method)
+    end
+    assert_passed(test_result)
+    assert @logger.warnings.include?("stubbing non-public method: #{instance}.protected_method")
+  end
+  
+  def test_should_prevent_stubbing_private_instance_method
+    Mocha::Configuration.prevent(:stubbing_non_public_method)
+    instance = Class.new do
+      def private_method; end
+      private :private_method
+    end.new
+    test_result = run_test do
+      instance.stubs(:private_method)
+    end
+    assert_failed(test_result)
+    assert test_result.error_messages.include?("Mocha::StubbingError: stubbing non-public method: #{instance}.private_method")
+  end
+  
+  def test_should_prevent_stubbing_protected_instance_method
+    Mocha::Configuration.prevent(:stubbing_non_public_method)
+    instance = Class.new do
+      def protected_method; end
+      protected :protected_method
+    end.new
+    test_result = run_test do
+      instance.stubs(:protected_method)
+    end
+    assert_failed(test_result)
+    assert test_result.error_messages.include?("Mocha::StubbingError: stubbing non-public method: #{instance}.protected_method")
+  end
+  
+  def test_should_default_to_allow_stubbing_private_instance_method
+    instance = Class.new do
+      def private_method; end
+      private :private_method
+    end.new
+    test_result = run_test do
+      instance.stubs(:private_method)
+    end
+    assert_passed(test_result)
+    assert !@logger.warnings.include?("stubbing non-public method: #{instance}.private_method")
+  end
+  
+  def test_should_default_to_allow_stubbing_protected_instance_method
+    instance = Class.new do
+      def protected_method; end
+      protected :protected_method
+    end.new
+    test_result = run_test do
+      instance.stubs(:protected_method)
+    end
+    assert_passed(test_result)
+    assert !@logger.warnings.include?("stubbing non-public method: #{instance}.protected_method")
+  end
+  
+  def test_should_allow_stubbing_public_instance_method
+    Mocha::Configuration.prevent(:stubbing_non_public_method)
+    instance = Class.new do
+      def public_method; end
+      public :public_method
+    end.new
+    test_result = run_test do
+      instance.stubs(:public_method)
+    end
+    assert_passed(test_result)
+  end
+
+  def test_should_allow_stubbing_method_to_which_instance_responds
+    Mocha::Configuration.prevent(:stubbing_non_public_method)
+    instance = Class.new do
+      def respond_to?(method, include_private_methods = false)
+        (method == :method_to_which_instance_responds)
+      end
+    end.new
+    test_result = run_test do
+      instance.stubs(:method_to_which_instance_responds)
+    end
+    assert_passed(test_result)
+  end
+
+end

data/test/rails_root/vendor/gems/mocha-0.9.4/test/acceptance/stubbing_on_non_mock_object_test.rb

@@ -0,0 +1,64 @@
+require File.join(File.dirname(__FILE__), "acceptance_test_helper")
+require 'mocha'
+
+class StubbingOnNonMockObjectTest < Test::Unit::TestCase
+  
+  include AcceptanceTest
+  
+  def setup
+    setup_acceptance_test
+  end
+  
+  def teardown
+    teardown_acceptance_test
+  end
+  
+  def test_should_allow_stubbing_method_on_non_mock_object
+    Mocha::Configuration.allow(:stubbing_method_on_non_mock_object)
+    non_mock_object = Class.new { def existing_method; end }
+    test_result = run_test do
+      non_mock_object.stubs(:existing_method)
+    end
+    assert_passed(test_result)
+    assert !@logger.warnings.include?("stubbing method on non-mock object: #{non_mock_object}.existing_method")
+  end
+  
+  def test_should_warn_on_stubbing_method_on_non_mock_object
+    Mocha::Configuration.warn_when(:stubbing_method_on_non_mock_object)
+    non_mock_object = Class.new { def existing_method; end }
+    test_result = run_test do
+      non_mock_object.stubs(:existing_method)
+    end
+    assert_passed(test_result)
+    assert @logger.warnings.include?("stubbing method on non-mock object: #{non_mock_object}.existing_method")
+  end
+  
+  def test_should_prevent_stubbing_method_on_non_mock_object
+    Mocha::Configuration.prevent(:stubbing_method_on_non_mock_object)
+    non_mock_object = Class.new { def existing_method; end }
+    test_result = run_test do
+      non_mock_object.stubs(:existing_method)
+    end
+    assert_failed(test_result)
+    assert test_result.error_messages.include?("Mocha::StubbingError: stubbing method on non-mock object: #{non_mock_object}.existing_method")
+  end
+  
+  def test_should_default_to_allow_stubbing_method_on_non_mock_object
+    non_mock_object = Class.new { def existing_method; end }
+    test_result = run_test do
+      non_mock_object.stubs(:existing_method)
+    end
+    assert_passed(test_result)
+    assert !@logger.warnings.include?("stubbing method on non-mock object: #{non_mock_object}.existing_method")
+  end
+  
+  def test_should_allow_stubbing_method_on_mock_object
+    Mocha::Configuration.prevent(:stubbing_method_on_non_mock_object)
+    test_result = run_test do
+      mock = mock('mock')
+      mock.stubs(:any_method)
+    end
+    assert_passed(test_result)
+  end
+
+end

data/test/rails_root/vendor/gems/mocha-0.9.4/test/deprecation_disabler.rb

@@ -0,0 +1,15 @@
+require 'mocha/deprecation'
+
+module DeprecationDisabler
+
+  def disable_deprecations
+    original_mode = Mocha::Deprecation.mode
+    Mocha::Deprecation.mode = :disabled
+    begin
+      yield
+    ensure
+      Mocha::Deprecation.mode = original_mode
+    end
+  end
+
+end

data/test/rails_root/vendor/gems/mocha-0.9.4/test/execution_point.rb

@@ -0,0 +1,36 @@
+class ExecutionPoint
+  
+  attr_reader :backtrace
+
+  def self.current
+    new(caller)
+  end
+  
+  def initialize(backtrace)
+    @backtrace = backtrace
+  end
+  
+  def file_name
+    return "unknown" unless @backtrace && @backtrace.first
+    /\A(.*?):\d+/.match(@backtrace.first)[1]
+  end
+  
+  def line_number
+    return "unknown" unless @backtrace && @backtrace.first
+    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/test/rails_root/vendor/gems/mocha-0.9.4/test/method_definer.rb

@@ -0,0 +1,24 @@
+require 'mocha/metaclass'
+
+module Mocha
+  
+  module ObjectMethods
+    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
+  
+end
+
+class Object
+  include Mocha::ObjectMethods
+end

data/test/rails_root/vendor/gems/mocha-0.9.4/test/simple_counter.rb

@@ -0,0 +1,13 @@
+class SimpleCounter
+  
+  attr_reader :count
+  
+  def initialize
+    @count = 0
+  end
+  
+  def increment
+    @count += 1
+  end
+  
+end

data/test/rails_root/vendor/gems/mocha-0.9.4/test/test_helper.rb

@@ -0,0 +1,11 @@
+unless defined?(STANDARD_OBJECT_PUBLIC_INSTANCE_METHODS)
+  STANDARD_OBJECT_PUBLIC_INSTANCE_METHODS = Object.public_instance_methods
+end
+
+$:.unshift File.expand_path(File.join(File.dirname(__FILE__), "..", "lib"))
+$:.unshift File.expand_path(File.join(File.dirname(__FILE__)))
+$:.unshift File.expand_path(File.join(File.dirname(__FILE__), 'unit'))
+$:.unshift File.expand_path(File.join(File.dirname(__FILE__), 'unit', 'parameter_matchers'))
+$:.unshift File.expand_path(File.join(File.dirname(__FILE__), 'acceptance'))
+
+require 'test/unit'

data/test/rails_root/vendor/gems/mocha-0.9.4/test/test_runner.rb

@@ -0,0 +1,33 @@
+require 'test/unit/testresult'
+require 'test/unit/testcase'
+
+module TestRunner
+  
+  def run_test(test_result = Test::Unit::TestResult.new, &block)
+    test_class = Class.new(Test::Unit::TestCase) do
+      define_method(:test_me, &block)
+    end
+    test = test_class.new(:test_me)
+    test.run(test_result) {}
+    class << test_result
+      attr_reader :failures, :errors
+      def failure_messages
+        failures.map { |failure| failure.message }
+      end
+      def error_messages
+        errors.map { |error| error.message }
+      end
+    end
+    test_result
+  end
+  
+  def assert_passed(test_result)
+    flunk "Test failed unexpectedly with message: #{test_result.failures}" if test_result.failure_count > 0
+    flunk "Test failed unexpectedly with message: #{test_result.errors}" if test_result.error_count > 0
+  end
+
+  def assert_failed(test_result)
+    flunk "Test passed unexpectedly" if test_result.passed?
+  end
+
+end

data/test/rails_root/vendor/gems/mocha-0.9.4/test/unit/any_instance_method_test.rb

@@ -0,0 +1,126 @@
+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.hide_original_method
+    method.define_new_method
+
+    instance = klass.new
+    result = instance.method_x(:param1, :param2)
+        
+    assert_equal :result, result
+    assert mocha.__verified__?
+  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.remove_new_method
+    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/test/rails_root/vendor/gems/mocha-0.9.4/test/unit/array_inspect_test.rb

@@ -0,0 +1,16 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper")
+require 'mocha/inspect'
+
+class ArrayInspectTest < Test::Unit::TestCase
+  
+  def test_should_use_inspect
+    array = [1, 2]
+    assert_equal array.inspect, array.mocha_inspect
+  end
+  
+  def test_should_use_mocha_inspect_on_each_item
+    array = [1, 2, "chris"]
+    assert_equal "[1, 2, 'chris']", array.mocha_inspect
+  end
+  
+end

data/test/rails_root/vendor/gems/mocha-0.9.4/test/unit/backtrace_filter_test.rb

@@ -0,0 +1,19 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper")
+require 'mocha/backtrace_filter'
+
+class BacktraceFilterTest < Test::Unit::TestCase
+  
+  include Mocha
+  
+  def test_should_exclude_mocha_locations_from_backtrace
+    mocha_lib = "/username/workspace/mocha_wibble/lib/"
+    backtrace = [ mocha_lib + 'exclude/me/1', mocha_lib + 'exclude/me/2', '/keep/me', mocha_lib + 'exclude/me/3']
+    filter = BacktraceFilter.new(mocha_lib)
+    assert_equal ['/keep/me'], filter.filtered(backtrace)
+  end
+
+  def test_should_determine_path_for_mocha_lib_directory
+    assert_match Regexp.new("/lib/$"), BacktraceFilter::LIB_DIRECTORY
+  end
+  
+end