vinted-parallel_tests 0.13.3

data/lib/parallel_tests/tasks.rb

@@ -0,0 +1,139 @@
+require 'rake'
+
+module ParallelTests
+  module Tasks
+    class << self
+      def rails_env
+        ENV['RAILS_ENV'] || 'test'
+      end
+
+      def run_in_parallel(cmd, options={})
+        count = " -n #{options[:count]}" if options[:count]
+        executable = File.expand_path("../../../bin/parallel_test", __FILE__)
+        command = "#{executable} --exec '#{cmd}'#{count}#{' --non-parallel' if options[:non_parallel]}"
+        command << " --advance-number #{options[:advance_number]}" if options[:advance_number]
+        abort unless system(command)
+      end
+
+      # this is a crazy-complex solution for a very simple problem:
+      # removing certain lines from the output without chaning the exit-status
+      # normally I'd not do this, but it has been lots of fun and a great learning experience :)
+      #
+      # - sed does not support | without -r
+      # - grep changes 0 exitstatus to 1 if nothing matches
+      # - sed changes 1 exitstatus to 0
+      # - pipefail makes pipe fail with exitstatus of first failed command
+      # - pipefail is not supported in (zsh)
+      # - defining a new rake task like silence_schema would force users to load parallel_tests in test env
+      # - do not use ' since run_in_parallel uses them to quote stuff
+      # - simple system "set -o pipefail" returns nil even though set -o pipefail exists with 0
+      def suppress_output(command, ignore_regex)
+        activate_pipefail = "set -o pipefail"
+        remove_ignored_lines = %Q{(grep -v "#{ignore_regex}" || test 1)}
+
+        if system("#{activate_pipefail} 2>/dev/null && test 1")
+          "#{activate_pipefail} && (#{command}) | #{remove_ignored_lines}"
+        else
+          command
+        end
+      end
+
+      def check_for_pending_migrations
+        abort_migrations = "db:abort_if_pending_migrations"
+        if Rake::Task.task_defined?(abort_migrations)
+          Rake::Task[abort_migrations].invoke
+        end
+      end
+
+      # parallel:spec[:count, :pattern, :options]
+      def parse_args(args)
+        # order as given by user
+        args = [args[:count], args[:pattern], args[:options]]
+
+        # count given or empty ?
+        # parallel:spec[2,models,options]
+        # parallel:spec[,models,options]
+        count = args.shift if args.first.to_s =~ /^\d*$/
+        num_processes = count.to_i unless count.to_s.empty?
+        pattern = args.shift
+        options = args.shift
+
+        [num_processes, pattern.to_s, options.to_s]
+      end
+    end
+  end
+end
+
+namespace :parallel do
+  desc "create test databases via db:create --> parallel:create[num_cpus]"
+  task :create, :count do |t,args|
+    ParallelTests::Tasks.run_in_parallel("rake db:create RAILS_ENV=#{ParallelTests::Tasks.rails_env}", args)
+  end
+
+  desc "drop test databases via db:drop --> parallel:drop[num_cpus]"
+  task :drop, :count do |t,args|
+    ParallelTests::Tasks.run_in_parallel("rake db:drop RAILS_ENV=#{ParallelTests::Tasks.rails_env}", args)
+  end
+
+  desc "update test databases by dumping and loading --> parallel:prepare[num_cpus]"
+  task(:prepare, [:count]) do |t,args|
+    ParallelTests::Tasks.check_for_pending_migrations
+    if defined?(ActiveRecord) && ActiveRecord::Base.schema_format == :ruby
+      # dump then load in parallel
+      Rake::Task['db:schema:dump'].invoke
+      Rake::Task['parallel:load_schema'].invoke(args[:count])
+    else
+      # there is no separate dump / load for schema_format :sql -> do it safe and slow
+      args = args.to_hash.merge(:non_parallel => true) # normal merge returns nil
+      ParallelTests::Tasks.run_in_parallel('rake db:test:prepare --trace', args)
+    end
+  end
+
+  # when dumping/resetting takes too long
+  desc "update test databases via db:migrate --> parallel:migrate[num_cpus]"
+  task :migrate, :count do |t,args|
+    ParallelTests::Tasks.run_in_parallel("rake db:migrate RAILS_ENV=#{ParallelTests::Tasks.rails_env}", args)
+  end
+
+  # just load the schema (good for integration server <-> no development db)
+  desc "load dumped schema for test databases via db:schema:load --> parallel:load_schema[num_cpus]"
+  task :load_schema, :count do |t,args|
+    command = "rake db:schema:load RAILS_ENV=#{ParallelTests::Tasks.rails_env}"
+    ParallelTests::Tasks.run_in_parallel(ParallelTests::Tasks.suppress_output(command, "^   ->\\|^-- "), args)
+  end
+
+  desc "load the seed data from db/seeds.rb via db:seed --> parallel:seed[num_cpus]"
+  task :seed, :count do |t,args|
+    ParallelTests::Tasks.run_in_parallel("rake db:seed RAILS_ENV=#{ParallelTests::Tasks.rails_env}", args)
+  end
+
+  desc "launch given rake command in parallel"
+  task :rake, :command do |t, args|
+    ParallelTests::Tasks.run_in_parallel("RAILS_ENV=#{ParallelTests::Tasks.rails_env} rake #{args.command}")
+  end
+
+  ['test', 'spec', 'features'].each do |type|
+    desc "run #{type} in parallel with parallel:#{type}[num_cpus]"
+    task type, [:count, :pattern, :options] do |t, args|
+      ParallelTests::Tasks.check_for_pending_migrations
+
+      $LOAD_PATH << File.expand_path(File.join(File.dirname(__FILE__), '..'))
+      require "parallel_tests"
+
+      count, pattern, options = ParallelTests::Tasks.parse_args(args)
+      test_framework = {
+        'spec' => 'rspec',
+        'test' => 'test',
+        'features' => 'cucumber'
+      }[type]
+
+      executable = File.join(File.dirname(__FILE__), '..', '..', 'bin', 'parallel_test')
+      command = "#{executable} #{type} --type #{test_framework} " \
+        "-n #{count} "                     \
+        "--pattern '#{pattern}' "          \
+        "--test-options '#{options}'"
+
+      abort unless system(command) # allow to chain tasks e.g. rake parallel:spec parallel:features
+    end
+  end
+end

data/lib/parallel_tests/test/runner.rb

@@ -0,0 +1,168 @@
+require 'open3'
+
+module ParallelTests
+  module Test
+    class Runner
+      NAME = 'Test'
+
+      class << self
+        # --- usually overwritten by other runners
+
+        def name
+          NAME
+        end
+
+        def runtime_log
+          'tmp/parallel_runtime_test.log'
+        end
+
+        def test_suffix
+          "_test.rb"
+        end
+
+        def test_file_name
+          "test"
+        end
+
+        def run_tests(test_files, process_number, num_processes, options)
+          require_list = test_files.map { |filename| %{"#{File.expand_path filename}"} }.join(",")
+          cmd = "#{executable} -Itest -e '[#{require_list}].each {|f| require f }' -- #{options[:test_options]}"
+          execute_command(cmd, process_number, num_processes, options)
+        end
+
+        def line_is_result?(line)
+          line =~ /\d+ failure/
+        end
+
+        # --- usually used by other runners
+
+        # finds all tests and partitions them into groups
+        def tests_in_groups(tests, num_groups, options={})
+          tests = find_tests(tests, options)
+
+          tests = if options[:group_by] == :found
+            tests.map { |t| [t, 1] }
+          else
+            with_runtime_info(tests)
+          end
+          Grouper.in_even_groups_by_size(tests, num_groups, options)
+        end
+
+        def execute_command(cmd, process_number,  num_processes, options)
+          env = (options[:env] || {}).merge(
+            "TEST_ENV_NUMBER" => test_env_number(process_number, options),
+            "PARALLEL_TEST_GROUPS" => num_processes
+          )
+          cmd = "nice #{cmd}" if options[:nice]
+          execute_command_and_capture_output(env, cmd, options[:serialize_stdout])
+        end
+
+        def execute_command_and_capture_output(env, cmd, silence)
+          # make processes descriptive / visible in ps -ef
+          exports = env.map do |k,v|
+            "#{k}=#{v};export #{k}"
+          end.join(";")
+          cmd = "#{exports};#{cmd}"
+
+          output = open("|#{cmd}", "r") { |output| capture_output(output, silence) }
+          exitstatus = $?.exitstatus
+
+          {:stdout => output, :exit_status => exitstatus}
+        end
+
+        def find_results(test_output)
+          test_output.split("\n").map {|line|
+            line = line.gsub(/\.|F|\*/,'').gsub(/\e\[\d+m/,'')
+            next unless line_is_result?(line)
+            line
+          }.compact
+        end
+
+        def test_env_number(process_number, options)
+          n = options[:advance_number].to_i + process_number + 1
+          n == 0 ? '' : n
+        end
+
+        def summarize_results(results)
+          sums = sum_up_results(results)
+          sums.sort.map{|word, number|  "#{number} #{word}#{'s' if number != 1}" }.join(', ')
+        end
+
+        protected
+
+        def executable
+          ENV['PARALLEL_TESTS_EXECUTABLE'] || determine_executable
+        end
+
+        def determine_executable
+          "ruby"
+        end
+
+        def sum_up_results(results)
+          results = results.join(' ').gsub(/s\b/,'') # combine and singularize results
+          counts = results.scan(/(\d+) (\w+)/)
+          counts.inject(Hash.new(0)) do |sum, (number, word)|
+            sum[word] += number.to_i
+            sum
+          end
+        end
+
+        # read output of the process and print it in chunks
+        def capture_output(out, silence)
+          result = ""
+          loop do
+            begin
+              read = out.readpartial(1000000) # read whatever chunk we can get
+              result << read
+              unless silence
+                $stdout.print read
+                $stdout.flush
+              end
+            end
+          end rescue EOFError
+          result
+        end
+
+        def with_runtime_info(tests)
+          lines = File.read(runtime_log).split("\n") rescue []
+
+          # use recorded test runtime if we got enough data
+          if lines.size * 1.5 > tests.size
+            puts "Using recorded test runtime"
+            times = Hash.new(1)
+            lines.each do |line|
+              test, time = line.split(":")
+              next unless test and time
+              times[File.expand_path(test)] = time.to_f
+            end
+            tests.sort.map{|test| [test, times[File.expand_path(test)]] }
+          else # use file sizes
+            tests.sort.map{|test| [test, File.stat(test).size] }
+          end
+        end
+
+        def find_tests(tests, options = {})
+          (tests || []).map do |file_or_folder|
+            if File.directory?(file_or_folder)
+              files = files_in_folder(file_or_folder, options)
+              files.grep(/#{Regexp.escape test_suffix}$/).grep(options[:pattern]||//)
+            else
+              file_or_folder
+            end
+          end.flatten.uniq
+        end
+
+        def files_in_folder(folder, options={})
+          pattern = if options[:symlinks] == false # not nil or true
+            "**/*"
+          else
+            # follow one symlink and direct children
+            # http://stackoverflow.com/questions/357754/can-i-traverse-symlinked-directories-in-ruby-with-a-glob
+            "**{,/*/**}/*"
+          end
+          Dir[File.join(folder, pattern)].uniq
+        end
+      end
+    end
+  end
+end

data/lib/parallel_tests/test/runtime_logger.rb

@@ -0,0 +1,97 @@
+require 'parallel_tests'
+require 'parallel_tests/test/runner'
+
+module ParallelTests
+  module Test
+    class RuntimeLogger
+      @@has_started = false
+
+      class << self
+        def log(test, start_time, end_time)
+          return if test.is_a? ::Test::Unit::TestSuite # don't log for suites-of-suites
+
+          if !@@has_started # make empty log file
+            File.open(logfile, 'w'){}
+            @@has_started = true
+          end
+
+          locked_appending_to(logfile) do |file|
+            file.puts(message(test, start_time, end_time))
+          end
+        end
+
+        private
+
+        def message(test, start_time, end_time)
+          delta = "%.2f" % (end_time.to_f-start_time.to_f)
+          filename = class_directory(test.class) + class_to_filename(test.class) + ".rb"
+          "#{filename}:#{delta}"
+        end
+
+        # Note: this is a best guess at conventional test directory structure, and may need
+        # tweaking / post-processing to match correctly for any given project
+        def class_directory(suspect)
+          result = "test/"
+
+          if defined?(Rails)
+            result += case suspect.superclass.name
+            when "ActionDispatch::IntegrationTest"
+              "integration/"
+            when "ActionDispatch::PerformanceTest"
+              "performance/"
+            when "ActionController::TestCase"
+              "functional/"
+            when "ActionView::TestCase"
+              "unit/helpers/"
+            else
+              "unit/"
+            end
+          end
+          result
+        end
+
+        # based on https://github.com/grosser/single_test/blob/master/lib/single_test.rb#L117
+        def class_to_filename(suspect)
+          word = suspect.to_s.dup
+          return word unless word.match /^[A-Z]/ and not word.match %r{/[a-z]}
+
+          word.gsub!(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+          word.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
+          word.gsub!(/\:\:/, '/')
+          word.tr!("-", "_")
+          word.downcase!
+          word
+        end
+
+        def locked_appending_to(file)
+          File.open(file, 'a') do |f|
+            begin
+              f.flock File::LOCK_EX
+              yield f
+            ensure
+              f.flock File::LOCK_UN
+            end
+          end
+        end
+
+        def logfile
+          ParallelTests::Test::Runner.runtime_log
+        end
+      end
+    end
+  end
+end
+
+require 'test/unit/testsuite'
+class ::Test::Unit::TestSuite
+  alias :run_without_timing :run unless defined? @@timing_installed
+
+  def run(result, &progress_block)
+    start_time = ParallelTests.now
+    run_without_timing(result, &progress_block)
+    end_time = ParallelTests.now
+    ParallelTests::Test::RuntimeLogger.log(self.tests.first, start_time, end_time)
+  end
+
+  @@timing_installed = true
+end

data/lib/parallel_tests/version.rb

@@ -0,0 +1,3 @@
+module ParallelTests
+  VERSION = Version = '0.13.3'
+end

data/lib/parallel_tests.rb

@@ -0,0 +1,61 @@
+require "parallel"
+require "parallel_tests/railtie" if defined? Rails::Railtie
+
+module ParallelTests
+  GREP_PROCESSES_COMMAND = "ps -ef | grep [T]EST_ENV_NUMBER= 2>&1"
+
+  autoload :CLI, "parallel_tests/cli"
+  autoload :VERSION, "parallel_tests/version"
+  autoload :Grouper, "parallel_tests/grouper"
+
+  class << self
+    def determine_number_of_processes(count)
+      [
+        count,
+        ENV["PARALLEL_TEST_PROCESSORS"],
+        Parallel.processor_count
+      ].detect{|c| not c.to_s.strip.empty? }.to_i
+    end
+
+    # copied from http://github.com/carlhuda/bundler Bundler::SharedHelpers#find_gemfile
+    def bundler_enabled?
+      return true if Object.const_defined?(:Bundler)
+
+      previous = nil
+      current = File.expand_path(Dir.pwd)
+
+      until !File.directory?(current) || current == previous
+        filename = File.join(current, "Gemfile")
+        return true if File.exists?(filename)
+        current, previous = File.expand_path("..", current), current
+      end
+
+      false
+    end
+
+    def first_process?
+      !ENV["TEST_ENV_NUMBER"] || ENV["TEST_ENV_NUMBER"].to_i == 0
+    end
+
+    def wait_for_other_processes_to_finish
+      return unless ENV["TEST_ENV_NUMBER"]
+      sleep 1 until number_of_running_processes <= 1
+    end
+
+    # Fun fact: this includes the current process if it's run via parallel_tests
+    def number_of_running_processes
+      result = `#{GREP_PROCESSES_COMMAND}`
+      raise "Could not grep for processes -> #{result}" if result.strip != "" && !$?.success?
+      result.split("\n").size
+    end
+
+    # real time even if someone messed with timecop in tests
+    def now
+      if Time.respond_to?(:now_without_mock_time) # Timecop
+        Time.now_without_mock_time
+      else
+        Time.now
+      end
+    end
+  end
+end

data/parallel_tests.gemspec

@@ -0,0 +1,14 @@
+$LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
+name = "vinted-parallel_tests"
+require "parallel_tests/version"
+
+Gem::Specification.new name, ParallelTests::VERSION do |s|
+  s.summary = "Run Test::Unit / RSpec / Cucumber in parallel"
+  s.authors = ["Laurynas Butkus", "Tomas Varaneckas", "Justas Janauskas"]
+  s.email = ["laurynas.butkus@gmail.com", "tomas.varaneckas@gmail.com", "jjanauskas@gmail.com"]
+  s.homepage = "http://github.com/vinted/parallel_tests"
+  s.files = `git ls-files`.split("\n")
+  s.license = "MIT"
+  s.executables = ["parallel_cucumber", "parallel_rspec", "parallel_test"]
+  s.add_runtime_dependency "parallel"
+end