vinted-parallel_tests 0.13.3

data/spec/parallel_tests/grouper_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+require 'parallel_tests/grouper'
+require 'tmpdir'
+
+describe ParallelTests::Grouper do
+  describe :by_steps do
+    def write(file, content)
+      File.open(file,'w'){|f| f.write content }
+    end
+
+    it "sorts features by steps" do
+      tmpdir = nil
+      result = Dir.mktmpdir do |dir|
+        tmpdir = dir
+        write("#{dir}/a.feature", "Feature: xxx\n  Scenario: xxx\n    Given something")
+        write("#{dir}/b.feature", "Feature: xxx\n  Scenario: xxx\n    Given something\n  Scenario: yyy\n    Given something")
+        write("#{dir}/c.feature", "Feature: xxx\n  Scenario: xxx\n    Given something")
+        ParallelTests::Grouper.by_steps(["#{dir}/a.feature", "#{dir}/b.feature", "#{dir}/c.feature"], 2, {})
+      end
+
+      # testing inside mktmpdir is always green
+      result.should =~ [
+        ["#{tmpdir}/a.feature", "#{tmpdir}/c.feature"],
+        ["#{tmpdir}/b.feature"]
+      ]
+    end
+  end
+
+  describe :in_even_groups_by_size do
+    let(:files_with_size){ {"1" => 1, "2" => 2, "3" => 3, "4" => 4, "5" => 5} }
+
+    def call(num_groups)
+      ParallelTests::Grouper.in_even_groups_by_size(files_with_size, num_groups)
+    end
+
+    it "groups 1 by 1 for same groups as size" do
+      call(5).should == [["5"], ["4"], ["3"], ["2"], ["1"]]
+    end
+
+    it "groups into even groups" do
+      call(2).should ==  [["1", "2", "5"], ["3", "4"]]
+    end
+
+    it "groups into a single group" do
+      call(1).should == [["1", "2", "3", "4", "5"]]
+    end
+
+    it "adds empty groups if there are more groups than feature files" do
+      call(6).should == [["5"], ["4"], ["3"], ["2"], ["1"], []]
+    end
+  end
+end

data/spec/parallel_tests/rspec/failures_logger_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+
+describe ParallelTests::RSpec::FailuresLogger do
+  def silence_warnings
+    old_verbose, $VERBOSE = $VERBOSE, nil
+    yield
+  ensure
+    $VERBOSE = old_verbose
+  end
+
+  before do
+    @output     = OutputLogger.new([])
+    @example1   = mock( 'example', :location => "#{Dir.pwd}/spec/path/to/example:123", :full_description => 'should do stuff', :description => 'd' )
+    @example2   = mock( 'example', :location => "#{Dir.pwd}/spec/path/to/example2:456", :full_description => 'should do other stuff', :description => 'd')
+    @exception1 = mock( :to_s => 'exception', :backtrace => [ '/path/to/error/line:33' ] )
+    @failure1   = mock( 'example', :location => "#{Dir.pwd}/example:123", :header => 'header', :exception => @exception1 )
+    @logger = ParallelTests::RSpec::FailuresLogger.new(@output)
+  end
+
+  after do
+    silence_warnings{ ParallelTests::RSpec::LoggerBase::RSPEC_1 = false }
+  end
+
+  def clean_output
+    @output.output.join("\n").gsub(/\e\[\d+m/,'')
+  end
+
+  it "should produce a list of command lines for failing examples" do
+    @logger.example_failed @example1
+    @logger.example_failed @example2
+
+    @logger.dump_failures
+    @logger.dump_summary(1,2,3,4)
+
+    clean_output.should =~ /^rspec .*? should do stuff/
+    clean_output.should =~ /^rspec .*? should do other stuff/
+  end
+
+  it "should invoke spec for rspec 1" do
+    silence_warnings{ ParallelTests::RSpec::LoggerBase::RSPEC_1 = true }
+    ParallelTests.stub!(:bundler_enabled?).and_return true
+    ParallelTests::RSpec::Runner.stub!(:run).with("bundle show rspec-core").and_return "Could not find gem 'rspec-core'."
+    @logger.example_failed @example1
+
+    @logger.dump_failures
+    @logger.dump_summary(1,2,3,4)
+
+    clean_output.should =~ /^bundle exec spec/
+  end
+
+  it "should invoke rspec for rspec 2" do
+    ParallelTests.stub!(:bundler_enabled?).and_return true
+    ParallelTests::RSpec::Runner.stub!(:run).with("bundle show rspec").and_return "/foo/bar/rspec-core-2.0.2"
+    @logger.example_failed @example1
+
+    @logger.dump_failures
+    @logger.dump_summary(1,2,3,4)
+
+    clean_output.should =~ /^rspec/
+  end
+
+  it "should return relative paths" do
+    @logger.example_failed @example1
+    @logger.example_failed @example2
+
+    @logger.dump_failures
+    @logger.dump_summary(1,2,3,4)
+
+    clean_output.should =~ %r(\./spec/path/to/example:123)
+    clean_output.should =~ %r(\./spec/path/to/example2:456)
+  end
+
+
+  # should not longer be a problem since its using native rspec methods
+  xit "should not log examples without location" do
+    example = mock('example', :location => 'bla', :full_description => 'before :all')
+    @logger.example_failed example
+    @logger.dump_failures
+    @logger.dump_summary(1,2,3,4)
+    clean_output.should == ''
+  end
+end

data/spec/parallel_tests/rspec/runner_spec.rb

@@ -0,0 +1,187 @@
+require "spec_helper"
+require "parallel_tests/rspec/runner"
+
+describe ParallelTests::RSpec::Runner do
+  test_tests_in_groups(ParallelTests::RSpec::Runner, '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
+      File.stub!(:file?).with('.rspec_parallel').and_return false
+      ParallelTests.stub!(:bundler_enabled?).and_return false
+    end
+
+    def call(*args)
+      ParallelTests::RSpec::Runner.run_tests(*args)
+    end
+
+    def should_run_with(regex)
+      ParallelTests::Test::Runner.should_receive(:execute_command).with{|a,b,c,d| a =~ regex}
+    end
+
+    def should_not_run_with(regex)
+      ParallelTests::Test::Runner.should_receive(:execute_command).with{|a,b,c,d| a !~ regex}
+    end
+
+    it "runs command using nice when specifed" do
+      ParallelTests::Test::Runner.should_receive(:execute_command_and_capture_output).with{|a,b,c| b =~ %r{^nice rspec}}
+      call('xxx', 1, 22, :nice => true)
+    end
+
+    it "runs with color when called from cmdline" do
+      should_run_with %r{ --tty}
+      $stdout.should_receive(:tty?).and_return true
+      call('xxx', 1, 22, {})
+    end
+
+    it "runs without color when not called from cmdline" do
+      should_not_run_with %r{ --tty}
+      $stdout.should_receive(:tty?).and_return false
+      call('xxx', 1, 22, {})
+    end
+
+    it "runs with color for rspec 1 when called for the cmdline" do
+      File.should_receive(:file?).with('script/spec').and_return true
+      ParallelTests::Test::Runner.should_receive(:execute_command).with { |a, b, c, d| d[:env] == {"RSPEC_COLOR" => "1"} }
+      $stdout.should_receive(:tty?).and_return true
+      call('xxx', 1, 22, {})
+    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
+      ParallelTests::Test::Runner.should_receive(:execute_command).with { |a, b, c, d| d[:env] == {} }
+      $stdout.should_receive(:tty?).and_return false
+      call('xxx', 1, 22, {})
+    end
+
+    it "run bundle exec spec when on bundler rspec 1" do
+      File.stub!(:file?).with('script/spec').and_return false
+      ParallelTests.stub!(:bundler_enabled?).and_return true
+      ParallelTests::RSpec::Runner.stub!(:run).with("bundle show rspec-core").and_return "Could not find gem 'rspec-core' in bundler."
+      should_run_with %r{bundle exec spec}
+      call('xxx', 1, 22, {})
+    end
+
+    it "run bundle exec rspec when on bundler rspec 2" do
+      File.stub!(:file?).with('script/spec').and_return false
+      ParallelTests.stub!(:bundler_enabled?).and_return true
+      ParallelTests::RSpec::Runner.stub!(:run).with("bundle show rspec-core").and_return "/foo/bar/rspec-core-2.0.2"
+      should_run_with %r{bundle exec rspec}
+      call('xxx', 1, 22, {})
+    end
+
+    it "runs script/spec when script/spec can be found" do
+      File.should_receive(:file?).with('script/spec').and_return true
+      should_run_with %r{script/spec}
+      call('xxx' ,1, 22, {})
+    end
+
+    it "runs spec when script/spec cannot be found" do
+      File.stub!(:file?).with('script/spec').and_return false
+      should_not_run_with %r{ script/spec}
+      call('xxx', 1, 22, {})
+    end
+
+    it "uses bin/rspec when present" do
+      File.stub(:exists?).with('bin/rspec').and_return true
+      should_run_with %r{bin/rspec}
+      call('xxx', 1, 22, {})
+    end
+
+    it "uses no -O when no opts where found" do
+      File.stub!(:file?).with('spec/spec.opts').and_return false
+      should_not_run_with %r{spec/spec.opts}
+      call('xxx', 1, 22, {})
+    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
+      should_run_with %r{script/spec\s+-O spec/spec.opts}
+      call('xxx', 1, 22, {})
+    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
+      should_run_with %r{script/spec\s+-O spec/parallel_spec.opts}
+      call('xxx', 1, 22, {})
+    end
+
+    it "uses -O .rspec_parallel when found (with script/spec)" do
+      File.stub!(:file?).with('script/spec').and_return true
+      File.should_receive(:file?).with('.rspec_parallel').and_return true
+      should_run_with %r{script/spec\s+-O .rspec_parallel}
+      call('xxx', 1, 22, {})
+    end
+
+    it "uses -O spec/parallel_spec.opts with rspec1" do
+      File.should_receive(:file?).with('spec/parallel_spec.opts').and_return true
+
+      ParallelTests.stub!(:bundler_enabled?).and_return true
+      ParallelTests::RSpec::Runner.stub!(:run).with("bundle show rspec-core").and_return "Could not find gem 'rspec-core'."
+
+      should_run_with %r{spec\s+-O spec/parallel_spec.opts}
+      call('xxx', 1, 22, {})
+    end
+
+    it "uses -O spec/parallel_spec.opts with rspec2" do
+      pending if RUBY_PLATFORM == "java" # FIXME not sure why, but fails on travis
+      File.should_receive(:file?).with('spec/parallel_spec.opts').and_return true
+
+      ParallelTests.stub!(:bundler_enabled?).and_return true
+      ParallelTests::RSpec::Runner.stub!(:run).with("bundle show rspec-core").and_return "/foo/bar/rspec-core-2.4.2"
+
+      should_run_with %r{rspec\s+--color --tty -O spec/parallel_spec.opts}
+      call('xxx', 1, 22, {})
+    end
+
+    it "uses options passed in" do
+      should_run_with %r{rspec -f n}
+      call('xxx', 1, 22, :test_options => '-f n')
+    end
+
+    it "returns the output" do
+      ParallelTests::RSpec::Runner.should_receive(:execute_command).and_return :x => 1
+      call('xxx', 1, 22, {}).should == {:x => 1}
+    end
+  end
+
+  describe :find_results do
+    def call(*args)
+      ParallelTests::RSpec::Runner.find_results(*args)
+    end
+
+    it "finds multiple results in spec output" do
+      output = "
+....F...
+..
+failute fsddsfsd
+...
+ff.**..
+0 examples, 0 failures, 0 pending
+ff.**..
+1 example, 1 failure, 1 pending
+"
+
+      call(output).should == ['0 examples, 0 failures, 0 pending','1 example, 1 failure, 1 pending']
+    end
+
+    it "is robust against scrambeled output" do
+      output = "
+....F...
+..
+failute fsddsfsd
+...
+ff.**..
+0 exFampl*es, 0 failures, 0 pend.ing
+ff.**..
+1 exampF.les, 1 failures, 1 pend.ing
+"
+
+      call(output).should == ['0 examples, 0 failures, 0 pending','1 examples, 1 failures, 1 pending']
+    end
+  end
+end

data/spec/parallel_tests/rspec/runtime_logger_spec.rb

@@ -0,0 +1,126 @@
+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(:file_path => "#{Dir.pwd}/spec/foo.rb"))
+      logger.example_group_started example
+      logger.example_group_finished example
+      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 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
+
+  context "integration" do
+    around do |example|
+      Dir.mktmpdir do |dir|
+        Dir.chdir(dir, &example)
+      end
+    end
+
+    def write(file, content)
+      FileUtils.mkdir_p(File.dirname(file))
+      File.open(file, 'w') { |f| f.write content }
+    end
+
+    it "logs shared examples into the running files" do
+      write "spec/spec_helper.rb", <<-RUBY
+        shared_examples "foo" do
+          it "is slow" do
+            sleep 0.5
+          end
+        end
+      RUBY
+
+      ["a", "b"].each do |letter|
+        write "spec/#{letter}_spec.rb", <<-RUBY
+          require 'spec_helper'
+          describe 'xxx' do
+            it_behaves_like "foo"
+          end
+        RUBY
+      end
+
+      system("TEST_ENV_NUMBER=1 rspec spec -I #{Bundler.root.join("lib")} --format ParallelTests::RSpec::RuntimeLogger --out runtime.log 2>&1") || raise("nope")
+
+      result = File.read("runtime.log")
+      result.should include "a_spec.rb:0.5"
+      result.should include "b_spec.rb:0.5"
+      result.should_not include "spec_helper"
+    end
+
+    it "logs multiple describe blocks" do
+      write "spec/a_spec.rb", <<-RUBY
+        describe "xxx" do
+          it "is slow" do
+            sleep 0.5
+          end
+        end
+
+        describe "yyy" do
+          it "is slow" do
+            sleep 0.5
+          end
+
+          describe "yep" do
+            it "is slow" do
+              sleep 0.5
+            end
+          end
+        end
+      RUBY
+
+      system("TEST_ENV_NUMBER=1 rspec spec -I #{Bundler.root.join("lib")} --format ParallelTests::RSpec::RuntimeLogger --out runtime.log 2>&1") || raise("nope")
+
+      result = File.read("runtime.log")
+      result.should include "a_spec.rb:1.5"
+    end
+  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 2>/dev/null && 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 2>/dev/null && 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