wd_newrelic_rpm 3.3.4.1 → 3.5.5

data/test/intentional_fail.rb

@@ -0,0 +1,10 @@
+require 'test/unit'
+class IntentionalFail < Test::Unit::TestCase
+
+  # This test suite is provided to facilitate testing that build scripts (e.g.
+  # rake test) return the correct exit codes when tests fail.
+  def test_fail
+    assert false
+  end
+
+end

data/test/multiverse/.gitignore

@@ -0,0 +1,10 @@
+tmp
+*.swp
+.bundler_work_area
+Gemfile
+Gemfile.lock
+*.log
+*.db
+.idea
+tags
+*.sqlite3

data/test/multiverse/README.md

@@ -0,0 +1,85 @@
+# Multiverse
+
+## Testing in a multitude of environments
+
+Multiverse was created to solve a specific problem experienced by the Agent
+team.  Not only does the New Relic Agent run in a wide variety of environments,
+but its expected behavior *changes* based on the environment.  Instrumenation is
+toggled on and off based on the presence of certain libraries, and some of these
+libraries are incompatible with each other.  Effective testing requires us to
+specify different environments for different tests; Multiverse aims to make this
+painless.
+
+
+## Getting started
+
+You can invoke this via rake
+
+    rake test:multiverse
+
+If you only want to run some test suites you can filter by their names
+
+    rake test:multiverse[sinatra]
+
+You can run tests of multiverse itself with
+
+    rake test:multiverse:self
+
+### Adding a test suite
+
+To add tests add a directory to the `suites` directory.  This directory should
+contain at least two files.
+
+#### Envfile
+
+The Envfile is a meta gem file.  It allows you to specify one or more gemset
+that the tests in this directory should be run against.  For example:
+
+    gemfile <<-GEMFILE
+      gem "rails", "~>3.2.0"
+    GEMFILE
+
+    gemfile <<-GEMFILE
+      gem "rails", "~>3.1.0"
+    GEMFILE
+
+This will run these tests against 2 environments, one running rails 3.1, the
+other running rails 3.2.
+
+New Relic is automatically included in the environment.  Specifying it in the
+Envfile will trigger and error.  You can override where newrelic is loaded from
+using two environment variables.
+
+The default gemfile line is
+
+    gem 'newrelic_rpm', :path => '../../../ruby_agent'
+
+`ENV['NEWRELIC_GEMFILE_LINE']` will specify the full line for the gemfile
+
+`ENV['NEWRELIC_GEM_PATH']` will override the `:path` option in the default line.
+
+
+#### Test files
+
+All files in a test suite directory that end with .rb will be executed as test
+files.  These should use test unit.
+
+For example:
+
+    require 'test/unit'
+    class ATest < Test::Unit::TestCase
+      def test_json_is_loaded
+        assert JSON
+      end
+
+      def test_haml_is_not_loaded
+        assert !defined?(Haml)
+      end
+    end
+
+
+## Testing Multiverse
+
+Multiverse has a suite of tests in the `test` directory for testing the
+framework itself (sooo meta).  These help confirm that the system is working as
+expected.

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