newrelic_rpm 3.5.2.17 → 3.5.3.24

data/test/multiverse/lib/multiverse/color.rb

@@ -0,0 +1,13 @@
+module Multiverse
+  module Color
+    def red(string)
+      "\e[0;31;49m#{string}\e[0m "
+    end
+    def green(string)
+      "\e[0;32;49m#{string}\e[0m "
+    end
+    def yellow(string)
+      "\e[0;33;49m#{string}\e[0m "
+    end
+  end
+end

data/test/multiverse/lib/multiverse/envfile.rb

@@ -0,0 +1,66 @@
+module Multiverse
+  # Reads an envfile.rb and converts it into gemfiles that can be used by
+  # bundler
+  class Envfile
+    attr_accessor :file_path, :condition, :newrelic_gemfile_options
+    attr_reader :before, :after, :mode, :skip_message
+
+    def initialize(file_path)
+      self.file_path = file_path
+      @gemfiles = []
+      @mode = 'fork'
+      if File.exist? file_path
+        @text = File.read self.file_path
+        instance_eval @text
+      end
+      @gemfiles = [''] if @gemfiles.empty?
+    end
+
+    def suite_condition(skip_message, &block)
+      @skip_message = skip_message
+      @condition = block
+    end
+
+    # string representation options hash to append to the newrelic_rpm line
+    # when setting up Gemfile
+    # e.g. ":require => false"
+    def newrelic_gemfile_options=(options_string)
+      @newrelic_gemfile_options = options_string
+    end
+
+
+    def gemfile(content)
+      @gemfiles.push content
+    end
+
+    def before_suite(&block)
+      @before = block
+    end
+
+    def after_suite(&block)
+      @after = block
+    end
+
+    def execute_mode(mode)
+      valid_modes = %w| fork spawn |
+      unless valid_modes.member? mode
+        raise ArgumentError, "#{mode.inspect} is not a valid execute mode.  Valid modes: #{valid_modes.inspect}"
+      end
+      @mode = mode
+    end
+
+    include Enumerable
+    def each(&block)
+      @gemfiles.each(&block)
+    end
+
+    def [](key)
+      @gemfiles[key]
+    end
+
+    def size
+      @gemfiles.size
+    end
+
+  end
+end

data/test/multiverse/lib/multiverse/environment.rb

@@ -0,0 +1,16 @@
+require 'fileutils'
+require 'test/unit'
+module Multiverse
+  ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..', '..'))
+  $: << File.expand_path(File.join(ROOT, 'lib'))
+
+  # Include from our unit testing path to share fake_collector and fake_service
+  $: << File.expand_path(File.join(ROOT, '..', 'new_relic'))
+
+  SUITES_DIRECTORY = ENV['SUITES_DIRECTORY'] || File.join(ROOT, '/suites')
+  require 'multiverse/color'
+  require 'multiverse/output_collector'
+  require 'multiverse/runner'
+  require 'multiverse/envfile'
+  require 'multiverse/suite'
+end

data/test/multiverse/lib/multiverse/output_collector.rb

@@ -0,0 +1,29 @@
+# This module is responsible for intercepting output made through various stdlib
+# calls (i.e. puts, print, etc.) and printing summary information (e.g. a list
+# of failing tests) at the end of the process.
+#
+module Multiverse
+  module OutputCollector
+    include Color
+    extend Color
+    def self.buffers
+      @buffer ||= []
+    end
+
+    def self.failing_output
+      @failing ||= []
+    end
+
+    def self.report
+      puts
+      puts
+      if failing_output.empty?
+        puts green("There were no test failures")
+      else
+        puts red("There were failures in #{failing_output.size} test suites")
+        puts "Here is their output"
+        puts *failing_output
+      end
+    end
+  end
+end

data/test/multiverse/lib/multiverse/runner.rb

@@ -0,0 +1,44 @@
+module Multiverse
+  module Runner
+    extend self
+    extend Color
+
+    def exit_status
+      @exit_status ||= 0
+    end
+
+    def notice_exit_status(i)
+      exit_status # initialize it
+      # we don't want to return exit statuses > 256 since these get converted
+      # to 0
+      if i != 0
+        puts red("FAIL! Exited #{i}")
+        @exit_status = 1
+      else
+        puts green("PASS. Exited #{i}")
+      end
+      @exit_status
+    end
+
+    def run(filter="")
+      Dir.new(SUITES_DIRECTORY).entries.each do |dir|
+        next if dir =~ /\A\./
+        next unless dir.include? filter
+        full_path = File.join(SUITES_DIRECTORY, dir)
+        begin
+          suite = Suite.new full_path
+          suite.execute
+        rescue => e
+          puts red("Error when trying to run suite in #{full_path.inspect}")
+          puts
+          puts "#{e.class}: #{e}"
+          puts *e.backtrace
+          notice_exit_status 1
+        end
+      end
+
+      OutputCollector.report
+      exit exit_status
+    end
+  end
+end

data/test/multiverse/lib/multiverse/suite.rb

@@ -0,0 +1,162 @@
+#!/usr/bin/env ruby
+require File.expand_path(File.join(File.dirname(__FILE__), 'environment'))
+module Multiverse
+  class Suite
+    include Color
+    attr_accessor :directory, :include_debugger
+    def initialize(directory, include_debugger=nil)
+      self.directory = directory
+      self.include_debugger = !!include_debugger
+    end
+
+    def clean_gemfiles
+      FileUtils.rm_rf File.join(directory, 'Gemfile')
+      FileUtils.rm_rf File.join(directory, 'Gemfile.lock')
+    end
+
+
+    def environments
+      @environments ||= (
+        Dir.chdir directory
+        Envfile.new(File.join(directory, 'Envfile'))
+      )
+    end
+
+    # load the environment for this suite after we've forked
+    def load_dependencies(gemfile_text)
+      clean_gemfiles
+      begin
+        generate_gemfile(gemfile_text)
+        bundle
+      rescue => e
+        puts "#{e.class}: #{e}"
+        puts "Fast local bundle failed.  Attempting to install from rubygems.org"
+        clean_gemfiles
+        generate_gemfile(gemfile_text, false)
+        bundle
+      end
+      print_environment
+    end
+
+    def bundle
+      require 'rubygems'
+      require 'bundler'
+      bundler_out = `bundle`
+      raise "bundle command failed with (#{$?})" unless $? == 0
+      puts bundler_out if verbose?
+      Bundler.require
+    end
+
+    def generate_gemfile(gemfile_text, local = true)
+      gemfile = File.join(Dir.pwd, 'Gemfile')
+      File.open(gemfile,'w') do |f|
+        f.puts '  source :rubygems' unless local
+        f.print gemfile_text
+        f.puts newrelic_gemfile_line unless gemfile_text =~ /^\s*gem .newrelic_rpm./
+        if RUBY_VERSION > '1.8.7'
+          f.puts "  gem 'test-unit', :require => 'test/unit'"
+          f.puts "  gem 'debugger'" if include_debugger
+        end
+      end
+      puts yellow("Gemfile set to:") if verbose?
+      puts File.open(gemfile).read if verbose?
+    end
+
+    def newrelic_gemfile_line
+      line = ENV['NEWRELIC_GEMFILE_LINE'] if ENV['NEWRELIC_GEMFILE_LINE']
+      path = ENV['NEWRELIC_GEM_PATH'] || '../../../..'
+      line ||= "  gem 'newrelic_rpm', :path => '#{path}'"
+      line += ", #{environments.newrelic_gemfile_options}" if environments.newrelic_gemfile_options
+      line
+    end
+
+    def print_environment
+      puts yellow("Environment loaded with:") if verbose?
+      gems = Bundler.definition.specs.inject([]) do |m, s|
+        next m if s.name == 'bundler'
+        m.push "#{s.name} (#{s.version})"
+        m
+      end.sort
+      puts(gems.join(', '))
+    end
+
+    def execute_child_environment(env_index)
+      gemfile_text = environments[env_index]
+      load_dependencies(gemfile_text)
+      execute_ruby_files
+      trigger_test_unit
+    end
+
+    # Load the test suite's environment and execute it.
+    #
+    # Normally we fork to do this, and wait for the child to exit, to avoid
+    # polluting the parent process with test dependencies.  JRuby doesn't
+    # implement #fork so we resort to a hack.  We exec this lib file, which
+    # loads a new JVM for the tests to run in.
+    def execute
+      if environments.condition && !environments.condition.call
+        puts yellow("SKIPPED #{directory.inspect}: #{environments.skip_message}")
+        return
+      end
+      puts yellow("\nRunning #{directory.inspect} in #{environments.size} environments")
+      environments.before.call if environments.before
+      environments.each_with_index do |gemfile_text, i|
+        execute_with_pipe(i)
+      end
+      environments.after.call if environments.after
+    end
+
+    def execute_with_pipe(env)
+      OutputCollector.buffers.push('')
+      IO.popen("#{__FILE__} #{directory} #{env}") do |io|
+        while chars = io.read(8) do
+          OutputCollector.buffers.last << chars
+          print chars
+        end
+      end
+      if $? != 0
+        OutputCollector.failing_output.push(OutputCollector.buffers.last)
+      end
+      Multiverse::Runner.notice_exit_status $?
+    end
+
+    # something makes Test::Unit not want to run automatically.  Seems like the
+    # at_exit hook may be failing to run due to forking.
+    def trigger_test_unit
+      case
+      when defined? Test::Unit::RunCount # 1.9.3
+        # JRuby 1.7 doesn't seem to have a problem triggering test unit.  In
+        # contrast to MRI triggering it like this causes an error.
+        return if defined?(JRuby)
+
+        Test::Unit::RunCount.run_once do
+          exit(Test::Unit::Runner.new.run || true)
+        end
+      when defined? MiniTest::Unit # 1.9.2
+        exit(MiniTest::Unit.new.run)
+      when defined? Test::Unit::AutoRunner # 1.8.7
+        exit(Test::Unit::AutoRunner.run)
+      else
+        raise "Can't figure out how to trigger Test::Unit"
+      end
+    end
+
+    def execute_ruby_files
+      Dir.chdir directory
+      Dir[File.join(directory, '*.rb')].each do |file|
+        puts yellow("Executing #{file.inspect}") if verbose?
+        load file
+      end
+    end
+
+    def verbose?
+      ENV['VERBOSE']
+    end
+  end
+end
+
+# Exectute the suite.  We need this if we want to execute a suite by spawning a
+# new process instead of forking.
+if $0 == __FILE__
+  Multiverse::Suite.new(ARGV[0], ARGV[2]).execute_child_environment(ARGV[1].to_i)
+end

data/test/multiverse/script/run_one

@@ -0,0 +1,3 @@
+#!/bin/sh
+
+test/multiverse/lib/multiverse/suite.rb $PWD/test/multiverse/suites/$1 "$2" true

data/test/multiverse/script/runner

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+require 'fileutils'
+require 'test/unit'
+
+module Multiverse
+  require File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', 'multiverse', 'environment'))
+end
+
+Multiverse::Runner.run ARGV[0].to_s

data/test/multiverse/suites/active_record/Envfile

@@ -0,0 +1,13 @@
+gemfile <<-RB
+  if RUBY_VERSION == '1.8.6'
+    gem 'activerecord', '2.3.14'
+  elsif RUBY_PLATFORM == 'java'
+    gem 'jdbc-sqlite3'
+    gem 'activerecord-jdbcsqlite3-adapter'
+    gem 'activerecord'
+  else
+    gem 'activerecord'
+    gem 'sqlite3'
+  end
+  
+RB

data/test/multiverse/suites/active_record/ar_method_aliasing.rb

@@ -0,0 +1,94 @@
+
+require 'rubygems'
+
+require 'active_record'
+require 'test/unit'
+require 'newrelic_rpm'
+require 'multiverse/color'
+
+
+class InstrumentActiveRecordMethods < Test::Unit::TestCase
+  extend Multiverse::Color
+
+  if RUBY_VERSION >= '1.8.7'
+    if RUBY_PLATFORM == 'java'
+      require 'jdbc/sqlite3'
+      @@adapter = 'jdbcsqlite3'
+    else
+      require 'sqlite3'
+      @@adapter = 'sqlite3'
+    end
+
+    class User < ActiveRecord::Base 
+      include NewRelic::Agent::MethodTracer 
+      has_many :aliases
+
+      add_method_tracer :save!
+      add_method_tracer :persisted?
+    end
+
+    class Alias < ActiveRecord::Base
+      include NewRelic::Agent::MethodTracer
+
+      add_method_tracer :save!
+      add_method_tracer :persisted?
+      add_method_tracer :destroyed?
+    end
+    
+    def setup
+      puts "adapter : #{@@adapter}"
+      @db_connection = ActiveRecord::Base.establish_connection( :adapter => @@adapter, :database => "testdb.sqlite3")
+      ActiveRecord::Migration.class_eval do
+        @connection = @db_connection
+        create_table :users do |t|
+              t.string  :name
+        end
+
+        create_table :aliases do |t|
+            t.integer :user_id
+            t.string :aka
+        end
+      end
+    end
+
+    def teardown
+      @db_connection = ActiveRecord::Base.establish_connection( :adapter => "sqlite3", :database => "testdb.sqlite3")
+      ActiveRecord::Migration.class_eval do
+        @connection = @db_connection
+        drop_table :users
+        drop_table :aliases
+      end
+    end
+
+    def test_basic_creation
+      a_user = User.new :name => "Bob"
+      assert a_user.new_record?
+      a_user.save!
+      assert User.connected?
+      assert a_user.persisted?
+      assert a_user.id == 1 
+    end
+
+    def test_alias_collection_query_method
+      a_user = User.new :name => "Bob"
+      a_user.save!
+      a_user = User.find(1)
+      assert User.connected?
+      assert a_user.id = 1  
+
+      an_alias = Alias.new :user_id => a_user.id, :aka => "the Blob"
+      assert an_alias.new_record?
+      an_alias.save!
+      assert an_alias.persisted?
+      an_alias.destroy
+      assert an_alias.destroyed?
+    end
+
+  else
+    def test_truth
+      assert true # jruby freaks out if there are no tests defined in the test class
+    end
+    puts yellow('SKIPPED! skipped until ruby 1.8.6 compatibilites ironed out')
+  end
+end
+