parallel_tests 0.5.0 → 0.6.0

data/Readme.md

@@ -61,13 +61,12 @@ OR as plugin
     rake parallel:test    --> got 4 CPUs? --> 26 seconds
     ...
 
-Test just a subfolder (e.g. use one integration server per subfolder)
+Test by pattern (e.g. use one integration server per subfolder / see if you broke any user-related tests)
 
-    rake parallel:test[models]
-    rake parallel:test[something/else]
+    rake parallel:test[^unit] # everything in test/unit folder (every test file matching /^unit/)
+    rake parallel:test[user]  # run users_controller + user_helper + user tests
+    rake parallel:test['user|product']  # run user and product related tests
 
-    partial paths are OK too...
-    rake parallel:test[functional] == rake parallel:test[fun]
 
 Example output
 --------------

data/VERSION

@@ -1 +1 @@
-0.5.0
+0.6.0

data/bin/parallel_test

@@ -17,7 +17,7 @@ Run all tests in parallel, giving each process ENV['TEST_ENV_NUMBER'] ('', '2',
 Options are:
 BANNER
   opts.on("-n [PROCESSES]", Integer, "How many processes to use, default: available CPUs"){|n| options[:count] = n }
-  opts.on("-p", '--path [PATH]', "run tests inside this path only"){|path| options[:path_prefix] = path }
+  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 }
@@ -60,10 +60,10 @@ else
 
   start = Time.now
 
-  tests_folder = File.join(task, options[:path_prefix].to_s)
+  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, :no_sort => options[:no_sort])
+  groups = klass.tests_in_groups(options[:files] || tests_folder, num_processes, :no_sort => options[:no_sort], :pattern => options[:pattern])
   num_processes = groups.size
 
   #adjust processes to groups

data/lib/parallel_tests.rb

@@ -5,26 +5,31 @@ require 'parallel_tests/railtie'
 class ParallelTests
   VERSION = File.read( File.join(File.dirname(__FILE__),'..','VERSION') ).strip
 
-  # parallel:spec[2,controller] <-> parallel:spec[controller]
+  # parallel:spec[:count, :pattern, :options]
   def self.parse_rake_args(args)
-    num_processes = Parallel.processor_count
-    options = ""
-    if args[:count].to_s =~ /^\d*$/ # number or empty
-      num_processes = args[:count] unless args[:count].to_s.empty?
-      prefix = args[:path_prefix]
-      options = args[:options] if args[:options]
-    else # something stringy
-      prefix = args[:count]
-    end
-    [num_processes.to_i, prefix.to_s, options]
+    # 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_s.empty? ? Parallel.processor_count : count.to_i)
+
+    pattern = args.shift
+    options = args.shift
+
+    [num_processes.to_i, pattern.to_s, options.to_s]
   end
 
   # finds all tests and partitions them into groups
   def self.tests_in_groups(root, num_groups, options={})
+    tests = find_tests(root, options)
     if options[:no_sort] == true
-      Grouper.in_groups(find_tests(root), num_groups)
+      Grouper.in_groups(tests, num_groups)
     else
-      Grouper.in_even_groups_by_size(tests_with_runtime(root), num_groups)
+      tests = with_runtime_info(tests)
+      Grouper.in_even_groups_by_size(tests, num_groups)
     end
   end
 
@@ -91,7 +96,7 @@ class ParallelTests
 
   # copied from http://github.com/carlhuda/bundler Bundler::SharedHelpers#find_gemfile
   def self.bundler_enabled?
-    return true if Object.const_defined?(:Bundler) 
+    return true if Object.const_defined?(:Bundler)
 
     previous = nil
     current = File.expand_path(Dir.pwd)
@@ -113,8 +118,7 @@ class ParallelTests
     "_test.rb"
   end
 
-  def self.tests_with_runtime(root)
-    tests = find_tests(root)
+  def self.with_runtime_info(tests)
     lines = File.read(runtime_log).split("\n") rescue []
 
     # use recorded test runtime if we got enough data
@@ -131,11 +135,16 @@ class ParallelTests
     end
   end
 
-  def self.find_tests(root)
+  def self.find_tests(root, options={})
     if root.is_a?(Array)
       root
     else
-      Dir["#{root}**/**/*#{self.test_suffix}"]
+      # 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 = files.map{|f| f.sub(root+'/','') }
+      files = files.grep(/#{options[:pattern]}/)
+      files.map{|f| "#{root}/#{f}" }
     end
   end
 end

data/lib/parallel_tests/tasks.rb

@@ -43,12 +43,12 @@ namespace :parallel do
 
   ['test', 'spec', 'features'].each do |type|
     desc "run #{type} in parallel with parallel:#{type}[num_cpus]"
-    task type, :count, :path_prefix, :options do |t,args|
+    task type, :count, :pattern, :options do |t,args|
       $LOAD_PATH << File.expand_path(File.join(File.dirname(__FILE__), '..'))
       require "parallel_tests"
-      count, prefix, options = ParallelTests.parse_rake_args(args)
+      count, pattern, options = ParallelTests.parse_rake_args(args)
       executable = File.join(File.dirname(__FILE__), '..', '..', 'bin', 'parallel_test')
-      command = "#{executable} --type #{type} -n #{count} -p '#{prefix}' -r '#{Rails.root}' -o '#{options}'"
+      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
@@ -66,15 +66,15 @@ namespace :spec do
     end
   end
 
-  task :parallel, :count, :path_prefix do |t,args|
+  task :parallel, :count, :pattern do |t,args|
     $stderr.puts "WARNING -- Deprecated! use parallel:spec"
-    Rake::Task['parallel:spec'].invoke(args[:count], args[:path_prefix])
+    Rake::Task['parallel:spec'].invoke(args[:count], args[:pattern])
   end
 end
 
 namespace :test do
-  task :parallel, :count, :path_prefix do |t,args|
+  task :parallel, :count, :pattern do |t,args|
     $stderr.puts "WARNING -- Deprecated! use parallel:test"
-    Rake::Task['parallel:test'].invoke(args[:count], args[:path_prefix])
+    Rake::Task['parallel:test'].invoke(args[:count], args[:pattern])
   end
 end

data/parallel_tests.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{parallel_tests}
-  s.version = "0.5.0"
+  s.version = "0.6.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Michael Grosser"]
-  s.date = %q{2011-07-03}
+  s.date = %q{2011-08-09}
   s.email = %q{grosser.michael@gmail.com}
   s.executables = ["parallel_cucumber", "parallel_test", "parallel_spec"]
   s.files = [

data/spec/integration_spec.rb

@@ -59,8 +59,8 @@ describe 'CLI' do
   end
 
   it "can exec given commands with ENV['TEST_ENV_NUM']" do
-    result = `#{executable} -e 'ruby -e "puts ENV[:TEST_ENV_NUMBER.to_s].inspect"' -n 4`
-    result.split("\n").sort.should == %w["" "2" "3" "4"]
+    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
@@ -83,14 +83,11 @@ describe 'CLI' do
   end
 
   it "runs faster with more processes" do
-    write 'xxx_spec.rb', 'describe("it"){it("should"){sleep 2}}'
-    write 'xxx2_spec.rb', 'describe("it"){it("should"){sleep 2}}'
-    write 'xxx3_spec.rb', 'describe("it"){it("should"){sleep 2}}'
-    write 'xxx4_spec.rb', 'describe("it"){it("should"){sleep 2}}'
-    write 'xxx5_spec.rb', 'describe("it"){it("should"){sleep 2}}'
-    write 'xxx6_spec.rb', 'describe("it"){it("should"){sleep 2}}'
+    2.times{|i|
+      write "xxx#{i}_spec.rb",  'describe("it"){it("should"){sleep 5}}; $stderr.puts ENV["TEST_ENV_NUMBER"]'
+    }
     t = Time.now
-    run_specs :processes => 6
+    puts run_specs(:processes => 2)
     expected = 10
     (Time.now - t).should <= expected
   end

data/spec/parallel_tests_spec.rb

@@ -14,13 +14,13 @@ describe ParallelTests do
       ParallelTests.parse_rake_args(args).should == [Parallel.processor_count, "models", ""]
     end
 
-    it "should return the count and prefix" do
-      args = {:count => 2, :path_prefix => "models"}
+    it "should return the count and pattern" do
+      args = {:count => 2, :pattern => "models"}
       ParallelTests.parse_rake_args(args).should == [2, "models", ""]
     end
 
-    it "should return the count, prefix, and options" do
-      args = {:count => 2, :path_prefix => "plain", :options => "-p default" }
+    it "should return the count, pattern, and options" do
+      args = {:count => 2, :pattern => "plain", :options => "-p default" }
       ParallelTests.parse_rake_args(args).should == [2, "plain", "-p default"]
     end
   end
@@ -136,6 +136,54 @@ EOF
     end
   end
 
+  describe :find_tests do
+    it "returns if root is an array" do
+      ParallelTests.send(:find_tests, [1]).should == [1]
+    end
+
+    it "finds all test files" do
+      begin
+        root = "/tmp/test-find_tests-#{rand(999)}"
+        `mkdir #{root}`
+        `mkdir #{root}/a`
+        `mkdir #{root}/b`
+        `touch #{root}/x_test.rb`
+        `touch #{root}/a/x_test.rb`
+        `touch #{root}/a/test.rb`
+        `touch #{root}/b/y_test.rb`
+        `touch #{root}/b/test.rb`
+        `ln -s #{root}/b #{root}/c`
+        `ln -s #{root}/b #{root}/a/`
+        ParallelTests.send(:find_tests, root).sort.should == [
+          "#{root}/a/b/y_test.rb",
+          "#{root}/a/x_test.rb",
+          "#{root}/b/y_test.rb",
+          "#{root}/c/y_test.rb",
+          "#{root}/x_test.rb"
+        ]
+      ensure
+        `rm -rf #{root}`
+      end
+    end
+
+    it "finds files by pattern" do
+      begin
+        root = "/tmp/test-find_tests-#{rand(999)}"
+        `mkdir #{root}`
+        `mkdir #{root}/a`
+        `touch #{root}/a/x_test.rb`
+        `touch #{root}/a/y_test.rb`
+        `touch #{root}/a/z_test.rb`
+        ParallelTests.send(:find_tests, root, :pattern => '^a/(y|z)_test').sort.should == [
+          "#{root}/a/y_test.rb",
+          "#{root}/a/z_test.rb",
+        ]
+      ensure
+        `rm -rf #{root}`
+      end
+    end
+  end
+
   it "has a version" do
     ParallelTests::VERSION.should =~ /^\d+\.\d+\.\d+$/
   end

data/spec/spec_helper.rb

@@ -64,7 +64,7 @@ def test_tests_in_groups(klass, folder, suffix)
 
     it "groups when given an array of files" do
       list_of_files = Dir["#{test_root}/**/*#{suffix}"]
-      found = klass.tests_with_runtime(list_of_files)
+      found = klass.with_runtime_info(list_of_files)
       found.should =~ list_of_files.map{ |file| [file, File.stat(file).size]}
     end
 

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: parallel_tests
 version: !ruby/object:Gem::Version 
-  hash: 11
+  hash: 7
   prerelease: 
   segments: 
   - 0
-  - 5
+  - 6
   - 0
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors: 
 - Michael Grosser
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-07-03 00:00:00 +02:00
+date: 2011-08-09 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency