parallel_tests-instructure 0.6.16

data/lib/parallel_tests/grouper.rb

@@ -0,0 +1,49 @@
+class ParallelTests
+  class Grouper
+    def self.in_groups(items, num_groups)
+      groups = Array.new(num_groups){ [] }
+
+      until items.empty?
+        num_groups.times do |group_number|
+          groups[group_number] << items.shift
+        end
+      end
+
+      groups.map!(&:sort!)
+    end
+
+    def self.in_even_groups_by_size(items_with_sizes, num_groups, options={})
+      groups = Array.new(num_groups){{:items => [], :size => 0}}
+
+      # add all files that should run in a single process to one group
+      (options[:single_process]||[]).each do |pattern|
+        matched, items_with_sizes = items_with_sizes.partition{|item, size| item =~ pattern }
+        smallest = smallest_group(groups)
+        matched.each{|item,size| add_to_group(smallest, item, size) }
+      end
+
+      # add all other files
+      largest_first(items_with_sizes).each do |item, size|
+        smallest = smallest_group(groups)
+        add_to_group(smallest, item, size)
+      end
+
+      groups.map!{|g| g[:items].sort }
+    end
+
+    def self.largest_first(files)
+      files.sort_by{|item, size| size }.reverse
+    end
+
+  private
+
+    def self.smallest_group(groups)
+      groups.min_by{|g| g[:size] }
+    end
+
+    def self.add_to_group(group, item, size)
+      group[:items] << item
+      group[:size] += size
+    end
+  end
+end

data/lib/parallel_tests/railtie.rb

@@ -0,0 +1,10 @@
+# add rake tasks if we are inside Rails
+if defined?(Rails::Railtie)
+  class ParallelTests
+    class Railtie < ::Rails::Railtie
+      rake_tasks do
+        load File.expand_path("../../tasks/parallel_tests.rake", __FILE__)
+      end
+    end
+  end
+end

data/lib/parallel_tests/runtime_logger.rb

@@ -0,0 +1,78 @@
+class ParallelTests::RuntimeLogger
+  @@has_started = false
+
+  def self.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(ParallelTests.runtime_log, 'w') do end
+      @@has_started = true
+    end
+
+    File.open(ParallelTests.runtime_log, 'a') do |output|
+      begin
+        output.flock File::LOCK_EX
+        output.puts(self.message(test, start_time, end_time))
+      ensure
+        output.flock File::LOCK_UN
+      end
+    end
+  end
+
+  def self.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"
+    message="#{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 self.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 self.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
+
+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=Time.now
+    run_without_timing(result, &progress_block)
+    end_time=Time.now
+    ParallelTests::RuntimeLogger.log(self.tests.first, start_time, end_time)
+  end
+  @@timing_installed = true
+
+end

data/lib/parallel_tests/tasks.rb

@@ -0,0 +1,80 @@
+namespace :parallel do
+  def run_in_parallel(cmd, options)
+    count = (options[:count] ? options[:count].to_i : nil)
+    executable = File.join(File.dirname(__FILE__), '..', '..', 'bin', 'parallel_test')
+    command = "#{executable} --exec '#{cmd}' -n #{count} #{'--non-parallel' if options[:non_parallel]}"
+    abort unless system(command)
+  end
+
+  desc "create test databases via db:create --> parallel:create[num_cpus]"
+  task :create, :count do |t,args|
+    run_in_parallel('rake db:create RAILS_ENV=test', args)
+  end
+
+  desc "drop test databases via db:drop --> parallel:drop[num_cpus]"
+  task :drop, :count do |t,args|
+    run_in_parallel('rake db:drop RAILS_ENV=test', args)
+  end
+
+  desc "update test databases by dumping and loading --> parallel:prepare[num_cpus]"
+  task(:prepare, [:count] => 'db:abort_if_pending_migrations') do |t,args|
+    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
+      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|
+    run_in_parallel('rake db:migrate RAILS_ENV=test', 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|
+    run_in_parallel('rake db:test:load', args)
+  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|
+      $LOAD_PATH << File.expand_path(File.join(File.dirname(__FILE__), '..'))
+      require "parallel_tests"
+      count, pattern, options = ParallelTests.parse_rake_args(args)
+      executable = File.join(File.dirname(__FILE__), '..', '..', 'bin', 'parallel_test')
+      command = "#{executable} --type #{type} -n #{count} -p '#{pattern}' -r '#{Rails.root}' -o '#{options}'"
+      abort unless system(command) # allow to chain tasks e.g. rake parallel:spec parallel:features
+    end
+  end
+end
+
+#backwards compatability
+#spec:parallel:prepare
+#spec:parallel
+#test:parallel
+namespace :spec do
+  namespace :parallel do
+    task :prepare, :count do |t,args|
+      $stderr.puts "WARNING -- Deprecated!  use parallel:prepare"
+      Rake::Task['parallel:prepare'].invoke(args[:count])
+    end
+  end
+
+  task :parallel, :count, :pattern do |t,args|
+    $stderr.puts "WARNING -- Deprecated! use parallel:spec"
+    Rake::Task['parallel:spec'].invoke(args[:count], args[:pattern])
+  end
+end
+
+namespace :test do
+  task :parallel, :count, :pattern do |t,args|
+    $stderr.puts "WARNING -- Deprecated! use parallel:test"
+    Rake::Task['parallel:test'].invoke(args[:count], args[:pattern])
+  end
+end

data/lib/tasks/parallel_tests.rake

@@ -0,0 +1 @@
+require File.join(File.dirname(__FILE__), "/../parallel_tests/tasks")

data/parallel_tests-instructure.gemspec

@@ -0,0 +1,67 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = "parallel_tests-instructure"
+  s.version = "0.6.16"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Michael Grosser, Bryan Madsen"]
+  s.date = "2012-02-27"
+  s.executables = ["parallel_cucumber", "parallel_test", "parallel_spec"]
+  s.files = [
+    "Gemfile",
+    "Gemfile.lock",
+    "Rakefile",
+    "Readme.md",
+    "VERSION",
+    "bin/parallel_cucumber",
+    "bin/parallel_spec",
+    "bin/parallel_test",
+    "lib/parallel_cucumber.rb",
+    "lib/parallel_cucumber/runtime_logger.rb",
+    "lib/parallel_specs.rb",
+    "lib/parallel_specs/spec_failures_logger.rb",
+    "lib/parallel_specs/spec_logger_base.rb",
+    "lib/parallel_specs/spec_runtime_logger.rb",
+    "lib/parallel_specs/spec_summary_logger.rb",
+    "lib/parallel_specs/spec_error_count_logger.rb",
+    "lib/parallel_specs/spec_error_logger.rb",
+    "lib/parallel_specs/spec_start_finish_logger.rb",
+    "lib/parallel_tests.rb",
+    "lib/parallel_tests/grouper.rb",
+    "lib/parallel_tests/railtie.rb",
+    "lib/parallel_tests/runtime_logger.rb",
+    "lib/parallel_tests/tasks.rb",
+    "lib/tasks/parallel_tests.rake",
+    "parallel_tests-instructure.gemspec",
+    "spec/integration_spec.rb",
+    "spec/parallel_cucumber_spec.rb",
+    "spec/parallel_specs/spec_failure_logger_spec.rb",
+    "spec/parallel_specs/spec_runtime_logger_spec.rb",
+    "spec/parallel_specs/spec_summary_logger_spec.rb",
+    "spec/parallel_specs_spec.rb",
+    "spec/parallel_tests/runtime_logger_spec.rb",
+    "spec/parallel_tests_spec.rb",
+    "spec/spec_helper.rb"
+  ]
+  s.homepage = "http://github.com/bmad/parallel_tests-instructure"
+  s.require_paths = ["lib"]
+  s.rubygems_version = "1.8.15"
+  s.summary = "Run tests / specs / features in parallel"
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<parallel>, [">= 0"])
+    else
+      s.add_dependency(%q<parallel>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<parallel>, [">= 0"])
+  end
+end
+

data/spec/integration_spec.rb

@@ -0,0 +1,133 @@
+require 'spec_helper'
+
+describe 'CLI' do
+  before do
+    `rm -rf #{folder}`
+  end
+
+  after do
+    `rm -rf #{folder}`
+  end
+
+  def folder
+    "/tmp/parallel_tests_tests"
+  end
+
+  def write(file, content)
+    path = "#{folder}/#{file}"
+    `mkdir -p #{File.dirname(path)}` unless File.exist?(File.dirname(path))
+    File.open(path, 'w'){|f| f.write content }
+    path
+  end
+
+  def bin_folder
+    "#{File.expand_path(File.dirname(__FILE__))}/../bin"
+  end
+
+  def executable
+    "#{bin_folder}/parallel_test"
+  end
+
+  def run_tests(options={})
+    `cd #{folder} && #{executable} --chunk-timeout 999 -t #{options[:type] || 'spec'} -n #{options[:processes]||2} #{options[:add]} 2>&1`
+  end
+
+  it "runs tests in parallel" do
+    write 'spec/xxx_spec.rb', 'describe("it"){it("should"){puts "TEST1"}}'
+    write 'spec/xxx2_spec.rb', 'describe("it"){it("should"){puts "TEST2"}}'
+    result = run_tests
+
+    # test ran and gave their puts
+    result.should include('TEST1')
+    result.should include('TEST2')
+
+    # all results present
+    result.scan('1 example, 0 failure').size.should == 2 # 2 results
+    result.scan('2 examples, 0 failures').size.should == 1 # 1 summary
+    result.scan(/Finished in \d+\.\d+ seconds/).size.should == 2
+    result.scan(/Took \d+\.\d+ seconds/).size.should == 1 # parallel summary
+    $?.success?.should == true
+  end
+
+  it "does not run any tests if there are none" do
+    write 'spec/xxx.rb', 'xxx'
+    result = run_tests
+    result.should include('No examples found')
+    result.should include('Took')
+  end
+
+  it "fails when tests fail" do
+    write 'spec/xxx_spec.rb', 'describe("it"){it("should"){puts "TEST1"}}'
+    write 'spec/xxx2_spec.rb', 'describe("it"){it("should"){1.should == 2}}'
+    result = run_tests
+
+    result.scan('1 example, 1 failure').size.should == 1
+    result.scan('1 example, 0 failure').size.should == 1
+    result.scan('2 examples, 1 failure').size.should == 1
+    $?.success?.should == false
+  end
+
+  it "can exec given commands with ENV['TEST_ENV_NUM']" do
+    result = `#{executable} -e 'ruby -e "print ENV[:TEST_ENV_NUMBER.to_s].to_i"' -n 4`
+    result.gsub('"','').split('').sort.should == %w[0 2 3 4]
+  end
+
+  it "can exec given command non-parallel" do
+    result = `#{executable} -e 'ruby -e "sleep(rand(10)/100.0); puts ENV[:TEST_ENV_NUMBER.to_s].inspect"' -n 4 --non-parallel`
+    result.split("\n").should == %w["" "2" "3" "4"]
+  end
+
+  it "exists with success if all sub-processes returned success" do
+    system("#{executable} -e 'cat /dev/null' -n 4").should == true
+  end
+
+  it "exists with failure if any sub-processes returned failure" do
+    system("#{executable} -e 'test -e xxxx' -n 4").should == false
+  end
+
+  it "can run through parallel_spec / parallel_cucumber" do
+    version = `#{executable} -v`
+    `#{bin_folder}/parallel_spec -v`.should == version
+    `#{bin_folder}/parallel_cucumber -v`.should == version
+  end
+
+  it "runs faster with more processes" do
+    2.times{|i|
+      write "spec/xxx#{i}_spec.rb",  'describe("it"){it("should"){sleep 5}}; $stderr.puts ENV["TEST_ENV_NUMBER"]'
+    }
+    t = Time.now
+    run_tests(:processes => 2)
+    expected = 10
+    (Time.now - t).should <= expected
+  end
+
+  it "can can with given files" do
+    write "spec/x1_spec.rb", "puts '111'"
+    write "spec/x2_spec.rb", "puts '222'"
+    write "spec/x3_spec.rb", "puts '333'"
+    result = run_tests(:add => 'spec/x1_spec.rb spec/x3_spec.rb')
+    result.should include('111')
+    result.should include('333')
+    result.should_not include('222')
+  end
+
+  it "can run with test-options" do
+    write "spec/x1_spec.rb", ""
+    write "spec/x2_spec.rb", ""
+    result = run_tests(:add => "--test-options ' --version'", :processes => 2)
+    result.should =~ /\d+\.\d+\.\d+.*\d+\.\d+\.\d+/m # prints version twice
+  end
+
+  it "runs with test::unit" do
+    write "test/x1_test.rb", "require 'test/unit'; class XTest < Test::Unit::TestCase; def test_xxx; end; end"
+    result = run_tests(:type => :test)
+    result.should include('1 test')
+    $?.success?.should == true
+  end
+
+  it "passes test options to test::unit" do
+    write "test/x1_test.rb", "require 'test/unit'; class XTest < Test::Unit::TestCase; def test_xxx; end; end"
+    result = run_tests(:type => :test, :add => '--test-options "-v"')
+    result.should include('test_xxx') # verbose output of every test
+  end
+end

data/spec/parallel_cucumber_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+describe ParallelCucumber do
+  test_tests_in_groups(ParallelCucumber, 'features', ".feature")
+
+  describe :run_tests do
+    before do
+      ParallelCucumber.stub!(:bundler_enabled?).and_return false
+      File.stub!(:file?).with('.bundle/environment.rb').and_return false
+      File.stub!(:file?).with('script/cucumber').and_return true
+    end
+
+    it "uses TEST_ENV_NUMBER=blank when called for process 0" do
+      ParallelCucumber.should_receive(:open).with{|x,y| x=~/TEST_ENV_NUMBER= /}.and_return mocked_process
+      ParallelCucumber.run_tests(['xxx'],0,{})
+    end
+
+    it "uses TEST_ENV_NUMBER=2 when called for process 1" do
+      ParallelCucumber.should_receive(:open).with{|x,y| x=~/TEST_ENV_NUMBER=2/}.and_return mocked_process
+      ParallelCucumber.run_tests(['xxx'],1,{})
+    end
+
+    it "returns the output" do
+      io = open('spec/spec_helper.rb')
+      ParallelCucumber.stub!(:print)
+      ParallelCucumber.should_receive(:open).and_return io
+      ParallelCucumber.run_tests(['xxx'],1,{})[:stdout].should =~ /\$LOAD_PATH << File/
+    end
+
+    it "runs bundle exec cucumber when on bundler 0.9" do
+      ParallelCucumber.stub!(:bundler_enabled?).and_return true
+      ParallelCucumber.should_receive(:open).with{|x,y| x =~ %r{bundle exec cucumber}}.and_return mocked_process
+      ParallelCucumber.run_tests(['xxx'],1,{})
+    end
+
+    it "runs script/cucumber when script/cucumber is found" do
+      ParallelCucumber.should_receive(:open).with{|x,y| x =~ %r{script/cucumber}}.and_return mocked_process
+      ParallelCucumber.run_tests(['xxx'],1,{})
+    end
+
+    it "runs cucumber by default" do
+      File.stub!(:file?).with('script/cucumber').and_return false
+      ParallelCucumber.should_receive(:open).with{|x,y| x !~ %r{(script/cucumber)|(bundle exec cucumber)}}.and_return mocked_process
+      ParallelCucumber.run_tests(['xxx'],1,{})
+    end
+
+    it "uses options passed in" do
+      ParallelCucumber.should_receive(:open).with{|x,y| x =~ %r{script/cucumber .* -p default}}.and_return mocked_process
+      ParallelCucumber.run_tests(['xxx'],1,:test_options => '-p default')
+    end
+  end
+
+  describe :find_results do
+    it "finds multiple results in test output" do
+      output = <<EOF
+And I should not see "/en/"                                       # features/step_definitions/webrat_steps.rb:87
+
+7 scenarios (3 failed, 4 passed)
+33 steps (3 failed, 2 skipped, 28 passed)
+/apps/rs/features/signup.feature:2
+    Given I am on "/"                                           # features/step_definitions/common_steps.rb:12
+    When I click "register"                                     # features/step_definitions/common_steps.rb:6
+    And I should have "2" emails                                # features/step_definitions/user_steps.rb:25
+
+4 scenarios (4 passed)
+40 steps (40 passed)
+
+EOF
+      ParallelCucumber.find_results(output).should == ["7 scenarios (3 failed, 4 passed)", "33 steps (3 failed, 2 skipped, 28 passed)", "4 scenarios (4 passed)", "40 steps (40 passed)"]
+    end
+  end
+end