parallelized_specs 0.0.5 → 0.0.6

data/lib/tasks/parallelized_tests.rake

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

data/spec/integration_spec.rb

@@ -1,132 +0,0 @@
-require 'spec_helper'
-
-describe 'CLI' do
-  before do
-    `rm -rf #{folder}`
-  end
-
-  after do
-    `rm -rf #{folder}`
-  end
-
-  def folder
-    "/tmp/parallelized_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}/parallelized_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}/parallelized_spec -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/parallelized_tests/runtime_logger_spec.rb

@@ -1,74 +0,0 @@
-require 'spec_helper'
-
-describe ParallelizedTests::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(ParallelizedTests.runtime_log, 'w'){ |f| f.puts("FooBar") }
-      ParallelizedTests::RuntimeLogger.send(:class_variable_set,:@@has_started, false)
-      ParallelizedTests::RuntimeLogger.log(test, time, Time.at(time.to_f+2.00))
-      result = File.read(ParallelizedTests.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(ParallelizedTests.runtime_log, 'w'){ |f| f.puts("FooBar") }
-      ParallelizedTests::RuntimeLogger.send(:class_variable_set,:@@has_started, false)
-      ParallelizedTests::RuntimeLogger.log(test, time, Time.at(time.to_f+2.00))
-      ParallelizedTests::RuntimeLogger.log(other_test, time, Time.at(time.to_f+2.00))
-      result = File.read(ParallelizedTests.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
-      ParallelizedTests::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
-      ParallelizedTests::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
-      ParallelizedTests::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/parallelized_tests_spec.rb

@@ -1,229 +0,0 @@
-require 'spec_helper'
-
-describe ParallelizedTests do
-  test_tests_in_groups(ParallelizedTests, 'test', '_test.rb')
-
-  describe :parse_rake_args do
-    it "should return the count" do
-      args = {:count => 2}
-      ParallelizedTests.parse_rake_args(args).should == [2, '', ""]
-    end
-
-    it "should default to the prefix" do
-      args = {:count => "models"}
-      ParallelizedTests.parse_rake_args(args).should == [Parallel.processor_count, "models", ""]
-    end
-
-    it "should return the count and pattern" do
-      args = {:count => 2, :pattern => "models"}
-      ParallelizedTests.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" }
-      ParallelizedTests.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'
-      ParallelizedTests.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}
-      ParallelizedTests.parse_rake_args(args).should == [2, '', ""]
-    end
-  end
-
-  describe :run_tests do
-    it "uses TEST_ENV_NUMBER=blank when called for process 0" do
-      ParallelizedTests.should_receive(:open).with{|x,y|x=~/TEST_ENV_NUMBER= /}.and_return mocked_process
-      ParallelizedTests.run_tests(['xxx'],0,{})
-    end
-
-    it "uses TEST_ENV_NUMBER=2 when called for process 1" do
-      ParallelizedTests.should_receive(:open).with{|x,y| x=~/TEST_ENV_NUMBER=2/}.and_return mocked_process
-      ParallelizedTests.run_tests(['xxx'],1,{})
-    end
-
-    it "uses options" do
-      ParallelizedTests.should_receive(:open).with{|x,y| x=~ %r{ruby -Itest .* -- -v}}.and_return mocked_process
-      ParallelizedTests.run_tests(['xxx'],1,:test_options => '-v')
-    end
-
-    it "returns the output" do
-      io = open('spec/spec_helper.rb')
-      ParallelizedTests.stub!(:print)
-      ParallelizedTests.should_receive(:open).and_return io
-      ParallelizedTests.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
-      ParallelizedTests.should_not_receive(:smallest_first)
-      ParallelizedTests.tests_in_groups [], 1, :no_sort => true
-    end
-
-    it "does sort when not passed do_sort option" do
-      ParallelizedTests.stub!(:tests_with_runtime).and_return([])
-      ParallelizedTests::Grouper.should_receive(:largest_first).and_return([])
-      ParallelizedTests.tests_in_groups [], 1
-    end
-
-    it "groups by single_process pattern and then via size" do
-      ParallelizedTests.should_receive(:with_runtime_info).and_return([['aaa',5],['aaa2',5],['bbb',2],['ccc',1],['ddd',1]])
-      result = ParallelizedTests.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
-
-      ParallelizedTests.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
-
-      ParallelizedTests.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
-        ParallelizedTests.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
-        ParallelizedTests.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")
-        ParallelizedTests.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"))
-        ParallelizedTests.send(:bundler_enabled?).should == true
-      end
-    end
-  end
-
-  describe :find_tests do
-    it "returns if root is an array" do
-      ParallelizedTests.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/`
-        ParallelizedTests.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`
-        ParallelizedTests.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
-      ParallelizedTests.summarize_results(['1 foo 3 bar','2 foo 5 bar']).should == '8 bars, 3 foos'
-    end
-
-    it "adds results with braces" do
-      ParallelizedTests.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
-      ParallelizedTests.summarize_results(['1 foo 3 bar','2 foos 5 bar']).should == '8 bars, 3 foos'
-    end
-
-    it "adds non-similar results" do
-      ParallelizedTests.summarize_results(['1 xxx 2 yyy','1 xxx 2 zzz']).should == '2 xxxs, 2 yyys, 2 zzzs'
-    end
-
-    it "does not pluralize 1" do
-      ParallelizedTests.summarize_results(['1 xxx 2 yyy']).should == '1 xxx, 2 yyys'
-    end
-  end
-
-  it "has a version" do
-    ParallelizedTests::VERSION.should =~ /^\d+\.\d+\.\d+$/
-  end
-end