friendlyfashion-parallel_tests 0.9.0

data/spec/parallel_tests/rspec/runtime_logger_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+
+describe ParallelTests::RSpec::RuntimeLogger 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
+        ParallelTests::RSpec::RuntimeLogger.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'
+      ParallelTests::RSpec::RuntimeLogger.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'
+      ParallelTests::RSpec::RuntimeLogger.new(f.path)
+    end
+    result.should_not include('FooBar')
+    result.should include('foo.rb')
+  end
+end

data/spec/parallel_tests/rspec/summary_logger_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe ParallelTests::RSpec::SummaryLogger do
+  let(:output){ OutputLogger.new([]) }
+  let(:logger){ ParallelTests::RSpec::SummaryLogger.new(output) }
+
+  def decolorize(string)
+    string.gsub(/\e\[\d+m/,'')
+  end
+
+  # 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.map{|o| decolorize(o) }.should == ["\nFinished in 1 second\n", "2 examples, 3 failures, 4 pending"]
+  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.map{|o| decolorize(o) }.should == ["\nFinished in 1 second\n", "2 examples, 3 failures, 4 pending"]
+  end
+end

data/spec/parallel_tests/tasks_spec.rb

@@ -0,0 +1,151 @@
+require 'spec_helper'
+require 'parallel_tests/tasks'
+
+describe ParallelTests::Tasks do
+  describe ".parse_args" do
+    it "should return the count" do
+      args = {:count => 2}
+      ParallelTests::Tasks.parse_args(args).should == [2, "", ""]
+    end
+
+    it "should default to the prefix" do
+      args = {:count => "models"}
+      ParallelTests::Tasks.parse_args(args).should == [nil, "models", ""]
+    end
+
+    it "should return the count and pattern" do
+      args = {:count => 2, :pattern => "models"}
+      ParallelTests::Tasks.parse_args(args).should == [2, "models", ""]
+    end
+
+    it "should return the count, pattern, and options" do
+      args = {:count => 2, :pattern => "plain", :options => "-p default"}
+      ParallelTests::Tasks.parse_args(args).should == [2, "plain", "-p default"]
+    end
+  end
+
+  describe ".rails_env" do
+    around do |example|
+      begin
+        old = ENV["RAILS_ENV"]
+        ENV.delete "RAILS_ENV"
+        example.call
+      ensure
+        ENV["RAILS_ENV"] = old
+      end
+    end
+
+    it "should be test when nothing was set" do
+      ParallelTests::Tasks.rails_env.should == "test"
+    end
+
+    it "should be whatever was set" do
+      ENV["RAILS_ENV"] = "foo"
+      ParallelTests::Tasks.rails_env.should == "foo"
+    end
+  end
+
+  describe ".run_in_parallel" do
+    let(:full_path){ File.expand_path("../../../bin/parallel_test", __FILE__) }
+
+    it "should have the executable" do
+      File.file?(full_path).should == true
+      File.executable?(full_path).should == true
+    end
+
+    it "runs command in parallel" do
+      ParallelTests::Tasks.should_receive(:system).with("#{full_path} --exec 'echo'").and_return true
+      ParallelTests::Tasks.run_in_parallel("echo")
+    end
+
+    it "runs command with :count option" do
+      ParallelTests::Tasks.should_receive(:system).with("#{full_path} --exec 'echo' -n 123").and_return true
+      ParallelTests::Tasks.run_in_parallel("echo", :count => 123)
+    end
+
+    it "runs command with :non_parallel option" do
+      ParallelTests::Tasks.should_receive(:system).with("#{full_path} --exec 'echo' --non-parallel").and_return true
+      ParallelTests::Tasks.run_in_parallel("echo", :non_parallel => true)
+    end
+
+    it "runs aborts if the command fails" do
+      ParallelTests::Tasks.should_receive(:system).and_return false
+      ParallelTests::Tasks.should_receive(:abort).and_return false
+      ParallelTests::Tasks.run_in_parallel("echo")
+    end
+  end
+
+  describe ".suppress_output" do
+    def call(command, grep)
+      result = `#{ParallelTests::Tasks.suppress_output(command, grep)}`
+      [result, $?.success?]
+    end
+
+    context "with pipefail supported" do
+      before :all do
+        if not system("set -o pipefail && test 1")
+          pending "pipefail is not supported on your system"
+        end
+      end
+
+      it "should hide offending lines" do
+        call("echo 123", "123").should == ["", true]
+      end
+
+      it "should not hide other lines" do
+        call("echo 124", "123").should == ["124\n", true]
+      end
+
+      it "should fail if command fails and the pattern matches" do
+        call("echo 123 && test", "123").should == ["", false]
+      end
+
+      it "should fail if command fails and the pattern fails" do
+        call("echo 124 && test", "123").should == ["124\n", false]
+      end
+    end
+
+    context "without pipefail supported" do
+      before do
+        ParallelTests::Tasks.should_receive(:system).with("set -o pipefail && test 1").and_return false
+      end
+
+      it "should not filter and succeed" do
+        call("echo 123", "123").should == ["123\n", true]
+      end
+
+      it "should not filter and fail" do
+        call("echo 123 && test", "123").should == ["123\n", false]
+      end
+    end
+  end
+
+  describe ".check_for_pending_migrations" do
+    after do
+      Rake.application.instance_variable_get('@tasks').delete("db:abort_if_pending_migrations")
+    end
+
+    it "should do nothing if pending migrations is no defined" do
+      ParallelTests::Tasks.check_for_pending_migrations
+    end
+
+    it "should run pending migrations is task is defined" do
+      foo = 1
+      Rake::Task.define_task("db:abort_if_pending_migrations") do
+        foo = 2
+      end
+      ParallelTests::Tasks.check_for_pending_migrations
+      foo.should == 2
+    end
+
+    it "should not execute the task twice" do
+      foo = 1
+      Rake::Task.define_task("db:abort_if_pending_migrations") do
+        foo += 1
+      end
+      ParallelTests::Tasks.check_for_pending_migrations
+      ParallelTests::Tasks.check_for_pending_migrations
+      foo.should == 2
+    end
+  end
+end

data/spec/parallel_tests/test/runner_spec.rb

@@ -0,0 +1,273 @@
+require 'spec_helper'
+
+describe ParallelTests::Test::Runner do
+  test_tests_in_groups(ParallelTests::Test::Runner, 'test', '_test.rb')
+
+  describe :run_tests do
+    def call(*args)
+      ParallelTests::Test::Runner.run_tests(*args)
+    end
+
+    it "uses TEST_ENV_NUMBER=blank when called for process 0" do
+      ParallelTests::Test::Runner.should_receive(:open).with{|x,y|x=~/TEST_ENV_NUMBER= /}.and_return mocked_process
+      call(['xxx'],0,{})
+    end
+
+    it "uses TEST_ENV_NUMBER=2 when called for process 1" do
+      ParallelTests::Test::Runner.should_receive(:open).with{|x,y| x=~/TEST_ENV_NUMBER=2/}.and_return mocked_process
+      call(['xxx'],1,{})
+    end
+
+    it "uses options" do
+      ParallelTests::Test::Runner.should_receive(:open).with{|x,y| x=~ %r{ruby -Itest .* -- -v}}.and_return mocked_process
+      call(['xxx'],1,:test_options => '-v')
+    end
+
+    it "returns the output" do
+      io = open('spec/spec_helper.rb')
+      $stdout.stub!(:print)
+      ParallelTests::Test::Runner.should_receive(:open).and_return io
+      call(['xxx'],1,{})[:stdout].should =~ /\$LOAD_PATH << File/
+    end
+  end
+
+  describe :test_in_groups do
+    def call(*args)
+      ParallelTests::Test::Runner.tests_in_groups(*args)
+    end
+
+    it "does not sort when passed false do_sort option" do
+      ParallelTests::Test::Runner.should_not_receive(:smallest_first)
+      call([], 1, :group_by => :found)
+    end
+
+    it "does sort when not passed do_sort option" do
+      ParallelTests::Test::Runner.stub!(:tests_with_runtime).and_return([])
+      ParallelTests::Grouper.should_receive(:largest_first).and_return([])
+      call([], 1)
+    end
+
+    it "groups by single_process pattern and then via size" do
+      ParallelTests::Test::Runner.should_receive(:with_runtime_info).
+        and_return([
+          ['aaa', 5],
+          ['aaa2', 5],
+          ['bbb', 2],
+          ['ccc', 1],
+          ['ddd', 1]
+        ])
+      result = call([], 3, :single_process => [/^a.a/])
+      result.should == [["aaa", "aaa2"], ["bbb"], ["ccc", "ddd"]]
+    end
+
+    it "groups by size and adds isolated separately" do
+      ParallelTests::Test::Runner.should_receive(:with_runtime_info).
+        and_return([
+          ['aaa', 0],
+          ['bbb', 3],
+          ['ccc', 1],
+          ['ddd', 2],
+          ['eee', 1]
+        ])
+
+      result = call([], 3, :isolate => true, :single_process => [/^aaa/])
+      result.should == [["aaa"], ["bbb", "eee"], ["ccc", "ddd"]]
+    end
+  end
+
+  describe :find_results do
+    def call(*args)
+      ParallelTests::Test::Runner.find_results(*args)
+    end
+
+    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
+
+      call(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
+
+      call(output).should == ['10 tests, 20 assertions, 0 failures, 0 errors','14 tedsts, 20 assertions, 0 failures, 0 errors']
+    end
+
+    it "ignores color-codes" do
+      output = <<EOF
+10 tests, 20 assertions, 0 \e[31mfailures, 0 errors
+EOF
+      call(output).should == ['10 tests, 20 assertions, 0 failures, 0 errors']
+    end
+  end
+
+  describe :find_tests do
+    def call(*args)
+      ParallelTests::Test::Runner.send(:find_tests, *args)
+    end
+
+    def with_files(files)
+      begin
+        root = "/tmp/test-find_tests-#{rand(999)}"
+        `mkdir #{root}`
+        files.each do |file|
+          parent = "#{root}/#{File.dirname(file)}"
+          `mkdir -p #{parent}` unless File.exist?(parent)
+          `touch #{root}/#{file}`
+        end
+        yield root
+      ensure
+        `rm -rf #{root}`
+      end
+    end
+
+    def inside_dir(dir)
+      old = Dir.pwd
+      Dir.chdir dir
+      yield
+    ensure
+      Dir.chdir old
+    end
+
+    it "finds test in folders with appended /" do
+      with_files(['b/a_test.rb']) do |root|
+        call(["#{root}/"]).sort.should == [
+          "#{root}/b/a_test.rb",
+        ]
+      end
+    end
+
+    it "finds test files nested in symlinked folders" do
+      with_files(['a/a_test.rb','b/b_test.rb']) do |root|
+        `ln -s #{root}/a #{root}/b/link`
+        call(["#{root}/b"]).sort.should == [
+          "#{root}/b/b_test.rb",
+          "#{root}/b/link/a_test.rb",
+        ]
+      end
+    end
+
+    it "finds test files but ignores those in symlinked folders" do
+      with_files(['a/a_test.rb','b/b_test.rb']) do |root|
+        `ln -s #{root}/a #{root}/b/link`
+        call(["#{root}/b"], :symlinks => false).sort.should == [
+          "#{root}/b/b_test.rb",
+        ]
+      end
+    end
+
+    it "finds test files nested in different folders" do
+      with_files(['a/a_test.rb','b/b_test.rb', 'c/c_test.rb']) do |root|
+        call(["#{root}/a", "#{root}/b"]).sort.should == [
+          "#{root}/a/a_test.rb",
+          "#{root}/b/b_test.rb",
+        ]
+      end
+    end
+
+    it "only finds tests in folders" do
+      with_files(['a/a_test.rb', 'a/test.rb', 'a/test_helper.rb']) do |root|
+        call(["#{root}/a"]).sort.should == [
+          "#{root}/a/a_test.rb"
+        ]
+      end
+    end
+
+    it "finds tests in nested folders" do
+      with_files(['a/b/c/d/a_test.rb']) do |root|
+        call(["#{root}/a"]).sort.should == [
+          "#{root}/a/b/c/d/a_test.rb"
+        ]
+      end
+    end
+
+    it "does not expand paths" do
+      with_files(['a/x_test.rb']) do |root|
+        inside_dir root do
+          call(['a']).sort.should == [
+            "a/x_test.rb"
+          ]
+        end
+      end
+    end
+
+    it "finds test files in folders by pattern" do
+      with_files(['a/x_test.rb','a/y_test.rb','a/z_test.rb']) do |root|
+        inside_dir root do
+          call(["a"], :pattern => /^a\/(y|z)_test/).sort.should == [
+            "a/y_test.rb",
+            "a/z_test.rb",
+          ]
+        end
+      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
+    def call(*args)
+      ParallelTests::Test::Runner.summarize_results(*args)
+    end
+
+    it "adds results" do
+      call(['1 foo 3 bar','2 foo 5 bar']).should == '8 bars, 3 foos'
+    end
+
+    it "adds results with braces" do
+      call(['1 foo(s) 3 bar(s)','2 foo 5 bar']).should == '8 bars, 3 foos'
+    end
+
+    it "adds same results with plurals" do
+      call(['1 foo 3 bar','2 foos 5 bar']).should == '8 bars, 3 foos'
+    end
+
+    it "adds non-similar results" do
+      call(['1 xxx 2 yyy','1 xxx 2 zzz']).should == '2 xxxs, 2 yyys, 2 zzzs'
+    end
+
+    it "does not pluralize 1" do
+      call(['1 xxx 2 yyy']).should == '1 xxx, 2 yyys'
+    end
+  end
+end