end

def test_default_path

end

def test_default_path_missing_vendor

end

def test_default_path_user_home

end

def test_default_path_vendor_dir

end

def test_self_default_sources

assert_equal expected, Gem.find_files('sff/discover').sort

assert_equal expected, Gem.find_files('sff/**.rb').sort, '[ruby-core:31730]'

ensure

end

def test_self_find_latest_files

refute Gem.try_activate 'nonexistent'

end

end

def test_self_use_paths_with_nils

end

def test_self_needs

a = util_spec "a", "1"

b = util_spec "b", "1", "c" => nil

c = util_spec "c", "2"

def test_self_needs_picks_up_unresolved_deps

save_loaded_features do

a = util_spec "a", "1"

b = util_spec "b", "1", "c" => nil

c = util_spec "c", "2"

end

def test_self_vendor_dir

end

def test_self_vendor_dir_ENV_GEM_VENDOR

end

def test_self_vendor_dir_missing

end

def test_load_plugins

end

def test_auto_activation_of_specific_gemdeps_file

a = util_spec "a", "1", nil, "lib/a.rb"

b = util_spec "b", "1", nil, "lib/b.rb"

c = util_spec "c", "1", nil, "lib/c.rb"

end

def test_auto_activation_of_used_gemdeps_file

a = util_spec "a", "1", nil, "lib/a.rb"

b = util_spec "b", "1", nil, "lib/b.rb"

c = util_spec "c", "1", nil, "lib/c.rb"

end

def test_looks_for_gemdeps_files_automatically_on_start

a = util_spec "a", "1", nil, "lib/a.rb"

b = util_spec "b", "1", nil, "lib/b.rb"

end

def test_looks_for_gemdeps_files_automatically_on_start_in_parent_dir

a = util_spec "a", "1", nil, "lib/a.rb"

b = util_spec "b", "1", nil, "lib/b.rb"

assert_nil Gem.find_unresolved_default_spec("README")

end

def test_use_gemdeps

gem_deps_file = 'gem.deps.rb'.untaint

spec = util_spec 'a', 1

end

def test_build_signed_gem

trust_dir = Gem::Security.trust_dir

end

def test_build_signed_gem_with_cert_expiration_length_days

gem_path = File.join Gem.user_home, ".gem"

Dir.mkdir gem_path

end

def test_build_auto_resign_cert

gem_path = File.join Gem.user_home, ".gem"

Dir.mkdir gem_path

output = @ui.output.split "\n"

assert_equal "INFO: Your certificate has expired, trying to re-sign it...", output.shift

assert_equal "INFO: Your cert: #{tmp_expired_cert_file } has been auto re-signed with the key: #{tmp_private_key_file}", output.shift

end

end

warn 'Skipping `gem cert` tests. openssl not found.'

end

class TestGemCommandsCertCommand < Gem::TestCase

ALTERNATE_CERT = load_cert 'alternate'

e.message

end

EOF

assert_equal expected, @stub_ui.output

end

def test_execute_remote

@cmd.options[:domain] = :remote

use_ui @stub_ui do

end

assert_match %r%^a %, @stub_ui.output

assert_path_exists File.join(bin_dir, "#{e}.bat")

end

end

default_dir = Gem::Specification.default_specifications_dir

@ui.outs.set_encoding @default_external if @default_external

end

def setup

super

@cmd = Gem::Commands::SourcesCommand.new

@new_repo = "http://beta-gems.example.com"

end

def test_initialize_proxy

end

def test_execute_add_nonexistent_source

uri = "http://beta-gems.example.com/specs.#{@marshal_version}.gz"

@fetcher.data[uri] = proc do

raise Gem::RemoteFetcher::FetchError.new('it died', uri)

end

def test_execute_add_redundant_source

@cmd.handle_options %W[--add #{@gem_repo}]

use_ui @ui do

end

def test_execute_add_redundant_source_trailing_slash

# Remove pre-existing gem source (w/ slash)

repo_with_slash = "http://gems.example.com/"

@cmd.handle_options %W[--remove #{repo_with_slash}]

end

def test_execute_remove_no_network

@cmd.handle_options %W[--remove #{@gem_repo}]

@fetcher.data["#{@gem_repo}Marshal.#{Gem.marshal_version}"] = proc do

def setup

super

@cmd = Gem::Commands::UninstallCommand.new

@executable = File.join(@gemhome, 'bin', 'executable')

end

def test_execute_all_named

util_make_gems

default = new_default_spec 'default', '1'

end

def test_execute_dependency_order

c = quick_gem 'c' do |spec|

spec.add_dependency 'a'

end

end

def test_execute_removes_executable

if win_platform?

assert File.exist?(@executable)

end

def test_execute_removes_formatted_executable

FileUtils.rm_f @executable # Wish this didn't happen in #setup

Gem::Installer.exec_format = 'foo-%s-bar'

formatted_executable = File.join @gemhome, 'bin', 'foo-executable-bar'

assert_equal true, File.exist?(formatted_executable)

@gem = File.join @tempdir, @spec.file_name

FileUtils.touch @gem

build_rake_in do

use_ui @ui do

end

end

end

def test_execute_with_version_leaves_non_matching_versions

ui = Gem::MockGemUi.new

util_make_gems

assert_equal 3, Gem::Specification.find_all_by_name('a').length

end

def test_execute_with_version_specified_as_colon

ui = Gem::MockGemUi.new "y\n"

util_make_gems

assert_equal 3, Gem::Specification.find_all_by_name('a').length

end

def test_execute_with_force_and_without_version_uninstalls_everything

ui = Gem::MockGemUi.new "y\n"

a_1, = util_gem 'a', 1

a_3a, = util_gem 'a', '3.a'

install_gem a_3a

assert_equal 3, Gem::Specification.find_all_by_name('a').length

@cmd.options[:force] = true

end

def test_execute_with_force_ignores_dependencies

ui = Gem::MockGemUi.new

util_make_gems

assert Gem::Specification.find_all_by_name('dep_x').length > 0

assert Gem::Specification.find_all_by_name('x').length > 0

end

def test_handle_options_vendor

WARNING: Use your OS package manager to uninstall vendor gems

end

def test_execute_two_version

end

def test_handle_options_vendor_missing

end

def test_execute_with_gem_not_installed

end

def test_execute_with_gem_uninstall_error

util_make_gems

@cmd.options[:args] = %w[a]

assert_match %r!Error: unable to successfully uninstall '#{@spec.name}'!, @ui.error

end

end

assert_equal '--prefix', arguments.shift

assert_equal Gem.prefix, arguments.shift

assert_equal '--previous-version', arguments.shift

assert_equal Gem::VERSION, arguments.shift

assert_empty arguments

end

def test_explain

spec_fetcher do |fetcher|

fetcher.download 'a', 2

s.add_development_dependency 'c'

end

util_reset_gems

end

p1a, gem = util_gem 'a', '10.a'

util_setup_spec_fetcher(p1a, @a1, @a1_pre)

p1a_data = Gem.read_binary(gem)

p1a, gem = util_gem 'p', '1.a'

util_setup_spec_fetcher(p1a)

p1a_data = Gem.read_binary(gem)

util_setup_gems

util_setup_spec_fetcher(@a1, @a1_pre)

p1a_data = Gem.read_binary(@a1_gem)

s.add_dependency 'b'

end

FileUtils.mv @a1_gem, @tempdir

FileUtils.mv @b1_gem, @tempdir

FileUtils.mv e1_gem, @tempdir

s.add_dependency 'a'

end

FileUtils.mv @a1_gem, @tempdir

FileUtils.mv @b1_gem, @tempdir

FileUtils.mv b2_gem, @tempdir

si = util_setup_spec_fetcher @a1, a2_o

@fetcher.data['http://gems.example.com/gems/yaml'] = si.to_yaml

a1_data = nil

util_setup_spec_fetcher(*[@a1, @a1_pre, @b1, @c1_pre,

@d1, @d2, @x1_m, @x1_o, @w1, @y1,

@y1_1_p, @z1].compact)

end

end

def setup

super

@deplist = Gem::DependencyList.new

# TODO: switch to util_spec

end

def test_ok_eh

assert @deplist.ok?, 'no dependencies'

@deplist.add @b2

end

def test_why_not_ok_eh

assert_equal({}, @deplist.why_not_ok?)

@deplist.add @b2

end

def test_remove_by_name

@deplist.add @a1, @b2

@deplist.remove_by_name "a-1"

assert_equal %w[--with-foo-dir=/nonexistent], builder.build_args

end

# Details: https://.com/rubygems/rubygems/issues/1270#issuecomment-177368340

skip "CmakeBuilder doesn't work on Windows." if Gem.win_platform?

system('cmake', out: IO::NULL, err: [:child, :out])

skip 'cmake not present' unless $?.success?

end

def test_self_build

skip("test_self_build skipped on MS Windows (VC++)") if vc_windows?

File.open File.join(@ext, './configure'), 'w' do |configure|

end

def test_self_build_fail

skip("test_self_build_fail skipped on MS Windows (VC++)") if vc_windows?

output = []

end

def test_class_build

if vc_windows? && !nmake_found?

skip("test_class_build skipped - nmake not found")

end

end

def test_class_build_rbconfig_make_prog

configure_args do

File.open File.join(@ext, 'extconf.rb'), 'w' do |extconf|

env_make = ENV.delete 'MAKE'

ENV['MAKE'] = 'anothermake'

configure_args '' do

File.open File.join(@ext, 'extconf.rb'), 'w' do |extconf|

extconf.puts "require 'mkmf'\ncreate_makefile 'foo'"

def setup

super

util_make_gems

@d2_0 = util_spec 'd', '2.0' do |s|

@default = new_default_spec 'default', 2

install_default_gems @default

FileUtils.mkdir_p gems

FileUtils.mv Dir[File.join(@gemhome, "cache", '*.gem')], gems

end

def test_initialize

assert_match %r{#{Dir.mktmpdir('gem_generate_index').match(/.*-/)}}, @indexer.directory

assert indexer.build_modern

assert indexer.build_modern

end

@indexer.generate_index

end

marshal_quickdir = File.join quickdir, "Marshal.#{@marshal_version}"

assert_directory_exists quickdir

refute_indexed marshal_quickdir, File.basename(@c1_2.spec_file)

end

def test_generate_index_modern

@indexer.generate_index

end

marshal_quickdir = File.join quickdir, "Marshal.#{@marshal_version}"

assert_directory_exists quickdir, 'quickdir should be directory'

refute_indexed quickdir, "#{File.basename(@c1_2.spec_file)}"

refute_indexed marshal_quickdir, "#{File.basename(@c1_2.spec_file)}"

end

def test_generate_index_modern_back_to_back

@indexer.generate_index

end

@indexer.build_modern = true

use_ui @ui do

@indexer.generate_index

end

marshal_quickdir = File.join quickdir, "Marshal.#{@marshal_version}"

assert_directory_exists quickdir

assert_indexed marshal_quickdir, "#{File.basename(@a1.spec_file)}.rz"

assert_indexed marshal_quickdir, "#{File.basename(@a2.spec_file)}.rz"

end

def test_generate_index_ui

@indexer.generate_index

end

specs_dump = Gem.read_binary specs_path

specs = Marshal.load specs_dump

@indexer.generate_index

end

latest_specs_dump = Gem.read_binary latest_specs_path

latest_specs = Marshal.load latest_specs_dump

@indexer.generate_index

end

prerelease_specs_dump = Gem.read_binary prerelease_specs_path

prerelease_specs = Marshal.load prerelease_specs_dump

@indexer.generate_index

end

marshal_quickdir = File.join quickdir, "Marshal.#{@marshal_version}"

assert_directory_exists quickdir

util_build_gem @d2_1_a

@d2_1_a_tuple = [@d2_1_a.name, @d2_1_a.version, @d2_1_a.original_platform]

FileUtils.mv @d2_1.cache_file, gems

FileUtils.mv @d2_1_a.cache_file, gems

-f

-i /install_to

-w

--post-install-message

]

args.concat %w[-P HighSecurity] if defined?(OpenSSL::SSL)

assert @cmd.handles?(args)

end

def test_user_install_enabled

@cmd.handle_options %w[--user-install]

assert @cmd.options[:user_install]

end

def test_user_install_disabled_read_only

if win_platform?

skip('test_user_install_disabled_read_only test skipped on MS Windows')

elsif Process.uid.zero?

end

def test_vendor

end

def test_vendor_missing

end

def test_post_install_message_no

super

common_installer_setup

@config = Gem.configuration

end

end

def test_app_script_text

util_make_exec @spec, ''

expected = <<-EOF

end

EOF

assert_equal expected, wrapper

end

def test_check_executable_overwrite

@spec = Gem::Specification.new do |s|

s.files = ['lib/code.rb']

end

util_make_exec

installed_exec = File.join util_inst_bindir, 'executable'

assert_path_exists installed_exec

end

def test_check_executable_overwrite_default_bin_dir

if defined?(RUBY_FRAMEWORK_VERSION)

orig_RUBY_FRAMEWORK_VERSION = RUBY_FRAMEWORK_VERSION

Object.send :remove_const, :RUBY_FRAMEWORK_VERSION

ui = Gem::MockGemUi.new "n\n"

use_ui ui do

e = assert_raises Gem::InstallError do

end

conflicted = File.join @gemhome, 'bin', 'executable'

end

def test_check_executable_overwrite_format_executable

@spec = Gem::Specification.new do |s|

s.files = ['lib/code.rb']

util_make_exec

Gem::Installer.exec_format = 'foo-%s-bar'

installed_exec = File.join util_inst_bindir, 'foo-executable-bar'

assert_path_exists installed_exec

end

def test_check_executable_overwrite_other_gem

util_conflict_executable true

ui = Gem::MockGemUi.new "n\n"

use_ui ui do

e = assert_raises Gem::InstallError do

end

assert_equal '"executable" from a conflicts with installed executable from conflict',

end

def test_check_executable_overwrite_other_gem_force

util_conflict_executable true

installed_exec = File.join util_inst_bindir, 'executable'

assert_path_exists installed_exec

end

def test_check_executable_overwrite_other_non_gem

util_conflict_executable false

installed_exec = File.join util_inst_bindir, 'executable'

assert_path_exists installed_exec

end unless Gem.win_platform?

def test_check_that_user_bin_dir_is_in_path

if Gem.win_platform?

bin_dir = bin_dir.downcase.gsub(File::SEPARATOR, File::ALT_SEPARATOR)

ENV['PATH'], [ENV['PATH'], bin_dir].join(File::PATH_SEPARATOR)

use_ui @ui do

end

assert_empty @ui.error

orig_PATH, ENV['PATH'] =

ENV['PATH'], [ENV['PATH'], '~/bin'].join(File::PATH_SEPARATOR)

use_ui @ui do

end

assert_empty @ui.error

end

def test_check_that_user_bin_dir_is_in_path_not_in_path

use_ui @ui do

end

if Gem.win_platform?

expected = expected.downcase.gsub(File::SEPARATOR, File::ALT_SEPARATOR)

end

def test_ensure_dependency

util_spec 'a'

dep = Gem::Dependency.new 'a', '>= 2'

dep = Gem::Dependency.new 'b', '> 2'

e = assert_raises Gem::InstallError do

end

assert_equal 'a requires b (> 2)', e.message

end

def test_extract_files

assert_path_exists File.join @spec.gem_dir, 'bin/executable'

end

def test_generate_bin_bindir

@spec.executables = %w[executable]

@spec.bindir = 'bin'

exec_path = File.join @spec.gem_dir, exec_file

File.open exec_path, 'w' do |f|

f.puts '#!/usr/bin/ruby'

end

assert_directory_exists util_inst_bindir

installed_exec = File.join(util_inst_bindir, 'executable')

end

def test_generate_bin_script

util_make_exec

assert_directory_exists util_inst_bindir

installed_exec = File.join util_inst_bindir, 'executable'

assert_path_exists installed_exec

end

def test_generate_bin_script_format

util_make_exec

Gem::Installer.exec_format = 'foo-%s-bar'

assert_directory_exists util_inst_bindir

installed_exec = File.join util_inst_bindir, 'foo-executable-bar'

assert_path_exists installed_exec

end

def test_generate_bin_script_format_disabled

util_make_exec

Gem::Installer.exec_format = 'foo-%s-bar'

assert_directory_exists util_inst_bindir

installed_exec = File.join util_inst_bindir, 'executable'

assert_path_exists installed_exec

end

def test_generate_bin_script_install_dir

gem_dir = File.join("#{@gemhome}2", "gems", @spec.full_name)

gem_bindir = File.join gem_dir, 'bin'

f.puts "#!/bin/ruby"

end

installed_exec = File.join("#{@gemhome}2", "bin", 'executable')

assert_path_exists installed_exec

end

def test_generate_bin_script_no_execs

refute_path_exists util_inst_bindir, 'bin dir was created when not needed'

end

def test_generate_bin_script_no_perms

util_make_exec

Dir.mkdir util_inst_bindir

FileUtils.chmod 0000, util_inst_bindir

assert_raises Gem::FilePermissionError do

end

end

ensure

end

def test_generate_bin_script_no_shebang

@spec.executables = %w[executable]

gem_dir = File.join @gemhome, 'gems', @spec.full_name

f.puts "blah blah blah"

end

installed_exec = File.join @gemhome, 'bin', 'executable'

assert_path_exists installed_exec

end

def test_generate_bin_script_wrappers

util_make_exec

installed_exec = File.join(util_inst_bindir, 'executable')

real_exec = File.join @spec.gem_dir, 'bin', 'executable'

FileUtils.ln_s real_exec, installed_exec

end

assert_directory_exists util_inst_bindir

assert_path_exists installed_exec

assert_equal mask, File.stat(installed_exec).mode unless win_platform?

def test_generate_bin_symlink

return if win_platform? #Windows FS do not support symlinks

util_make_exec

assert_directory_exists util_inst_bindir

installed_exec = File.join util_inst_bindir, 'executable'

assert_equal true, File.symlink?(installed_exec)

end

def test_generate_bin_symlink_no_execs

refute_path_exists util_inst_bindir

end

def test_generate_bin_symlink_no_perms

util_make_exec

Dir.mkdir util_inst_bindir

FileUtils.chmod 0000, util_inst_bindir

assert_raises Gem::FilePermissionError do

end

end

ensure

def test_generate_bin_symlink_update_newer

return if win_platform? #Windows FS do not support symlinks

util_make_exec

installed_exec = File.join(util_inst_bindir, 'executable')

assert_equal(File.join(@spec.gem_dir, 'bin', 'executable'),

File.readlink(installed_exec))

end

util_make_exec

installed_exec = File.join(util_inst_bindir, 'executable')

assert_equal(@spec.bin_file('executable'),

File.readlink(installed_exec),

def test_generate_bin_symlink_update_older

return if !symlink_supported?

util_make_exec

installed_exec = File.join(util_inst_bindir, 'executable')

assert_equal(File.join(@spec.gem_dir, 'bin', 'executable'),

File.readlink(installed_exec))

util_make_exec

one = @spec.dup

one.version = 1

installed_exec = File.join util_inst_bindir, 'executable'

expected = File.join @spec.gem_dir, 'bin', 'executable'

def test_generate_bin_symlink_update_remove_wrapper

return if !symlink_supported?

util_make_exec

installed_exec = File.join util_inst_bindir, 'executable'

assert_path_exists installed_exec

util_make_exec

util_installer @spec, @gemhome

installed_exec = File.join util_inst_bindir, 'executable'

assert_equal(@spec.bin_file('executable'),

old_alt_separator = File::ALT_SEPARATOR

File.__send__(:remove_const, :ALT_SEPARATOR)

File.const_set(:ALT_SEPARATOR, '\\')

util_make_exec

use_ui @ui do

end

assert_directory_exists util_inst_bindir

def test_generate_bin_uses_default_shebang

return if !symlink_supported?

util_make_exec

default_shebang = Gem.ruby

shebang_line = open("#{@gemhome}/bin/executable") { |f| f.readlines.first }

end

def test_initialize_user_install

installer = Gem::Installer.at @gem, :user_install => true

assert_equal File.join(Gem.user_dir, 'gems', @spec.full_name),

end

def test_initialize_user_install_bin_dir

installer =

Gem::Installer.at @gem, :user_install => true, :bin_dir => @tempdir

end

def test_install

gemdir = File.join @gemhome, 'gems', @spec.full_name

cache_file = File.join @gemhome, 'cache', @spec.file_name

rakefile = File.join gemdir, 'ext', 'a', 'Rakefile'

spec_file = File.join @gemhome, 'specifications', @spec.spec_name

refute_path_exists cache_file, 'cache file must not exist yet'

refute_path_exists spec_file, 'spec file must not exist yet'

true

end

assert_path_exists gemdir, 'gem install dir must exist'

assert_path_exists rakefile, 'gem executable must exist'

refute_path_exists stub_exe, 'gem executable must not exist'

true

end

assert_path_exists cache_file, 'cache file must exist'

assert_path_exists spec_file, 'spec file must exist'

end

@newspec = nil

build_rake_in do

use_ui @ui do

end

end

assert_path_exists rakefile

assert_equal spec_file, @newspec.loaded_from

assert_path_exists spec_file

end

def test_install_creates_working_binstub

gemdir = File.join @gemhome, 'gems', @spec.full_name

@newspec = nil

build_rake_in do

use_ui @ui do

end

end

end

def test_conflicting_binstubs

# build old version that has a bin file

File.open File.join('bin', 'executable'), 'w' do |f|

f.puts "require 'code'"

end

end

end

build_rake_in do

use_ui @ui do

end

end

# build new version that doesn't have a bin file

FileUtils.rm File.join('bin', 'executable')

spec.files.delete File.join('bin', 'executable')

spec.executables.delete 'executable'

build_rake_in do

use_ui @ui do

end

end

end

def test_install_creates_binstub_that_understand_version

@newspec = nil

build_rake_in do

use_ui @ui do

end

end

end

def test_install_creates_binstub_that_prefers_user_installed_gem_to_default

install_default_gems new_default_spec('default', '2')

spec.name = 'default'

spec.version = '2'

end

util_clear_gems

@newspec = nil

build_rake_in do

use_ui @ui do

end

end

end

def test_install_creates_binstub_that_dont_trust_encoding

@newspec = nil

build_rake_in do

use_ui @ui do

end

end

end

def test_install_with_no_prior_files

build_rake_in do

use_ui @ui do

end

end

gemdir = File.join(@gemhome, 'gems', @spec.full_name)

assert_path_exists File.join gemdir, 'lib', 'code.rb'

# Morph spec to have lib/other.rb instead of code.rb and recreate

@spec.files = File.join('lib', 'other.rb')

Dir.chdir @tempdir do

Gem::Package.build @spec

end

end

build_rake_in do

use_ui @ui do

end

end

end

def test_install_missing_dirs

FileUtils.rm_f File.join(Gem.dir, 'cache')

FileUtils.rm_f File.join(Gem.dir, 'doc')

FileUtils.rm_f File.join(Gem.dir, 'specifications')

use_ui @ui do

end

assert_directory_exists File.join(Gem.dir, 'cache')

end

def test_install_post_build_false

Gem.post_build do

false

use_ui @ui do

e = assert_raises Gem::InstallError do

end

location = "#{__FILE__}:#{__LINE__ - 9}"

end

def test_install_post_build_nil

Gem.post_build do

nil

end

use_ui @ui do

end

spec_file = File.join @gemhome, 'specifications', @spec.spec_name

end

def test_install_pre_install_false

Gem.pre_install do

false

use_ui @ui do

e = assert_raises Gem::InstallError do

end

location = "#{__FILE__}:#{__LINE__ - 9}"

end

def test_install_pre_install_nil

Gem.pre_install do

nil

end

use_ui @ui do

end

spec_file = File.join @gemhome, 'specifications', @spec.spec_name

end

def test_install_with_message

@spec.post_install_message = 'I am a shiny gem!'

use_ui @ui do

path = Gem::Package.build @spec

end

assert_match %r|I am a shiny gem!|, @ui.output

end

def test_install_with_skipped_message

@spec.post_install_message = 'I am a shiny gem!'

use_ui @ui do

path = Gem::Package.build @spec

end

refute_match %r|I am a shiny gem!|, @ui.output

def test_install_extension_dir

gemhome2 = "#{@gemhome}2"

@spec.extensions << "extconf.rb"

write_file File.join(@tempdir, "extconf.rb") do |io|

io.write <<-RUBY

end

def test_install_extension_dir_is_removed_on_reinstall

@spec.extensions << "extconf.rb"

write_file File.join(@tempdir, "extconf.rb") do |io|

io.write <<-RUBY

end

def test_install_user_extension_dir

@spec.extensions << "extconf.rb"

write_file File.join(@tempdir, "extconf.rb") do |io|

io.write <<-RUBY

end

def test_find_lib_file_after_install

@spec.extensions << "extconf.rb"

write_file File.join(@tempdir, "extconf.rb") do |io|

io.write <<-RUBY

end

def test_install_extension_and_script

@spec.extensions << "extconf.rb"

write_file File.join(@tempdir, "extconf.rb") do |io|

io.write <<-RUBY

use_ui @ui do

path = Gem::Package.build @spec

end

assert_path_exists File.join @spec.gem_dir, rb

assert_path_exists File.join @spec.gem_dir, rb2

end

def test_install_extension_flat

@spec.require_paths = ["."]

@spec.extensions << "extconf.rb"

use_ui @ui do

path = Gem::Package.build @spec

end

assert_path_exists so

rescue

end

def test_installation_satisfies_dependency_eh

util_spec 'a'

dep = Gem::Dependency.new 'a', '>= 2'

dep = Gem::Dependency.new 'a', '> 2'

end

def test_installation_satisfies_dependency_eh_development

util_spec 'a'

dep = Gem::Dependency.new 'a', :development

end

def test_pre_install_checks_dependencies

@spec.add_dependency 'b', '> 5'

use_ui @ui do

assert_raises Gem::InstallError do

end

end

end

def test_pre_install_checks_dependencies_ignore

@spec.add_dependency 'b', '> 5'

build_rake_in do

use_ui @ui do

end

end

end

def test_pre_install_checks_dependencies_install_dir

gemhome2 = "#{@gemhome}2"

@spec.add_dependency 'd'

quick_gem 'd', 2

gem = File.join(@gemhome, 'cache', spec.file_name)

use_ui @ui do

e = assert_raises Gem::RuntimeRequirementNotMetError do

end

rgv = Gem::VERSION

assert_equal "old_rubygems_required requires RubyGems version < 0. The current RubyGems version is #{rgv}. " +

gem = File.join(@gemhome, 'cache', spec.file_name)

use_ui @ui do

e = assert_raises Gem::InstallError do

end

assert_equal '#<Gem::Specification name=../malicious version=1> has an invalid name', e.message

end

gem = File.join(@gemhome, 'cache', spec.file_name)

use_ui @ui do

e = assert_raises Gem::InstallError do

end

assert_equal "#<Gem::Specification name=malicious\n::Object.const_set(:FROM_EVAL, true)# version=1> has an invalid name", e.message

end

gem = File.join(@gemhome, 'cache', spec.file_name)

use_ui @ui do

e = assert_raises Gem::InstallError do

end

assert_equal "#<Gem::Specification name=malicious version=1> has an invalid require_paths", e.message

end

gem = File.join(@gemhome, 'cache', spec.file_name)

use_ui @ui do

e = assert_raises Gem::InstallError do

end

assert_equal "#<Gem::Specification name=malicious version=1> has an invalid extensions", e.message

end

gem = File.join(@gemhome, 'cache', spec.file_name)

use_ui @ui do

e = assert_raises Gem::InstallError do

end

assert_equal "#<Gem::Specification name=malicious version=1> has an invalid specification_version", e.message

end

gem = File.join(@gemhome, 'cache', spec.file_name)

use_ui @ui do

e = assert_raises Gem::InstallError do

end

assert_equal "#<Gem::Specification name=malicious version=1> has an invalid dependencies", e.message

end

end

def test_shebang

util_make_exec @spec, "#!/usr/bin/ruby"

assert_equal "#!#{Gem.ruby}", shebang

end

def test_process_options

end

def test_process_options_build_root

build_root = File.join @tempdir, 'build_root'

end

def test_shebang_arguments

util_make_exec @spec, "#!/usr/bin/ruby -ws"

assert_equal "#!#{Gem.ruby} -ws", shebang

end

def test_shebang_empty

util_make_exec @spec, ''

assert_equal "#!#{Gem.ruby}", shebang

end

def test_shebang_env

util_make_exec @spec, "#!/usr/bin/env ruby"

assert_equal "#!#{Gem.ruby}", shebang

end

def test_shebang_env_arguments

util_make_exec @spec, "#!/usr/bin/env ruby -ws"

assert_equal "#!#{Gem.ruby} -ws", shebang

end

def test_shebang_env_shebang

util_make_exec @spec, ''

env_shebang = "/usr/bin/env" unless Gem.win_platform?

end

def test_shebang_nested

util_make_exec @spec, "#!/opt/local/ruby/bin/ruby"

assert_equal "#!#{Gem.ruby}", shebang

end

def test_shebang_nested_arguments

util_make_exec @spec, "#!/opt/local/ruby/bin/ruby -ws"

assert_equal "#!#{Gem.ruby} -ws", shebang

end

def test_shebang_version

util_make_exec @spec, "#!/usr/bin/ruby18"

assert_equal "#!#{Gem.ruby}", shebang

end

def test_shebang_version_arguments

util_make_exec @spec, "#!/usr/bin/ruby18 -ws"

assert_equal "#!#{Gem.ruby} -ws", shebang

end

def test_shebang_version_env

util_make_exec @spec, "#!/usr/bin/env ruby18"

assert_equal "#!#{Gem.ruby}", shebang

end

def test_shebang_version_env_arguments

util_make_exec @spec, "#!/usr/bin/env ruby18 -ws"

assert_equal "#!#{Gem.ruby} -ws", shebang

end

def test_shebang_custom

conf = Gem::ConfigFile.new []

conf[:custom_shebang] = 'test'

util_make_exec @spec, "#!/usr/bin/ruby"

assert_equal "#!test", shebang

end

def test_shebang_custom_with_expands

bin_env = win_platform? ? '' : '/usr/bin/env'

conf = Gem::ConfigFile.new []

conf[:custom_shebang] = '1 $env 2 $ruby 3 $exec 4 $name'

util_make_exec @spec, "#!/usr/bin/ruby"

assert_equal "#!1 #{bin_env} 2 #{Gem.ruby} 3 executable 4 a", shebang

end

def test_shebang_custom_with_expands_and_arguments

bin_env = win_platform? ? '' : '/usr/bin/env'

conf = Gem::ConfigFile.new []

conf[:custom_shebang] = '1 $env 2 $ruby 3 $exec'

util_make_exec @spec, "#!/usr/bin/ruby -ws"

assert_equal "#!1 #{bin_env} 2 #{Gem.ruby} -ws 3 executable", shebang

end

def test_unpack

dest = File.join @gemhome, 'gems', @spec.full_name

Gem::Deprecate.skip_during do

end

assert_path_exists File.join dest, 'lib', 'code.rb'

end

def test_write_build_info_file

refute_path_exists @spec.build_info_file

--with-libyaml-dir /usr/local/Cellar/libyaml/0.1.4

]

assert_path_exists @spec.build_info_file

end

def test_write_build_info_file_empty

refute_path_exists @spec.build_info_file

refute_path_exists @spec.build_info_file

end

def test_write_build_info_file_install_dir

installer = Gem::Installer.at @gem, :install_dir => "#{@gemhome}2"

installer.build_args = %w[

end

def test_write_cache_file

cache_file = File.join @gemhome, 'cache', @spec.file_name

gem = File.join @gemhome, @spec.file_name

end

def test_write_spec

FileUtils.rm @spec.spec_file

refute_path_exists @spec.spec_file

assert_path_exists @spec.spec_file

end

def test_write_spec_writes_cached_spec

FileUtils.rm @spec.spec_file

refute_path_exists @spec.spec_file

@spec.files = %w[a.rb b.rb c.rb]

# cached specs have no file manifest:

@spec.files = []

end

def test_dir

end

def test_default_gem_loaded_from

end

def test_default_gem_without_wrappers

FileUtils.rm_f File.join(Gem.dir, 'specifications')

use_ui @ui do

end

assert_directory_exists File.join(@spec.gem_dir, 'bin')

end

def test_default_gem_with_wrappers

use_ui @ui do

end

assert_directory_exists util_inst_bindir

end

def test_default_gem_with_exe_as_bindir

@spec = quick_gem 'c' do |spec|

util_make_exec spec, '#!/usr/bin/ruby', 'exe'

end

@spec = util_spec 'z'

util_build_gem @spec

end

def util_conflict_executable(wrappers)

# frozen_string_literal: true

require 'rubygems/package/tar_test_case'

class TestGemPackage < Gem::Package::TarTestCase

end

def test_class_new_old_format

File.open 'old_format.gem', 'wb' do |io|

io.write SIMPLE_GEM

end

end

def test_verify_corrupt

tf = Tempfile.open 'corrupt' do |io|

data = Gem::Util.gzip 'a' * 10

io.write \

# frozen_string_literal: true

require 'rubygems/test_case'

end

end

end

end

end

end

end

end

end

end

def test_full_name_null

@entry.header.prefix << "\000"

e = assert_raises Gem::Package::TarInvalidError do

end

def test_initialize_path

end

def test_initialize_regexp_path_separator

end

def test_initialize_home_path

end

def util_path

def test_ssl_client_cert_auth_connection

skip 'openssl is missing' unless defined?(OpenSSL::SSL)

ssl_server = self.class.start_ssl_server({

:SSLVerifyClient =>

end

end if defined?(OpenSSL::SSL)

end

def test_verify_certificate

store = OpenSSL::X509::Store.new

context = OpenSSL::X509::StoreContext.new store

context.error = OpenSSL::X509::V_ERR_OUT_OF_MEM

end

def test_verify_certificate_extra_message

store = OpenSSL::X509::Store.new

context = OpenSSL::X509::StoreContext.new store

context.error = OpenSSL::X509::V_ERR_INVALID_CA

engine

end

r1 = Gem::Resolver::DependencyRequest.new dep('a', '= 1'), nil

res = Gem::Resolver.new [a1]

r1 = Gem::Resolver::DependencyRequest.new dep('a', '= 1'), nil

res = Gem::Resolver.new [act]

res.development = true

r1 = Gem::Resolver::DependencyRequest.new dep('a', '= 1'), nil

res = Gem::Resolver.new [a1]

res.ignore_dependencies = true

source = Gem::Source::Local.new

platform = Gem::Platform::RUBY

@a3 = @DR::IndexSpecification.new nil, 'a', v(3), source, platform

end

def test_development_eh

dep_req = @DR::DependencyRequest.new dep('a', '>= 0', :development), nil

assert act_req.development?

end

def test_inspect

assert_match 'a-3', @req.inspect

assert_match 'from a (>= 0)', @req.inspect

end

def test_installed_eh

v_spec = Gem::Resolver::VendorSpecification.new nil, @a3

assert @req.installed?

end

end

# functional test for Gem::Ext::Builder

def test_install_extension

name, _, repository, = git_gem 'a', 1 do |s|

s.extensions << 'ext/extconf.rb'

end

warn 'Skipping Gem::Security tests. openssl not found.'

end

class TestGemSecurity < Gem::TestCase

CHILD_KEY = load_key 'child'

assert_equal key.to_pem, key_from_file.to_pem

end

end

def test_sign_expired_auto_update

FileUtils.mkdir_p File.join(Gem.user_home, '.gem'), :mode => 0700

private_key_path = File.join(Gem.user_home, '.gem', 'gem-private_key.pem')

system @git, 'add', 'b.gemspec'

system @git, 'commit', '--quiet', '-m', 'add b/b.gemspec'

end

end

specs = nil

end

def test_build_args

ext_spec

assert_empty @ext.build_args

end

def test_build_extensions

ext_spec

refute_path_exists @ext.extension_dir, 'sanity check'

end

def test_build_extensions_built

ext_spec

refute_empty @ext.extensions, 'sanity check'

end

def test_build_extensions_error

ext_spec

refute_empty @ext.extensions, 'sanity check'

skip 'chmod not supported' if Gem.win_platform?

skip 'skipped in root privilege' if Process.uid.zero?

ext_spec

refute_empty @ext.extensions, 'sanity check'

@ext.build_extensions

refute_path_exists @ext.extension_dir

ensure

FileUtils.chmod 0755, File.join(@ext.base_dir, 'extensions')

FileUtils.chmod 0755, @ext.base_dir

end

def test_build_extensions_no_extensions_dir_unwritable

skip 'chmod not supported' if Gem.win_platform?

ext_spec

refute_empty @ext.extensions, 'sanity check'

end

def test_build_extensions_old

ext_spec

refute_empty @ext.extensions, 'sanity check'

end

def test_build_extensions_preview

ext_spec

extconf_rb = File.join @ext.gem_dir, @ext.extensions.first

end

def test_contains_requirable_file_eh_extension

ext_spec

_, err = capture_io do

end

def test_missing_extensions_eh

ext_spec

assert @ext.missing_extensions?

end

def test_contains_requirable_file_eh_extension

stub_with_extension do |stub|

_, err = capture_io do

refute stub.contains_requirable_file? 'nonexistent'

end

def test_missing_extensions_eh

stub = stub_with_extension do |s|

extconf_rb = File.join s.gem_dir, s.extensions.first

FileUtils.mkdir_p File.dirname extconf_rb

def setup

super

common_installer_setup

build_rake_in do

class TestGemUtil < Gem::TestCase

def test_class_popen

assert_equal "0\n", Gem::Util.popen(Gem.ruby, '-I', File.expand_path('../../../lib', __FILE__), '-e', 'p 0')

assert_raises Errno::ECHILD do

end

def test_silent_system

assert_silent do

Gem::Util.silent_system Gem.ruby, '-I', File.expand_path('../../../lib', __FILE__), '-e', 'puts "hello"; warn "hello"'

end

end

def test_traverse_parents_does_not_crash_on_permissions_error

FileUtils.mkdir_p 'd/e/f'

# remove 'execute' permission from "e" directory and make it

assert_equal File.realpath("..", Dir.tmpdir), paths[3]

ensure

# restore default permissions, allow the directory to be removed

end

def test_linked_list_find

assert_equal expected_paths.to_set, files_with_relative_base.to_set

end

end

# frozen_string_literal: true

class TestGemValidator < Gem::TestCase

def setup

super

@validator = Gem::Validator.new

end

end

def test_activate_via_require_respects_loaded_files

a1 = util_spec "a", "1", {"b" => ">= 1"}, "lib/test_gem_require_a.rb"

b1 = util_spec "b", "1", nil, "lib/benchmark.rb"

b2 = util_spec "b", "2", nil, "lib/benchmark.rb"

end

end

def test_no_kernel_require_in_warn_with_uplevel

lib = File.realpath("../../../lib", __FILE__)

Dir.mktmpdir("warn_test") do |dir|