newrelic_rpm 3.6.5.130 → 3.6.6.147

data/test/new_relic/agent/instrumentation/active_record_instrumentation_test.rb

@@ -597,6 +597,29 @@ class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::
   end
 end
 
+
+class ActiveRecordQueryEncodingTest < Test::Unit::TestCase
+
+  class DatabaseAdapter
+    # we patch in here
+    def log(*args)
+    end
+    include ::NewRelic::Agent::Instrumentation::ActiveRecord
+  end
+
+  def test_should_not_bomb_out_if_a_query_is_in_an_invalid_encoding
+    # Contains invalid UTF8 Byte
+    query = "select ICS95095010000000000083320000BS01030000004100+\xFF00000000000000000"
+    if RUBY_VERSION >= '1.9'
+      # Force the query to an invalid encoding
+      query.force_encoding 'UTF-8'
+      assert_equal false, query.valid_encoding?
+    end
+    db = DatabaseAdapter.new
+    db.send(:log, query)
+  end
+end
+
 else
   puts "Skipping tests in #{__FILE__} because Rails is unavailable"
 end

data/test/new_relic/agent/instrumentation/active_record_subscriber_test.rb

@@ -2,7 +2,9 @@
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
 
-if defined?(::Rails) && ::Rails::VERSION::MAJOR.to_i >= 4 && !NewRelic::LanguageSupport.using_engine?('jruby')
+MIN_RAILS_VERSION = 4
+
+if defined?(::Rails) && ::Rails::VERSION::MAJOR.to_i >= MIN_RAILS_VERSION && !NewRelic::LanguageSupport.using_engine?('jruby')
 
 require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','test_helper'))
 require 'new_relic/agent/instrumentation/active_record_subscriber'
@@ -131,5 +133,5 @@ class NewRelic::Agent::Instrumentation::ActiveRecordSubscriberTest < Test::Unit:
 end
 
 else
-  puts "Skipping tests in #{__FILE__} because Rails is unavailable"
+  puts "Skipping tests in #{__FILE__} because Rails >= #{MIN_RAILS_VERSION} is unavailable"
 end

data/test/new_relic/agent/instrumentation/instrumentation_test.rb

@@ -12,4 +12,3 @@ class NewRelic::Agent::Instrumentation::InstrumentationTest < Test::Unit::TestCa
     require 'new_relic/delayed_job_injection'
   end
 end
-

data/test/new_relic/agent/instrumentation/queue_time_test.rb

@@ -6,19 +6,23 @@ require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'te
 class NewRelic::Agent::Instrumentation::QueueTimeTest < Test::Unit::TestCase
   include NewRelic::Agent::Instrumentation
 
+  def setup
+    freeze_time
+  end
+
   def test_parse_frontend_timestamp_given_queue_start_header
     header = { 'HTTP_X_QUEUE_START' => format_header_time(Time.now - 60) }
-    assert_in_delta(seconds_ago(60), QueueTime.parse_frontend_timestamp(header), 0.1)
+    assert_in_delta(seconds_ago(60), QueueTime.parse_frontend_timestamp(header), 0.001)
   end
 
   def test_parse_frontend_timestamp_given_request_start_header
     header = { 'HTTP_X_REQUEST_START' => format_header_time(Time.now - 60) }
-    assert_in_delta(seconds_ago(60), QueueTime.parse_frontend_timestamp(header), 0.1)
+    assert_in_delta(seconds_ago(60), QueueTime.parse_frontend_timestamp(header), 0.001)
   end
 
   def test_parse_frontend_timestamp_given_middleware_start_header
     header = { 'HTTP_X_MIDDLEWARE_START' => format_header_time(Time.now - 60) }
-    assert_in_delta(seconds_ago(60), QueueTime.parse_frontend_timestamp(header), 0.1)
+    assert_in_delta(seconds_ago(60), QueueTime.parse_frontend_timestamp(header), 0.001)
   end
 
   def test_parse_frontend_timestamp_from_earliest_header
@@ -26,7 +30,7 @@ class NewRelic::Agent::Instrumentation::QueueTimeTest < Test::Unit::TestCase
                 'HTTP_X_QUEUE_START'      => format_header_time(Time.now - 62),
                 'HTTP_X_MIDDLEWARE_START' => format_header_time(Time.now - 61)}
 
-    assert_in_delta(seconds_ago(63), QueueTime.parse_frontend_timestamp(headers), 0.1)
+    assert_in_delta(seconds_ago(63), QueueTime.parse_frontend_timestamp(headers), 0.001)
   end
 
   def test_parse_frontend_timestamp_from_earliest_header_out_of_order
@@ -34,39 +38,40 @@ class NewRelic::Agent::Instrumentation::QueueTimeTest < Test::Unit::TestCase
                 'HTTP_X_REQUEST_START'    => format_header_time(Time.now - 62),
                 'HTTP_X_QUEUE_START'      => format_header_time(Time.now - 61) }
 
-    assert_in_delta(seconds_ago(63), QueueTime.parse_frontend_timestamp(headers), 0.1)
+    assert_in_delta(seconds_ago(63), QueueTime.parse_frontend_timestamp(headers), 0.001)
   end
 
   def test_parse_frontend_timestamp_from_header_in_seconds
     header = { 'HTTP_X_QUEUE_START' => "t=#{Time.now.to_f - 60}" }
-    assert_in_delta(seconds_ago(60), QueueTime.parse_frontend_timestamp(header), 0.1)
+    assert_in_delta(seconds_ago(60), QueueTime.parse_frontend_timestamp(header), 0.001)
   end
 
   def test_parse_frontend_timestamp_from_header_in_milliseconds
     header = { 'HTTP_X_QUEUE_START' => "t=#{(Time.now.to_f - 60) * 1_000}" }
-    assert_in_delta(seconds_ago(60), QueueTime.parse_frontend_timestamp(header), 0.1)
+    assert_in_delta(seconds_ago(60), QueueTime.parse_frontend_timestamp(header), 0.001)
   end
 
   def test_parse_frontend_timestamp_from_header_with_multiple_servers
     now = Time.now.to_f
     header = { 'HTTP_X_QUEUE_START' => "servera t=#{now - 60}, serverb t=#{now - 30}" }
-    assert_in_delta(seconds_ago(60), QueueTime.parse_frontend_timestamp(header), 0.1)
+    assert_in_delta(seconds_ago(60), QueueTime.parse_frontend_timestamp(header), 0.001)
   end
 
   def test_parse_frontend_timestamp_from_header_missing_t_equals
     header = { 'HTTP_X_REQUEST_START' => (Time.now.to_f - 60).to_s }
-    assert_in_delta(seconds_ago(60), QueueTime.parse_frontend_timestamp(header), 0.1)
+    sleep 2
+    assert_in_delta(seconds_ago(60), QueueTime.parse_frontend_timestamp(header), 0.001)
   end
 
   def test_parse_frontend_timestamp_from_header_negative
     now = Time.now
     the_future = Time.at(now.to_f + 60)
     header = { 'HTTP_X_REQUEST_START' => the_future.to_f.to_s }
-    assert_in_delta(now, QueueTime.parse_frontend_timestamp(header, now), 0.1)
+    assert_in_delta(now, QueueTime.parse_frontend_timestamp(header, now), 0.001)
   end
 
   def test_recording_queue_time_metric
-    assert_metric_value_in_delta(60, 'WebFrontend/QueueTime', 0.1) do
+    assert_metric_value_in_delta(60, 'WebFrontend/QueueTime', 0.001) do
       QueueTime.record_frontend_metrics(Time.at(Time.now.to_f - 60))
     end
   end

data/test/new_relic/agent/instrumentation/rack_test.rb

@@ -36,4 +36,3 @@ class NewRelic::Agent::Instrumentation::RackTest < Test::Unit::TestCase
     assert_equal [404, {}, ["whee"]], x.call({})
   end
 end
-

data/test/new_relic/agent/memcache_instrumentation_test.rb

@@ -29,11 +29,11 @@ end
 
 class NewRelic::Agent::MemcacheInstrumentationTest < Test::Unit::TestCase
   include NewRelic::Agent::Instrumentation::ControllerInstrumentation
-  
+
   def setup
     NewRelic::Agent.manual_start
     @engine = NewRelic::Agent.instance.stats_engine
-    
+
     case MEMCACHED_CLASS.name
     when 'Memcached'
       @cache = MEMCACHED_CLASS.new('localhost', :support_cas => true)
@@ -45,7 +45,7 @@ class NewRelic::Agent::MemcacheInstrumentationTest < Test::Unit::TestCase
     @key = 'schluessel'
     @cache.set('schluessel', 1)
   end
-  
+
   def teardown
     if MEMCACHED_CLASS.name == 'Memcached'
       @cache.flush
@@ -56,7 +56,7 @@ class NewRelic::Agent::MemcacheInstrumentationTest < Test::Unit::TestCase
       @cache.flush_all
     end
   end
-  
+
   def _call_test_method_in_web_transaction(method, *args)
     @engine.clear_stats
     perform_action_with_newrelic_trace(:name=>'action', :category => :controller) do
@@ -105,7 +105,7 @@ class NewRelic::Agent::MemcacheInstrumentationTest < Test::Unit::TestCase
   def test_reads__background
     commands = ['get']
     commands << 'get_multi' unless MEMCACHED_CLASS.name == 'Spymemcached'
-    commands.each do |method|    
+    commands.each do |method|
       if @cache.class.method_defined?(method)
         _call_test_method_in_background_task(method)
         compare_metrics ["Memcache/#{method}", "Memcache/allOther", "Memcache/#{method}:OtherTransaction/Background/NewRelic::Agent::MemcacheInstrumentationTest/bg_task"],
@@ -142,6 +142,6 @@ class NewRelic::Agent::MemcacheInstrumentationTest < Test::Unit::TestCase
       end
       compare_metrics expected_metrics, @engine.metrics.select{|m| m =~ /^memcache.*/i}
       assert_equal 3, @cache.get(@key)
-    end    
-  end  
+    end
+  end
 end if memcached_ready

data/test/{multiverse/suites/agent_only/test_trace_method_with_punctuation.rb → new_relic/agent/method_interrobang_test.rb}

@@ -2,12 +2,10 @@
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
 
-
 require 'test/unit'
 require 'newrelic_rpm'
 require 'new_relic/agent/method_tracer'
 
-
 class MethodInterrobangTest < Test::Unit::TestCase
 	include NewRelic::Agent::MethodTracer
 
@@ -23,12 +21,12 @@ class MethodInterrobangTest < Test::Unit::TestCase
 	add_method_tracer :mutate!
 
 	def test_alias_method_ending_in_question_mark
-		assert_respond_to self,:interrogate?
+		assert_respond_to self, :interrogate?
 		assert_equal "say what?", interrogate?
 	end
 
 	def test_aliase_method_ending_in_exclamation_makr
-		assert_respond_to self,:mutate!
-		assert_equal "oh yeah!",mutate!
+		assert_respond_to self, :mutate!
+		assert_equal "oh yeah!", mutate!
 	end
 end

data/test/new_relic/agent/method_tracer/instance_methods/trace_execution_scoped_test.rb

@@ -219,7 +219,7 @@ class NewRelic::Agent::MethodTracer::InstanceMethods::TraceExecutionScopedTest <
   end
 
   def test_log_errors_with_error
-    expects_logging(:error, 
+    expects_logging(:error,
       includes("Caught exception in name."),
       instance_of(RuntimeError))
 
@@ -313,4 +313,3 @@ class NewRelic::Agent::MethodTracer::InstanceMethods::TraceExecutionScopedTest <
     mocked_object('control')
   end
 end
-

data/test/{multiverse/suites/agent_only → new_relic/agent}/method_visibility_test.rb

@@ -2,11 +2,8 @@
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
 
-require 'multiverse/color'
-
 class MethodVisibilityTest < Test::Unit::TestCase
-  extend Multiverse::Color
-  
+
   class InstrumentedClass
     include NewRelic::Agent::MethodTracer
     include NewRelic::Agent::Instrumentation::ControllerInstrumentation
@@ -68,35 +65,26 @@ class MethodVisibilityTest < Test::Unit::TestCase
   def setup
     @instance = InstrumentedClass.new
   end
-  
-  if NewRelic::VERSION::STRING >= '3.4.0.2'
-    %w| public private protected |.each do |visibility|
-      define_method "test_should_preserve_visibility_of_#{visibility}_traced_method" do
-        assert @instance.send("#{visibility}_methods").map{|s|s.to_sym}.include?(:"#{visibility}_method!"), "Method #{visibility}_method should be #{visibility}"
-      end
-      
-      define_method "test_should_preserve_visibility_of_#{visibility}_traced_transaction" do
-        assert @instance.send("#{visibility}_methods").map{|s|s.to_sym}.include?(:"#{visibility}_transaction!"), "Transcation #{visibility}_transaction should be #{visibility}"
-      end
-    end
 
-    def test_tracing_non_public_methods_doesnt_add_public_methods
-      assert_equal [], ObjectWithTracers.public_instance_methods - ObjectWithInstrumentation.public_instance_methods
+  %w| public private protected |.each do |visibility|
+    define_method "test_should_preserve_visibility_of_#{visibility}_traced_method" do
+      assert @instance.send("#{visibility}_methods").map{|s|s.to_sym}.include?(:"#{visibility}_method!"), "Method #{visibility}_method should be #{visibility}"
     end
 
-    # FIXME: Currently including MethodTracer and ControllerInstrumentation
-    # adds a bunch of public methods to the class.  It probably shouldn't do this.
-    #def test_instrumentation_doesnt_add_any_public_methods
-    #  assert_equal [], ObjectWithInstrumentation.public_instance_methods - Object.public_instance_methods
-    #end
-    #
+    define_method "test_should_preserve_visibility_of_#{visibility}_traced_transaction" do
+      assert @instance.send("#{visibility}_methods").map{|s|s.to_sym}.include?(:"#{visibility}_transaction!"), "Transcation #{visibility}_transaction should be #{visibility}"
+    end
+  end
 
+  def test_tracing_non_public_methods_doesnt_add_public_methods
+    assert_equal [], ObjectWithTracers.public_instance_methods - ObjectWithInstrumentation.public_instance_methods
+  end
 
+  # FIXME: Currently including MethodTracer and ControllerInstrumentation
+  # adds a bunch of public methods to the class.  It probably shouldn't do this.
+  #def test_instrumentation_doesnt_add_any_public_methods
+  #  assert_equal [], ObjectWithInstrumentation.public_instance_methods - Object.public_instance_methods
+  #end
+  #
 
-  else
-    def test_truth
-      assert true # jruby freaks out if there are no tests defined in the test class
-    end
-    puts yellow('SKIPPED! 3.4.0.1 and earlier fail preserve_visibility tests')
-  end
 end

data/test/new_relic/agent/new_relic_service_test.rb

@@ -110,7 +110,7 @@ class NewRelicServiceTest < Test::Unit::TestCase
 
   # This test does not actually use the ruby agent in any way - it's
   # testing that the CA file we ship actually validates our server's
-  # certificate. It's used for customers who enable verify_certificate
+  # certificate.
   def test_cert_file
     if internet_connection?
       require 'socket'

data/test/new_relic/agent/pipe_service_test.rb

@@ -16,7 +16,7 @@ class PipeServiceTest < Test::Unit::TestCase
   end
 
   def test_connect_returns_nil
-    assert_nil @service.connect({}) 
+    assert_nil @service.connect({})
   end
 
   # a #session method is required of services, though in the case of the

data/test/new_relic/agent/request_sampler_test.rb

@@ -17,7 +17,7 @@ class NewRelic::Agent::RequestSamplerTest < Test::Unit::TestCase
   def test_samples_on_transaction_finished_event
     with_sampler_config do
       advance_time( 0.60 )
-      @event_listener.notify( :transaction_finished, 'Controller/foo/bar', 0.095 )
+      @event_listener.notify( :transaction_finished, 'Controller/foo/bar', Time.now.to_f, 0.095 )
 
       assert_equal 1, @sampler.samples.length
     end
@@ -26,7 +26,7 @@ class NewRelic::Agent::RequestSamplerTest < Test::Unit::TestCase
   def test_samples_on_transaction_finished_event_include_options
     with_sampler_config do
       advance_time( 0.60 )
-      @event_listener.notify( :transaction_finished, 'Controller/foo/bar', 0.095, :foo => :bar )
+      @event_listener.notify( :transaction_finished, 'Controller/foo/bar', Time.now.to_f, 0.095, :foo => :bar )
 
       assert_equal :bar, @sampler.samples.first[:foo]
     end
@@ -37,7 +37,7 @@ class NewRelic::Agent::RequestSamplerTest < Test::Unit::TestCase
       # 240 requests over 6 seconds => 120 samples
       # with_debug_logging do
       241.times do
-        @event_listener.notify( :transaction_finished, 'Controller/foo/bar', 0.200 )
+        @event_listener.notify( :transaction_finished, 'Controller/foo/bar', Time.now.to_f, 0.200 )
         advance_time( 0.025 )
       end
       # end
@@ -57,14 +57,14 @@ class NewRelic::Agent::RequestSamplerTest < Test::Unit::TestCase
   def test_downsamples_and_reduces_sample_rate_when_throttled
     with_sampler_config( :'request_sampler.sample_rate_ms' => 50 ) do
       240.times do
-        @event_listener.notify( :transaction_finished, 'Controller/foo/bar', 0.200 )
+        @event_listener.notify( :transaction_finished, 'Controller/foo/bar', Time.now.to_f, 0.200 )
         advance_time( 0.025 )
       end
 
       @sampler.throttle( 2 )
 
       241.times do
-        @event_listener.notify( :transaction_finished, 'Controller/foo/bar', 0.200 )
+        @event_listener.notify( :transaction_finished, 'Controller/foo/bar', Time.now.to_f, 0.200 )
         advance_time( 0.025 )
       end
 
@@ -83,21 +83,21 @@ class NewRelic::Agent::RequestSamplerTest < Test::Unit::TestCase
   def test_downsamples_and_reduces_sample_rate_when_throttled_multiple_times
     with_sampler_config( :'request_sampler.sample_rate_ms' => 50 ) do
       240.times do
-        @event_listener.notify( :transaction_finished, 'Controller/foo/bar', 0.200 )
+        @event_listener.notify( :transaction_finished, 'Controller/foo/bar', Time.now.to_f, 0.200 )
         advance_time( 0.025 )
       end
 
       @sampler.throttle( 2 )
 
       240.times do
-        @event_listener.notify( :transaction_finished, 'Controller/foo/bar', 0.200 )
+        @event_listener.notify( :transaction_finished, 'Controller/foo/bar', Time.now.to_f, 0.200 )
         advance_time( 0.025 )
       end
 
       @sampler.throttle( 3 )
 
       241.times do
-        @event_listener.notify( :transaction_finished, 'Controller/foo/bar', 0.200 )
+        @event_listener.notify( :transaction_finished, 'Controller/foo/bar', Time.now.to_f, 0.200 )
         advance_time( 0.025 )
       end
 
@@ -115,7 +115,7 @@ class NewRelic::Agent::RequestSamplerTest < Test::Unit::TestCase
 
   def test_can_disable_sampling
     with_sampler_config( :'request_sampler.enabled' => false ) do
-      @event_listener.notify( :transaction_finished, 'Controller/foo/bar', 0.200 )
+      @event_listener.notify( :transaction_finished, 'Controller/foo/bar', Time.now.to_f, 0.200 )
       assert @sampler.samples.empty?
     end
   end
@@ -136,7 +136,7 @@ class NewRelic::Agent::RequestSamplerTest < Test::Unit::TestCase
     freeze_time
     with_sampler_config( :'request_sampler.sample_rate_ms' => 60_000 ) do
       15.times do
-        @event_listener.notify( :transaction_finished, 'Controller/foo/bar', 0.1)
+        @event_listener.notify( :transaction_finished, 'Controller/foo/bar', Time.now.to_f, 0.1)
         advance_time(60.001)
       end
       assert_equal(10, @sampler.samples.size)

data/test/new_relic/agent/rpm_agent_test.rb

@@ -2,10 +2,9 @@
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
 
-ENV['SKIP_RAILS'] = 'true'
 require File.expand_path('../../../test_helper', __FILE__)
 
-class NewRelic::Agent::RpmAgentTest < Test::Unit::TestCase # ActiveSupport::TestCase
+class NewRelic::Agent::RpmAgentTest < Test::Unit::TestCase
   def setup
     NewRelic::Agent.manual_start
     @agent = NewRelic::Agent.instance

data/test/new_relic/agent/stats_hash_test.rb

@@ -7,6 +7,7 @@ require File.expand_path(File.join(File.dirname(__FILE__),'..', '..','test_helpe
 class NewRelic::Agent::StatsHashTest < Test::Unit::TestCase
   def setup
     @hash = NewRelic::Agent::StatsHash.new
+    NewRelic::Agent.instance.error_collector.errors.clear
   end
 
   def test_creates_default_entries
@@ -109,10 +110,87 @@ class NewRelic::Agent::StatsHashTest < Test::Unit::TestCase
   end
 
   def test_marshal_dump
-    hash = NewRelic::Agent::StatsHash.new()
-    hash.record('foo', 1)
-    hash.record('bar', 2)
-    copy = Marshal.load(Marshal.dump(hash))
-    assert_equal(hash, copy)
+    @hash.record('foo', 1)
+    @hash.record('bar', 2)
+    copy = Marshal.load(Marshal.dump(@hash))
+    assert_equal(@hash, copy)
   end
+
+  def test_borked_default_proc_can_record_metric
+    fake_borked_default_proc(@hash)
+
+    @hash.record(DEFAULT_SPEC, 1)
+
+    assert_equal(1, @hash.fetch(DEFAULT_SPEC, nil).call_count)
+  end
+
+  def test_borked_default_proc_notices_agent_error
+    fake_borked_default_proc(@hash)
+
+    @hash.record(DEFAULT_SPEC, 1)
+
+    assert_has_error NewRelic::Agent::StatsHash::CorruptedDefaultProcError
+  end
+
+  # We can only fix up the default proc on Rubies that let us set it
+  if {}.respond_to?(:default_proc=)
+    def test_borked_default_proc_heals_thyself
+      fake_borked_default_proc(@hash)
+
+      @hash.record(DEFAULT_SPEC, 1)
+      NewRelic::Agent.instance.error_collector.errors.clear
+
+      @hash.record(NewRelic::MetricSpec.new('something/else/entirely'), 1)
+      assert_equal 0, NewRelic::Agent.instance.error_collector.errors.size
+    end
+  end
+
+  STAT_SETTERS = [:call_count=, :min_call_time=, :max_call_time=, :total_call_time=, :total_exclusive_time=, :sum_of_squares=]
+  DEFAULT_SPEC = NewRelic::MetricSpec.new('foo')
+
+  STAT_SETTERS.each do |setter|
+    define_method("test_merge_allows_nil_destination_for_#{setter.to_s.gsub('=', '')}") do
+      dest = NewRelic::Agent::Stats.new
+      dest.send(setter, nil)
+      expected = dest.dup
+
+      @hash[DEFAULT_SPEC] = dest
+
+      incoming = NewRelic::Agent::StatsHash.new
+      incoming[DEFAULT_SPEC] = NewRelic::Agent::Stats.new
+
+      @hash.merge!(incoming)
+
+      assert_equal expected, @hash[DEFAULT_SPEC]
+      assert_has_error NewRelic::Agent::StatsHash::StatsMergerError
+    end
+  end
+
+  STAT_SETTERS.each do |setter|
+    define_method("test_merge_allows_nil_source_for_#{setter.to_s.gsub('=', '')}") do
+      dest = NewRelic::Agent::Stats.new
+      expected = dest.dup
+
+      @hash[DEFAULT_SPEC] = dest
+
+      source = NewRelic::Agent::Stats.new
+      source.send(setter, nil)
+      incoming = NewRelic::Agent::StatsHash.new
+      incoming[DEFAULT_SPEC] = source
+
+      @hash.merge!(incoming)
+
+      assert_equal expected, @hash[DEFAULT_SPEC]
+    end
+  end
+
+  def fake_borked_default_proc(hash)
+    exception = NoMethodError.new("borked default proc gives a NoMethodError on `yield'")
+    if hash.respond_to?(:default_proc=)
+      hash.default_proc = Proc.new { raise exception }
+    else
+      hash.stubs(:[]).raises(exception)
+    end
+  end
+
 end