dolores_rpm 3.2.0.2

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

@@ -0,0 +1,35 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper'))
+require 'new_relic/agent/instrumentation/rack'
+
+class MinimalRackApp
+  def initialize(return_value)
+    @return_value = return_value
+  end
+
+  def call(env)
+    @return_value
+  end
+
+  include NewRelic::Agent::Instrumentation::Rack
+end
+
+class NewRelic::Agent::Instrumentation::RackTest < Test::Unit::TestCase
+
+  def test_basic_rack_app
+    # should return what we send in, even when instrumented
+    x = MinimalRackApp.new([200, {}, ["whee"]])
+    assert_equal [200, {}, ["whee"]], x.call({})
+  end
+
+  def test_basic_rack_app_404
+    x = MinimalRackApp.new([404, {}, ["whee"]])
+    assert_equal [404, {}, ["whee"]], x.call({})
+  end
+
+  def test_basic_rack_app_ignores_404
+    NewRelic::Agent::Instrumentation::MetricFrame.expects(:abort_transaction!)
+    x = MinimalRackApp.new([404, {}, ["whee"]])
+    assert_equal [404, {}, ["whee"]], x.call({})
+  end
+end
+

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

@@ -0,0 +1,184 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper'))
+
+class NewRelic::Agent::Instrumentation::TaskInstrumentationTest < Test::Unit::TestCase
+  include NewRelic::Agent::Instrumentation::ControllerInstrumentation
+  extend TestContexts
+  attr_accessor :agent
+
+  with_running_agent do
+
+    should "run" do
+      run_task_inner 0
+      stat_names = %w[Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_0
+                    HttpDispatcher
+                    Apdex Apdex/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_0].sort
+      expected_but_missing = stat_names - @agent.stats_engine.metrics
+      assert_equal 0, expected_but_missing.size, @agent.stats_engine.metrics.map  { |n|
+        stat = @agent.stats_engine.get_stats_no_scope(n)
+      "#{'%-26s' % n}: #{stat.call_count} calls @ #{stat.average_call_time} sec/call"
+      }.join("\n  ") + "\nmissing: #{expected_but_missing.inspect}"
+      assert_equal 0, @agent.stats_engine.get_stats_no_scope('Controller').call_count
+      assert_equal 1, @agent.stats_engine.get_stats_no_scope('Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_0').call_count
+    end
+
+    should "run_recursive" do
+      run_task_inner(3)
+      assert_equal 1, @agent.stats_engine.lookup_stats(
+                          'Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_0',
+                          'Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_1').call_count
+      assert_equal 1, @agent.stats_engine.lookup_stats(
+                          'Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_1',
+                          'Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_2').call_count
+      assert_equal 1, @agent.stats_engine.lookup_stats(
+                          'Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_2',
+                          'Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_3').call_count
+      assert_equal 1, @agent.stats_engine.get_stats_no_scope('Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_0').call_count
+      assert_equal 1, @agent.stats_engine.get_stats_no_scope('Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_1').call_count
+      assert_equal 1, @agent.stats_engine.get_stats_no_scope('Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_2').call_count
+      assert_equal 1, @agent.stats_engine.get_stats_no_scope('Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_3').call_count
+      assert_equal 0, @agent.stats_engine.get_stats_no_scope('Controller').call_count
+    end
+
+    should "run_nested" do
+      run_task_outer(3)
+      @agent.stats_engine.metrics.sort.each do |n|
+        stat = @agent.stats_engine.get_stats_no_scope(n)
+        #      puts "#{'%-26s' % n}: #{stat.call_count} calls @ #{stat.average_call_time} sec/call"
+      end
+      assert_equal 1, @agent.stats_engine.get_stats_no_scope('Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/outer_task').call_count
+      assert_equal 2, @agent.stats_engine.get_stats_no_scope('Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_0').call_count
+    end
+
+    should "reentrancy" do
+      assert_equal 0, NewRelic::Agent::BusyCalculator.busy_count
+      run_task_inner(1)
+      assert_equal 1, @agent.stats_engine.get_stats_no_scope('Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_0').call_count
+      assert_equal 1, @agent.stats_engine.get_stats_no_scope('Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_1').call_count
+      compare_metrics %w[
+      Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_0:Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_1
+      Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_0
+      Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_1
+      ], @agent.stats_engine.metrics.grep(/^Controller/)
+    end
+
+    should "transaction" do
+      assert_equal 0, @agent.transaction_sampler.scope_depth, "existing unfinished sample"
+      assert_nil @agent.transaction_sampler.last_sample
+      assert_equal @agent.transaction_sampler, @agent.stats_engine.instance_variable_get("@transaction_sampler")
+      run_task_outer(10)
+      assert_equal 0, @agent.transaction_sampler.scope_depth, "existing unfinished sample"
+      @agent.stats_engine.metrics.sort.each do |n|
+        stat = @agent.stats_engine.get_stats_no_scope(n)
+        #      puts "#{'%-26s' % n}: #{stat.call_count} calls @ #{stat.average_call_time} sec/call"
+      end
+      assert_equal 1, @agent.stats_engine.get_stats_no_scope('Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/outer_task').call_count
+      assert_equal 0, @agent.stats_engine.get_stats_no_scope('Controller').call_count
+      assert_equal 2, @agent.stats_engine.get_stats_no_scope('Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_0').call_count
+      assert_equal 0, @agent.transaction_sampler.scope_depth, "existing unfinished sample"
+      sample = @agent.transaction_sampler.last_sample
+      assert_not_nil sample
+      assert_not_nil sample.params[:cpu_time], "cpu time nil: \n#{sample}"
+      assert sample.params[:cpu_time] >= 0, "cpu time: #{sample.params[:cpu_time]},\n#{sample}"
+      assert_equal '10', sample.params[:request_params][:level]
+    end
+
+    should "abort" do
+      @acct = 'Redrocks'
+      perform_action_with_newrelic_trace(:name => 'hello', :force => true, :params => { :account => @acct}) do
+        self.class.inspect
+        NewRelic::Agent.abort_transaction!
+      end
+      # We record the controller metric still, but abort any transaction recording.
+      assert_equal 1, @agent.stats_engine.get_stats_no_scope('Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/hello').call_count
+      assert_nil @agent.transaction_sampler.last_sample
+    end
+    should "block" do
+      assert_equal @agent, NewRelic::Agent.instance
+      @acct = 'Redrocks'
+      perform_action_with_newrelic_trace(:name => 'hello', :force => true, :params => { :account => @acct}) do
+        self.class.inspect
+      end
+      @agent.stats_engine.metrics.sort.each do |n|
+        stat = @agent.stats_engine.get_stats_no_scope(n)
+        #puts "#{'%-26s' % n}: #{stat.call_count} calls @ #{stat.average_call_time} sec/call"
+      end
+      assert_equal @agent, NewRelic::Agent.instance
+      assert_equal 1, @agent.stats_engine.get_stats_no_scope('Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/hello').call_count
+      sample = @agent.transaction_sampler.last_sample
+      assert_not_nil sample
+      assert_equal 'Redrocks', sample.params[:request_params][:account]
+
+    end
+
+    should "error_handling" do
+      @agent.error_collector.ignore_error_filter
+      @agent.error_collector.harvest_errors([])
+      @agent.error_collector.expects(:notice_error).once
+      assert_equal @agent.error_collector, NewRelic::Agent.instance.error_collector
+      assert_raise RuntimeError do
+        run_task_exception
+      end
+    end
+
+    should "custom_params" do
+      @agent.error_collector.stubs(:enabled).returns(true)
+      @agent.error_collector.ignore_error_filter
+      @agent.error_collector.harvest_errors([])
+      assert_equal @agent.error_collector, NewRelic::Agent.instance.error_collector
+      assert_raise RuntimeError do
+        run_task_exception
+      end
+      errors = @agent.error_collector.harvest_errors([])
+      assert_equal 1, errors.size
+      error = errors.first
+      assert_equal "Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/run_task_exception", error.path
+      assert_not_nil error.params[:stack_trace]
+      assert_not_nil error.params[:custom_params]
+    end
+
+    should "instrument_bg" do
+      run_background_job
+      stat_names = %w[OtherTransaction/Background/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/run_background_job
+                    OtherTransaction/Background/all
+                    OtherTransaction/all].sort
+
+      expected_but_missing = stat_names - @agent.stats_engine.metrics
+      assert_equal 0, expected_but_missing.size, @agent.stats_engine.metrics.map  { |n|
+        stat = @agent.stats_engine.get_stats_no_scope(n)
+      "#{'%-26s' % n}: #{stat.call_count} calls @ #{stat.average_call_time} sec/call"
+      }.join("\n  ") + "\nmissing: #{expected_but_missing.inspect}"
+      assert_equal 1, @agent.stats_engine.get_stats_no_scope('OtherTransaction/all').call_count
+      assert_equal 1, @agent.stats_engine.get_stats_no_scope('OtherTransaction/Background/all').call_count
+    end
+  end
+
+  private
+
+  def run_task_inner(n)
+    return if n == 0
+    assert_equal 1, NewRelic::Agent::BusyCalculator.busy_count
+    run_task_inner(n-1)
+  end
+
+  def run_task_outer(n=0)
+    assert_equal 1, NewRelic::Agent::BusyCalculator.busy_count
+    run_task_inner(n)
+    run_task_inner(n)
+  end
+
+  def run_task_exception
+    NewRelic::Agent.add_custom_parameters(:custom_one => 'one custom val')
+    assert_equal 1, NewRelic::Agent::BusyCalculator.busy_count
+    raise "This is an error"
+  end
+
+  def run_background_job
+    "This is a background job"
+  end
+
+  add_transaction_tracer :run_task_exception
+  add_transaction_tracer :run_task_inner, :name => 'inner_task_#{args[0]}'
+  add_transaction_tracer :run_task_outer, :name => 'outer_task', :params => '{ :level => args[0] }'
+  # Eventually we need th change this to :category => :task
+  add_transaction_tracer :run_background_job, :category => 'OtherTransaction/Background'
+end

data/test/new_relic/agent/memcache_instrumentation_test.rb

@@ -0,0 +1,143 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
+
+memcached_ready = false
+classes = {
+#   'memcache' => 'MemCache',
+#   'dalli' => 'Dalli::Client',
+  'memcached' => 'Memcached'
+#   'spymemcached' => 'Spymemcached'
+}
+begin
+  TCPSocket.new('localhost', 11211)
+  classes.each do |req, const|
+    begin
+      require req
+      MEMCACHED_CLASS = const.constantize
+      puts "Testing #{MEMCACHED_CLASS}"
+      memcached_ready = true
+    rescue LoadError
+    rescue NameError
+    end
+  end
+rescue Errno::ECONNREFUSED
+rescue Errno::ETIMEDOUT
+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)
+    when 'Spymemcached'
+      @cache = MEMCACHED_CLASS.new('localhost:11211')
+    else
+      @cache = MEMCACHED_CLASS.new('localhost')
+    end
+    @key = 'schluessel'
+    @cache.set('schluessel', 1)
+  end
+  
+  def teardown
+    if MEMCACHED_CLASS.name == 'Memcached'
+      @cache.flush
+    elsif MEMCACHED_CLASS.name == 'Spymemcached'
+      @cache.flush
+      @cache.instance_eval{ @client.shutdown }
+    else
+      @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
+      @cache.send(method.to_sym, *[@key, *args])
+    end
+  end
+
+  def _call_test_method_in_background_task(method, *args)
+    @engine.clear_stats
+    perform_action_with_newrelic_trace(:name => 'bg_task', :category => :task) do
+      @cache.send(method.to_sym, *[@key, *args])
+    end
+  end
+
+  def test_reads__web
+    commands = ['get']
+    commands << 'get_multi' unless MEMCACHED_CLASS.name == 'Spymemcached'
+    commands.each do |method|
+      if @cache.class.method_defined?(method)
+        _call_test_method_in_web_transaction(method)
+        compare_metrics ["Memcache/#{method}", "Memcache/allWeb", "Memcache/#{method}:Controller/NewRelic::Agent::MemcacheInstrumentationTest/action"],
+        @engine.metrics.select{|m| m =~ /^memcache.*/i}
+      end
+    end
+  end
+
+  def test_writes__web
+    %w[delete].each do |method|
+      if @cache.class.method_defined?(method)
+        _call_test_method_in_web_transaction(method)
+        expected_metrics = ["Memcache/#{method}", "Memcache/allWeb", "Memcache/#{method}:Controller/NewRelic::Agent::MemcacheInstrumentationTest/action"]
+        compare_metrics expected_metrics, @engine.metrics.select{|m| m =~ /^memcache.*/i}
+      end
+    end
+
+    %w[set add].each do |method|
+      @cache.delete(@key) rescue nil
+      if @cache.class.method_defined?(method)
+        expected_metrics = ["Memcache/#{method}", "Memcache/allWeb", "Memcache/#{method}:Controller/NewRelic::Agent::MemcacheInstrumentationTest/action"]
+        _call_test_method_in_web_transaction(method, 'value')
+        compare_metrics expected_metrics, @engine.metrics.select{|m| m =~ /^memcache.*/i}
+      end
+    end
+  end
+
+  def test_reads__background
+    commands = ['get']
+    commands << 'get_multi' unless MEMCACHED_CLASS.name == 'Spymemcached'
+    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"],
+        @engine.metrics.select{|m| m =~ /^memcache.*/i}
+      end
+    end
+  end
+
+  def test_writes__background
+    %w[delete].each do |method|
+      expected_metrics = ["Memcache/#{method}", "Memcache/allOther", "Memcache/#{method}:OtherTransaction/Background/NewRelic::Agent::MemcacheInstrumentationTest/bg_task"]
+      if @cache.class.method_defined?(method)
+        _call_test_method_in_background_task(method)
+        compare_metrics expected_metrics, @engine.metrics.select{|m| m =~ /^memcache.*/i}
+      end
+    end
+
+    %w[set add].each do |method|
+      @cache.delete(@key) rescue nil
+      expected_metrics = ["Memcache/#{method}", "Memcache/allOther", "Memcache/#{method}:OtherTransaction/Background/NewRelic::Agent::MemcacheInstrumentationTest/bg_task"]
+      if @cache.class.method_defined?(method)
+        _call_test_method_in_background_task(method, 'value')
+        compare_metrics expected_metrics, @engine.metrics.select{|m| m =~ /^memcache.*/i}
+      end
+    end
+  end
+
+  def test_handles_cas
+    expected_metrics = ["Memcache/cas", "Memcache/allOther", "Memcache/cas:OtherTransaction/Background/NewRelic::Agent::MemcacheInstrumentationTest/bg_task"]
+    if @cache.class.method_defined?(:cas)
+      @engine.clear_stats
+      perform_action_with_newrelic_trace(:name => 'bg_task', :category => :task) do
+        @cache.cas(@key) {|val| val += 2 }
+      end
+      compare_metrics expected_metrics, @engine.metrics.select{|m| m =~ /^memcache.*/i}
+      assert_equal 3, @cache.get(@key)
+    end    
+  end  
+end if memcached_ready

data/test/new_relic/agent/method_tracer/class_methods/add_method_tracer_test.rb

@@ -0,0 +1,164 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','..','test_helper'))
+
+require 'set'
+module NewRelic
+  module Agent
+    class Agent
+      module MethodTracer
+        module ClassMethods
+          class AddMethodTracerTest < Test::Unit::TestCase
+            #  require 'new_relic/agent/method_tracer'
+            include NewRelic::Agent::MethodTracer::ClassMethods::AddMethodTracer
+
+            def test_validate_options_nonhash
+              assert_raise(TypeError) do
+                validate_options([])
+              end
+            end
+
+            def test_validate_options_defaults
+              self.expects(:check_for_illegal_keys!)
+              self.expects(:set_deduct_call_time_based_on_metric).with(DEFAULT_SETTINGS)
+              self.expects(:check_for_push_scope_and_metric)
+              validate_options({})
+            end
+
+            def test_validate_options_override
+              opts = {:push_scope => false, :metric => false, :force => true}
+              self.expects(:check_for_illegal_keys!)
+              self.expects(:check_for_push_scope_and_metric)
+              val = validate_options(opts)
+              assert val.is_a?(Hash)
+              assert (val[:push_scope] == false), val.inspect
+              assert (val[:metric] == false), val.inspect
+              assert (val[:force] == true), val.inspect
+            end
+
+            def test_default_metric_name_code
+              assert_equal "Custom/#{name}/test_method", default_metric_name_code('test_method')
+            end
+
+            def test_newrelic_method_exists_positive
+              self.expects(:method_defined?).returns(true)
+              assert newrelic_method_exists?('test_method')
+            end
+
+            def test_newrelic_method_exists_negative
+              self.expects(:method_defined?).returns(false)
+              self.expects(:private_method_defined?).returns(false)
+
+              fake_log = mock('log')
+              NewRelic::Control.instance.expects(:log).returns(fake_log)
+              fake_log.expects(:warn).with("Did not trace #{name}#test_method because that method does not exist")
+              assert !newrelic_method_exists?('test_method')
+            end
+
+            def test_set_deduct_call_time_based_on_metric_positive
+              opts = {:metric => true}
+              val = set_deduct_call_time_based_on_metric(opts)
+              assert val.is_a?(Hash)
+              assert val[:deduct_call_time_from_parent]
+            end
+
+            def test_set_deduct_call_time_based_on_metric_negative
+              opts = {:metric => false}
+              val = set_deduct_call_time_based_on_metric(opts)
+              assert val.is_a?(Hash)
+              assert !val[:deduct_call_time_from_parent]
+            end
+
+            def test_set_deduct_call_time_based_on_metric_non_nil
+              opts = {:deduct_call_time_from_parent => true, :metric => false}
+              val = set_deduct_call_time_based_on_metric(opts)
+              assert val.is_a?(Hash)
+              assert val[:deduct_call_time_from_parent]
+            end
+
+            def test_set_deduct_call_time_based_on_metric_opposite
+              opts = {:deduct_call_time_from_parent => false, :metric => true}
+              val = set_deduct_call_time_based_on_metric(opts)
+              assert val.is_a?(Hash)
+              assert !val[:deduct_call_time_from_parent]
+            end
+
+            def test_unrecognized_keys_positive
+              assert_equal [:unrecognized, :keys].to_set, unrecognized_keys([:hello, :world], {:unrecognized => nil, :keys => nil}).to_set
+            end
+
+            def test_unrecognized_keys_negative
+              assert_equal [], unrecognized_keys([:hello, :world], {:hello => nil, :world => nil})
+            end
+
+            def test_any_unrecognized_keys_positive
+              assert any_unrecognized_keys?([:one], {:one => nil, :two => nil})
+            end
+
+            def test_any_unrecognized_keys_negative
+              assert !any_unrecognized_keys?([:one], {:one => nil})
+            end
+
+            def test_check_for_illegal_keys_positive
+              assert_raise(RuntimeError) do
+                check_for_illegal_keys!({:unknown_key => nil})
+              end
+            end
+
+            def test_check_for_illegal_keys_negative
+              test_keys = Hash[ALLOWED_KEYS.map {|x| [x, nil]}]
+              check_for_illegal_keys!(test_keys)
+            end
+
+            def test_traced_method_exists_positive
+              self.expects(:_traced_method_name)
+              self.expects(:method_defined?).returns(true)
+              fake_log = mock('log')
+              NewRelic::Control.instance.expects(:log).returns(fake_log)
+              fake_log.expects(:warn).with('Attempt to trace a method twice with the same metric: Method = test_method, Metric Name = Custom/Test/test_method')
+              assert traced_method_exists?('test_method', 'Custom/Test/test_method')
+            end
+
+            def test_traced_method_exists_negative
+              self.expects(:_traced_method_name)
+              self.expects(:method_defined?).returns(false)
+              assert !traced_method_exists?(nil, nil)
+            end
+
+            def test_assemble_code_header_forced
+              opts = {:force => true, :code_header => 'CODE HEADER'}
+              assert_equal "CODE HEADER", assemble_code_header('test_method', 'Custom/Test/test_method', opts)
+            end
+
+            def test_assemble_code_header_unforced
+              self.expects(:_untraced_method_name).returns("method_name_without_tracing")
+              opts = {:force => false, :code_header => 'CODE HEADER'}
+              assert_equal "return method_name_without_tracing(*args, &block) unless NewRelic::Agent.is_execution_traced?\nCODE HEADER", assemble_code_header('test_method', 'Custom/Test/test_method', opts)
+            end
+
+            def test_check_for_push_scope_and_metric_positive
+              check_for_push_scope_and_metric({:push_scope => true})
+              check_for_push_scope_and_metric({:metric => true})
+            end
+
+            def test_check_for_push_scope_and_metric_negative
+              assert_raise(RuntimeError) do
+                check_for_push_scope_and_metric({:push_scope => false, :metric => false})
+              end
+            end
+
+            def test_code_to_eval_scoped
+              self.expects(:validate_options).returns({:push_scope => true})
+              self.expects(:method_with_push_scope).with('test_method', 'Custom/Test/test_method', {:push_scope => true})
+              code_to_eval('test_method', 'Custom/Test/test_method', {})
+            end
+
+            def test_code_to_eval_unscoped
+              self.expects(:validate_options).returns({:push_scope => false})
+              self.expects(:method_without_push_scope).with('test', 'Custom/Test/test', {:push_scope => false})
+              code_to_eval('test', 'Custom/Test/test', {})
+            end
+          end
+        end
+      end
+    end
+  end
+end