We're sorry, but something went wrong.
If you are the application owner check the logs for more information.
parallel_tests-5.4.0/spec/fixtures/rails72/public/apple-touch-icon-precomposed.png 0000664 0000000 0000000 00000000000 15043316274 0030270 0 ustar 00root root 0000000 0000000 parallel_tests-5.4.0/spec/fixtures/rails72/public/apple-touch-icon.png 0000664 0000000 0000000 00000000000 15043316274 0025752 0 ustar 00root root 0000000 0000000 parallel_tests-5.4.0/spec/fixtures/rails72/public/favicon.ico 0000664 0000000 0000000 00000000000 15043316274 0024216 0 ustar 00root root 0000000 0000000 parallel_tests-5.4.0/spec/fixtures/rails72/public/robots.txt 0000664 0000000 0000000 00000000143 15043316274 0024156 0 ustar 00root root 0000000 0000000 # See https://www.robotstxt.org/robotstxt.html for documentation on how to use the robots.txt file
parallel_tests-5.4.0/spec/fixtures/rails72/storage/ 0000775 0000000 0000000 00000000000 15043316274 0022275 5 ustar 00root root 0000000 0000000 parallel_tests-5.4.0/spec/fixtures/rails72/storage/.keep 0000664 0000000 0000000 00000000000 15043316274 0023210 0 ustar 00root root 0000000 0000000 parallel_tests-5.4.0/spec/fixtures/rails72/test/ 0000775 0000000 0000000 00000000000 15043316274 0021610 5 ustar 00root root 0000000 0000000 parallel_tests-5.4.0/spec/fixtures/rails72/test/application_system_test_case.rb 0000664 0000000 0000000 00000000235 15043316274 0030076 0 ustar 00root root 0000000 0000000 require "test_helper"
class ApplicationSystemTestCase < ActionDispatch::SystemTestCase
driven_by :selenium, using: :chrome, screen_size: [1400, 1400]
end
parallel_tests-5.4.0/spec/fixtures/rails72/test/channels/ 0000775 0000000 0000000 00000000000 15043316274 0023403 5 ustar 00root root 0000000 0000000 parallel_tests-5.4.0/spec/fixtures/rails72/test/channels/application_cable/ 0000775 0000000 0000000 00000000000 15043316274 0027034 5 ustar 00root root 0000000 0000000 parallel_tests-5.4.0/spec/fixtures/rails72/test/channels/application_cable/connection_test.rb 0000664 0000000 0000000 00000000370 15043316274 0032557 0 ustar 00root root 0000000 0000000 require "test_helper"
class ApplicationCable::ConnectionTest < ActionCable::Connection::TestCase
# test "connects with cookies" do
# cookies.signed[:user_id] = 42
#
# connect
#
# assert_equal connection.user_id, "42"
# end
end
parallel_tests-5.4.0/spec/fixtures/rails72/test/controllers/ 0000775 0000000 0000000 00000000000 15043316274 0024156 5 ustar 00root root 0000000 0000000 parallel_tests-5.4.0/spec/fixtures/rails72/test/controllers/.keep 0000664 0000000 0000000 00000000000 15043316274 0025071 0 ustar 00root root 0000000 0000000 parallel_tests-5.4.0/spec/fixtures/rails72/test/fixtures/ 0000775 0000000 0000000 00000000000 15043316274 0023461 5 ustar 00root root 0000000 0000000 parallel_tests-5.4.0/spec/fixtures/rails72/test/fixtures/files/ 0000775 0000000 0000000 00000000000 15043316274 0024563 5 ustar 00root root 0000000 0000000 parallel_tests-5.4.0/spec/fixtures/rails72/test/fixtures/files/.keep 0000664 0000000 0000000 00000000000 15043316274 0025476 0 ustar 00root root 0000000 0000000 parallel_tests-5.4.0/spec/fixtures/rails72/test/fixtures/users.yml 0000664 0000000 0000000 00000000542 15043316274 0025346 0 ustar 00root root 0000000 0000000 # Read about fixtures at https://api.rubyonrails.org/classes/ActiveRecord/FixtureSet.html
# This model initially had no columns defined. If you add columns to the
# model remove the "{}" from the fixture names and add the columns immediately
# below each fixture, per the syntax in the comments below
#
one: {}
# column: value
#
two: {}
# column: value
parallel_tests-5.4.0/spec/fixtures/rails72/test/helpers/ 0000775 0000000 0000000 00000000000 15043316274 0023252 5 ustar 00root root 0000000 0000000 parallel_tests-5.4.0/spec/fixtures/rails72/test/helpers/.keep 0000664 0000000 0000000 00000000000 15043316274 0024165 0 ustar 00root root 0000000 0000000 parallel_tests-5.4.0/spec/fixtures/rails72/test/integration/ 0000775 0000000 0000000 00000000000 15043316274 0024133 5 ustar 00root root 0000000 0000000 parallel_tests-5.4.0/spec/fixtures/rails72/test/integration/.keep 0000664 0000000 0000000 00000000000 15043316274 0025046 0 ustar 00root root 0000000 0000000 parallel_tests-5.4.0/spec/fixtures/rails72/test/mailers/ 0000775 0000000 0000000 00000000000 15043316274 0023244 5 ustar 00root root 0000000 0000000 parallel_tests-5.4.0/spec/fixtures/rails72/test/mailers/.keep 0000664 0000000 0000000 00000000000 15043316274 0024157 0 ustar 00root root 0000000 0000000 parallel_tests-5.4.0/spec/fixtures/rails72/test/models/ 0000775 0000000 0000000 00000000000 15043316274 0023073 5 ustar 00root root 0000000 0000000 parallel_tests-5.4.0/spec/fixtures/rails72/test/models/.keep 0000664 0000000 0000000 00000000000 15043316274 0024006 0 ustar 00root root 0000000 0000000 parallel_tests-5.4.0/spec/fixtures/rails72/test/models/user_test.rb 0000664 0000000 0000000 00000000166 15043316274 0025440 0 ustar 00root root 0000000 0000000 require "test_helper"
class UserTest < ActiveSupport::TestCase
# test "the truth" do
# assert true
# end
end
parallel_tests-5.4.0/spec/fixtures/rails72/test/system/ 0000775 0000000 0000000 00000000000 15043316274 0023134 5 ustar 00root root 0000000 0000000 parallel_tests-5.4.0/spec/fixtures/rails72/test/system/.keep 0000664 0000000 0000000 00000000000 15043316274 0024047 0 ustar 00root root 0000000 0000000 parallel_tests-5.4.0/spec/fixtures/rails72/test/test_helper.rb 0000664 0000000 0000000 00000000602 15043316274 0024451 0 ustar 00root root 0000000 0000000 ENV["RAILS_ENV"] ||= "test"
require_relative "../config/environment"
require "rails/test_help"
class ActiveSupport::TestCase
# Run tests in parallel with specified workers
parallelize(workers: :number_of_processors)
# Setup all fixtures in test/fixtures/*.yml for all tests in alphabetical order.
fixtures :all
# Add more helper methods to be used by all tests here...
end
parallel_tests-5.4.0/spec/fixtures/rails72/vendor/ 0000775 0000000 0000000 00000000000 15043316274 0022126 5 ustar 00root root 0000000 0000000 parallel_tests-5.4.0/spec/fixtures/rails72/vendor/.keep 0000664 0000000 0000000 00000000000 15043316274 0023041 0 ustar 00root root 0000000 0000000 parallel_tests-5.4.0/spec/fixtures/rails72/vendor/javascript/ 0000775 0000000 0000000 00000000000 15043316274 0024274 5 ustar 00root root 0000000 0000000 parallel_tests-5.4.0/spec/fixtures/rails72/vendor/javascript/.keep 0000664 0000000 0000000 00000000000 15043316274 0025207 0 ustar 00root root 0000000 0000000 parallel_tests-5.4.0/spec/integration_spec.rb 0000664 0000000 0000000 00000075663 15043316274 0021400 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'spec_helper'
describe 'CLI' do
before do
FileUtils.remove_dir(folder, true)
end
after do
FileUtils.remove_dir(folder, true)
end
def folder
"/tmp/parallel_tests_tests"
end
def write(file, content)
path = "#{folder}/#{file}"
FileUtils.mkpath File.dirname(path)
File.write(path, content)
path
end
def read(file)
File.read "#{folder}/#{file}"
end
def bin_folder
File.expand_path('../bin', __dir__)
end
def executable(options = {})
["ruby", "#{bin_folder}/parallel_#{options[:type] || 'test'}"]
end
def run_tests(test_folder, options = {})
FileUtils.mkpath folder
command = [*executable(options), *test_folder]
command += ["-n", (options[:processes] || 2).to_s] unless options[:processes] == false
command += options[:add] if options[:add]
result = ''
Dir.chdir(folder) do
env = options[:export] || {}
IO.popen(env, command, err: [:child, :out]) do |io|
yield(io) if block_given?
result = io.read
end
end
raise "FAILED #{command}\n#{result}" if $?.success? == !!options[:fail]
result
end
def self.it_runs_the_default_folder_if_it_exists(type, test_folder)
it "runs the default folder if it exists" do
full_path_to_test_folder = File.join(folder, test_folder)
FileUtils.mkpath full_path_to_test_folder
results = run_tests(nil, fail: false, type: type)
expect(results).to_not include("Pass files or folders to run")
FileUtils.remove_dir(full_path_to_test_folder, true)
results = run_tests(nil, fail: true, type: type)
expect(results).to include("Pass files or folders to run")
end
end
let(:printed_commands) { /specs? per process\nTEST_ENV_NUMBER=(\d+)? PARALLEL_TEST_GROUPS=\d+ bundle exec rspec/ }
let(:printed_rerun) { /run the group again:\n\nTEST_ENV_NUMBER=(\d+)? PARALLEL_TEST_GROUPS=\d+ bundle exec rspec/ }
context "running tests sequentially" do
it "exits with 0 when each run is successful" do
run_tests "spec", type: 'rspec', fail: 0
end
it "exits with 1 when a test run fails" do
write 'spec/xxx2_spec.rb', 'describe("it"){it("should"){ expect(true).to be false }}'
run_tests "spec", type: 'rspec', fail: 1
end
it "exits with 1 even when the test run exits with a different status" do
write 'spec/xxx2_spec.rb', <<~SPEC
RSpec.configure { |c| c.failure_exit_code = 99 }
describe("it"){it("should"){ expect(true).to be false }}
SPEC
run_tests "spec", type: 'rspec', fail: 1
end
it "exits with the highest exit status" do
write 'spec/xxx2_spec.rb', <<~SPEC
RSpec.configure { |c| c.failure_exit_code = 99 }
describe("it"){it("should"){ expect(true).to be false }}
SPEC
run_tests "spec", type: 'rspec', add: ["--highest-exit-status"], fail: 99
end
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"}}'
# set processes to false so we verify empty groups are discarded by default
result = run_tests "spec", type: 'rspec', processes: 4
# test ran and gave their puts
expect(result).to include('TEST1')
expect(result).to include('TEST2')
# all results present
expect(result).to include_exactly_times('1 example, 0 failure', 2) # 2 results
expect(result).to include_exactly_times('2 examples, 0 failures', 1) # 1 summary
expect(result).to include_exactly_times(/Finished in \d+(\.\d+)? seconds/, 2)
expect(result).to include_exactly_times(/Took \d+ seconds/, 1) # parallel summary
# verify empty groups are discarded. if retained then it'd say 4 processes for 2 specs
expect(result).to include '2 processes for 2 specs, ~ 1 spec per process'
end
context "running test in parallel" do
it "exits with 0 when each run is successful" do
run_tests "spec", type: 'rspec', processes: 4, fail: 0
end
it "exits with 1 when a test run fails" do
write 'spec/xxx2_spec.rb', 'describe("it"){it("should"){ expect(true).to be false }}'
run_tests "spec", type: 'rspec', processes: 4, fail: 1
end
it "exits with 1 even when the test run exits with a different status" do
write 'spec/xxx2_spec.rb', <<~SPEC
RSpec.configure { |c| c.failure_exit_code = 99 }
describe("it"){it("should"){ expect(true).to be false }}
SPEC
run_tests "spec", type: 'rspec', processes: 4, fail: 1
end
it "exits with the highest exit status" do
write 'spec/xxx2_spec.rb', <<~SPEC
RSpec.configure { |c| c.failure_exit_code = 99 }
describe("it"){it("should"){ expect(true).to be false }}
SPEC
run_tests "spec", type: 'rspec', processes: 4, add: ["--highest-exit-status"], fail: 99
end
end
# Uses `Process.kill` under the hood, which on Windows doesn't work as expected. It kills all process group instead of just one process.
describe "--fail-fast", unless: Gem.win_platform? do
def run_tests(test_option: nil)
# group-by + order for stable execution ... doc and verbose to ease debugging
test_options = "--format doc --order defined"
test_options = "#{test_options} #{test_option}" if test_option
super(
"spec",
fail: true,
type: 'rspec',
processes: 2,
add: ["--group-by", "found", "--verbose", "--fail-fast", "--test-options", test_options]
)
end
before do
write 'spec/xxx1_spec.rb', 'describe("T1"){it("E1"){puts "YE" + "S"; sleep 0.5; expect(1).to eq(2)}}' # group 1 executed
write 'spec/xxx2_spec.rb', 'describe("T2"){it("E2"){sleep 1; puts "OK"}}' # group 2 executed
write 'spec/xxx3_spec.rb', 'describe("T3"){it("E3"){puts "NO3"}}' # group 1 skipped
write 'spec/xxx4_spec.rb', 'describe("T4"){it("E4"){puts "NO4"}}' # group 2 skipped
write 'spec/xxx5_spec.rb', 'describe("T5"){it("E5"){puts "NO5"}}' # group 1 skipped
write 'spec/xxx6_spec.rb', 'describe("T6"){it("E6"){puts "NO6"}}' # group 2 skipped
end
it "can fail fast on a single test" do
result = run_tests(test_option: "--fail-fast")
expect(result).to include_exactly_times("YES", 1)
expect(result).to include_exactly_times("OK", 1) # is allowed to finish but no new test is started after
expect(result).to_not include("NO")
expect(result).to include_exactly_times('1 example, 1 failure', 1) # rspec group 1
expect(result).to include_exactly_times('1 example, 0 failure', 1) # rspec group 2
expect(result).to include_exactly_times('2 examples, 1 failure', 1) # parallel_rspec summary
expect(result).to include '2 processes for 6 specs, ~ 3 specs per process'
end
it "can fail fast on a single group" do
result = run_tests
expect(result).to include_exactly_times("YES", 1)
expect(result).to include_exactly_times("OK", 1) # is allowed to finish but no new test is started after
expect(result).to include_exactly_times("NO", 2)
expect(result).to include_exactly_times('3 examples, 1 failure', 1) # rspec group 1
expect(result).to include_exactly_times('1 example, 0 failure', 1) # rspec group 2
expect(result).to include_exactly_times('4 examples, 1 failure', 1) # parallel_rspec summary
expect(result).to include '2 processes for 6 specs, ~ 3 specs per process'
end
end
it "runs tests which outputs accented characters" do
write "spec/xxx_spec.rb", "#encoding: utf-8\ndescribe('it'){it('should'){puts 'Byłem tu'}}"
result = run_tests "spec", type: 'rspec'
# test ran and gave their puts
expect(result).to include('Byłem tu')
end
it "respects default encoding when reading child stdout" do
write 'test/xxx_test.rb', <<-EOF
require 'test/unit'
class XTest < Test::Unit::TestCase
def test_unicode
raise '¯\\_(ツ)_/¯'
end
end
EOF
# Need to tell Ruby to default to utf-8 to simulate environments where
# this is set. (Otherwise, it defaults to nil and the undefined conversion
# issue doesn't come up.)
result = run_tests('test', fail: true, export: { 'RUBYOPT' => 'Eutf-8:utf-8' })
expect(result).to include('¯\_(ツ)_/¯')
end
it "does not run any tests if there are none" do
write 'spec/xxx_spec.rb', '1'
result = run_tests "spec", type: 'rspec'
expect(result).to include('No examples found')
expect(result).to include('Took')
end
it "shows command and rerun with --verbose-command" do
write 'spec/xxx_spec.rb', 'describe("it"){it("should"){puts "TEST1"}}'
write 'spec/xxx2_spec.rb', 'describe("it"){it("should"){expect(1).to eq(2)}}'
result = run_tests ["spec", "--verbose-command"], type: 'rspec', fail: true
expect(result).to match printed_commands
expect(result).to match printed_rerun
expect(result).to include "bundle exec rspec spec/xxx_spec.rb"
expect(result).to include "bundle exec rspec spec/xxx2_spec.rb"
end
it "shows only rerun with --verbose-rerun-command" do
write 'spec/xxx_spec.rb', 'describe("it"){it("should"){expect(1).to eq(2)}}'
result = run_tests ["spec", "--verbose-rerun-command"], type: 'rspec', fail: true
expect(result).to match printed_rerun
expect(result).to_not match printed_commands
end
it "shows only process with --verbose-process-command" do
write 'spec/xxx_spec.rb', 'describe("it"){it("should"){expect(1).to eq(2)}}'
result = run_tests ["spec", "--verbose-process-command"], type: 'rspec', fail: true
expect(result).to_not match printed_rerun
expect(result).to match printed_commands
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"){expect(1).to eq(2)}}'
result = run_tests "spec", fail: true, type: 'rspec'
expect(result).to include_exactly_times('1 example, 1 failure', 1)
expect(result).to include_exactly_times('1 example, 0 failure', 1)
expect(result).to include_exactly_times('2 examples, 1 failure', 1)
end
it "can serialize stdout" do
write 'spec/xxx_spec.rb', '5.times{describe("it"){it("should"){sleep 0.01; puts "TEST1"}}}'
write 'spec/xxx2_spec.rb', 'sleep 0.01; 5.times{describe("it"){it("should"){sleep 0.01; puts "TEST2"}}}'
result = run_tests "spec", type: 'rspec', add: ["--serialize-stdout"]
expect(result).not_to match(/TEST1.*TEST2.*TEST1/m)
expect(result).not_to match(/TEST2.*TEST1.*TEST2/m)
end
it "can show simulated output when serializing stdout" do
write 'spec/xxx_spec.rb', 'describe("it"){it("should"){sleep 0.5; puts "TEST1"}}'
write 'spec/xxx2_spec.rb', 'describe("it"){it("should"){sleep 1; puts "TEST2"}}'
result = run_tests "spec", type: 'rspec', add: ["--serialize-stdout"], export: { 'PARALLEL_TEST_HEARTBEAT_INTERVAL' => '0.01' }
expect(result).to match(/\.{4}.*TEST1.*\.{4}.*TEST2/m)
end
it "can show simulated output preceded by command when serializing stdout with verbose option" do
write 'spec/xxx_spec.rb', 'describe("it"){it("should"){sleep 1.5; puts "TEST1"}}'
result = run_tests ["spec", "--verbose"], type: 'rspec', add: ["--serialize-stdout"], export: { 'PARALLEL_TEST_HEARTBEAT_INTERVAL' => '0.02' }
expect(result).to match(/\.{5}.*\nbundle exec rspec spec\/xxx_spec\.rb\n.*^TEST1/m)
end
it "can serialize stdout and stderr" do
write 'spec/xxx_spec.rb', '5.times{describe("it"){it("should"){sleep 0.01; $stderr.puts "errTEST1"; puts "TEST1"}}}'
write 'spec/xxx2_spec.rb', 'sleep 0.01; 5.times{describe("it"){it("should"){sleep 0.01; $stderr.puts "errTEST2"; puts "TEST2"}}}'
result = run_tests ["spec"], type: 'rspec', add: ["--serialize-stdout", "--combine-stderr"]
expect(result).not_to match(/TEST1.*TEST2.*TEST1/m)
expect(result).not_to match(/TEST2.*TEST1.*TEST2/m)
end
context "with given commands" do
it "can exec given commands with ENV['TEST_ENV_NUMBER']" do
result = run_tests ['-e', 'ruby -e "print ENV[:TEST_ENV_NUMBER.to_s].to_i"'], processes: 4
expect(result.gsub('"', '').chars.sort).to eq(['0', '2', '3', '4'])
end
it "can exec given commands with $TEST_ENV_NUMBER" do
result = run_tests ['-e', 'echo foo-$TEST_ENV_NUMBER'], processes: 4
expect(result.split(/\n+/).sort).to eq(['foo-', 'foo-2', 'foo-3', 'foo-4'])
end
it "can exec given command non-parallel" do
result = run_tests(
['-e', 'ruby -e "sleep(rand(10)/100.0); puts ENV[:TEST_ENV_NUMBER.to_s].inspect"'],
processes: 4,
add: ['--non-parallel']
)
expect(result.split(/\n+/)).to eq(['""', '"2"', '"3"', '"4"'])
end
it "can exec given command with a restricted set of groups" do
result = run_tests(
['-e', 'ruby -e "print ENV[:TEST_ENV_NUMBER.to_s].to_i"'],
process: 4,
add: ['--only-group', '1,3']
)
expect(result.gsub('"', '').chars.sort).to eq(['0', '3'])
end
it "can serialize stdout" do
result = run_tests(
['-e', 'ruby -e "5.times{sleep 0.01;puts ENV[:TEST_ENV_NUMBER.to_s].to_i;STDOUT.flush}"'],
processes: 2,
add: ['--serialize-stdout']
)
expect(result).not_to match(/0.*2.*0/m)
expect(result).not_to match(/2.*0.*2/m)
end
it "runs command in parallel with files as arguments" 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 "spec", type: 'rspec', add: ["--exec-args", "echo"]
expect(result).to include_exactly_times('spec/xxx_spec.rb', 1)
expect(result).to include_exactly_times('spec/xxx2_spec.rb', 1)
end
it "runs two commands in parallel with files as arguments" do
write 'spec/xxx_spec.rb', 'p ARGV; describe("it"){it("should"){puts "TEST1"}}'
write 'spec/xxx2_spec.rb', 'describe("it"){it("should"){puts "TEST2"}}'
# need to `--` so sh uses them as arguments that then go into $@
result = run_tests "spec", type: 'rspec', add: ["--exec-args", "sh -c \"echo 'hello world' && rspec $@\" --"]
expect(result).to include_exactly_times('hello world', 2)
expect(result).to include_exactly_times('TEST1', 1)
expect(result).to include_exactly_times('TEST2', 1)
end
it "exists with success if all sub-processes returned success" do
expect(system(*executable, '-e', 'cat /dev/null', '-n', '4')).to eq(true)
end
it "exists with failure if any sub-processes returned failure" do
expect(system(*executable, '-e', 'test -e xxxx', '-n', '4')).to eq(false)
end
end
['rspec', 'cucumber', 'spinach'].each do |type|
it "runs through parallel_#{type}" do
test_version = IO.popen([*executable, '-v'], &:read)
expect($?.success?).to be(true)
type_version = IO.popen(['ruby', "#{bin_folder}/parallel_#{type}", '-v'], &:read)
expect($?.success?).to be(true)
expect(type_version).to eq(test_version)
end
end
it "runs with --group-by found" do
# it only tests that it does not blow up, as it did before fixing...
write "spec/x1_spec.rb", "puts 'TEST111'"
run_tests ["spec"], type: 'rspec', add: ['--group-by', 'found']
end
it "runs in parallel" do
2.times do |i|
write "spec/xxx#{i}_spec.rb", 'STDOUT.sync = true; describe("it") { it("should"){ puts "START"; sleep 1; puts "END" } }'
end
result = run_tests(["spec"], processes: 2, type: 'rspec')
expect(result.scan(/START|END/)).to eq(["START", "START", "END", "END"])
end
it "disables spring so correct database is used" do
write "spec/xxx_spec.rb", 'puts "SPRING: #{ENV["DISABLE_SPRING"]}"'
result = run_tests(["spec"], processes: 2, type: 'rspec')
expect(result).to include "SPRING: 1"
end
it "can enable spring" do
write "spec/xxx_spec.rb", 'puts "SPRING: #{ENV["DISABLE_SPRING"]}"'
result = run_tests(["spec"], processes: 2, type: 'rspec', export: { "DISABLE_SPRING" => "0" })
expect(result).to include "SPRING: 0"
end
it "runs with files that have spaces" do
write "test/xxx _test.rb", 'puts "TEST_SUCCESS"'
result = run_tests(["test"], processes: 2, type: 'test')
expect(result).to include "TEST_SUCCESS"
end
it "uses relative paths for easy copying" do
write "test/xxx_test.rb", 'puts "Test output: YES"'
result = run_tests(["test"], processes: 2, type: 'test', add: ['--verbose'])
expect(result).to include "Test output: YES"
expect(result).to include "\\[test/xxx_test.rb\\]"
expect(result).not_to include Dir.pwd
end
it "can run with given files" do
write "spec/x1_spec.rb", "puts 'TEST111'"
write "spec/x2_spec.rb", "puts 'TEST222'"
write "spec/x3_spec.rb", "puts 'TEST333'"
result = run_tests ["spec/x1_spec.rb", "spec/x3_spec.rb"], type: 'rspec'
expect(result).to include('TEST111')
expect(result).to include('TEST333')
expect(result).not_to include('TEST222')
end
it "can run with test-options" do
write "spec/x1_spec.rb", "111"
write "spec/x2_spec.rb", "111"
result = run_tests ["spec"], add: ["--test-options", "--version"], processes: 2, type: 'rspec'
expect(result).to match(/\d+\.\d+\.\d+.*\d+\.\d+\.\d+/m) # prints version twice
end
it "runs with PARALLEL_TEST_PROCESSORS processes" do
skip if RUBY_PLATFORM == "java" # execution expired issue on JRuby
processes = 5
processes.times do |i|
write "spec/x#{i}_spec.rb", "puts %{ENV-\#{ENV['TEST_ENV_NUMBER']}-}"
end
result = run_tests(
["spec"], export: { "PARALLEL_TEST_PROCESSORS" => processes.to_s }, processes: processes, type: 'rspec'
)
expect(result.scan(/ENV-.?-/)).to match_array(["ENV--", "ENV-2-", "ENV-3-", "ENV-4-", "ENV-5-"])
end
it "filters test by given pattern and relative paths" do
write "spec/x_spec.rb", "puts 'TESTXXX'"
write "spec/y_spec.rb", "puts 'TESTYYY'"
write "spec/z_spec.rb", "puts 'TESTZZZ'"
result = run_tests ["spec"], add: ["-p", "^spec/(x|z)"], type: "rspec"
expect(result).to include('TESTXXX')
expect(result).not_to include('TESTYYY')
expect(result).to include('TESTZZZ')
end
it "excludes test by given pattern and relative paths" do
write "spec/x_spec.rb", "puts 'TESTXXX'"
write "spec/acceptance/y_spec.rb", "puts 'TESTYYY'"
write "spec/integration/z_spec.rb", "puts 'TESTZZZ'"
result = run_tests ["spec"], add: ["--exclude-pattern", "spec/(integration|acceptance)"], type: "rspec"
expect(result).to include('TESTXXX')
expect(result).not_to include('TESTYYY')
expect(result).not_to include('TESTZZZ')
end
it "can wait_for_other_processes_to_finish" do
skip if RUBY_PLATFORM == "java" # just too slow ...
write "test/a_test.rb", "require 'parallel_tests'; sleep 0.5 ; ParallelTests.wait_for_other_processes_to_finish; puts 'OutputA'"
write "test/b_test.rb", "sleep 1; puts 'OutputB'"
write "test/c_test.rb", "sleep 1.5; puts 'OutputC'"
write "test/d_test.rb", "sleep 2; puts 'OutputD'"
actual = run_tests(["test"], processes: 4).scan(/Output[ABCD]/)
actual_sorted = [*actual[0..2].sort, actual[3]]
expect(actual_sorted).to match(["OutputB", "OutputC", "OutputD", "OutputA"])
end
it "can run only a single group" do
skip if RUBY_PLATFORM == "java" # just too slow ...
write "test/long_test.rb", "puts 'this is a long test'"
write "test/short_test.rb", "puts 'short test'"
group_1_result = run_tests(["test"], processes: 2, add: ['--only-group', '1'])
expect(group_1_result).to include("this is a long test")
expect(group_1_result).not_to include("short test")
group_2_result = run_tests(["test"], processes: 2, add: ['--only-group', '2'])
expect(group_2_result).not_to include("this is a long test")
expect(group_2_result).to include("short test")
end
it "shows nice --help" do
result = run_tests ["--help"]
expect(
result[/(.*)How many processes/, 1].size
).to(
eq(result[/( +)found /, 1].size),
"Multiline option description must align with regular option description"
)
end
it "can run with uncommon file names" do
skip if RUBY_PLATFORM == "java" # just too slow ...
write "test/long ( stuff ) _test.rb", "puts 'hey'"
expect(run_tests(["test"], processes: 2)).to include("hey")
end
context "RSpec" do
it_runs_the_default_folder_if_it_exists "rspec", "spec"
it "captures seed with random failures with --verbose" 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 ["spec", "--verbose"], add: ["--test-options", "--seed 1234"], fail: true, type: 'rspec'
expect(result).to include("Randomized with seed 1234")
expect(result).to include("bundle exec rspec --seed 1234 spec/xxx2_spec.rb")
end
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 ["test"]
expect(result).to include('1 test')
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(["test"], add: ['--test-options', '-v'])
expect(result).to include('test_xxx') # verbose output of every test
end
it_runs_the_default_folder_if_it_exists "test", "test"
end
context "Cucumber" do
before do
write "features/steps/a.rb", "
Given('I print TEST_ENV_NUMBER'){ puts \"YOUR TEST ENV IS \#{ENV['TEST_ENV_NUMBER']}!\" }
And('I sleep a bit'){ sleep 0.5 }
And('I pass'){ true }
And('I fail'){ fail }
"
end
it "runs tests which outputs accented characters" do
write "features/good1.feature", "Feature: xxx\n Scenario: xxx\n Given I print accented characters"
write "features/steps/a.rb", "#encoding: utf-8\nGiven('I print accented characters'){ puts \"I tu też\" }"
result = run_tests ["features"], type: "cucumber", add: ['--pattern', 'good']
expect(result).to include('I tu też')
end
it "passes TEST_ENV_NUMBER when running with pattern (issue #86)" do
write "features/good1.feature", "Feature: xxx\n Scenario: xxx\n Given I print TEST_ENV_NUMBER"
write "features/good2.feature", "Feature: xxx\n Scenario: xxx\n Given I print TEST_ENV_NUMBER"
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 ["features"], type: "cucumber", add: ['--pattern', 'good']
expect(result).to include('YOUR TEST ENV IS 2!')
expect(result).to include('YOUR TEST ENV IS !')
expect(result).not_to include('I FAIL')
end
it "writes a runtime log" do
skip "TODO find out why this fails" if RUBY_PLATFORM == "java"
log = "tmp/parallel_runtime_cucumber.log"
write(log, "x")
2.times do |i|
# needs sleep so that runtime loggers dont overwrite each other initially
write "features/good#{i}.feature", "Feature: xxx\n Scenario: xxx\n Given I print TEST_ENV_NUMBER\n And I sleep a bit"
end
run_tests ["features"], type: "cucumber"
expect(read(log).gsub(/\.\d+/, '').split("\n")).to match_array(["features/good0.feature:0", "features/good1.feature:0"])
end
it "runs each feature once when there are more processes then features (issue #89)" do
2.times do |i|
write "features/good#{i}.feature", "Feature: xxx\n Scenario: xxx\n Given I print TEST_ENV_NUMBER"
end
result = run_tests ["features"], type: "cucumber", add: ['-n', '3']
expect(result.scan(/YOUR TEST ENV IS \d?!/).sort).to eq(["YOUR TEST ENV IS !", "YOUR TEST ENV IS 2!"])
end
it_runs_the_default_folder_if_it_exists "cucumber", "features"
it "collates failing scenarios" do
write "features/pass.feature", "Feature: xxx\n Scenario: xxx\n Given I pass"
write "features/fail1.feature", "Feature: xxx\n Scenario: xxx\n Given I fail"
write "features/fail2.feature", "Feature: xxx\n Scenario: xxx\n Given I fail"
results = run_tests ["features"], processes: 3, type: "cucumber", fail: true
failing_scenarios = if Gem.win_platform? && RUBY_VERSION < "3.3.0"
["cucumber features/fail1.feature:2 # Scenario: xxx", "cucumber features/fail2.feature:2 # Scenario: xxx"]
else
["cucumber features/fail2.feature:2 # Scenario: xxx", "cucumber features/fail1.feature:2 # Scenario: xxx"]
end
results.gsub!(/.*WARNING.*\n/, "")
expect(results).to include <<-EOF.gsub(' ', '')
Failing Scenarios:
#{failing_scenarios[0]}
#{failing_scenarios[1]}
3 scenarios (2 failed, 1 passed)
3 steps (2 failed, 1 passed)
EOF
end
it "groups by scenario" do
write "features/long.feature", <<-EOS
Feature: xxx
Scenario: xxx
Given I print TEST_ENV_NUMBER
Scenario: xxx
Given I print TEST_ENV_NUMBER
Scenario Outline: xxx
Given I print TEST_ENV_NUMBER
Examples:
| num |
| one |
| two |
EOS
result = run_tests ["features"], type: "cucumber", add: ["--group-by", "scenarios"]
expect(result).to include("2 processes for 4 scenarios")
end
it "groups by step" do
write "features/good1.feature", "Feature: xxx\n Scenario: xxx\n Given I print TEST_ENV_NUMBER"
write "features/good2.feature", "Feature: xxx\n Scenario: xxx\n Given I print TEST_ENV_NUMBER"
result = run_tests ["features"], type: "cucumber", add: ['--group-by', 'steps']
expect(result).to include("2 processes for 2 features")
end
it "captures seed with random failures with --verbose" do
write "features/good1.feature", "Feature: xxx\n Scenario: xxx\n Given I fail"
result = run_tests ["features", "--verbose"], type: "cucumber", add: ["--test-options", "--order random:1234"], fail: true
expect(result).to include("Randomized with seed 1234")
expect(result).to match(%r{bundle exec cucumber "?features/good1.feature"? --order random:1234})
end
end
context "Spinach" do
before do
write "features/steps/a.rb", <<-RUBY.strip_heredoc
class A < Spinach::FeatureSteps
Given 'I print TEST_ENV_NUMBER' do
puts "YOUR TEST ENV IS \#{ENV['TEST_ENV_NUMBER']}!"
end
And 'I sleep a bit' do
sleep 0.2
end
end
RUBY
end
it "runs tests which outputs accented characters" do
write "features/good1.feature", "Feature: a\n Scenario: xxx\n Given I print accented characters"
write "features/steps/a.rb", "#encoding: utf-8\nclass A < Spinach::FeatureSteps\nGiven 'I print accented characters' do\n puts \"I tu też\" \n end\nend"
result = run_tests ["features"], type: "spinach", add: ['features/good1.feature'] # , :add => '--pattern good'
expect(result).to include('I tu też')
end
it "passes TEST_ENV_NUMBER when running with pattern (issue #86)" do
write "features/good1.feature", "Feature: a\n Scenario: xxx\n Given I print TEST_ENV_NUMBER"
write "features/good2.feature", "Feature: a\n Scenario: xxx\n Given I print TEST_ENV_NUMBER"
write "features/b.feature", "Feature: b\n Scenario: xxx\n Given I FAIL" # Expect this not to be run
result = run_tests ["features"], type: "spinach", add: ['--pattern', 'good']
expect(result).to include('YOUR TEST ENV IS 2!')
expect(result).to include('YOUR TEST ENV IS !')
expect(result).not_to include('I FAIL')
end
it "writes a runtime log" do
skip 'not yet implemented -- custom runtime logging'
log = "tmp/parallel_runtime_spinach.log"
write(log, "x")
2.times do |i|
# needs sleep so that runtime loggers dont overwrite each other initially
write "features/good#{i}.feature", "Feature: A\n Scenario: xxx\n Given I print TEST_ENV_NUMBER\n And I sleep a bit"
end
run_tests ["features"], type: "spinach"
expect(read(log).gsub(/\.\d+/, '').split("\n")).to match_array(["features/good0.feature:0", "features/good1.feature:0"])
end
it "runs each feature once when there are more processes then features (issue #89)" do
2.times do |i|
write "features/good#{i}.feature", "Feature: A\n Scenario: xxx\n Given I print TEST_ENV_NUMBER\n"
end
result = run_tests ["features"], type: "spinach", add: ['-n', '3']
expect(result.scan(/YOUR TEST ENV IS \d?!/).sort).to eq(["YOUR TEST ENV IS !", "YOUR TEST ENV IS 2!"])
end
it_runs_the_default_folder_if_it_exists "spinach", "features"
end
describe "graceful shutdown" do
# Process.kill on Windows doesn't work as expected. It kills all process group instead of just one process.
it "passes on int signal to child processes", unless: Gem.win_platform? do
timeout = 2
write(
"spec/test_spec.rb",
"sleep #{timeout}; describe { specify { p 'Should not get here' }; specify { p 'Should not get here either'} }"
)
pid = nil
Thread.new { sleep timeout - 0.5; Process.kill("INT", pid) }
result = run_tests(["spec"], processes: 2, type: 'rspec', fail: true) { |io| pid = io.pid }
expect(result).to include("RSpec is shutting down")
expect(result).to_not include("Should not get here")
expect(result).to_not include("Should not get here either")
end
# Process.kill on Windows doesn't work as expected. It kills all process group instead of just one process.
it "exits immediately if another int signal is received", unless: Gem.win_platform? do
timeout = 2
write "spec/test_spec.rb", "describe { specify { sleep #{timeout}; p 'Should not get here'} }"
pid = nil
Thread.new { sleep timeout - 0.5; Process.kill("INT", pid) }
Thread.new { sleep timeout - 0.3; Process.kill("INT", pid) }
result = run_tests(["spec"], processes: 2, type: 'rspec', fail: false) { |io| pid = io.pid }
expect(result).to_not include("Should not get here")
end
end
describe "--test-file-limit" do
let(:test_count) { 3 }
before do
test_count.times do |i|
write "spec/x#{i}_spec.rb", "puts %(TEST-\#{ENV['TEST_ENV_NUMBER']}-\#{Process.pid})"
end
end
it "runs in batches" do
result = run_tests ["spec"], type: 'rspec', add: ['--test-file-limit', '1', '--first-is-1', '-n', '2']
expect(result.scan(/TEST-\d/).sort).to eq(["TEST-1", "TEST-1", "TEST-2"])
pids = result.scan(/TEST-\d-(\d+)/).flatten.uniq
expect(pids.size).to eq test_count # did not run 2 tests in the same process
end
it "does not run in batches when above limit" do
result = run_tests ["spec"], type: 'rspec', add: ['--test-file-limit', '2', '--first-is-1', '-n', '2']
expect(result.scan(/TEST-\d/).sort).to eq(["TEST-1", "TEST-1", "TEST-2"])
pids = result.scan(/TEST-\d-(\d+)/).flatten.uniq
expect(pids.size).to eq 2
end
end
end
parallel_tests-5.4.0/spec/parallel_tests/ 0000775 0000000 0000000 00000000000 15043316274 0020513 5 ustar 00root root 0000000 0000000 parallel_tests-5.4.0/spec/parallel_tests/cli_spec.rb 0000664 0000000 0000000 00000042576 15043316274 0022637 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require "spec_helper"
require "parallel_tests/cli"
require "parallel_tests/rspec/runner"
describe ParallelTests::CLI do
subject { ParallelTests::CLI.new }
describe "#parse_options" do
let(:defaults) { { files: ["test"] } }
def call(*args)
subject.send(:parse_options!, *args)
end
it "does not fail without file" do
expect(subject).not_to receive(:abort)
call(["-n3", "-t", "rspec"])
end
it "cleanups file paths" do
expect(call(["./test"])).to eq(defaults)
end
it "parses execute" do
expect(call(["--exec", "echo"])).to eq(execute: ["echo"])
end
it "parses execute arguments" do
expect(call(["test", "--exec-args", "echo"])).to eq(defaults.merge(execute_args: ["echo"]))
end
it "parses excludes pattern" do
expect(call(["test", "--exclude-pattern", "spec/"])).to eq(defaults.merge(exclude_pattern: /spec\//))
end
it "parses regular count" do
expect(call(["test", "-n3"])).to eq(defaults.merge(count: 3))
end
it "parses count 0 as non-parallel" do
expect(call(["test", "-n0"])).to eq(defaults.merge(non_parallel: true))
end
it "parses non-parallel as non-parallel" do
expect(call(["test", "--non-parallel"])).to eq(defaults.merge(non_parallel: true))
end
it "finds the correct type when multiple are given" do
call(["test", "--type", "test", "-t", "rspec"])
expect(subject.instance_variable_get(:@runner)).to eq(ParallelTests::RSpec::Runner)
end
it "parses nice as nice" do
expect(call(["test", "--nice"])).to eq(defaults.merge(nice: true))
end
it "parses --verbose" do
expect(call(["test", "--verbose"])).to eq(defaults.merge(verbose: true))
end
it "parses --verbose-command" do
expect(call(['test', '--verbose-command'])).to eq(
defaults.merge(verbose_process_command: true, verbose_rerun_command: true)
)
end
it "parses --verbose-process-command" do
expect(call(['test', '--verbose-process-command'])).to eq(
defaults.merge(verbose_process_command: true)
)
end
it "parses --verbose-rerun-command" do
expect(call(['test', '--verbose-rerun-command'])).to eq(
defaults.merge(verbose_rerun_command: true)
)
end
it "parses --failure-exit-code" do
expect(call(["test", "--failure-exit-code", "42"])).to eq(defaults.merge(failure_exit_code: 42))
end
it "parses --quiet" do
expect(call(["test", "--quiet"])).to eq(defaults.merge(quiet: true))
end
it "fails if both --verbose and --quiet are present" do
expect { call(["test", "--verbose", "--quiet"]) }.to raise_error(RuntimeError)
end
it "parses --suffix" do
expect(call(["test", "--suffix", "_(test|spec).rb$"])).to eq(defaults.merge(suffix: /_(test|spec).rb$/))
end
it "parses --first-is-1" do
expect(call(["test", "--first-is-1"]))
.to eq(defaults.merge(first_is_1: true))
end
it "parses allow-duplicates" do
expect(call(["test", "--allow-duplicates"])).to eq(defaults.merge(allow_duplicates: true))
end
context "parse only-group" do
it "group_by should be set to filesize" do
expect(call(["test", "--only-group", '1'])).to eq(defaults.merge(only_group: [1], group_by: :filesize))
end
it "allows runtime" do
expect(call(["test", "--only-group", '1', '--group-by', 'runtime'])).to eq(defaults.merge(only_group: [1], group_by: :runtime))
end
it "raise error when group_by isn't filesize" do
expect do
call(["test", "--only-group", '1', '--group-by', 'steps'])
end.to raise_error(RuntimeError)
end
it "with multiple groups" do
expect(call(["test", "--only-group", '4,5'])).to eq(defaults.merge(only_group: [4, 5], group_by: :filesize))
end
it "with a single group" do
expect(call(["test", "--only-group", '4'])).to eq(defaults.merge(only_group: [4], group_by: :filesize))
end
end
context "single and isolate" do
it "single_process should be an array of patterns" do
expect(call(["test", "--single", '1'])).to eq(defaults.merge(single_process: [/1/]))
end
it "single_process should be an array of patterns" do
expect(call(["test", "--single", '1', "--single", '2'])).to eq(defaults.merge(single_process: [/1/, /2/]))
end
it "isolate should set isolate_count defaults" do
expect(call(["test", "--single", '1', "--isolate"])).to eq(defaults.merge(single_process: [/1/], isolate: true))
end
it "isolate_n should set isolate_count and turn on isolate" do
expect(call(["test", "-n", "3", "--single", '1', "--isolate-n", "2"])).to eq(
defaults.merge(count: 3, single_process: [/1/], isolate_count: 2)
)
end
end
context "specify groups" do
it "groups can be just one string" do
expect(call(["test", "--specify-groups", 'test'])).to eq(defaults.merge(specify_groups: 'test'))
end
it "groups can be a string separated by commas and pipes" do
expect(call(["test", "--specify-groups", 'test1,test2|test3'])).to eq(defaults.merge(specify_groups: 'test1,test2|test3'))
end
end
context "when the -- option separator is used" do
it "interprets arguments as files/directories" do
expect(call(['--', 'test'])).to eq(files: ['test'])
expect(call(['--', './test'])).to eq(files: ['test'])
expect(call(['--', 'test', 'test2'])).to eq(files: ['test', 'test2'])
expect(call(['--', '--foo', 'test'])).to eq(files: ['--foo', 'test'])
expect(call(['--', 'test', '--foo', 'test2'])).to eq(files: ['test', '--foo', 'test2'])
end
it "correctly handles arguments with spaces" do
expect(call(['--', 'file name with space'])).to eq(files: ['file name with space'])
end
context "when the -o options has also been given" do
it "merges the options together" do
expect(call(['-o', "'-f'", '--', 'test', '--foo', 'test2'])).to eq(files: ['test', '--foo', 'test2'], test_options: ['-f'])
end
end
context "when a second -- option separator is used" do
it "interprets the first set as test_options" do
expect(call(['--', '-r', 'foo', '--', 'test'])).to eq(files: ['test'], test_options: ['-r', 'foo'])
expect(call(['--', '-r', 'foo', '--', 'test', 'test2'])).to eq(files: ['test', 'test2'], test_options: ['-r', 'foo'])
expect(call(['--', '-r', 'foo', '-o', 'out.log', '--', 'test', 'test2'])).to eq(files: ['test', 'test2'], test_options: ['-r', 'foo', '-o', 'out.log'])
end
context "when existing test_options have previously been given" do
it "appends the new options" do
expect(call(['-o', '-f', '--', '-r', 'foo.rb', '--', 'test'])).to eq(files: ['test'], test_options: ['-f', '-r', 'foo.rb'])
end
it "correctly handles argument values with spaces" do
argv = ["-o 'path with spaces1'", '--', '--out', 'path with spaces2', '--', 'foo']
expected_test_options = ['path with spaces1', '--out', 'path with spaces2']
expect(call(argv)).to eq(files: ['foo'], test_options: expected_test_options)
end
end
end
end
end
describe "#load_runner" do
it "requires and loads default runner" do
expect(subject).to receive(:require).with("parallel_tests/test/runner")
expect(subject.send(:load_runner, "test")).to eq(ParallelTests::Test::Runner)
end
it "requires and loads rspec runner" do
expect(subject).to receive(:require).with("parallel_tests/rspec/runner")
expect(subject.send(:load_runner, "rspec")).to eq(ParallelTests::RSpec::Runner)
end
it "requires and loads runner with underscores" do
expect(subject).to receive(:require).with("parallel_tests/my_test_runner/runner")
expect(subject.send(:load_runner, "my_test_runner")).to eq(ParallelTests::MyTestRunner::Runner)
end
it "fails to load unfindable runner" do
expect do
expect(subject.send(:load_runner, "foo")).to eq(ParallelTests::RSpec::Runner)
end.to raise_error(LoadError)
end
end
describe ".report_failure_rerun_command" do
let(:single_failed_command) { [{ exit_status: 1, command: ['foo'], seed: nil, output: 'blah' }] }
it "prints nothing if there are no failures" do
expect($stdout).not_to receive(:puts)
subject.send(
:report_failure_rerun_commmand,
[
{ exit_status: 0, command: 'foo', seed: nil, output: 'blah' }
],
{ verbose: true }
)
end
def self.it_prints_nothing_about_rerun_commands(options)
it 'prints nothing about rerun commands' do
expect do
subject.send(:report_failure_rerun_commmand, single_failed_command, options)
end.to_not output(/Use the following command to run the group again/).to_stdout
end
end
describe "failure" do
before do
subject.instance_variable_set(:@runner, ParallelTests::Test::Runner)
end
context 'without options' do
it_prints_nothing_about_rerun_commands({})
end
context 'with verbose disabled' do
it_prints_nothing_about_rerun_commands(verbose: false)
end
context "with verbose rerun command" do
it "prints command if there is a failure" do
expect do
subject.send(:report_failure_rerun_commmand, single_failed_command, verbose_rerun_command: true)
end.to output("\n\nTests have failed for a parallel_test group. Use the following command to run the group again:\n\nTEST_ENV_NUMBER= PARALLEL_TEST_GROUPS= foo\n").to_stdout
end
end
context 'with verbose' do
it "prints a message and the command if there is a failure" do
expect do
subject.send(:report_failure_rerun_commmand, single_failed_command, verbose: true)
end.to output("\n\nTests have failed for a parallel_test group. Use the following command to run the group again:\n\nTEST_ENV_NUMBER= PARALLEL_TEST_GROUPS= foo\n").to_stdout
end
it "prints multiple commands if there are multiple failures" do
expect do
subject.send(
:report_failure_rerun_commmand,
[
{ exit_status: 1, command: ['foo'], seed: nil, output: 'blah' },
{ exit_status: 1, command: ['bar'], seed: nil, output: 'blah' },
{ exit_status: 1, command: ['baz'], seed: nil, output: 'blah' }
],
{ verbose: true }
)
end.to output(/\sfoo\n.+?\sbar\n.+?\sbaz/).to_stdout
end
it "only includes failures" do
expect do
subject.send(
:report_failure_rerun_commmand,
[
{ exit_status: 1, command: ['foo', '--color'], seed: nil, output: 'blah' },
{ exit_status: 0, command: ['bar'], seed: nil, output: 'blah' },
{ exit_status: 1, command: ['baz'], seed: nil, output: 'blah' }
],
{ verbose: true }
)
end.to output(/\sfoo --color\n.+?\sbaz/).to_stdout
end
it "prints the command with the seed added by the runner" do
command = ['rspec', '--color', 'spec/foo_spec.rb']
seed = 555
expect(ParallelTests::Test::Runner).to receive(:command_with_seed).with(command, seed)
.and_return(['my', 'seeded', 'command', 'result', '--seed', seed])
single_failed_command[0].merge!(seed: seed, command: command)
expect do
subject.send(:report_failure_rerun_commmand, single_failed_command, verbose: true)
end.to output(/my seeded command result --seed 555/).to_stdout
end
end
end
end
describe "#final_fail_message" do
before do
subject.instance_variable_set(:@runner, ParallelTests::Test::Runner)
end
it 'returns a plain fail message if colors are nor supported' do
expect(subject).to receive(:use_colors?).and_return(false)
expect(subject.send(:final_fail_message)).to eq("Tests Failed")
end
it 'returns a colorized fail message if colors are supported' do
expect(subject).to receive(:use_colors?).and_return(true)
expect(subject.send(:final_fail_message)).to eq("\e[31mTests Failed\e[0m")
end
end
describe "#run_tests_in_parallel" do
context "specific groups to run" do
let(:results) { { stdout: "", exit_status: 0 } }
let(:common_options) do
{ files: ["test"], group_by: :filesize, first_is_1: false }
end
before do
allow(subject).to receive(:puts)
expect(subject).to receive(:load_runner).with("my_test_runner").and_return(ParallelTests::MyTestRunner::Runner)
allow(ParallelTests::MyTestRunner::Runner).to receive(:test_file_name).and_return("test")
expect(ParallelTests::MyTestRunner::Runner).to receive(:tests_in_groups).and_return(
[
['aaa', 'bbb'],
['ccc', 'ddd'],
['eee', 'fff']
]
)
expect(subject).to receive(:report_results).and_return(nil)
end
it "calls run_tests once when one group specified" do
expect(subject).to receive(:run_tests).once.and_return(results)
subject.run(['test', '-n', '3', '--only-group', '1', '-t', 'my_test_runner'])
end
it "calls run_tests twice when two groups are specified" do
expect(subject).to receive(:run_tests).twice.and_return(results)
subject.run(['test', '-n', '3', '--only-group', '1,2', '-t', 'my_test_runner'])
end
it "run only one group specified" do
options = common_options.merge(count: 3, only_group: [2])
expect(subject).to receive(:run_tests).once.with(['ccc', 'ddd'], 0, 1, options).and_return(results)
subject.run(['test', '-n', '3', '--only-group', '2', '-t', 'my_test_runner'])
end
it "run last group when passing a group that is not filled" do
count = 3
options = common_options.merge(count: count, only_group: [count])
expect(subject).to receive(:run_tests).once.with(['eee', 'fff'], 0, 1, options).and_return(results)
subject.run(['test', '-n', count.to_s, '--only-group', count.to_s, '-t', 'my_test_runner'])
end
it "run twice with multiple groups" do
skip "fails on jruby" if RUBY_PLATFORM == "java"
options = common_options.merge(count: 3, only_group: [2, 3])
expect(subject).to receive(:run_tests).once.with(['ccc', 'ddd'], 0, 1, options).and_return(results)
expect(subject).to receive(:run_tests).once.with(['eee', 'fff'], 1, 1, options).and_return(results)
subject.run(['test', '-n', '3', '--only-group', '2,3', '-t', 'my_test_runner'])
end
end
context 'when --allow-duplicates' do
let(:results) { { stdout: "", exit_status: 0 } }
let(:processes) { 2 }
let(:common_options) do
{ files: ['test'], allow_duplicates: true, first_is_1: false }
end
before do
allow(subject).to receive(:puts)
expect(subject).to receive(:load_runner).with("my_test_runner").and_return(ParallelTests::MyTestRunner::Runner)
allow(ParallelTests::MyTestRunner::Runner).to receive(:test_file_name).and_return("test")
expect(subject).to receive(:report_results).and_return(nil)
end
before do
expect(ParallelTests::MyTestRunner::Runner).to receive(:tests_in_groups).and_return(
[
['foo'],
['foo'],
['bar']
]
)
end
it "calls run_tests with --only-group" do
options = common_options.merge(count: processes, only_group: [2, 3], group_by: :filesize)
expect(subject).to receive(:run_tests).once.with(['foo'], 0, 1, options).and_return(results)
expect(subject).to receive(:run_tests).once.with(['bar'], 1, 1, options).and_return(results)
subject.run(['test', '-n', processes.to_s, '--allow-duplicates', '--only-group', '2,3', '-t', 'my_test_runner'])
end
it "calls run_tests with --first-is-1" do
options = common_options.merge(count: processes, first_is_1: true)
expect(subject).to receive(:run_tests).once.with(['foo'], 0, processes, options).and_return(results)
expect(subject).to receive(:run_tests).once.with(['foo'], 1, processes, options).and_return(results)
expect(subject).to receive(:run_tests).once.with(['bar'], 2, processes, options).and_return(results)
subject.run(['test', '-n', processes.to_s, '--first-is-1', '--allow-duplicates', '-t', 'my_test_runner'])
end
end
end
describe "#display_duration" do
def call(*args)
subject.send(:detailed_duration, *args)
end
it "displays for durations near one minute" do
expect(call(59)).to eq(nil)
expect(call(60)).to eq(" (1:00)")
expect(call(61)).to eq(" (1:01)")
end
it "displays for durations near one hour" do
expect(call(3599)).to eq(" (59:59)")
expect(call(3600)).to eq(" (1:00:00)")
expect(call(3601)).to eq(" (1:00:01)")
end
it "displays the correct string for miscellaneous durations" do
expect(call(9296)).to eq(" (2:34:56)")
expect(call(45296)).to eq(" (12:34:56)")
expect(call(2756601)).to eq(" (765:43:21)") # hours into three digits? Buy more CI hardware...
expect(call(0)).to eq(nil)
end
end
end
module ParallelTests
module MyTestRunner
class Runner
end
end
end
parallel_tests-5.4.0/spec/parallel_tests/cucumber/ 0000775 0000000 0000000 00000000000 15043316274 0022320 5 ustar 00root root 0000000 0000000 parallel_tests-5.4.0/spec/parallel_tests/cucumber/failure_logger_spec.rb 0000664 0000000 0000000 00000002307 15043316274 0026647 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'spec_helper'
require 'parallel_tests/gherkin/io'
require 'parallel_tests/cucumber/failures_logger'
require 'cucumber/configuration'
describe ParallelTests::Cucumber::FailuresLogger do
let(:parallel_cucumber_failures) { StringIO.new }
let(:config) { Cucumber::Configuration.new(out_stream: parallel_cucumber_failures) }
let(:logger1) { ParallelTests::Cucumber::FailuresLogger.new(config) }
let(:logger2) { ParallelTests::Cucumber::FailuresLogger.new(config) }
let(:logger3) { ParallelTests::Cucumber::FailuresLogger.new(config) }
it "should produce a list of failing scenarios" do
feature1 = double('feature', file: "feature/one.feature")
feature2 = double('feature', file: "feature/two.feature")
logger1.instance_variable_set("@failures", { feature1.file => [1, 3] })
logger2.instance_variable_set("@failures", { feature2.file => [2, 4] })
logger3.instance_variable_set("@failures", {})
config.event_bus.broadcast(Cucumber::Events::TestRunFinished.new)
parallel_cucumber_failures.rewind
expect(parallel_cucumber_failures.read).to eq 'feature/one.feature:1 feature/one.feature:3 feature/two.feature:2 feature/two.feature:4 '
end
end
parallel_tests-5.4.0/spec/parallel_tests/cucumber/runner_spec.rb 0000664 0000000 0000000 00000005203 15043316274 0025170 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require "spec_helper"
require "parallel_tests/gherkin/runner_behaviour"
require "parallel_tests/cucumber/runner"
describe ParallelTests::Cucumber::Runner do
test_tests_in_groups(ParallelTests::Cucumber::Runner, ".feature")
it_should_behave_like 'gherkin runners' do
let(:runner_name) { 'cucumber' }
let(:runner_class) { ParallelTests::Cucumber::Runner }
describe :summarize_results do
def call(*args)
runner_class.summarize_results(*args)
end
it "collates failing scenarios" do
results = [
"Failing Scenarios:", "cucumber features/failure:1", "cucumber features/failure:2",
"Failing Scenarios:", "cucumber features/failure:3", "cucumber features/failure:4",
"Failing Scenarios:", "cucumber features/failure:5", "cucumber features/failure:6"
]
output = call(results)
output.gsub!(/.*WARNING.*\n/, "")
expect(output).to eq(<<~TXT)
Failing Scenarios:
cucumber features/failure:1
cucumber features/failure:2
cucumber features/failure:3
cucumber features/failure:4
cucumber features/failure:5
cucumber features/failure:6
TXT
end
it "collates flaky scenarios separately" do
results = [
"Failing Scenarios:", "cucumber features/failure:1", "cucumber features/failure:2",
"Flaky Scenarios:", "cucumber features/failure:3", "cucumber features/failure:4",
"Failing Scenarios:", "cucumber features/failure:5", "cucumber features/failure:6",
"Flaky Scenarios:", "cucumber features/failure:7", "cucumber features/failure:8"
]
expect(call(results)).to eq("Failing Scenarios:\ncucumber features/failure:1\ncucumber features/failure:2\ncucumber features/failure:5\ncucumber features/failure:6\n\nFlaky Scenarios:\ncucumber features/failure:3\ncucumber features/failure:4\ncucumber features/failure:7\ncucumber features/failure:8\n\n")
end
end
end
describe ".command_with_seed" do
def call(*args)
ParallelTests::Cucumber::Runner.command_with_seed(['cucumber', *args], 555)
end
it "adds the randomized seed" do
expect(call).to eq(["cucumber", "--order", "random:555"])
end
it "does not duplicate existing random command" do
expect(call("--order", "random", "good1.feature")).to eq(["cucumber", "good1.feature", "--order", "random:555"])
end
it "does not duplicate existing random command with seed" do
expect(call("--order", "random:123", "good1.feature")).to eq(["cucumber", "good1.feature", "--order", "random:555"])
end
end
end
parallel_tests-5.4.0/spec/parallel_tests/cucumber/scenarios_spec.rb 0000664 0000000 0000000 00000021472 15043316274 0025653 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'tempfile'
require 'parallel_tests/cucumber/scenarios'
describe ParallelTests::Cucumber::Scenarios do
let(:feature_file) do
Tempfile.new('grouper.feature').tap do |feature|
feature.write <<-EOS
Feature: Grouping by scenario
Scenario: First
Given I do nothing
Scenario: Second
Given I don't do anything
Scenario Outline: Third
Given I don't do anything
Examples:
| param |
| value 1 |
| value 2 |
EOS
feature.rewind
end
end
context 'by default' do
it 'returns all the scenarios' do
scenarios = ParallelTests::Cucumber::Scenarios.all([feature_file.path])
expect(scenarios).to eq [
"#{feature_file.path}:3",
"#{feature_file.path}:6",
"#{feature_file.path}:13",
"#{feature_file.path}:14"
]
end
end
context 'with line numbers' do
it 'only returns scenarios that match the provided lines' do
scenarios = ParallelTests::Cucumber::Scenarios.all(["#{feature_file.path}:6:14"])
expect(scenarios).to eq ["#{feature_file.path}:6", "#{feature_file.path}:14"]
end
end
context 'with tags' do
let(:feature_file) do
Tempfile.new('grouper.feature').tap do |feature|
feature.write <<-EOS
@colours
Feature: Grouping by scenario
@black
Scenario: Black
Given I am black
@white
Scenario: White
Given I am blue
@black @white
Scenario: Gray
Given I am Gray
@red
Scenario Outline: Red
Give I am