parallel_tests 0.7.0.alpha → 0.7.0.alpha2

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    parallel_tests (0.7.0.alpha)
+    parallel_tests (0.7.0.alpha2)
       parallel
 
 GEM

data/Readme.md

@@ -3,8 +3,9 @@ ParallelTests splits tests into even groups(by number of tests or runtime) and r
 
 Setup for Rails
 ===============
+[still using Rails 2?](https://github.com/grosser/parallel_tests/blob/master/ReadmeRails2.md)
+
 ## Install
-### Rails 3
 If you use RSpec: ensure you got >= 2.4
 
 As gem
@@ -19,28 +20,6 @@ OR as plugin
     # add to Gemfile
     gem "parallel", :group => :development
 
-
-### Rails 2
-
-As gem
-
-    gem install parallel_tests
-
-    # add to config/environments/development.rb
-    config.gem "parallel_tests"
-
-    # add to Rakefile
-    begin; require 'parallel_tests/tasks'; rescue LoadError; end
-
-OR as plugin
-
-    gem install parallel
-
-    # add to config/environments/development.rb
-    config.gem "parallel"
-
-    ./script/plugin install git://github.com/grosser/parallel_tests.git
-
 ## Setup
 ParallelTests uses 1 database per test-process, 2 processes will use `*_test` and `*_test2`.
 
@@ -91,17 +70,14 @@ Log test runtime to give each process the same runtime.
 
 Rspec: Add to your `.rspec_parallel` (or `.rspec`) :
 
-    RSpec 1.x:
-      --format progress
-      --require parallel_tests/spec/runtime_logger
-      --format ParallelTests::Spec::RuntimeLogger:tmp/parallel_profile.log
-    RSpec >= 2.4:
+    RSpec
       If installed as plugin: -I vendor/plugins/parallel_tests/lib
       --format progress
       --format ParallelTests::Spec::RuntimeLogger --out tmp/parallel_profile.log
 
 Test::Unit:  Add to your `test_helper.rb`:
-    require 'parallel_tests/runtime_logger'
+
+    require 'parallel_tests/test/runtime_logger'
 
 
 SpecSummaryLogger
@@ -111,11 +87,7 @@ This logger logs the test output without the different processes overwriting eac
 
 Add the following to your `.rspec_parallel` (or `.rspec`) :
 
-    RSpec 1.x:
-      --format progress
-      --require parallel_tests/spec/summary_logger
-      --format ParallelTests::Spec::SummaryLogger:tmp/spec_summary.log
-    RSpec >= 2.2:
+    RSpec:
       If installed as plugin: -I vendor/plugins/parallel_tests/lib
       --format progress
       --format ParallelTests::Spec::SummaryLogger --out tmp/spec_summary.log
@@ -131,23 +103,21 @@ E.g.
 
 Add the following to your `.rspec_parallel` (or `.rspec`) :
 
-    RSpec 1.x:
-      --format progress
-      --require parallel_tests/spec/failures_logger
-      --format ParallelTests::Spec::FailuresLogger:tmp/failing_specs.log
-    RSpec >= 2.4:
+    RSpec:
       If installed as plugin: -I vendor/plugins/parallel_tests/lib
       --format progress
       --format ParallelTests::Spec::FailuresLogger --out tmp/failing_specs.log
 
 Setup for non-rails
 ===================
-    sudo gem install parallel_tests
+    gem install parallel_tests
     # go to your project dir
-    parallel_test OR parallel_spec OR parallel_cucumber
-    # [Optional] use ENV['TEST_ENV_NUMBER'] inside your tests to select separate db/memcache/etc.
+    parallel_test test/
+    parallel_spec spec/
+    parallel_cucumber features/
 
-[optional] Only run selected files & folders:
+ - use ENV['TEST_ENV_NUMBER'] inside your tests to select separate db/memcache/etc.
+ - Only run selected files & folders:
 
     parallel_test test/bar test/baz/foo_text.rb
 
@@ -157,15 +127,14 @@ Options are:
     -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
+    -t, --type [TYPE]                test(default) / spec / cucumber
         --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
+You can run any kind of code in parallel 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"
@@ -183,11 +152,9 @@ You can run any kind of code with -e / --execute
 TIPS
 ====
  - [Capybara + Selenium] add to env.rb: `Capybara.server_port = 8888 + ENV['TEST_ENV_NUMBER'].to_i`
- - [RSpec] add a `spec/parallel_spec.opts` to use different options, e.g. no --drb (default: `spec/spec.opts`)
- - [RSpec] if something looks fishy try to delete `script/spec`
- - [RSpec] if `script/spec` is missing parallel:spec uses just `spec` (which solves some issues with double-loaded environment.rb)
- - [RSpec] 'script/spec_server' or [spork](http://github.com/timcharper/spork/tree/master) do not work in parallel
- - [RSpec] `./script/generate rspec` if you are running rspec from gems (this plugin uses script/spec which may fail if rspec files are outdated)
+ - [RSpec] add a `.rspec_parallel` to use different options, e.g. **no --drb**
+ - [RSpec] delete `script/spec`
+ - [RSpec] [spork](https://github.com/timcharper/spork) does not work in parallel
  - [RSpec] remove --loadby from you spec/*.opts
  - [Bundler] if you have a `Gemfile` then `bundle exec` will be used to run tests
  - [Capybara setup](https://github.com/grosser/parallel_tests/wiki)
@@ -196,11 +163,11 @@ TIPS
  - [SQL schema format] use :ruby schema format to get faster parallel:prepare`
  - [ActiveRecord] if you do not have `db:abort_if_pending_migrations` add this to your Rakefile: `task('db:abort_if_pending_migrations'){}`
  - `export PARALLEL_TEST_PROCESSORS=X` in your environment and parallel_tests will use this number of processors by default
- - with zsh this would be `rake "parallel:prepare[3]"`
+ - [ZSH] use quotes to use rake arguments `rake "parallel:prepare[3]"`
 
 TODO
 ====
- - move everything Rails 2 related to a e.g. Rails2Readme.md and link it
+ - document how to use cucumber runtime logger
  - unify runtime-log location
  - add tests for cucumber runtime formatter
  - make jRuby compatible [basics](http://yehudakatz.com/2009/07/01/new-rails-isolation-testing/)
@@ -240,5 +207,4 @@ inspired by [pivotal labs](http://pivotallabs.com/users/miked/blog/articles/849-
 
 [Michael Grosser](http://grosser.it)<br/>
 michael@grosser.it<br/>
-Hereby placed under public domain, do what you want, just do not hold me accountable...<br/>
-[![Flattr](http://api.flattr.com/button/flattr-badge-large.png)](https://flattr.com/submit/auto?user_id=grosser&url=https://github.com/grosser/parallel_tests&title=parallel_tests&language=en_GB&tags=github&category=software)
+License: MIT

data/ReadmeRails2.md

@@ -0,0 +1,44 @@
+### Install
+
+As gem
+
+    gem install parallel_tests
+
+    # add to config/environments/development.rb
+    config.gem "parallel_tests"
+
+    # add to Rakefile
+    begin; require 'parallel_tests/tasks'; rescue LoadError; end
+
+OR as plugin
+
+    gem install parallel
+
+    # add to config/environments/development.rb
+    config.gem "parallel"
+
+    ./script/plugin install git://github.com/grosser/parallel_tests.git
+
+Even process runtimes
+-----------------
+
+    RSpec 1.x:
+      --format progress
+      --require parallel_tests/spec/runtime_logger
+      --format ParallelTests::Spec::RuntimeLogger:tmp/parallel_profile.log
+
+SpecSummaryLogger
+--------------------
+
+    RSpec 1.x:
+      --format progress
+      --require parallel_tests/spec/summary_logger
+      --format ParallelTests::Spec::SummaryLogger:tmp/spec_summary.log
+
+SpecFailuresLogger
+-----------------------
+
+    RSpec 1.x:
+      --format progress
+      --require parallel_tests/spec/failures_logger
+      --format ParallelTests::Spec::FailuresLogger:tmp/failing_specs.log

data/bin/parallel_cucumber

@@ -1,2 +1,2 @@
 #!/usr/bin/env ruby
-exec "#{File.join(File.dirname(__FILE__), 'parallel_test')} -t features #{ARGV * ' '}"
+exec "#{File.join(File.dirname(__FILE__), 'parallel_test')} -t cucumber #{ARGV * ' '}"

data/lib/parallel_tests/cli.rb

@@ -4,6 +4,51 @@ require 'parallel_tests/test/runner'
 module ParallelTest
   module CLI
     def self.run(argv)
+      options = parse_options!(argv)
+      test_results = nil
+
+      num_processes = ParallelTests.determine_number_of_processes(options[:count])
+      num_processes = num_processes * (options[:multiply] || 1)
+
+      if options[:execute]
+        execute_shell_command_in_parallel(options[:execute], num_processes, options)
+      else
+        lib = options[:type] || 'test'
+        require "parallel_tests/#{lib}/runner"
+        runner = eval("ParallelTests::#{lib.capitalize}::Runner")
+        name = runner.test_file_name
+
+        report_time_taken do
+          groups = runner.tests_in_groups(options[:files], num_processes, options)
+          abort "no #{name}s found!" if groups.size == 0
+
+          num_processes = groups.size
+          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|
+            if group.empty?
+              {:stdout => '', :exit_status => 0}
+            else
+              runner.run_tests(group, groups.index(group), options)
+            end
+          end
+
+          #parse and print results
+          results = runner.find_results(test_results.map { |result| result[:stdout] }*"")
+          puts ""
+          puts runner.summarize_results(results)
+        end
+
+        #exit with correct status code so rake parallel:test && echo 123 works
+        failed = test_results.any? { |result| result[:exit_status] != 0 }
+        abort "#{lib.capitalize}s Failed" if failed
+      end
+    end
+
+    private
+
+    def self.parse_options!(argv)
       options = {}
       OptionParser.new do |opts|
         opts.banner = <<BANNER
@@ -18,14 +63,13 @@ BANNER
         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("-t", "--type [TYPE]", "test(default) / spec / cucumber") { |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 ParallelTests::VERSION; exit }
@@ -34,69 +78,30 @@ BANNER
 
       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 = ParallelTests.determine_number_of_processes(options[:count])
-      num_processes = num_processes * (options[:multiply] || 1)
+      options[:files] = argv
+      options
+    end
 
-      if options[:execute]
-        runs = (0...num_processes).to_a
-        results = if options[:non_parallel]
-          runs.map do |i|
-            ParallelTests::Test::Runner.execute_command(options[:execute], i, options)
-          end
-        else
-          Parallel.map(runs, :in_processes => num_processes) do |i|
-            ParallelTests::Test::Runner.execute_command(options[:execute], i, options)
-          end
-        end.flatten
-        abort if results.any? { |r| r[:exit_status] != 0 }
+    def self.execute_shell_command_in_parallel(command, num_processes, options)
+      runs = (0...num_processes).to_a
+      results = if options[:non_parallel]
+        runs.map do |i|
+          ParallelTests::Test::Runner.execute_command(command, i, options)
+        end
       else
-        lib, name, task = {
-          'test' => ["test", "test", "test"],
-          'spec' => ["spec", "spec", "spec"],
-          'features' => ["cucumber", "feature", "features"]
-        }[options[:type]||'test']
-
-        require "parallel_tests/#{lib}/runner"
-        klass = eval("ParallelTests::#{lib.capitalize}::Runner")
-
-        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|
-          if group.empty?
-            {:stdout => '', :exit_status => 0}
-          else
-            klass.run_tests(group, groups.index(group), options)
-          end
+        Parallel.map(runs, :in_processes => num_processes) do |i|
+          ParallelTests::Test::Runner.execute_command(command, i, options)
         end
+      end.flatten
 
-        #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"
+      abort if results.any? { |r| r[:exit_status] != 0 }
+    end
 
-        #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
+    def self.report_time_taken
+      start = Time.now
+      yield
+      puts ""
+      puts "Took #{Time.now - start} seconds"
     end
   end
 end

data/lib/parallel_tests/cucumber/runner.rb

@@ -26,7 +26,9 @@ module ParallelTests
         'tmp/parallel_runtime_cucumber.log'
       end
 
-      protected
+      def self.test_file_name
+        "feature"
+      end
 
       def self.test_suffix
         ".feature"

data/lib/parallel_tests/spec/runner.rb

@@ -27,7 +27,15 @@ module ParallelTests
         'tmp/parallel_profile.log'
       end
 
-      protected
+      def self.test_file_name
+        "spec"
+      end
+
+      def self.test_suffix
+        "_spec.rb"
+      end
+
+      private
 
       # so it can be stubbed....
       def self.run(cmd)
@@ -47,10 +55,6 @@ module ParallelTests
         return unless options_file
         "-O #{options_file}"
       end
-
-      def self.test_suffix
-        "_spec.rb"
-      end
     end
   end
 end

data/lib/parallel_tests/tasks.rb

@@ -47,8 +47,9 @@ namespace :parallel do
       $LOAD_PATH << File.expand_path(File.join(File.dirname(__FILE__), '..'))
       require "parallel_tests"
       count, pattern, options = ParallelTests.parse_rake_args(args)
+      test_type = (type == 'features' ? 'cucumber' : type)
       executable = File.join(File.dirname(__FILE__), '..', '..', 'bin', 'parallel_test')
-      command = "#{executable} --type #{type} -n #{count} -p '#{pattern}' -r '#{Rails.root}' -o '#{options}'"
+      command = "#{executable} '#{Rails.root}/#{type}' --type #{test_type} -n #{count} -p '#{pattern}' -o '#{options}'"
       abort unless system(command) # allow to chain tasks e.g. rake parallel:spec parallel:features
     end
   end

data/lib/parallel_tests/test/runner.rb

@@ -1,9 +1,36 @@
 module ParallelTests
   module Test
     class Runner
+      # --- usually overwritten by other runners
+
+      def self.runtime_log
+        'tmp/parallel_runtime_test.log'
+      end
+
+      def self.test_suffix
+        "_test.rb"
+      end
+
+      def self.test_file_name
+        "test"
+      end
+
+      def self.run_tests(test_files, process_number, options)
+        require_list = test_files.map { |filename| %{"#{File.expand_path filename}"} }.join(",")
+        cmd = "ruby -Itest -e '[#{require_list}].each {|f| require f }' -- #{options[:test_options]}"
+        execute_command(cmd, process_number, options)
+      end
+
+      def self.line_is_result?(line)
+        line =~ /\d+ failure/
+      end
+
+      # --- usually used by other runners
+
       # finds all tests and partitions them into groups
-      def self.tests_in_groups(root, num_groups, options={})
-        tests = find_tests(root, options)
+      def self.tests_in_groups(tests, num_groups, options={})
+        tests = find_tests(tests, options)
+
         if options[:no_sort] == true
           Grouper.in_groups(tests, num_groups)
         else
@@ -12,12 +39,6 @@ module ParallelTests
         end
       end
 
-      def self.run_tests(test_files, process_number, options)
-        require_list = test_files.map { |filename| %{"#{File.expand_path filename}"} }.join(",")
-        cmd = "ruby -Itest -e '[#{require_list}].each {|f| require f }' -- #{options[:test_options]}"
-        execute_command(cmd, process_number, options)
-      end
-
       def self.execute_command(cmd, process_number, options)
         cmd = "TEST_ENV_NUMBER=#{test_env_number(process_number)} ; export TEST_ENV_NUMBER; #{cmd}"
         f = open("|#{cmd}", 'r')
@@ -38,10 +59,6 @@ module ParallelTests
         process_number == 0 ? '' : process_number + 1
       end
 
-      def self.runtime_log
-        'tmp/parallel_runtime_test.log'
-      end
-
       def self.summarize_results(results)
         results = results.join(' ').gsub(/s\b/,'') # combine and singularize results
         counts = results.scan(/(\d+) (\w+)/)
@@ -83,14 +100,6 @@ module ParallelTests
         all
       end
 
-      def self.line_is_result?(line)
-        line =~ /\d+ failure/
-      end
-
-      def self.test_suffix
-        "_test.rb"
-      end
-
       def self.with_runtime_info(tests)
         lines = File.read(runtime_log).split("\n") rescue []
 
@@ -109,17 +118,23 @@ module ParallelTests
         end
       end
 
-      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 = files.map{|f| f.sub(root+'/','') }
-          files = files.grep(/#{options[:pattern]}/)
-          files.map{|f| "#{root}/#{f}" }
-        end
+      def self.find_tests(tests, options={})
+        (tests||[]).map do |file_or_folder|
+          if File.directory?(file_or_folder)
+            tests_in_folder(file_or_folder, options)
+          else
+            file_or_folder
+          end
+        end.flatten.uniq
+      end
+
+      def self.tests_in_folder(folder, options)
+        # follow one symlink and direct children
+        # http://stackoverflow.com/questions/357754/can-i-traverse-symlinked-directories-in-ruby-with-a-glob
+        files = Dir["#{folder}/**{,/*/**}/*#{test_suffix}"].uniq
+        files = files.map{|f| f.sub(folder+'/','') }
+        files = files.grep(/#{options[:pattern]}/)
+        files.map{|f| "#{folder}/#{f}" }
       end
     end
   end

data/lib/parallel_tests/version.rb

@@ -1,3 +1,3 @@
 module ParallelTests
-  VERSION = Version = '0.7.0.alpha'
+  VERSION = Version = '0.7.0.alpha2'
 end

data/parallel_tests.gemspec

@@ -3,7 +3,7 @@ name = "parallel_tests"
 require "#{name}/version"
 
 Gem::Specification.new name, ParallelTests::VERSION do |s|
-  s.summary = "Run tests / specs / features in parallel"
+  s.summary = "Run Test::Unit / RSpec / Cucumber in parallel"
   s.authors = ["Michael Grosser"]
   s.email = "michael@grosser.it"
   s.homepage = "http://github.com/grosser/#{name}"

data/spec/integration_spec.rb

@@ -15,7 +15,7 @@ describe 'CLI' do
 
   def write(file, content)
     path = "#{folder}/#{file}"
-    `mkdir -p #{File.dirname(path)}` unless File.exist?(File.dirname(path))
+    ensure_folder File.dirname(path)
     File.open(path, 'w'){|f| f.write content }
     path
   end
@@ -28,15 +28,22 @@ describe 'CLI' do
     "#{bin_folder}/parallel_test"
   end
 
-  def run_tests(options={})
+  def ensure_folder(folder)
+    `mkdir -p #{folder}` unless File.exist?(folder)
+  end
+
+  def run_tests(test_folder, options={})
+    ensure_folder folder
     processes = "-n #{options[:processes]||2}" unless options[:processes] == false
-    `cd #{folder} && #{options[:export]} #{executable} --chunk-timeout 999 -t #{options[:type] || 'spec'} #{processes} #{options[:add]} 2>&1`
+    result = `cd #{folder} && #{options[:export]} #{executable} #{test_folder} --chunk-timeout 999 -t #{options[:type] || 'spec'} #{processes} #{options[:add]} 2>&1`
+    raise "FAILED #{result}" if $?.success? == !!options[:fail]
+    result
   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
+    result = run_tests "spec"
 
     # test ran and gave their puts
     result.should include('TEST1')
@@ -47,12 +54,11 @@ describe 'CLI' do
     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_spec.rb', '1'
-    result = run_tests
+    result = run_tests "spec"
     result.should include('No examples found')
     result.should include('Took')
   end
@@ -60,12 +66,11 @@ describe 'CLI' do
   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 = run_tests "spec", :fail => true
 
     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
@@ -101,7 +106,7 @@ describe 'CLI' do
       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)
+    run_tests("spec", :processes => 2)
     expected = 10
     (Time.now - t).should <= expected
   end
@@ -110,16 +115,22 @@ describe 'CLI' 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 = run_tests("spec/x1_spec.rb spec/x3_spec.rb")
     result.should include('111')
     result.should include('333')
     result.should_not include('222')
   end
 
+  it "runs successfully without any files" do
+    results = run_tests("")
+    results.should include("2 processes for 0 specs")
+    results.should include("Took")
+  end
+
   it "can run with test-options" do
     write "spec/x1_spec.rb", "111"
     write "spec/x2_spec.rb", "111"
-    result = run_tests(:add => "--test-options ' --version'", :processes => 2)
+    result = run_tests("spec", :add => "--test-options ' --version'", :processes => 2)
     result.should =~ /\d+\.\d+\.\d+.*\d+\.\d+\.\d+/m # prints version twice
   end
 
@@ -128,23 +139,28 @@ describe 'CLI' do
     processes.times{|i|
       write "spec/x#{i}_spec.rb", "puts %{ENV-\#{ENV['TEST_ENV_NUMBER']}-}"
     }
-    result = run_tests(:export => "PARALLEL_TEST_PROCESSORS=#{processes}", :processes => processes)
+    result = run_tests("spec", :export => "PARALLEL_TEST_PROCESSORS=#{processes}", :processes => processes)
     result.scan(/ENV-.?-/).should =~ ["ENV--", "ENV-2-", "ENV-3-", "ENV-4-", "ENV-5-"]
   end
 
   context "Test::Unit" do
     it "runs" 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 = run_tests("test", :type => :test)
       result.should include('1 test')
-      $?.success?.should == true
     end
 
     it "passes test options" 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 = run_tests("test", :type => :test, :add => '--test-options "-v"')
       result.should include('test_xxx') # verbose output of every test
     end
+
+    it "runs successfully without any files" do
+      results = run_tests("", :type => "test")
+      results.should include("2 processes for 0 tests")
+      results.should include("Took")
+    end
   end
 
   context "Cucumber" do
@@ -154,8 +170,7 @@ describe 'CLI' do
       write "features/b.feature", "Feature: xxx\n  Scenario: xxx\n    Given I FAIL"
       write "features/steps/a.rb", "Given('I print TEST_ENV_NUMBER'){ puts \"YOUR TEST ENV IS \#{ENV['TEST_ENV_NUMBER']}!\" }"
 
-      result = run_tests :type => 'features', :add => '--pattern good'
-      $?.success?.should == true
+      result = run_tests "features", :type => "cucumber", :add => '--pattern good'
 
       result.should include('YOUR TEST ENV IS 2!')
       result.should include('YOUR TEST ENV IS !')
@@ -167,9 +182,14 @@ describe 'CLI' do
       2.times{|i|
         write "features/good#{i}.feature", "Feature: xxx\n  Scenario: xxx\n    Given I print TEST_ENV_NUMBER"
       }
-      result = run_tests :type => 'features', :add => '-n 3'
-      $?.success?.should == true
+      result = run_tests "features", :type => "cucumber", :add => '-n 3'
       result.scan(/YOUR TEST ENV IS \d?!/).sort.should == ["YOUR TEST ENV IS !", "YOUR TEST ENV IS 2!"]
     end
+
+    it "runs successfully without any files" do
+      results = run_tests("", :type => "cucumber")
+      results.should include("2 processes for 0 features")
+      results.should include("Took")
+    end
   end
 end

data/spec/parallel_tests/test/runner_spec.rb

@@ -104,11 +104,7 @@ EOF
       ParallelTests::Test::Runner.send(:find_tests, *args)
     end
 
-    it "returns if root is an array" do
-      call([1]).should == [1]
-    end
-
-    it "finds all test files" do
+    it "finds test files nested in folders" do
       begin
         root = "/tmp/test-find_tests-#{rand(999)}"
         `mkdir #{root}`
@@ -121,7 +117,7 @@ EOF
         `touch #{root}/b/test.rb`
         `ln -s #{root}/b #{root}/c`
         `ln -s #{root}/b #{root}/a/`
-        call(root).sort.should == [
+        call([root]).sort.should == [
           "#{root}/a/b/y_test.rb",
             "#{root}/a/x_test.rb",
             "#{root}/b/y_test.rb",
@@ -133,7 +129,7 @@ EOF
       end
     end
 
-    it "finds files by pattern" do
+    it "finds test files in folders by pattern" do
       begin
         root = "/tmp/test-find_tests-#{rand(999)}"
         `mkdir #{root}`
@@ -141,7 +137,7 @@ EOF
         `touch #{root}/a/x_test.rb`
         `touch #{root}/a/y_test.rb`
         `touch #{root}/a/z_test.rb`
-        call(root, :pattern => '^a/(y|z)_test').sort.should == [
+        call([root], :pattern => '^a/(y|z)_test').sort.should == [
           "#{root}/a/y_test.rb",
             "#{root}/a/z_test.rb",
         ]
@@ -149,6 +145,22 @@ EOF
         `rm -rf #{root}`
       end
     end
+
+    it "finds nothing if I pass nothing" do
+      call(nil).should == []
+    end
+
+    it "finds nothing if I pass nothing (empty array)" do
+      call([]).should == []
+    end
+
+    it "keeps invalid files" do
+      call(['baz']).should == ['baz']
+    end
+
+    it "discards duplicates" do
+      call(['baz','baz']).should == ['baz']
+    end
   end
 
   describe :summarize_results do

data/spec/spec_helper.rb

@@ -75,6 +75,13 @@ def test_tests_in_groups(klass, folder, suffix)
       `rm -f #{klass.runtime_log}`
     end
 
+    def setup_runtime_log
+      File.open(@log,'w') do |f|
+        @files[1..-1].each{|file| f.puts "#{file}:#{@files.index(file)}"}
+        f.puts "#{@files[0]}:10"
+      end
+    end
+
     it "groups when given an array of files" do
       list_of_files = Dir["#{test_root}/**/*#{suffix}"]
       found = klass.with_runtime_info(list_of_files)
@@ -82,38 +89,31 @@ def test_tests_in_groups(klass, folder, suffix)
     end
 
     it "finds all tests" do
-      found = klass.tests_in_groups(test_root, 1)
+      found = klass.tests_in_groups([test_root], 1)
       all = [ Dir["#{test_root}/**/*#{suffix}"] ]
       (found.flatten - all.flatten).should == []
     end
 
     it "partitions them into groups by equal size" do
-      groups = klass.tests_in_groups(test_root, 2)
+      groups = klass.tests_in_groups([test_root], 2)
       groups.map{|g| size_of(g)}.should == [400, 400]
     end
 
     it 'should partition correctly with a group size of 4' do
-      groups = klass.tests_in_groups(test_root, 4)
+      groups = klass.tests_in_groups([test_root], 4)
       groups.map{|g| size_of(g)}.should == [200, 200, 200, 200]
     end
 
     it 'should partition correctly with an uneven group size' do
-      groups = klass.tests_in_groups(test_root, 3)
+      groups = klass.tests_in_groups([test_root], 3)
       groups.map{|g| size_of(g)}.should =~ [300, 300, 200]
     end
 
-    def setup_runtime_log
-      File.open(@log,'w') do |f|
-        @files[1..-1].each{|file| f.puts "#{file}:#{@files.index(file)}"}
-        f.puts "#{@files[0]}:10"
-      end
-    end
-
     it "partitions by runtime when runtime-data is available" do
       klass.stub!(:puts)
       setup_runtime_log
 
-      groups = klass.tests_in_groups(test_root, 2)
+      groups = klass.tests_in_groups([test_root], 2)
       groups.size.should == 2
       # 10 + 1 + 3 + 5 = 19
       groups[0].should == [@files[0],@files[1],@files[3],@files[5]]
@@ -125,7 +125,7 @@ def test_tests_in_groups(klass, folder, suffix)
       klass.stub!(:puts)
       setup_runtime_log
 
-      groups = klass.tests_in_groups(test_root, 2)
+      groups = klass.tests_in_groups([test_root], 2)
       groups.size.should == 2
 
       groups[0].should == groups[0].sort

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: parallel_tests
 version: !ruby/object:Gem::Version
-  version: 0.7.0.alpha
+  version: 0.7.0.alpha2
   prerelease: 6
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-02-25 00:00:00.000000000 Z
+date: 2012-02-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parallel
-  requirement: &16612760 !ruby/object:Gem::Requirement
+  requirement: &16386080 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,7 +21,7 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *16612760
+  version_requirements: *16386080
 description: 
 email: michael@grosser.it
 executables:
@@ -36,6 +36,7 @@ files:
 - Gemfile.lock
 - Rakefile
 - Readme.md
+- ReadmeRails2.md
 - bin/parallel_cucumber
 - bin/parallel_spec
 - bin/parallel_test
@@ -80,7 +81,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -20791927037817869
+      hash: -3495402516497603622
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -92,5 +93,5 @@ rubyforge_project:
 rubygems_version: 1.8.15
 signing_key: 
 specification_version: 3
-summary: Run tests / specs / features in parallel
+summary: Run Test::Unit / RSpec / Cucumber in parallel
 test_files: []