parallelized_specs 0.0.1

data/spec/parallel_specs/spec_runtime_logger_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+
+describe ParallelSpecs::SpecRuntimeLogger do
+  before do
+    # pretend we run in parallel or the logger will log nothing
+    ENV['TEST_ENV_NUMBER'] = ''
+    @clean_output = %r{^spec/foo.rb:[-\.e\d]+$}m
+  end
+
+  after do
+    ENV.delete 'TEST_ENV_NUMBER'
+  end
+
+  def log_for_a_file(options={})
+    Tempfile.open('xxx') do |temp|
+      temp.close
+      f = File.open(temp.path,'w')
+      logger = if block_given?
+        yield(f)
+      else
+        ParallelSpecs::SpecRuntimeLogger.new(f)
+      end
+
+      example = (mock(:location => "#{Dir.pwd}/spec/foo.rb:123"))
+      logger.example_started example
+      logger.example_passed example
+      if options[:pending]
+        logger.example_pending example
+        logger.dump_pending
+      end
+      if options[:failed]
+        logger.example_failed example
+        logger.dump_failures
+      end
+      logger.start_dump
+
+      #f.close
+      return File.read(f.path)
+    end
+  end
+
+  it "logs runtime with relative paths" do
+    log_for_a_file.should =~ @clean_output
+  end
+
+  it "does not log pending" do
+    log_for_a_file(:pending => true).should =~ @clean_output
+  end
+
+  it "does not log failures" do
+    log_for_a_file(:failed => true).should =~ @clean_output
+  end
+
+  it "does not log if we do not run in parallel" do
+    ENV.delete 'TEST_ENV_NUMBER'
+    log_for_a_file.should == ""
+  end
+
+  it "appends to a given file" do
+    result = log_for_a_file do |f|
+      f.write 'FooBar'
+      ParallelSpecs::SpecRuntimeLogger.new(f)
+    end
+    result.should include('FooBar')
+    result.should include('foo.rb')
+  end
+
+  it "overwrites a given path" do
+    result = log_for_a_file do |f|
+      f.write 'FooBar'
+      ParallelSpecs::SpecRuntimeLogger.new(f.path)
+    end
+    result.should_not include('FooBar')
+    result.should include('foo.rb')
+  end
+end

data/spec/parallel_specs/spec_summary_logger_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe ParallelSpecs::SpecSummaryLogger do
+  let(:output){ OutputLogger.new([]) }
+  let(:logger){ ParallelSpecs::SpecSummaryLogger.new(output) }
+
+  # TODO somehow generate a real example with an exception to test this
+  xit "prints failing examples" do
+    logger.example_failed XXX
+    logger.example_failed XXX
+    logger.dump_failures
+    output.output.should == [
+      "bundle exec rspec ./spec/path/to/example.rb:123 # should do stuff",
+      "bundle exec rspec ./spec/path/to/example.rb:125 # should not do stuff"
+    ]
+  end
+
+  it "does not print anything for passing examples" do
+    logger.example_passed mock(:location => "/my/spec/foo.rb:123")
+    logger.dump_failures
+    output.output.should == []
+    logger.dump_summary(1,2,3,4)
+    output.output.should == ["\nFinished in 1 seconds\n", "\e[31m2 examples, 3 failures, 4 pending\e[0m"]
+  end
+
+  it "does not print anything for pending examples" do
+    logger.example_pending mock(:location => "/my/spec/foo.rb:123")
+    logger.dump_failures
+    output.output.should == []
+    logger.dump_summary(1,2,3,4)
+    output.output.should == ["\nFinished in 1 seconds\n", "\e[31m2 examples, 3 failures, 4 pending\e[0m"]
+  end
+end

data/spec/parallel_specs_spec.rb

@@ -0,0 +1,165 @@
+require 'spec_helper'
+require 'parallel_specs/spec_runtime_logger'
+require 'parallel_specs/spec_summary_logger'
+require 'parallel_specs/spec_failures_logger'
+
+describe ParallelSpecs do
+  test_tests_in_groups(ParallelSpecs, 'spec', '_spec.rb')
+
+  describe :run_tests do
+    before do
+      File.stub!(:file?).with('script/spec').and_return false
+      File.stub!(:file?).with('spec/spec.opts').and_return false
+      File.stub!(:file?).with('spec/parallel_spec.opts').and_return false
+      ParallelSpecs.stub!(:bundler_enabled?).and_return false
+    end
+
+    it "uses TEST_ENV_NUMBER=blank when called for process 0" do
+      ParallelSpecs.should_receive(:open).with{|x,y|x=~/TEST_ENV_NUMBER= /}.and_return mocked_process
+      ParallelSpecs.run_tests(['xxx'],0,{})
+    end
+
+    it "uses TEST_ENV_NUMBER=2 when called for process 1" do
+      ParallelSpecs.should_receive(:open).with{|x,y| x=~/TEST_ENV_NUMBER=2/}.and_return mocked_process
+      ParallelSpecs.run_tests(['xxx'],1,{})
+    end
+
+    it "runs with color when called from cmdline" do
+      ParallelSpecs.should_receive(:open).with{|x,y| x=~/ --tty /}.and_return mocked_process
+      $stdout.should_receive(:tty?).and_return true
+      ParallelSpecs.run_tests(['xxx'],1,{})
+    end
+
+    it "runs without color when not called from cmdline" do
+      ParallelSpecs.should_receive(:open).with{|x,y| x !~ / --tty /}.and_return mocked_process
+      $stdout.should_receive(:tty?).and_return false
+      ParallelSpecs.run_tests(['xxx'],1,{})
+    end
+
+    it "runs with color for rspec 1 when called for the cmdline" do
+      File.should_receive(:file?).with('script/spec').and_return true
+      ParallelSpecs.should_receive(:open).with{|x,y| x=~/ RSPEC_COLOR=1 /}.and_return mocked_process
+      $stdout.should_receive(:tty?).and_return true
+      ParallelSpecs.run_tests(['xxx'],1,{})
+    end
+
+    it "runs without color for rspec 1 when not called for the cmdline" do
+      File.should_receive(:file?).with('script/spec').and_return true
+      ParallelSpecs.should_receive(:open).with{|x,y| x !~ / RSPEC_COLOR=1 /}.and_return mocked_process
+      $stdout.should_receive(:tty?).and_return false
+      ParallelSpecs.run_tests(['xxx'],1,{})
+    end
+
+    it "run bundle exec spec when on bundler rspec 1" do
+      File.stub!(:file?).with('script/spec').and_return false
+      ParallelSpecs.stub!(:bundler_enabled?).and_return true
+      ParallelSpecs.stub!(:run).with("bundle show rspec").and_return "/foo/bar/rspec-1.0.2"
+      ParallelSpecs.should_receive(:open).with{|x,y| x =~ %r{bundle exec spec}}.and_return mocked_process
+      ParallelSpecs.run_tests(['xxx'],1,{})
+    end
+
+    it "run bundle exec rspec when on bundler rspec 2" do
+      File.stub!(:file?).with('script/spec').and_return false
+      ParallelSpecs.stub!(:bundler_enabled?).and_return true
+      ParallelSpecs.stub!(:run).with("bundle show rspec").and_return "/foo/bar/rspec-2.0.2"
+      ParallelSpecs.should_receive(:open).with{|x,y| x =~ %r{bundle exec rspec}}.and_return mocked_process
+      ParallelSpecs.run_tests(['xxx'],1,{})
+    end
+
+    it "runs script/spec when script/spec can be found" do
+      File.should_receive(:file?).with('script/spec').and_return true
+      ParallelSpecs.should_receive(:open).with{|x,y| x =~ %r{script/spec}}.and_return mocked_process
+      ParallelSpecs.run_tests(['xxx'],1,{})
+    end
+
+    it "runs spec when script/spec cannot be found" do
+      File.stub!(:file?).with('script/spec').and_return false
+      ParallelSpecs.should_receive(:open).with{|x,y| x !~ %r{script/spec}}.and_return mocked_process
+      ParallelSpecs.run_tests(['xxx'],1,{})
+    end
+
+    it "uses no -O when no opts where found" do
+      File.stub!(:file?).with('spec/spec.opts').and_return false
+      ParallelSpecs.should_receive(:open).with{|x,y| x !~ %r{spec/spec.opts}}.and_return mocked_process
+      ParallelSpecs.run_tests(['xxx'],1,{})
+    end
+
+    it "uses -O spec/spec.opts when found (with script/spec)" do
+      File.stub!(:file?).with('script/spec').and_return true
+      File.stub!(:file?).with('spec/spec.opts').and_return true
+      ParallelSpecs.should_receive(:open).with{|x,y| x =~ %r{script/spec\s+ -O spec/spec.opts}}.and_return mocked_process
+      ParallelSpecs.run_tests(['xxx'],1,{})
+    end
+
+    it "uses -O spec/parallel_spec.opts when found (with script/spec)" do
+      File.stub!(:file?).with('script/spec').and_return true
+      File.should_receive(:file?).with('spec/parallel_spec.opts').and_return true
+      ParallelSpecs.should_receive(:open).with{|x,y| x =~ %r{script/spec\s+ -O spec/parallel_spec.opts}}.and_return mocked_process
+      ParallelSpecs.run_tests(['xxx'],1,{})
+    end
+
+    it "uses -O spec/parallel_spec.opts with rspec1" do
+      File.should_receive(:file?).with('spec/parallel_spec.opts').and_return true
+
+      ParallelSpecs.stub!(:bundler_enabled?).and_return true
+      ParallelSpecs.stub!(:run).with("bundle show rspec").and_return "/foo/bar/rspec-1.0.2"
+
+      ParallelSpecs.should_receive(:open).with{|x,y| x =~ %r{spec\s+ -O spec/parallel_spec.opts}}.and_return mocked_process
+      ParallelSpecs.run_tests(['xxx'],1,{})
+    end
+
+    it "uses -O spec/parallel_spec.opts with rspec2" do
+      File.should_receive(:file?).with('spec/parallel_spec.opts').and_return true
+
+      ParallelSpecs.stub!(:bundler_enabled?).and_return true
+      ParallelSpecs.stub!(:run).with("bundle show rspec").and_return "/foo/bar/rspec-2.4.2"
+
+      ParallelSpecs.should_receive(:open).with{|x,y| x =~ %r{rspec\s+ --color --tty -O spec/parallel_spec.opts}}.and_return mocked_process
+      ParallelSpecs.run_tests(['xxx'],1,{})
+    end
+
+    it "uses options passed in" do
+      ParallelSpecs.should_receive(:open).with{|x,y| x =~ %r{rspec -f n}}.and_return mocked_process
+      ParallelSpecs.run_tests(['xxx'],1, :test_options => '-f n')
+    end
+
+    it "returns the output" do
+      io = open('spec/spec_helper.rb')
+      ParallelSpecs.stub!(:print)
+      ParallelSpecs.should_receive(:open).and_return io
+      ParallelSpecs.run_tests(['xxx'],1,{})[:stdout].should =~ /\$LOAD_PATH << File/
+    end
+  end
+
+  describe :find_results do
+    it "finds multiple results in spec output" do
+      output = <<EOF
+....F...
+..
+failute fsddsfsd
+...
+ff.**..
+0 examples, 0 failures, 0 pending
+ff.**..
+1 example, 1 failure, 1 pending
+EOF
+
+      ParallelSpecs.find_results(output).should == ['0 examples, 0 failures, 0 pending','1 example, 1 failure, 1 pending']
+    end
+
+    it "is robust against scrambeled output" do
+      output = <<EOF
+....F...
+..
+failute fsddsfsd
+...
+ff.**..
+0 exFampl*es, 0 failures, 0 pend.ing
+ff.**..
+1 exampF.les, 1 failures, 1 pend.ing
+EOF
+
+      ParallelSpecs.find_results(output).should == ['0 examples, 0 failures, 0 pending','1 examples, 1 failures, 1 pending']
+    end
+  end
+end

data/spec/parallel_tests/runtime_logger_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+
+describe ParallelTests::RuntimeLogger do
+
+  describe :writing do
+    it "overwrites the runtime_log file on first log invocation" do
+      class FakeTest
+      end
+      test = FakeTest.new
+      time = Time.now
+      File.open(ParallelTests.runtime_log, 'w'){ |f| f.puts("FooBar") }
+      ParallelTests::RuntimeLogger.send(:class_variable_set,:@@has_started, false)
+      ParallelTests::RuntimeLogger.log(test, time, Time.at(time.to_f+2.00))
+      result = File.read(ParallelTests.runtime_log)
+      result.should_not include('FooBar')
+      result.should include('test/fake_test.rb:2.00')
+    end
+
+    it "appends to the runtime_log file after first log invocation" do
+      class FakeTest
+      end
+      test = FakeTest.new
+      class OtherFakeTest
+      end
+      other_test = OtherFakeTest.new
+
+      time = Time.now
+      File.open(ParallelTests.runtime_log, 'w'){ |f| f.puts("FooBar") }
+      ParallelTests::RuntimeLogger.send(:class_variable_set,:@@has_started, false)
+      ParallelTests::RuntimeLogger.log(test, time, Time.at(time.to_f+2.00))
+      ParallelTests::RuntimeLogger.log(other_test, time, Time.at(time.to_f+2.00))
+      result = File.read(ParallelTests.runtime_log)
+      result.should_not include('FooBar')
+      result.should include('test/fake_test.rb:2.00')
+      result.should include('test/other_fake_test.rb:2.00')
+    end
+
+  end
+
+  describe :formatting do
+    it "formats results for simple test names" do
+      class FakeTest
+      end
+      test = FakeTest.new
+      time = Time.now
+      ParallelTests::RuntimeLogger.message(test, time, Time.at(time.to_f+2.00)).should == 'test/fake_test.rb:2.00'
+    end
+
+    it "formats results for complex test names" do
+      class AVeryComplex
+        class FakeTest
+        end
+      end
+      test = AVeryComplex::FakeTest.new
+      time = Time.now
+      ParallelTests::RuntimeLogger.message(test, time, Time.at(time.to_f+2.00)).should == 'test/a_very_complex/fake_test.rb:2.00'
+    end
+
+    it "guesses subdirectory structure for rails test classes" do
+      module Rails
+      end
+      class ActionController
+        class TestCase
+        end
+      end
+      class FakeControllerTest < ActionController::TestCase
+      end
+      test = FakeControllerTest.new
+      time = Time.now
+      ParallelTests::RuntimeLogger.message(test, time, Time.at(time.to_f+2.00)).should == 'test/functional/fake_controller_test.rb:2.00'
+    end
+  end
+
+end

data/spec/parallel_tests_spec.rb

@@ -0,0 +1,229 @@
+require 'spec_helper'
+
+describe ParallelTests do
+  test_tests_in_groups(ParallelTests, 'test', '_test.rb')
+
+  describe :parse_rake_args do
+    it "should return the count" do
+      args = {:count => 2}
+      ParallelTests.parse_rake_args(args).should == [2, '', ""]
+    end
+
+    it "should default to the prefix" do
+      args = {:count => "models"}
+      ParallelTests.parse_rake_args(args).should == [Parallel.processor_count, "models", ""]
+    end
+
+    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, pattern, and options" do
+      args = {:count => 2, :pattern => "plain", :options => "-p default" }
+      ParallelTests.parse_rake_args(args).should == [2, "plain", "-p default"]
+    end
+
+    it "should use the PARALLEL_TEST_PROCESSORS env var for processor_count if set" do
+      ENV['PARALLEL_TEST_PROCESSORS'] = '28'
+      ParallelTests.parse_rake_args({}).should == [28, '', '']
+    end
+
+    it "should use count over PARALLEL_TEST_PROCESSORS env var" do
+      ENV['PARALLEL_TEST_PROCESSORS'] = '28'
+      args = {:count => 2}
+      ParallelTests.parse_rake_args(args).should == [2, '', ""]
+    end
+  end
+
+  describe :run_tests do
+    it "uses TEST_ENV_NUMBER=blank when called for process 0" do
+      ParallelTests.should_receive(:open).with{|x,y|x=~/TEST_ENV_NUMBER= /}.and_return mocked_process
+      ParallelTests.run_tests(['xxx'],0,{})
+    end
+
+    it "uses TEST_ENV_NUMBER=2 when called for process 1" do
+      ParallelTests.should_receive(:open).with{|x,y| x=~/TEST_ENV_NUMBER=2/}.and_return mocked_process
+      ParallelTests.run_tests(['xxx'],1,{})
+    end
+
+    it "uses options" do
+      ParallelTests.should_receive(:open).with{|x,y| x=~ %r{ruby -Itest .* -- -v}}.and_return mocked_process
+      ParallelTests.run_tests(['xxx'],1,:test_options => '-v')
+    end
+
+    it "returns the output" do
+      io = open('spec/spec_helper.rb')
+      ParallelTests.stub!(:print)
+      ParallelTests.should_receive(:open).and_return io
+      ParallelTests.run_tests(['xxx'],1,{})[:stdout].should =~ /\$LOAD_PATH << File/
+    end
+  end
+
+  describe :test_in_groups do
+    it "does not sort when passed false do_sort option" do
+      ParallelTests.should_not_receive(:smallest_first)
+      ParallelTests.tests_in_groups [], 1, :no_sort => true
+    end
+
+    it "does sort when not passed do_sort option" do
+      ParallelTests.stub!(:tests_with_runtime).and_return([])
+      ParallelTests::Grouper.should_receive(:largest_first).and_return([])
+      ParallelTests.tests_in_groups [], 1
+    end
+
+    it "groups by single_process pattern and then via size" do
+      ParallelTests.should_receive(:with_runtime_info).and_return([['aaa',5],['aaa2',5],['bbb',2],['ccc',1],['ddd',1]])
+      result = ParallelTests.tests_in_groups [], 3, :single_process => [/^a.a/]
+      result.should == [["aaa", "aaa2"], ["bbb"], ["ccc", "ddd"]]
+    end
+  end
+
+  describe :find_results do
+    it "finds multiple results in test output" do
+      output = <<EOF
+Loaded suite /opt/ruby-enterprise/lib/ruby/gems/1.8/gems/rake-0.8.4/lib/rake/rake_test_loader
+Started
+..............
+Finished in 0.145069 seconds.
+
+10 tests, 20 assertions, 0 failures, 0 errors
+Loaded suite /opt/ruby-enterprise/lib/ruby/gems/1.8/gems/rake-0.8.4/lib/rake/rake_test_loader
+Started
+..............
+Finished in 0.145069 seconds.
+
+14 tests, 20 assertions, 0 failures, 0 errors
+
+EOF
+
+      ParallelTests.find_results(output).should == ['10 tests, 20 assertions, 0 failures, 0 errors','14 tests, 20 assertions, 0 failures, 0 errors']
+    end
+
+    it "is robust against scrambled output" do
+      output = <<EOF
+Loaded suite /opt/ruby-enterprise/lib/ruby/gems/1.8/gems/rake-0.8.4/lib/rake/rake_test_loader
+Started
+..............
+Finished in 0.145069 seconds.
+
+10 tests, 20 assertions, 0 failures, 0 errors
+Loaded suite /opt/ruby-enterprise/lib/ruby/gems/1.8/gems/rake-0.8.4/lib/rake/rake_test_loader
+Started
+..............
+Finished in 0.145069 seconds.
+
+14 te.dsts, 20 assertions, 0 failures, 0 errors
+EOF
+
+      ParallelTests.find_results(output).should == ['10 tests, 20 assertions, 0 failures, 0 errors','14 tedsts, 20 assertions, 0 failures, 0 errors']
+    end
+  end
+
+  describe :bundler_enabled? do
+    before do
+      Object.stub!(:const_defined?).with(:Bundler).and_return false
+    end
+
+    it "should return false" do
+      use_temporary_directory_for do
+        ParallelTests.send(:bundler_enabled?).should == false
+      end
+    end
+
+    it "should return true when there is a constant called Bundler" do
+      use_temporary_directory_for do
+        Object.stub!(:const_defined?).with(:Bundler).and_return true
+        ParallelTests.send(:bundler_enabled?).should == true
+      end
+    end
+
+    it "should be true when there is a Gemfile" do
+      use_temporary_directory_for do
+        FileUtils.touch("Gemfile")
+        ParallelTests.send(:bundler_enabled?).should == true
+      end
+    end
+
+    it "should be true when there is a Gemfile in the parent directory" do
+      use_temporary_directory_for do
+        FileUtils.touch(File.join("..", "Gemfile"))
+        ParallelTests.send(:bundler_enabled?).should == true
+      end
+    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
+
+  describe :summarize_results do
+    it "adds results" do
+      ParallelTests.summarize_results(['1 foo 3 bar','2 foo 5 bar']).should == '8 bars, 3 foos'
+    end
+
+    it "adds results with braces" do
+      ParallelTests.summarize_results(['1 foo(s) 3 bar(s)','2 foo 5 bar']).should == '8 bars, 3 foos'
+    end
+
+    it "adds same results with plurals" do
+      ParallelTests.summarize_results(['1 foo 3 bar','2 foos 5 bar']).should == '8 bars, 3 foos'
+    end
+
+    it "adds non-similar results" do
+      ParallelTests.summarize_results(['1 xxx 2 yyy','1 xxx 2 zzz']).should == '2 xxxs, 2 yyys, 2 zzzs'
+    end
+
+    it "does not pluralize 1" do
+      ParallelTests.summarize_results(['1 xxx 2 yyy']).should == '1 xxx, 2 yyys'
+    end
+  end
+
+  it "has a version" do
+    ParallelTests::VERSION.should =~ /^\d+\.\d+\.\d+$/
+  end
+end