parallelized_specs 0.0.8 → 0.1.6

data/Gemfile

@@ -0,0 +1,10 @@
+source :rubygems
+
+gem 'parallel'
+
+group :dev do
+  gem 'test-unit', :platform => :ruby_19
+  gem 'rspec', '>=2.4'
+  gem 'rake'
+  gem 'jeweler'
+end

data/Gemfile.lock

@@ -1,30 +1,7 @@
 GEM
-  remote: http://rubygems.org/
   specs:
-    diff-lcs (1.1.2)
-    git (1.2.5)
-    jeweler (1.6.3)
-      bundler (~> 1.0)
-      git (>= 1.2.5)
-      rake
-    parallel (0.5.1)
-    rake (0.8.7)
-    rspec (2.6.0)
-      rspec-core (~> 2.6.0)
-      rspec-expectations (~> 2.6.0)
-      rspec-mocks (~> 2.6.0)
-    rspec-core (2.6.4)
-    rspec-expectations (2.6.0)
-      diff-lcs (~> 1.1.2)
-    rspec-mocks (2.6.0)
-    test-unit (2.4.4)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
-  jeweler
-  parallel
-  rake
-  rspec (>= 2.4)
-  test-unit

data/Rakefile

@@ -12,7 +12,7 @@ begin
     gem.email    = "jake@instructure.com"
     gem.homepage = "http://github.com/jakesorce/#{gem.name}"
     gem.authors  = "Jake Sorce, Bryan Madsen"
-    gem.version = "0.0.8"
+    gem.version = "0.1.6"
   end
 
   Jeweler::GemcutterTasks.new

data/Readme.md

@@ -56,9 +56,7 @@ ParallelizedSpecs uses 1 database per test-process, 2 processes will use `*_test
     rake parallel:prepare
 
 ### 4: Run!
-    rake parallel:test          # Test::Unit
     rake parallel:spec          # RSpec
-    rake parallel:features      # Cucumber
 
     rake parallel:test[1] --> force 1 CPU --> 86 seconds
     rake parallel:test    --> got 2 CPUs? --> 47 seconds
@@ -67,7 +65,7 @@ ParallelizedSpecs uses 1 database per test-process, 2 processes will use `*_test
 
 Test by pattern (e.g. use one integration server per subfolder / see if you broke any 'user'-related tests)
 
-    rake parallel:test[^unit] # everything in test/unit folder (every test file matching /^unit/)
+    rake parallel:test[^unit] # everything in test/spec folder (every test file matching /^spec/)
     rake parallel:test[user]  # run users_controller + user_helper + user tests
     rake parallel:test['user|product']  # run user and product related tests
 
@@ -151,35 +149,6 @@ Setup for non-rails
 
     parallelized_specs test/bar test/baz/xxx_text_spec.rb
 
-Options are:
-
-    -n [PROCESSES]                   How many processes to use, default: available CPUs
-    -p, --path [PATH]                run tests inside this path only
-        --no-sort                    do not sort files before running them
-    -m, --multiply-processes [FLOAT] use given number as a multiplier of processes to run
-    -r, --root [PATH]                execute test commands from this path
-    -e, --exec [COMMAND]             execute this code parallel and with ENV['TEST_ENV_NUM']
-    -o, --test-options '[OPTIONS]'   execute test commands with those options
-    -t, --type [TYPE]                which type of tests to run? test, spec or features
-        --non-parallel               execute same commands but do not in parallel, needs --exec
-    -v, --version                    Show Version
-    -h, --help                       Show this.
-
-You can run any kind of code with -e / --execute
-
-    parallel_test -n 5 -e 'ruby -e "puts %[hello from process #{ENV[:TEST_ENV_NUMBER.to_s].inspect}]"'
-    hello from process "2"
-    hello from process ""
-    hello from process "3"
-    hello from process "5"
-    hello from process "4"
-
-<table>
-<tr><td></td><td>1 Process</td><td>2 Processes</td><td>4 Processes</td></tr>
-<tr><td>RSpec spec-suite</td><td>18s</td><td>14s</td><td>10s</td></tr>
-<tr><td>Rails-ActionPack</td><td>88s</td><td>53s</td><td>44s</td></tr>
-</table>
-
 TIPS
 ====
  - [RSpec] add a `spec/parallel_spec.opts` to use different options, e.g. no --drb (default: `spec/spec.opts`)

data/VERSION

@@ -1 +1 @@
-0.0.8
+0.1.6

data/lib/parallelized_specs/grouper.rb

@@ -12,9 +12,8 @@ class ParallelizedSpecs
       groups.map!(&:sort!)
     end
 
-    def self.in_even_groups_by_size(items_with_sizes, num_groups, options={})
+    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 }

data/lib/parallelized_specs/tasks.rb

@@ -1,19 +1,19 @@
+$LOAD_PATH << File.expand_path(File.join(File.dirname(__FILE__), '..'))
+require "parallelized_specs"
+
 namespace :parallel do
-  def run_in_parallel(cmd, options)
-    count = (options[:count] ? options[:count].to_i : nil)
-    executable = File.join(File.dirname(__FILE__), '..', '..', 'bin', 'parallelized_spec')
-    command = "#{executable} --exec '#{cmd}' -n #{count} #{'--non-parallel' if options[:non_parallel]}"
-    abort unless system(command)
+  def run_db_in_parallel(cmd, options={})
+    ParallelizedSpecs.execute_parallel_db(cmd, options)
   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)
+    run_db_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)
+    run_db_in_parallel('rake db:drop RAILS_ENV=test', args)
   end
 
   desc "update test databases by dumping and loading --> parallel:prepare[num_cpus]"
@@ -25,46 +25,27 @@ namespace :parallel do
     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)
+      run_db_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)
+    run_db_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)
+    run_db_in_parallel('rake db:test:load', args)
   end
 
   desc "run spec in parallel with parallel:spec[num_cpus]"
   task 'spec', :count, :pattern, :options, :arguments do |t, args|
-    $LOAD_PATH << File.expand_path(File.join(File.dirname(__FILE__), '..'))
-    require "parallelized_specs"
     count, pattern, options = ParallelizedSpecs.parse_rake_args(args)
-    executable = File.join(File.dirname(__FILE__), '..', '..', 'bin', 'parallelized_spec')
-    command = "#{executable} --type 'spec' -n #{count} -p '#{pattern}' -r '#{Rails.root}' -o '#{options}' #{args[:arguments]}"
-    abort unless system(command) # allow to chain tasks e.g. rake parallel:spec
+    #command = "-n #{count} -p '#{pattern}' -r '#{Rails.root}' -o '#{options}' #{args[:arguments]}"
+    opts = Hash[:count => count, :pattern => pattern, :options => options, :root => Rails.root, :files => args[:arguments]]
+    ParallelizedSpecs.execute_parallel_specs(opts)
   end
 end
-
-#backwards compatability
-#spec:parallel:prepare
-#spec: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

data/lib/parallelized_specs.rb

@@ -1,4 +1,6 @@
 require 'parallel'
+raise "please ' gem install parallel '" if Gem::Version.new(Parallel::VERSION) < Gem::Version.new('0.4.2')
+require 'optparse'
 require 'parallelized_specs/grouper'
 require 'parallelized_specs/railtie'
 require 'parallelized_specs/spec_error_logger'
@@ -51,6 +53,64 @@ class ParallelizedSpecs
     "_spec.rb"
   end
 
+  def self.execute_parallel_db(cmd, options={})
+    count = options[:count].to_i
+    count = Parallel.processor_count if count == 0
+    runs = (0...count).to_a
+    results = if options[:non_parallel]
+                runs.map do |i|
+                  execute_command(cmd, i, options)
+                end
+              else
+                Parallel.map(runs, :in_processes => count) do |i|
+                  execute_command(cmd, i, options)
+                end
+              end.flatten
+    abort if results.any? { |r| r[:exit_status] != 0 }
+  end
+
+  def self.execute_parallel_specs(options)
+    num_processes = options[:count] || Parallel.processor_count
+    lib, name, task = {
+        'spec' => %w(specs spec spec),
+    }[options[:type]||'spec']
+
+    start = Time.now
+
+    tests_folder = task
+    tests_folder = File.join(options[:root], tests_folder) unless options[:root].to_s.empty?
+    if options[:files].is_a?(Array)
+      groups = tests_in_groups(options[:files] || tests_folder, num_processes, options)
+    else
+      files_array = options[:files].split(/ /)
+      groups = tests_in_groups(files_array || tests_folder, num_processes, options)
+    end
+    num_processes = groups.size
+
+    #adjust processes to groups
+    abort "no #{name}s found!" if groups.size == 0
+
+    num_tests = groups.inject(0) { |sum, item| sum + item.size }
+    puts "#{num_processes} processes for #{num_tests} #{name}s, ~ #{num_tests / groups.size} #{name}s per process"
+
+    test_results = Parallel.map(groups, :in_processes => num_processes) do |group|
+      run_tests(group, groups.index(group), options)
+    end
+
+    #parse and print results
+    results = find_results(test_results.map { |result| result[:stdout] }*"")
+    puts ""
+    puts summarize_results(results)
+
+    #report total time taken
+    puts ""
+    puts "Took #{Time.now - start} seconds"
+
+    #exit with correct status code so rake parallel:test && echo 123 works
+    failed = test_results.any? { |result| result[:exit_status] != 0 }
+    abort "#{name.capitalize}s Failed" if failed
+  end
+
   # parallel:spec[:count, :pattern, :options]
   def self.parse_rake_args(args)
     # order as given by user
@@ -71,7 +131,7 @@ class ParallelizedSpecs
   end
 
   # finds all tests and partitions them into groups
-  def self.tests_in_groups(root, num_groups, options={})
+  def self.tests_in_groups(root, num_groups, options)
     tests = find_tests(root, options)
     if options[:no_sort]
       Grouper.in_groups(tests, num_groups)
@@ -184,15 +244,15 @@ class ParallelizedSpecs
     end
   end
 
-  def self.find_tests(root, options={})
+  def self.find_tests(root, options)
     if root.is_a?(Array)
       root
     else
       # follow one symlink and direct children
       # http://stackoverflow.com/questions/357754/can-i-traverse-symlinked-directories-in-ruby-with-a-glob
-      files = Dir["#{root}/**{,/*/**}/*#{test_suffix}"].uniq
+      files = Dir["#{Rails.root}/**{,/*/**}/*#{test_suffix}"].uniq
       files = files.map { |f| f.sub(root+'/', '') }
-      files = files.grep(/#{options[:pattern]}/)
+      files = files.grep(/#{options['pattern']}/)
       files.map { |f| "#{root}/#{f}" }
     end
   end

data/parallelized_specs.gemspec

@@ -5,20 +5,18 @@
 
 Gem::Specification.new do |s|
   s.name = "parallelized_specs"
-  s.version = "0.0.8"
+  s.version = "0.1.6"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Jake Sorce, Bryan Madsen"]
-  s.date = "2012-04-23"
+  s.date = "2012-04-27"
   s.email = "jake@instructure.com"
-  s.executables = ["parallelized_spec"]
   s.files = [
     "Gemfile",
     "Gemfile.lock",
     "Rakefile",
     "Readme.md",
     "VERSION",
-    "bin/parallelized_spec",
     "lib/parallelized_specs.rb",
     "lib/parallelized_specs/grouper.rb",
     "lib/parallelized_specs/railtie.rb",
@@ -48,9 +46,12 @@ Gem::Specification.new do |s|
     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
 

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: parallelized_specs
 version: !ruby/object:Gem::Version 
-  hash: 15
+  hash: 23
   prerelease: 
   segments: 
   - 0
-  - 0
-  - 8
-  version: 0.0.8
+  - 1
+  - 6
+  version: 0.1.6
 platform: ruby
 authors: 
 - Jake Sorce, Bryan Madsen
@@ -15,13 +15,26 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-04-23 00:00:00 Z
-dependencies: []
-
+date: 2012-04-27 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: parallel
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
 description: 
 email: jake@instructure.com
-executables: 
-- parallelized_spec
+executables: []
+
 extensions: []
 
 extra_rdoc_files: []
@@ -32,7 +45,6 @@ files:
 - Rakefile
 - Readme.md
 - VERSION
-- bin/parallelized_spec
 - lib/parallelized_specs.rb
 - lib/parallelized_specs/grouper.rb
 - lib/parallelized_specs/railtie.rb

data/bin/parallelized_spec

@@ -1,95 +0,0 @@
-#!/usr/bin/env ruby
-require 'rubygems'
-require 'optparse'
-require 'parallel'
-raise "please ' gem install parallel '" if Gem::Version.new(Parallel::VERSION) < Gem::Version.new('0.4.2')
-$LOAD_PATH << File.join(File.dirname(__FILE__), '..', 'lib')
-require "parallelized_specs"
-
-options = {}
-OptionParser.new do |opts|
-  opts.banner = <<BANNER
-Run all tests in parallel, giving each process ENV['TEST_ENV_NUMBER'] ('', '2', '3', ...)
-
-[optional] Only run selected files & folders:
-    parallelized_spec test/bar test/baz/xxx_text_spec.rb
-
-Options are:
-BANNER
-  opts.on("-n [PROCESSES]", Integer, "How many processes to use, default: available CPUs"){|n| options[:count] = n }
-  opts.on("-p", '--pattern [PATTERN]', "run tests matching this pattern"){|pattern| options[:pattern] = pattern }
-  opts.on("--no-sort", "do not sort files before running them"){ |no_sort| options[:no_sort] = no_sort }
-  opts.on("-m [FLOAT]", "--multiply-processes [FLOAT]", Float, "use given number as a multiplier of processes to run"){ |multiply| options[:multiply] = multiply }
-  opts.on("-r", '--root [PATH]', "execute test commands from this path"){|path| options[:root] = path }
-  opts.on("-s [PATTERN]", "--single [PATTERN]", "Run all matching files in only one process") do |pattern|
-    options[:single_process] ||= []
-    options[:single_process] << /#{pattern}/
-  end
-  opts.on("-e", '--exec [COMMAND]', "execute this code parallel and with ENV['TEST_ENV_NUM']"){|path| options[:execute] = path }
-  opts.on("-o", "--test-options '[OPTIONS]'", "execute test commands with those options"){|arg| options[:test_options] = arg }
-  opts.on("-t", "--type [TYPE]", "which type of tests to run? test, spec or features"){|type| options[:type] = type }
-  opts.on("--non-parallel", "execute same commands but do not in parallel, needs --exec"){ options[:non_parallel] = true }
-  opts.on("--chunk-timeout [TIMEOUT]", "timeout before re-printing the output of a child-process"){|timeout| options[:chunk_timeout] = timeout.to_f }
-  opts.on('-v', '--version', 'Show Version'){ puts ParallelizedSpecs::VERSION; exit}
-  opts.on("-h", "--help", "Show this.") { puts opts; exit }
-end.parse!
-
-raise "--no-sort and --single-process are not supported" if options[:no_sort] and options[:single_process]
-
-# get files to run from arguments
-options[:files] = ARGV if ARGV.size > 0
-
-num_processes = options[:count] || Parallel.processor_count
-num_processes = num_processes * (options[:multiply] || 1)
-
-if options[:execute]
-  runs = (0...num_processes).to_a
-  results = if options[:non_parallel]
-    runs.map do |i|
-      ParallelizedSpecs.execute_command(options[:execute], i, options)
-    end
-  else
-    Parallel.map(runs, :in_processes => num_processes) do |i|
-      ParallelizedSpecs.execute_command(options[:execute], i, options)
-    end
-  end.flatten
-  abort if results.any?{|r| r[:exit_status] != 0 }
-else
-  lib, name, task = {
-    'spec' => %w(specs spec spec),
-  }[options[:type]||'spec']
-
-  require "parallelized_#{lib}"
-  klass = eval("Parallelized#{lib.capitalize}")
-
-  start = Time.now
-
-  tests_folder = task
-  tests_folder = File.join(options[:root], tests_folder) unless options[:root].to_s.empty?
-
-  groups = klass.tests_in_groups(options[:files] || tests_folder, num_processes, options)
-  num_processes = groups.size
-
-  #adjust processes to groups
-  abort "no #{name}s found!" if groups.size == 0
-
-  num_tests = groups.inject(0){|sum,item| sum + item.size }
-  puts "#{num_processes} processes for #{num_tests} #{name}s, ~ #{num_tests / groups.size} #{name}s per process"
-
-  test_results = Parallel.map(groups, :in_processes => num_processes) do |group|
-    klass.run_tests(group, groups.index(group), options)
-  end
-
-  #parse and print results
-  results = klass.find_results(test_results.map{|result| result[:stdout] }*"")
-  puts ""
-  puts klass.summarize_results(results)
-
-  #report total time taken
-  puts ""
-  puts "Took #{Time.now - start} seconds"
-
-  #exit with correct status code so rake parallel:test && echo 123 works
-  failed = test_results.any?{|result| result[:exit_status] != 0 }
-  abort "#{name.capitalize}s Failed" if failed
-end