mmtrix_rpm 1.0.0.1

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

@@ -0,0 +1,528 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+# This file is distributed under Mmtrix's license terms.
+# See https://github.com/mmtrix/rpm/blob/master/LICENSE for complete details.
+
+# This makes sure that the Multiverse environment loads with the gem
+# version of Minitest, which we use throughout, not the one in stdlib on
+# Rubies starting with 1.9.x
+require 'rubygems'
+require 'base64'
+require 'fileutils'
+require 'digest'
+
+require File.expand_path(File.join(File.dirname(__FILE__), 'environment'))
+
+module Multiverse
+  class Suite
+    include Color
+    attr_accessor :directory, :opts
+
+    def initialize(directory, opts={})
+      self.directory  = directory
+      self.opts       = opts
+      ENV["VERBOSE"]  = '1' if opts[:verbose]
+    end
+
+    def self.encode_options(decoded_opts)
+      Base64.encode64(Marshal.dump(decoded_opts)).gsub("\n", "")
+    end
+
+    def self.decode_options(encoded_opts)
+      Marshal.load(Base64.decode64(encoded_opts))
+    end
+
+    def suite
+      File.basename(directory)
+    end
+
+    def seed
+      opts.fetch(:seed, "")
+    end
+
+    def debug
+      opts.fetch(:debug, false)
+    end
+
+    def names
+      opts.fetch(:names, [])
+    end
+
+    def use_cache?
+      !opts.fetch(:nocache, false)
+    end
+
+    def filter_env
+      value = opts.fetch(:env, nil)
+      value = value.to_i if value
+    end
+
+    def filter_file
+      opts.fetch(:file, nil)
+    end
+
+    def clean_gemfiles(env_index)
+      FileUtils.rm_rf File.join(directory, "Gemfile.#{env_index}")
+      FileUtils.rm_rf File.join(directory, "Gemfile.#{env_index}.lock")
+    end
+
+    def envfile_path
+      File.join(directory, 'Envfile')
+    end
+
+    def environments
+      @environments ||= (
+        Dir.chdir directory
+        Envfile.new(envfile_path)
+      )
+    end
+
+    # load the environment for this suite after we've forked
+    def load_dependencies(gemfile_text, env_index, should_print=true)
+      ENV["BUNDLE_GEMFILE"] = "Gemfile.#{env_index}"
+      clean_gemfiles(env_index)
+      begin
+        generate_gemfile(gemfile_text, env_index)
+        ensure_bundle(env_index)
+      rescue => e
+        puts "#{e.class}: #{e}"
+        puts "Fast local bundle failed.  Attempting to install from rubygems.org"
+        clean_gemfiles(env_index)
+        generate_gemfile(gemfile_text, env_index, false)
+        ensure_bundle(env_index)
+      end
+      print_environment if should_print
+    end
+
+    def bundling_lock_file
+      File.join(Bundler.bundle_path, 'multiverse-bundler.lock')
+    end
+
+    def bundler_cache_dir
+      File.join(Bundler.bundle_path, 'multiverse-cache')
+    end
+
+    # Running the bundle should only happen one at a time per Ruby version or
+    # we occasionally get compilation errors. With the groups and parallelizing
+    # things out more, this is more of an issue, so start locking it down.
+    def exclusive_bundle
+      bundler_out = nil
+      File.open(bundling_lock_file, File::RDWR|File::CREAT) do |f|
+        puts "Waiting on '#{bundling_lock_file}' for our chance to bundle" if verbose?
+        f.flock(File::LOCK_EX)
+        puts "Let's get ready to BUNDLE!" if verbose?
+        bundler_out = `bundle`
+      end
+      bundler_out
+    end
+
+    def ensure_bundle(env_index)
+      require 'rubygems'
+      require 'bundler'
+      if use_cache?
+        ensure_bundle_cached(env_index) || ensure_bundle_uncached(env_index)
+      else
+        ensure_bundle_uncached(env_index)
+      end
+      Bundler.require
+    end
+
+    def envfile_hash
+      Digest::MD5.hexdigest(File.read(envfile_path))
+    end
+
+    def cached_gemfile_lock_filename(env_index)
+      "Gemfile.#{suite}.#{env_index}.#{envfile_hash}.lock"
+    end
+
+    def cache_gemfile_lock(env_index)
+      filename = cached_gemfile_lock_filename(env_index)
+      dst_path = File.join(bundler_cache_dir, filename)
+      src_path = File.join(directory, "Gemfile.#{env_index}.lock")
+      puts "Caching Gemfile.lock from #{src_path} to #{dst_path}" if verbose?
+      FileUtils.cp(src_path, dst_path)
+    end
+
+    def ensure_bundle_cached(env_index)
+      cache_dir = bundler_cache_dir
+      FileUtils.mkdir_p(cache_dir)
+      filename = cached_gemfile_lock_filename(env_index)
+      path = File.join(cache_dir, filename)
+
+      if File.exist?(path)
+        dst_path = File.join(directory, "Gemfile.#{env_index}.lock")
+        puts "Using cached Gemfile.lock from #{path} at #{dst_path}" if verbose?
+        FileUtils.cp(path, dst_path)
+        true
+      else
+        false
+      end
+    end
+
+    def ensure_bundle_uncached(env_index)
+      bundler_out = exclusive_bundle
+      puts bundler_out if verbose? || $? != 0
+      raise "bundle command failed with (#{$?})" unless $? == 0
+      cache_gemfile_lock(env_index) if use_cache?
+    end
+
+    def generate_gemfile(gemfile_text, env_index, local = true)
+      gemfile = File.join(Dir.pwd, "Gemfile.#{env_index}")
+      File.open(gemfile,'w') do |f|
+        f.puts '  source "https://rubygems.org"' unless local
+        f.print gemfile_text
+        f.puts mmtrix_gemfile_line unless gemfile_text =~ /^\s*gem .mmtrix_rpm./
+        f.puts jruby_openssl_line unless gemfile_text =~ /^\s*gem .jruby-openssl./
+        f.puts minitest_line unless gemfile_text =~ /^\s*gem .minitest[^_]./
+
+        rbx_gemfile_lines(f, gemfile_text)
+
+        f.puts "  gem 'mocha', '0.14.0', :require => false"
+
+        if debug
+          pry_version = RUBY_VERSION >= '1.8.7' ? '0.10.0' : '0.9.12'
+
+          # Pry 0.10.0 breaks compatibility with Ruby 1.8.7 :(
+          f.puts "  gem 'pry', '~> #{pry_version}'"
+          f.puts "  gem 'pry-byebug'" if RUBY_VERSION >= "2.0.0"
+          f.puts "  gem 'pry-stack_explorer'"
+        end
+      end
+      puts yellow("Gemfile.#{env_index} set to:") if verbose?
+      puts File.open(gemfile).read if verbose?
+    end
+
+    def mmtrix_gemfile_line
+      line = ENV['MMTRIX_GEMFILE_LINE'] if ENV['MMTRIX_GEMFILE_LINE']
+      path = ENV['MMTRIX_GEM_PATH'] || '../../../..'
+      line ||= "  gem 'mmtrix_rpm', :path => '#{path}'"
+      line
+    end
+
+    def rbx_gemfile_lines(f, gemfile_text)
+      return unless is_rbx?
+
+      f.puts "gem 'rubysl', :platforms => [:rbx]" unless gemfile_text =~ /^\s*gem .rubysl./
+      f.puts "gem 'json', :platforms => [:rbx]" unless gemfile_text =~ /^\s*gem .json./
+      f.puts "gem 'racc', :platforms => [:rbx]" unless gemfile_text =~ /^\s*gem .racc./
+    end
+
+    def is_rbx?
+      defined?(RUBY_ENGINE) && RUBY_ENGINE == "rbx"
+    end
+
+    def jruby_openssl_line
+      "gem 'jruby-openssl', :require => false, :platforms => [:jruby]"
+    end
+
+    def minitest_line
+      "gem 'minitest', '~> 4.7.5', :require => false"
+    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)
+      with_clean_env do
+        ENV["MULTIVERSE_ENV"] = env_index.to_s
+        log_test_running_process
+        configure_before_bundling
+
+        gemfile_text = environments[env_index]
+
+        load_dependencies(gemfile_text, env_index)
+
+        configure_child_environment
+        execute_ruby_files
+        trigger_test_run
+      end
+    end
+
+    def log_test_running_process
+      puts yellow("Starting tests in child PID #{Process.pid} at #{Time.now}\n")
+    end
+
+    def should_serialize?
+      ENV['SERIALIZE'] || debug
+    end
+
+    def check_environment_condition
+      if environments.condition && !environments.condition.call
+        puts yellow("SKIPPED #{directory.inspect}: #{environments.skip_message}")
+        false
+      else
+        true
+      end
+    end
+
+    def prime
+      ENV["VERBOSE"]= "1"
+      return unless check_environment_condition
+
+      puts yellow("\nPriming #{directory.inspect}")
+      @environments = nil
+
+      environments.each_with_index do |gemfile_text, env_index|
+        puts yellow("... for Envfile entry #{env_index}")
+        with_clean_env do
+          load_dependencies(gemfile_text, env_index, false)
+        end
+      end
+    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
+      return unless check_environment_condition
+
+      label = should_serialize? ? 'serial' : 'parallel'
+      env_count = filter_env ? 1 : environments.size
+      puts yellow("\nRunning #{directory.inspect} in #{env_count} environments in #{label}")
+
+      environments.before.call if environments.before
+      if should_serialize?
+        execute_serial
+      else
+        execute_parallel
+      end
+      environments.after.call if environments.after
+    rescue => e
+      puts red("Failure during execution of suite #{directory.inspect}.")
+      puts red("This typically is a result of a Ruby failure in your Envfile.")
+      puts
+      puts red(e.class)
+      puts red(e.message)
+      exit(1)
+    end
+
+    def execute_serial
+      with_each_environment do |_, i|
+        if debug
+          execute_in_foreground(i)
+        else
+          execute_in_background(i)
+        end
+      end
+    end
+
+    def execute_parallel
+      threads = []
+      with_each_environment do |_, i|
+        threads << Thread.new { execute_in_background(i) }
+      end
+      threads.each {|t| t.join}
+    end
+
+    def with_each_environment
+      environments.each_with_index do |gemfile_text, i|
+        next unless should_run_environment?(i)
+        yield gemfile_text, i
+      end
+    end
+
+    def should_run_environment?(index)
+      return true unless filter_env
+      return filter_env == index
+    end
+
+    def with_clean_env
+      if defined?(Bundler)
+        # clear $BUNDLE_GEMFILE and $RUBYOPT so that the ruby subprocess can run
+        # in the context of another bundle.
+        Bundler.with_clean_env { yield }
+      else
+        yield
+      end
+    end
+
+    def execute_in_foreground(env)
+      with_clean_env do
+        puts yellow("Running #{suite.inspect} for Envfile entry #{env}\n")
+        system(child_command_line(env))
+        check_for_failure(env)
+      end
+    end
+
+    def execute_in_background(env)
+      with_clean_env do
+        OutputCollector.write(suite, env, yellow("Running #{suite.inspect} for Envfile entry #{env}\n"))
+
+        IO.popen(child_command_line(env)) do |io|
+          until io.eof do
+            chars = io.read
+            OutputCollector.write(suite, env, chars)
+          end
+          OutputCollector.suite_report(suite, env)
+        end
+
+        check_for_failure(env)
+      end
+    end
+
+    def child_command_line(env)
+      "#{__FILE__} #{directory} #{env} '#{Suite.encode_options(opts)}'"
+    end
+
+    def check_for_failure(env)
+      if $? != 0
+        OutputCollector.write(suite, env, red("#{suite.inspect} for Envfile entry #{env} failed!"))
+        OutputCollector.failed(suite, env)
+      end
+      Multiverse::Runner.notice_exit_status $?
+    end
+
+    def trigger_test_run
+      # We drive everything manually ourselves through MiniTest.
+      #
+      # Autorun behaves differently across the different Ruby version we have
+      # to support, so this is simplest for making our test running consistent
+      options = []
+      options << "-v" if verbose?
+      options << "--seed=#{seed}" unless seed == ""
+      options << "--name=/#{names.map {|n| n + ".*"}.join("|")}/" unless names == []
+
+      original_options = options.dup
+
+      # MiniTest 5.0 moved things around, so choose which way to run it
+      if ::MiniTest.respond_to?(:run)
+        test_run = ::MiniTest.run(options)
+      else
+        test_run = ::MiniTest::Unit.new.run(options)
+      end
+
+      load @after_file if @after_file
+
+      if test_run
+        exit(test_run)
+      else
+        puts "No tests found with those options."
+        puts "options: #{original_options}"
+        exit(1)
+      end
+    end
+
+    def configure_before_bundling
+      disable_harvest_thread
+      configure_fake_collector
+    end
+
+    def configure_child_environment
+      require 'minitest/unit'
+      patch_minitest_base_for_old_versions
+      prevent_minitest_auto_run
+      require_mocha
+      require_helpers
+    end
+
+    def patch_minitest_base_for_old_versions
+      unless defined?(Minitest::Test)
+        ::Minitest.class_eval do
+          const_set(:Test, ::MiniTest::Unit::TestCase)
+        end
+      end
+    end
+
+    # Rails and minitest_tu_shim both want to do MiniTest::Unit.autorun for us
+    # We can't sidestep, so just gut the method to avoid doubled test runs
+    def prevent_minitest_auto_run
+      # MiniTest 4.x
+      ::MiniTest::Unit.class_eval do
+        def self.autorun
+          # NO-OP
+        end
+      end
+
+      # MiniTest 5.x
+      ::MiniTest.class_eval do
+        def self.autorun
+          # NO-OP
+        end
+      end
+    end
+
+    def require_mocha
+      require 'mocha/setup'
+    end
+
+    def disable_harvest_thread
+      # We don't want to have additional harvest threads running in our multiverse
+      # tests. The tests explicitly manage their lifecycle--resetting and harvesting
+      # to check results against the FakeCollector--so the harvest thread is actually
+      # destabilizing if it's running. Also, multiple restarts result in lots of
+      # threads running in some test suites.
+
+      ENV["MMTRIX_DISABLE_HARVEST_THREAD"] = "true"
+    end
+
+    def configure_fake_collector
+      ENV["MMTRIX_OMIT_FAKE_COLLECTOR"] = "true" if environments.omit_collector
+    end
+
+    def require_helpers
+      # If used from a 3rd-party, these paths likely need to be added
+      $LOAD_PATH << File.expand_path(File.join(__FILE__, "..", "..", "..", ".."))
+      $LOAD_PATH << File.expand_path(File.join(__FILE__, "..", "..", "..", "..", "mmtrix"))
+      require 'multiverse_helpers'
+    end
+
+    def execute_ruby_files
+      Dir.chdir directory
+      ordered_ruby_files(directory).each do |file|
+        puts yellow("Executing #{file.inspect}") if verbose?
+        require "./" + File.basename(file, ".rb")
+      end
+    end
+
+    def ordered_ruby_files(directory)
+      files = Dir[File.join(directory, '*.rb')]
+
+      @before_file = files.find { |file| File.basename(file) == "before_suite.rb" }
+      @after_file  = files.find { |file| File.basename(file) == "after_suite.rb" }
+
+      files.delete(@before_file)
+      files.delete(@after_file)
+
+      # Important that we filter after removing before/after so they don't get
+      # tromped for not matching our pattern!
+      files.select! {|file| file.include?(filter_file) } if filter_file
+
+      # Just put before_suite.rb at the head of the list.
+      # Will explicitly load after_suite.rb after the test run
+      files.insert(0, @before_file) if @before_file
+
+      files
+    end
+
+    def verbose?
+      ENV['VERBOSE'] == "1" || ENV['VERBOSE'] == "true"
+    end
+  end
+end
+
+# Execute the suite.  We need this if we want to execute a suite by spawning a
+# new process instead of forking.
+if $0 == __FILE__ && $already_running.nil?
+  # Suite might get re-required, but don't execute again
+  $already_running = true
+
+  # Redirect stderr to stdout so that we can capture both in the popen that
+  # feeds into the OutputCollector above.
+  $stderr.reopen($stdout)
+
+  # Ugly, but seralized args passed along to #popen when kicking child off
+  dir, env_index, encoded_opts, _ = *ARGV
+  opts = Multiverse::Suite.decode_options(encoded_opts)
+  suite = Multiverse::Suite.new(dir, opts)
+  suite.execute_child_environment(env_index.to_i)
+end

data/test/multiverse/script/runner

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

data/test/multiverse/suites/active_record/.gitignore

@@ -0,0 +1 @@
+db/schema.rb

data/test/multiverse/suites/active_record/Envfile

@@ -0,0 +1,73 @@
+boilerplate_gems = <<-BOILERPLATE
+  gem 'rack'
+  gem 'rake'
+  if RUBY_PLATFORM == 'java'
+    gem "activerecord-jdbcmysql-adapter"
+  else
+    gem 'mysql'
+  end
+BOILERPLATE
+
+if RUBY_VERSION >= '1.9.3'
+  gemfile <<-RB
+    gem 'activerecord', '~> 4.2.0'
+    gem 'minitest', '~> 5.2.3'
+    #{boilerplate_gems}
+  RB
+
+  gemfile <<-RB
+    gem 'activerecord', '~> 4.1.6'
+    gem 'minitest', '~> 5.2.3'
+    #{boilerplate_gems}
+  RB
+
+  gemfile <<-RB
+    gem 'activerecord', '~> 4.0.11'
+    #{boilerplate_gems}
+  RB
+end
+
+# AR 3.x does not have official support for Ruby 2.2, and there are several
+# known issues, including https://github.com/rails/rails/issues/18991, so
+# skip 3.x versions on 2.2.
+#
+if RUBY_VERSION < '2.2.0'
+  gemfile <<-RB
+    gem 'activerecord', '~> 3.2.19'
+    #{boilerplate_gems}
+  RB
+
+  gemfile <<-RB
+    gem 'activerecord', '~> 3.1.12'
+    #{boilerplate_gems}
+  RB
+
+  gemfile <<-RB
+    gem 'activerecord', '~> 3.0.20'
+    #{boilerplate_gems}
+  RB
+end
+
+# We pull in Rails on the older verions because ActiveRecord didn't have all
+# the tasks we need for setup, and there are some TestUnit vs Minitest oddities
+#
+# JRuby testing with 1.7 on Rails 2.x has issues and was already excluded in
+# test:env
+if RUBY_VERSION <= '1.9.3' && (!defined?(RUBY_ENGINE) || RUBY_ENGINE != 'jruby')
+gemfile <<-RB
+  gem 'rails', '~> 2.3.18'
+  #{boilerplate_gems}
+RB
+
+gemfile <<-RB
+  gem "rails", "~> 2.2.3"
+  #{boilerplate_gems}
+RB
+end
+
+if RUBY_VERSION < '1.9.2'
+gemfile <<-RB
+  gem "rails", "~> 2.1.2"
+  #{boilerplate_gems}
+RB
+end

data/test/multiverse/suites/active_record/Rakefile

@@ -0,0 +1,9 @@
+require File.expand_path('config/database')
+
+desc "Setup for ActiveRecord"
+task :environment do
+  if defined?(DatabaseTasks)
+    ActiveRecord::Base.configurations = DatabaseTasks.database_configuration
+    ActiveRecord::Base.establish_connection DatabaseTasks.env.to_sym
+  end
+end