mirror of
https://github.com/ruby/ruby.git
synced 2022-11-09 12:17:21 -05:00
2397 lines
61 KiB
Ruby
2397 lines
61 KiB
Ruby
# frozen_string_literal: true
|
|
require_relative "installer_test_case"
|
|
|
|
class TestGemInstaller < Gem::InstallerTestCase
|
|
def setup
|
|
super
|
|
common_installer_setup
|
|
|
|
@config = Gem.configuration
|
|
end
|
|
|
|
def teardown
|
|
common_installer_teardown
|
|
|
|
super
|
|
|
|
Gem.configuration = instance_variable_defined?(:@config) ? @config : nil
|
|
end
|
|
|
|
def test_app_script_text
|
|
load_relative "no" do
|
|
installer = setup_base_installer
|
|
|
|
util_make_exec @spec, ""
|
|
|
|
expected = <<-EOF
|
|
#!#{Gem.ruby}
|
|
#
|
|
# This file was generated by RubyGems.
|
|
#
|
|
# The application 'a' is installed as part of a gem, and
|
|
# this file is here to facilitate running it.
|
|
#
|
|
|
|
require 'rubygems'
|
|
|
|
Gem.use_gemdeps
|
|
|
|
version = \">= 0.a\"
|
|
|
|
str = ARGV.first
|
|
if str
|
|
str = str.b[/\\A_(.*)_\\z/, 1]
|
|
if str and Gem::Version.correct?(str)
|
|
version = str
|
|
ARGV.shift
|
|
end
|
|
end
|
|
|
|
if Gem.respond_to?(:activate_bin_path)
|
|
load Gem.activate_bin_path('a', 'executable', version)
|
|
else
|
|
gem "a", version
|
|
load Gem.bin_path("a", "executable", version)
|
|
end
|
|
EOF
|
|
|
|
wrapper = installer.app_script_text "executable"
|
|
assert_equal expected, wrapper
|
|
end
|
|
end
|
|
|
|
def test_check_executable_overwrite
|
|
installer = setup_base_installer
|
|
|
|
installer.generate_bin
|
|
|
|
@spec = Gem::Specification.new do |s|
|
|
s.files = ["lib/code.rb"]
|
|
s.name = "a"
|
|
s.version = "3"
|
|
s.summary = "summary"
|
|
s.description = "desc"
|
|
s.require_path = "lib"
|
|
end
|
|
|
|
util_make_exec
|
|
installer.gem_dir = @spec.gem_dir
|
|
installer.wrappers = true
|
|
installer.generate_bin
|
|
|
|
installed_exec = File.join util_inst_bindir, "executable"
|
|
assert_path_exist installed_exec
|
|
|
|
wrapper = File.read installed_exec
|
|
assert_match %r{generated by RubyGems}, wrapper
|
|
end
|
|
|
|
def test_check_executable_overwrite_default_bin_dir
|
|
installer = setup_base_installer(false)
|
|
|
|
bindir(Gem.bindir) do
|
|
util_conflict_executable false
|
|
|
|
ui = Gem::MockGemUi.new "n\n"
|
|
use_ui ui do
|
|
e = assert_raise Gem::InstallError do
|
|
installer.generate_bin
|
|
end
|
|
|
|
conflicted = File.join @gemhome, "bin", "executable"
|
|
assert_match %r{\A"executable" from a conflicts with (?:#{Regexp.quote(conflicted)}|installed executable from conflict)\z},
|
|
e.message
|
|
end
|
|
end
|
|
end
|
|
|
|
def test_check_executable_overwrite_format_executable
|
|
installer = setup_base_installer
|
|
|
|
installer.generate_bin
|
|
|
|
@spec = Gem::Specification.new do |s|
|
|
s.files = ["lib/code.rb"]
|
|
s.name = "a"
|
|
s.version = "3"
|
|
s.summary = "summary"
|
|
s.description = "desc"
|
|
s.require_path = "lib"
|
|
end
|
|
|
|
File.open File.join(util_inst_bindir, "executable"), "w" do |io|
|
|
io.write <<-EXEC
|
|
#!/usr/local/bin/ruby
|
|
#
|
|
# This file was generated by RubyGems
|
|
|
|
gem 'other', version
|
|
EXEC
|
|
end
|
|
|
|
util_make_exec
|
|
Gem::Installer.exec_format = "foo-%s-bar"
|
|
installer.gem_dir = @spec.gem_dir
|
|
installer.wrappers = true
|
|
installer.format_executable = true
|
|
|
|
installer.generate_bin # should not raise
|
|
|
|
installed_exec = File.join util_inst_bindir, "foo-executable-bar"
|
|
assert_path_exist installed_exec
|
|
|
|
wrapper = File.read installed_exec
|
|
assert_match %r{generated by RubyGems}, wrapper
|
|
ensure
|
|
Gem::Installer.exec_format = nil
|
|
end
|
|
|
|
def test_check_executable_overwrite_other_gem
|
|
installer = setup_base_installer(false)
|
|
|
|
util_conflict_executable true
|
|
|
|
ui = Gem::MockGemUi.new "n\n"
|
|
|
|
use_ui ui do
|
|
e = assert_raise Gem::InstallError do
|
|
installer.generate_bin
|
|
end
|
|
|
|
assert_equal '"executable" from a conflicts with installed executable from conflict',
|
|
e.message
|
|
end
|
|
end
|
|
|
|
def test_check_executable_overwrite_other_gem_force
|
|
installer = setup_base_installer
|
|
|
|
util_conflict_executable true
|
|
installer.wrappers = true
|
|
installer.force = true
|
|
|
|
installer.generate_bin
|
|
|
|
installed_exec = File.join util_inst_bindir, "executable"
|
|
assert_path_exist installed_exec
|
|
|
|
wrapper = File.read installed_exec
|
|
assert_match %r{generated by RubyGems}, wrapper
|
|
end
|
|
|
|
def test_check_executable_overwrite_other_non_gem
|
|
installer = setup_base_installer
|
|
|
|
util_conflict_executable false
|
|
installer.wrappers = true
|
|
|
|
installer.generate_bin
|
|
|
|
installed_exec = File.join util_inst_bindir, "executable"
|
|
assert_path_exist installed_exec
|
|
|
|
wrapper = File.read installed_exec
|
|
assert_match %r{generated by RubyGems}, wrapper
|
|
end unless Gem.win_platform?
|
|
|
|
def test_check_that_user_bin_dir_is_in_path
|
|
installer = setup_base_installer
|
|
|
|
bin_dir = installer.bin_dir
|
|
|
|
if Gem.win_platform?
|
|
bin_dir = bin_dir.downcase
|
|
end
|
|
|
|
orig_PATH, ENV["PATH"] =
|
|
ENV["PATH"], [ENV["PATH"], bin_dir].join(File::PATH_SEPARATOR)
|
|
|
|
use_ui @ui do
|
|
installer.check_that_user_bin_dir_is_in_path
|
|
end
|
|
|
|
assert_empty @ui.error
|
|
|
|
return unless win_platform?
|
|
|
|
ENV["PATH"] = [orig_PATH, bin_dir.tr(File::SEPARATOR, File::ALT_SEPARATOR)].join(File::PATH_SEPARATOR)
|
|
|
|
use_ui @ui do
|
|
installer.check_that_user_bin_dir_is_in_path
|
|
end
|
|
|
|
assert_empty @ui.error
|
|
ensure
|
|
ENV["PATH"] = orig_PATH
|
|
end
|
|
|
|
def test_check_that_user_bin_dir_is_in_path_tilde
|
|
pend "Tilde is PATH is not supported under MS Windows" if win_platform?
|
|
|
|
orig_PATH, ENV["PATH"] =
|
|
ENV["PATH"], [ENV["PATH"], "~/bin"].join(File::PATH_SEPARATOR)
|
|
|
|
installer = setup_base_installer
|
|
installer.bin_dir.replace File.join @userhome, "bin"
|
|
|
|
use_ui @ui do
|
|
installer.check_that_user_bin_dir_is_in_path
|
|
end
|
|
|
|
assert_empty @ui.error
|
|
ensure
|
|
ENV["PATH"] = orig_PATH unless win_platform?
|
|
end
|
|
|
|
def test_check_that_user_bin_dir_is_in_path_not_in_path
|
|
installer = setup_base_installer
|
|
|
|
use_ui @ui do
|
|
installer.check_that_user_bin_dir_is_in_path
|
|
end
|
|
|
|
expected = installer.bin_dir
|
|
|
|
if Gem.win_platform?
|
|
expected = expected.downcase
|
|
end
|
|
|
|
assert_match expected, @ui.error
|
|
end
|
|
|
|
def test_ensure_dependency
|
|
installer = setup_base_installer
|
|
|
|
util_spec "a"
|
|
|
|
dep = Gem::Dependency.new "a", ">= 2"
|
|
assert installer.ensure_dependency(@spec, dep)
|
|
|
|
dep = Gem::Dependency.new "b", "> 2"
|
|
e = assert_raise Gem::InstallError do
|
|
installer.ensure_dependency @spec, dep
|
|
end
|
|
|
|
assert_equal "a requires b (> 2)", e.message
|
|
end
|
|
|
|
def test_ensure_loadable_spec
|
|
a, a_gem = util_gem "a", 2 do |s|
|
|
s.add_dependency "garbage ~> 5"
|
|
end
|
|
|
|
installer = Gem::Installer.at a_gem
|
|
|
|
e = assert_raise Gem::InstallError do
|
|
installer.ensure_loadable_spec
|
|
end
|
|
|
|
assert_equal "The specification for #{a.full_name} is corrupt " +
|
|
"(SyntaxError)", e.message
|
|
end
|
|
|
|
def test_ensure_loadable_spec_security_policy
|
|
pend "openssl is missing" unless Gem::HAVE_OPENSSL
|
|
|
|
_, a_gem = util_gem "a", 2 do |s|
|
|
s.add_dependency "garbage ~> 5"
|
|
end
|
|
|
|
policy = Gem::Security::HighSecurity
|
|
installer = Gem::Installer.at a_gem, :security_policy => policy
|
|
|
|
assert_raise Gem::Security::Exception do
|
|
installer.ensure_loadable_spec
|
|
end
|
|
end
|
|
|
|
def test_extract_files
|
|
installer = setup_base_installer
|
|
|
|
installer.extract_files
|
|
|
|
assert_path_exist File.join @spec.gem_dir, "bin/executable"
|
|
end
|
|
|
|
def test_generate_bin_bindir
|
|
installer = setup_base_installer
|
|
|
|
installer.wrappers = true
|
|
|
|
@spec.executables = %w[executable]
|
|
@spec.bindir = "bin"
|
|
|
|
exec_file = installer.formatted_program_filename "executable"
|
|
exec_path = File.join @spec.gem_dir, exec_file
|
|
File.open exec_path, "w" do |f|
|
|
f.puts "#!/usr/bin/ruby"
|
|
end
|
|
|
|
installer.gem_dir = @spec.gem_dir
|
|
|
|
installer.generate_bin
|
|
|
|
assert_directory_exists util_inst_bindir
|
|
installed_exec = File.join(util_inst_bindir, "executable")
|
|
assert_path_exist installed_exec
|
|
assert_equal mask, File.stat(installed_exec).mode unless win_platform?
|
|
|
|
wrapper = File.read installed_exec
|
|
assert_match %r{generated by RubyGems}, wrapper
|
|
end
|
|
|
|
def test_generate_bin_bindir_with_user_install_warning
|
|
bin_dir = Gem.win_platform? ? File.expand_path(ENV["WINDIR"]).upcase :
|
|
"/usr/bin"
|
|
|
|
old_path = ENV["PATH"]
|
|
ENV["PATH"] = [ENV["PATH"], bin_dir].compact.join(File::PATH_SEPARATOR)
|
|
|
|
options = {
|
|
:bin_dir => bin_dir,
|
|
:install_dir => "/non/existent",
|
|
}
|
|
|
|
inst = Gem::Installer.at "", options
|
|
|
|
Gem::Installer.path_warning = false
|
|
|
|
use_ui @ui do
|
|
inst.check_that_user_bin_dir_is_in_path
|
|
end
|
|
|
|
assert_equal "", @ui.error
|
|
|
|
ensure
|
|
ENV["PATH"] = old_path
|
|
end
|
|
|
|
def test_generate_bin_script
|
|
installer = setup_base_installer
|
|
|
|
installer.wrappers = true
|
|
util_make_exec
|
|
installer.gem_dir = @spec.gem_dir
|
|
|
|
installer.generate_bin
|
|
assert_directory_exists util_inst_bindir
|
|
installed_exec = File.join util_inst_bindir, "executable"
|
|
assert_path_exist installed_exec
|
|
assert_equal mask, File.stat(installed_exec).mode unless win_platform?
|
|
|
|
wrapper = File.read installed_exec
|
|
assert_match %r{generated by RubyGems}, wrapper
|
|
end
|
|
|
|
def test_generate_bin_script_format
|
|
installer = setup_base_installer
|
|
|
|
installer.format_executable = true
|
|
installer.wrappers = true
|
|
util_make_exec
|
|
installer.gem_dir = @spec.gem_dir
|
|
|
|
Gem::Installer.exec_format = "foo-%s-bar"
|
|
installer.generate_bin
|
|
assert_directory_exists util_inst_bindir
|
|
installed_exec = File.join util_inst_bindir, "foo-executable-bar"
|
|
assert_path_exist installed_exec
|
|
ensure
|
|
Gem::Installer.exec_format = nil
|
|
end
|
|
|
|
def test_generate_bin_script_format_disabled
|
|
installer = setup_base_installer
|
|
|
|
installer.wrappers = true
|
|
util_make_exec
|
|
installer.gem_dir = @spec.gem_dir
|
|
|
|
Gem::Installer.exec_format = "foo-%s-bar"
|
|
installer.generate_bin
|
|
assert_directory_exists util_inst_bindir
|
|
installed_exec = File.join util_inst_bindir, "executable"
|
|
assert_path_exist installed_exec
|
|
ensure
|
|
Gem::Installer.exec_format = nil
|
|
end
|
|
|
|
def test_generate_bin_script_install_dir
|
|
installer = setup_base_installer
|
|
|
|
installer.wrappers = true
|
|
|
|
gem_dir = File.join("#{@gemhome}2", "gems", @spec.full_name)
|
|
gem_bindir = File.join gem_dir, "bin"
|
|
FileUtils.mkdir_p gem_bindir
|
|
File.open File.join(gem_bindir, "executable"), "w" do |f|
|
|
f.puts "#!/bin/ruby"
|
|
end
|
|
|
|
installer.gem_home = "#{@gemhome}2"
|
|
installer.gem_dir = gem_dir
|
|
installer.bin_dir = File.join "#{@gemhome}2", "bin"
|
|
|
|
installer.generate_bin
|
|
|
|
installed_exec = File.join("#{@gemhome}2", "bin", "executable")
|
|
assert_path_exist installed_exec
|
|
assert_equal mask, File.stat(installed_exec).mode unless win_platform?
|
|
|
|
wrapper = File.read installed_exec
|
|
assert_match %r{generated by RubyGems}, wrapper
|
|
end
|
|
|
|
def test_generate_bin_script_no_execs
|
|
installer = setup_base_installer
|
|
|
|
installer = util_execless
|
|
|
|
installer.wrappers = true
|
|
installer.generate_bin
|
|
|
|
assert_path_not_exist util_inst_bindir, "bin dir was created when not needed"
|
|
end
|
|
|
|
def test_generate_bin_script_no_perms
|
|
installer = setup_base_installer
|
|
|
|
installer.wrappers = true
|
|
util_make_exec
|
|
|
|
Dir.mkdir util_inst_bindir
|
|
|
|
if win_platform?
|
|
pend("test_generate_bin_script_no_perms skipped on MS Windows")
|
|
elsif Process.uid.zero?
|
|
pend("test_generate_bin_script_no_perms skipped in root privilege")
|
|
else
|
|
FileUtils.chmod 0000, util_inst_bindir
|
|
|
|
assert_raise Gem::FilePermissionError do
|
|
installer.generate_bin
|
|
end
|
|
end
|
|
ensure
|
|
FileUtils.chmod 0755, util_inst_bindir unless ($DEBUG || win_platform?)
|
|
end
|
|
|
|
def test_generate_bin_script_no_shebang
|
|
installer = setup_base_installer
|
|
|
|
installer.wrappers = true
|
|
@spec.executables = %w[executable]
|
|
|
|
gem_dir = File.join @gemhome, "gems", @spec.full_name
|
|
gem_bindir = File.join gem_dir, "bin"
|
|
FileUtils.mkdir_p gem_bindir
|
|
File.open File.join(gem_bindir, "executable"), "w" do |f|
|
|
f.puts "blah blah blah"
|
|
end
|
|
|
|
installer.generate_bin
|
|
|
|
installed_exec = File.join @gemhome, "bin", "executable"
|
|
assert_path_exist installed_exec
|
|
assert_equal mask, File.stat(installed_exec).mode unless win_platform?
|
|
|
|
wrapper = File.read installed_exec
|
|
assert_match %r{generated by RubyGems}, wrapper
|
|
# HACK some gems don't have #! in their executables, restore 2008/06
|
|
#assert_no_match %r|generated by RubyGems|, wrapper
|
|
end
|
|
|
|
def test_generate_bin_script_wrappers
|
|
installer = setup_base_installer
|
|
|
|
installer.wrappers = true
|
|
util_make_exec
|
|
installer.gem_dir = @spec.gem_dir
|
|
installed_exec = File.join(util_inst_bindir, "executable")
|
|
|
|
real_exec = File.join @spec.gem_dir, "bin", "executable"
|
|
|
|
# fake --no-wrappers for previous install
|
|
unless Gem.win_platform?
|
|
FileUtils.mkdir_p File.dirname(installed_exec)
|
|
FileUtils.ln_s real_exec, installed_exec
|
|
end
|
|
|
|
installer.generate_bin
|
|
assert_directory_exists util_inst_bindir
|
|
assert_path_exist installed_exec
|
|
assert_equal mask, File.stat(installed_exec).mode unless win_platform?
|
|
|
|
assert_match %r{generated by RubyGems}, File.read(installed_exec)
|
|
|
|
refute_match %r{generated by RubyGems}, File.read(real_exec),
|
|
"real executable overwritten"
|
|
end
|
|
|
|
def test_generate_bin_symlink
|
|
pend "Symlinks not supported or not enabled" unless symlink_supported?
|
|
|
|
installer = setup_base_installer
|
|
|
|
installer.wrappers = false
|
|
util_make_exec
|
|
installer.gem_dir = @spec.gem_dir
|
|
|
|
installer.generate_bin
|
|
assert_directory_exists util_inst_bindir
|
|
installed_exec = File.join util_inst_bindir, "executable"
|
|
assert_equal true, File.symlink?(installed_exec)
|
|
assert_equal(File.join(@spec.gem_dir, "bin", "executable"),
|
|
File.readlink(installed_exec))
|
|
end
|
|
|
|
def test_generate_bin_symlink_no_execs
|
|
installer = setup_base_installer
|
|
|
|
installer = util_execless
|
|
|
|
installer.wrappers = false
|
|
installer.generate_bin
|
|
|
|
assert_path_not_exist util_inst_bindir
|
|
end
|
|
|
|
def test_generate_bin_symlink_no_perms
|
|
installer = setup_base_installer
|
|
|
|
installer.wrappers = false
|
|
util_make_exec
|
|
installer.gem_dir = @spec.gem_dir
|
|
|
|
Dir.mkdir util_inst_bindir
|
|
|
|
if win_platform?
|
|
pend("test_generate_bin_symlink_no_perms skipped on MS Windows")
|
|
elsif Process.uid.zero?
|
|
pend("test_user_install_disabled_read_only test skipped in root privilege")
|
|
else
|
|
FileUtils.chmod 0000, util_inst_bindir
|
|
|
|
assert_raise Gem::FilePermissionError do
|
|
installer.generate_bin
|
|
end
|
|
end
|
|
ensure
|
|
FileUtils.chmod 0755, util_inst_bindir unless ($DEBUG || win_platform?)
|
|
end
|
|
|
|
def test_generate_bin_symlink_update_newer
|
|
pend "Symlinks not supported or not enabled" unless symlink_supported?
|
|
|
|
installer = setup_base_installer
|
|
|
|
installer.wrappers = false
|
|
util_make_exec
|
|
installer.gem_dir = @spec.gem_dir
|
|
|
|
installer.generate_bin
|
|
installed_exec = File.join(util_inst_bindir, "executable")
|
|
assert_equal(File.join(@spec.gem_dir, "bin", "executable"),
|
|
File.readlink(installed_exec))
|
|
|
|
@spec = Gem::Specification.new do |s|
|
|
s.files = ["lib/code.rb"]
|
|
s.name = "a"
|
|
s.version = "3"
|
|
s.summary = "summary"
|
|
s.description = "desc"
|
|
s.require_path = "lib"
|
|
end
|
|
|
|
util_make_exec
|
|
installer.gem_dir = @spec.gem_dir
|
|
installer.generate_bin
|
|
installed_exec = File.join(util_inst_bindir, "executable")
|
|
assert_equal(@spec.bin_file("executable"),
|
|
File.readlink(installed_exec),
|
|
"Ensure symlink moved to latest version")
|
|
end
|
|
|
|
def test_generate_bin_symlink_update_older
|
|
pend "Symlinks not supported or not enabled" unless symlink_supported?
|
|
|
|
installer = setup_base_installer
|
|
|
|
installer.wrappers = false
|
|
util_make_exec
|
|
installer.gem_dir = @spec.gem_dir
|
|
|
|
installer.generate_bin
|
|
installed_exec = File.join(util_inst_bindir, "executable")
|
|
assert_equal(File.join(@spec.gem_dir, "bin", "executable"),
|
|
File.readlink(installed_exec))
|
|
|
|
spec = Gem::Specification.new do |s|
|
|
s.files = ["lib/code.rb"]
|
|
s.name = "a"
|
|
s.version = "1"
|
|
s.summary = "summary"
|
|
s.description = "desc"
|
|
s.require_path = "lib"
|
|
end
|
|
|
|
util_make_exec
|
|
one = @spec.dup
|
|
one.version = 1
|
|
installer = Gem::Installer.for_spec spec
|
|
installer.gem_dir = one.gem_dir
|
|
|
|
installer.generate_bin
|
|
|
|
installed_exec = File.join util_inst_bindir, "executable"
|
|
expected = File.join @spec.gem_dir, "bin", "executable"
|
|
assert_equal(expected,
|
|
File.readlink(installed_exec),
|
|
"Ensure symlink not moved")
|
|
end
|
|
|
|
def test_generate_bin_symlink_update_remove_wrapper
|
|
pend "Symlinks not supported or not enabled" unless symlink_supported?
|
|
|
|
installer = setup_base_installer
|
|
|
|
installer.wrappers = true
|
|
util_make_exec
|
|
installer.gem_dir = @spec.gem_dir
|
|
|
|
installer.generate_bin
|
|
|
|
installed_exec = File.join util_inst_bindir, "executable"
|
|
assert_path_exist installed_exec
|
|
|
|
@spec = Gem::Specification.new do |s|
|
|
s.files = ["lib/code.rb"]
|
|
s.name = "a"
|
|
s.version = "3"
|
|
s.summary = "summary"
|
|
s.description = "desc"
|
|
s.require_path = "lib"
|
|
end
|
|
util_make_exec
|
|
|
|
util_installer @spec, @gemhome
|
|
installer.wrappers = false
|
|
installer.gem_dir = @spec.gem_dir
|
|
|
|
installer.generate_bin
|
|
|
|
installed_exec = File.join util_inst_bindir, "executable"
|
|
assert_equal(@spec.bin_file("executable"),
|
|
File.readlink(installed_exec),
|
|
"Ensure symlink moved to latest version")
|
|
end
|
|
|
|
def test_generate_bin_symlink_win32
|
|
old_win_platform = Gem.win_platform?
|
|
Gem.win_platform = true
|
|
old_alt_separator = File::ALT_SEPARATOR
|
|
File.__send__(:remove_const, :ALT_SEPARATOR)
|
|
File.const_set(:ALT_SEPARATOR, "\\")
|
|
|
|
installer = setup_base_installer
|
|
|
|
installer.wrappers = false
|
|
util_make_exec
|
|
installer.gem_dir = @spec.gem_dir
|
|
|
|
use_ui @ui do
|
|
installer.generate_bin
|
|
end
|
|
|
|
assert_directory_exists util_inst_bindir
|
|
installed_exec = File.join(util_inst_bindir, "executable")
|
|
assert_path_exist installed_exec
|
|
|
|
if symlink_supported?
|
|
assert File.symlink?(installed_exec)
|
|
return
|
|
end
|
|
|
|
assert_match(/Unable to use symlinks, installing wrapper/i,
|
|
@ui.error)
|
|
|
|
wrapper = File.read installed_exec
|
|
assert_match(/generated by RubyGems/, wrapper)
|
|
ensure
|
|
File.__send__(:remove_const, :ALT_SEPARATOR)
|
|
File.const_set(:ALT_SEPARATOR, old_alt_separator)
|
|
Gem.win_platform = old_win_platform
|
|
end
|
|
|
|
def test_generate_bin_uses_default_shebang
|
|
pend "Symlinks not supported or not enabled" unless symlink_supported?
|
|
|
|
load_relative "no" do
|
|
installer = setup_base_installer
|
|
|
|
installer.wrappers = true
|
|
util_make_exec
|
|
|
|
installer.generate_bin
|
|
|
|
default_shebang = Gem.ruby
|
|
shebang_line = File.open("#{@gemhome}/bin/executable") {|f| f.readlines.first }
|
|
assert_match(/\A#!/, shebang_line)
|
|
assert_match(/#{default_shebang}/, shebang_line)
|
|
end
|
|
end
|
|
|
|
def test_generate_bin_with_dangling_symlink
|
|
gem_with_dangling_symlink = File.expand_path("packages/ascii_binder-0.1.10.1.gem", __dir__)
|
|
|
|
installer = Gem::Installer.at(
|
|
gem_with_dangling_symlink,
|
|
:user_install => false,
|
|
:force => true
|
|
)
|
|
|
|
build_rake_in do
|
|
use_ui @ui do
|
|
installer.install
|
|
end
|
|
end
|
|
|
|
errors = @ui.error.split("\n")
|
|
assert_equal "WARNING: ascii_binder-0.1.10.1 ships with a dangling symlink named bin/ascii_binder pointing to missing bin/asciibinder file. Ignoring", errors.shift
|
|
assert_empty errors
|
|
|
|
assert_empty @ui.output
|
|
end
|
|
|
|
def test_generate_plugins
|
|
installer = util_setup_installer do |spec|
|
|
write_file File.join(@tempdir, "lib", "rubygems_plugin.rb") do |io|
|
|
io.write "puts __FILE__"
|
|
end
|
|
|
|
spec.files += %w[lib/rubygems_plugin.rb]
|
|
end
|
|
|
|
build_rake_in do
|
|
installer.install
|
|
end
|
|
|
|
plugin_path = File.join Gem.plugindir, "a_plugin.rb"
|
|
|
|
FileUtils.rm plugin_path
|
|
|
|
installer.generate_plugins
|
|
|
|
assert File.exist?(plugin_path), "plugin not written"
|
|
end
|
|
|
|
def test_generate_plugins_with_install_dir
|
|
spec = quick_gem "a" do |s|
|
|
write_file File.join(@tempdir, "lib", "rubygems_plugin.rb") do |io|
|
|
io.write "puts __FILE__"
|
|
end
|
|
|
|
s.files += %w[lib/rubygems_plugin.rb]
|
|
end
|
|
|
|
util_build_gem spec
|
|
|
|
plugin_path = File.join "#{@gemhome}2", "plugins", "a_plugin.rb"
|
|
installer = util_installer spec, "#{@gemhome}2"
|
|
|
|
assert_equal spec, installer.install
|
|
|
|
assert File.exist?(plugin_path), "plugin not written to install_dir"
|
|
end
|
|
|
|
def test_generate_plugins_with_user_install
|
|
spec = quick_gem "a" do |s|
|
|
write_file File.join(@tempdir, "lib", "rubygems_plugin.rb") do |io|
|
|
io.write "puts __FILE__"
|
|
end
|
|
|
|
s.files += %w[lib/rubygems_plugin.rb]
|
|
end
|
|
|
|
util_build_gem spec
|
|
|
|
File.chmod(0555, Gem.plugindir)
|
|
system_path = File.join(Gem.plugindir, "a_plugin.rb")
|
|
user_path = File.join(Gem.plugindir(Gem.user_dir), "a_plugin.rb")
|
|
installer = util_installer spec, Gem.dir, :user
|
|
|
|
assert_equal spec, installer.install
|
|
|
|
assert !File.exist?(system_path), "plugin incorrectly written to system plugins_dir"
|
|
assert File.exist?(user_path), "plugin not written to user plugins_dir"
|
|
end
|
|
|
|
def test_generate_plugins_with_build_root
|
|
spec = quick_gem "a" do |s|
|
|
write_file File.join(@tempdir, "lib", "rubygems_plugin.rb") do |io|
|
|
io.write "puts __FILE__"
|
|
end
|
|
|
|
s.files += %w[lib/rubygems_plugin.rb]
|
|
end
|
|
|
|
util_build_gem spec
|
|
|
|
File.chmod(0555, Gem.plugindir)
|
|
system_path = File.join(Gem.plugindir, "a_plugin.rb")
|
|
|
|
build_root = File.join(@tempdir, "build_root")
|
|
build_root_path = File.join(build_root, Gem.plugindir.gsub(/^[a-zA-Z]:/, ""), "a_plugin.rb")
|
|
|
|
installer = Gem::Installer.at spec.cache_file, :build_root => build_root
|
|
|
|
assert_equal spec, installer.install
|
|
|
|
assert !File.exist?(system_path), "plugin written incorrect written to system plugins_dir"
|
|
assert File.exist?(build_root_path), "plugin not written to build_root"
|
|
|
|
refute_includes File.read(build_root_path), build_root
|
|
end
|
|
|
|
def test_keeps_plugins_up_to_date
|
|
# NOTE: version a-2 is already installed by setup hooks
|
|
|
|
write_file File.join(@tempdir, "lib", "rubygems_plugin.rb") do |io|
|
|
io.write "puts __FILE__"
|
|
end
|
|
|
|
build_rake_in do
|
|
util_setup_installer do |spec|
|
|
spec.version = "1"
|
|
spec.files += %w[lib/rubygems_plugin.rb]
|
|
end.install
|
|
|
|
plugin_path = File.join Gem.plugindir, "a_plugin.rb"
|
|
refute File.exist?(plugin_path), "old version installed while newer version without plugin also installed, but plugin written"
|
|
|
|
util_setup_installer do |spec|
|
|
spec.version = "2"
|
|
spec.files += %w[lib/rubygems_plugin.rb]
|
|
end.install
|
|
|
|
plugin_path = File.join Gem.plugindir, "a_plugin.rb"
|
|
assert File.exist?(plugin_path), "latest version reinstalled, but plugin not written"
|
|
assert_match %r{\Arequire.*a-2/lib/rubygems_plugin\.rb}, File.read(plugin_path), "written plugin has incorrect content"
|
|
|
|
util_setup_installer do |spec|
|
|
spec.version = "3"
|
|
spec.files += %w[lib/rubygems_plugin.rb]
|
|
end.install
|
|
|
|
plugin_path = File.join Gem.plugindir, "a_plugin.rb"
|
|
assert File.exist?(plugin_path), "latest version installed, but plugin removed"
|
|
assert_match %r{\Arequire.*a-3/lib/rubygems_plugin\.rb}, File.read(plugin_path), "written plugin has incorrect content"
|
|
|
|
util_setup_installer do |spec|
|
|
spec.version = "4"
|
|
end.install
|
|
|
|
refute File.exist?(plugin_path), "new version installed without a plugin while older version with a plugin installed, but plugin not removed"
|
|
end
|
|
end
|
|
|
|
def test_generates_plugins_dir_under_install_dir_if_not_there
|
|
Gem.use_paths "#{@gemhome}2" # Set GEM_HOME to an uninitialized repo
|
|
|
|
@spec = util_spec "a"
|
|
|
|
path = Gem::Package.build @spec
|
|
|
|
installer = Gem::Installer.at path, :install_dir => "#{@gemhome}3"
|
|
assert_equal @spec, installer.install
|
|
end
|
|
|
|
def test_initialize
|
|
spec = util_spec "a" do |s|
|
|
s.platform = Gem::Platform.new "mswin32"
|
|
end
|
|
|
|
gem = File.join @tempdir, spec.file_name
|
|
|
|
Dir.mkdir util_inst_bindir
|
|
util_build_gem spec
|
|
FileUtils.mv spec.cache_file, @tempdir
|
|
|
|
installer = Gem::Installer.at gem
|
|
|
|
assert_equal File.join(@gemhome, "gems", spec.full_name), installer.gem_dir
|
|
assert_equal File.join(@gemhome, "bin"), installer.bin_dir
|
|
end
|
|
|
|
def test_initialize_user_install
|
|
@gem = setup_base_gem
|
|
|
|
installer = Gem::Installer.at @gem, :user_install => true
|
|
|
|
assert_equal File.join(Gem.user_dir, "gems", @spec.full_name),
|
|
installer.gem_dir
|
|
assert_equal Gem.bindir(Gem.user_dir), installer.bin_dir
|
|
end
|
|
|
|
def test_initialize_user_install_bin_dir
|
|
@gem = setup_base_gem
|
|
|
|
installer =
|
|
Gem::Installer.at @gem, :user_install => true, :bin_dir => @tempdir
|
|
|
|
assert_equal File.join(Gem.user_dir, "gems", @spec.full_name),
|
|
installer.gem_dir
|
|
assert_equal @tempdir, installer.bin_dir
|
|
end
|
|
|
|
def test_install
|
|
installer = util_setup_installer
|
|
|
|
gemdir = File.join @gemhome, "gems", @spec.full_name
|
|
cache_file = File.join @gemhome, "cache", @spec.file_name
|
|
stub_exe = File.join @gemhome, "bin", "executable"
|
|
rakefile = File.join gemdir, "ext", "a", "Rakefile"
|
|
spec_file = File.join @gemhome, "specifications", @spec.spec_name
|
|
|
|
Gem.pre_install do
|
|
assert_path_not_exist cache_file, "cache file must not exist yet"
|
|
true
|
|
end
|
|
|
|
Gem.post_build do
|
|
assert_path_exist gemdir, "gem install dir must exist"
|
|
assert_path_exist rakefile, "gem executable must exist"
|
|
assert_path_not_exist stub_exe, "gem executable must not exist"
|
|
true
|
|
end
|
|
|
|
Gem.post_install do
|
|
assert_path_exist cache_file, "cache file must exist"
|
|
end
|
|
|
|
@newspec = nil
|
|
build_rake_in do
|
|
use_ui @ui do
|
|
@newspec = installer.install
|
|
end
|
|
end
|
|
|
|
assert_equal @spec, @newspec
|
|
assert_path_exist gemdir
|
|
assert_path_exist stub_exe, "gem executable must exist"
|
|
|
|
exe = File.join gemdir, "bin", "executable"
|
|
assert_path_exist exe
|
|
|
|
exe_mode = File.stat(exe).mode & 0111
|
|
assert_equal 0111, exe_mode, "0%o" % exe_mode unless win_platform?
|
|
|
|
assert_path_exist File.join gemdir, "lib", "code.rb"
|
|
|
|
assert_path_exist rakefile
|
|
|
|
assert_equal spec_file, @newspec.loaded_from
|
|
assert_path_exist spec_file
|
|
|
|
assert_same installer, @post_build_hook_arg
|
|
assert_same installer, @post_install_hook_arg
|
|
assert_same installer, @pre_install_hook_arg
|
|
end
|
|
|
|
def test_install_creates_working_binstub
|
|
installer = util_setup_installer
|
|
|
|
installer.wrappers = true
|
|
|
|
gemdir = File.join @gemhome, "gems", @spec.full_name
|
|
|
|
@newspec = nil
|
|
build_rake_in do
|
|
use_ui @ui do
|
|
@newspec = installer.install
|
|
end
|
|
end
|
|
|
|
exe = File.join gemdir, "bin", "executable"
|
|
|
|
e = assert_raise RuntimeError do
|
|
instance_eval File.read(exe)
|
|
end
|
|
|
|
assert_match(/ran executable/, e.message)
|
|
end
|
|
|
|
def test_conflicting_binstubs
|
|
@gem = setup_base_gem
|
|
|
|
# build old version that has a bin file
|
|
installer = util_setup_gem do |spec|
|
|
File.open File.join("bin", "executable"), "w" do |f|
|
|
f.puts "require 'code'"
|
|
end
|
|
File.open File.join("lib", "code.rb"), "w" do |f|
|
|
f.puts 'raise "I have an executable"'
|
|
end
|
|
end
|
|
|
|
installer.wrappers = true
|
|
build_rake_in do
|
|
use_ui @ui do
|
|
@newspec = installer.install
|
|
end
|
|
end
|
|
|
|
old_bin_file = File.join installer.bin_dir, "executable"
|
|
|
|
# build new version that doesn't have a bin file
|
|
installer = util_setup_gem do |spec|
|
|
FileUtils.rm File.join("bin", "executable")
|
|
spec.files.delete File.join("bin", "executable")
|
|
spec.executables.delete "executable"
|
|
spec.version = @spec.version.bump
|
|
File.open File.join("lib", "code.rb"), "w" do |f|
|
|
f.puts 'raise "I do not have an executable"'
|
|
end
|
|
end
|
|
|
|
build_rake_in do
|
|
use_ui @ui do
|
|
@newspec = installer.install
|
|
end
|
|
end
|
|
|
|
e = assert_raise RuntimeError do
|
|
instance_eval File.read(old_bin_file)
|
|
end
|
|
|
|
# We expect the bin stub to activate the version that actually contains
|
|
# the binstub.
|
|
assert_match("I have an executable", e.message)
|
|
end
|
|
|
|
def test_install_creates_binstub_that_understand_version
|
|
installer = util_setup_installer
|
|
|
|
installer.wrappers = true
|
|
|
|
@newspec = nil
|
|
build_rake_in do
|
|
use_ui @ui do
|
|
@newspec = installer.install
|
|
end
|
|
end
|
|
|
|
exe = File.join @gemhome, "bin", "executable"
|
|
|
|
ARGV.unshift "_3.0_"
|
|
|
|
begin
|
|
Gem::Specification.reset
|
|
|
|
e = assert_raise Gem::GemNotFoundException do
|
|
instance_eval File.read(exe)
|
|
end
|
|
ensure
|
|
ARGV.shift if ARGV.first == "_3.0_"
|
|
end
|
|
|
|
assert_includes(e.message, "can't find gem a (= 3.0)")
|
|
end
|
|
|
|
def test_install_creates_binstub_that_prefers_user_installed_gem_to_default
|
|
default_spec = new_default_spec("default", "2", nil, "exe/executable")
|
|
default_spec.executables = "executable"
|
|
install_default_gems default_spec
|
|
|
|
exe = File.join @gemhome, "bin", "executable"
|
|
|
|
assert_path_exist exe, "default gem's executable not installed"
|
|
|
|
installer = util_setup_installer do |spec|
|
|
spec.name = "default"
|
|
spec.version = "2"
|
|
end
|
|
|
|
util_clear_gems
|
|
|
|
installer.wrappers = true
|
|
|
|
@newspec = nil
|
|
build_rake_in do
|
|
use_ui @ui do
|
|
@newspec = installer.install
|
|
end
|
|
end
|
|
|
|
e = assert_raise RuntimeError do
|
|
instance_eval File.read(exe)
|
|
end
|
|
|
|
assert_equal(e.message, "ran executable")
|
|
end
|
|
|
|
def test_install_creates_binstub_that_dont_trust_encoding
|
|
installer = util_setup_installer
|
|
|
|
installer.wrappers = true
|
|
|
|
@newspec = nil
|
|
build_rake_in do
|
|
use_ui @ui do
|
|
@newspec = installer.install
|
|
end
|
|
end
|
|
|
|
exe = File.join @gemhome, "bin", "executable"
|
|
|
|
extra_arg = "\xE4pfel".dup.force_encoding("UTF-8")
|
|
ARGV.unshift extra_arg
|
|
|
|
begin
|
|
Gem::Specification.reset
|
|
|
|
e = assert_raise RuntimeError do
|
|
instance_eval File.read(exe)
|
|
end
|
|
ensure
|
|
ARGV.shift if ARGV.first == extra_arg
|
|
end
|
|
|
|
assert_match(/ran executable/, e.message)
|
|
end
|
|
|
|
def test_install_with_no_prior_files
|
|
installer = util_setup_installer
|
|
|
|
build_rake_in do
|
|
use_ui @ui do
|
|
assert_equal @spec, installer.install
|
|
end
|
|
end
|
|
|
|
gemdir = File.join(@gemhome, "gems", @spec.full_name)
|
|
assert_path_exist File.join gemdir, "lib", "code.rb"
|
|
|
|
installer = util_setup_installer
|
|
|
|
# Morph spec to have lib/other.rb instead of code.rb and recreate
|
|
@spec.files = File.join("lib", "other.rb")
|
|
Dir.chdir @tempdir do
|
|
File.open File.join("lib", "other.rb"), "w" do |f|
|
|
f.puts "1"
|
|
end
|
|
|
|
use_ui ui do
|
|
FileUtils.rm @gem
|
|
Gem::Package.build @spec
|
|
end
|
|
end
|
|
installer = Gem::Installer.at @gem, :force => true
|
|
build_rake_in do
|
|
use_ui @ui do
|
|
assert_equal @spec, installer.install
|
|
end
|
|
end
|
|
|
|
assert_path_exist File.join gemdir, "lib", "other.rb"
|
|
assert_path_not_exist File.join gemdir, "lib", "code.rb",
|
|
"code.rb from prior install of same gem shouldn't remain here"
|
|
end
|
|
|
|
def test_install_force
|
|
_, missing_dep_gem = util_gem "missing_dep", "1" do |s|
|
|
s.add_dependency "doesnt_exist", "1"
|
|
end
|
|
|
|
use_ui @ui do
|
|
installer = Gem::Installer.at missing_dep_gem, :force => true
|
|
installer.install
|
|
end
|
|
|
|
gem_dir = File.join(@gemhome, "gems", "missing_dep-1")
|
|
assert_path_exist gem_dir
|
|
end
|
|
|
|
def test_install_build_root
|
|
build_root = File.join(@tempdir, "build_root")
|
|
|
|
@gem = setup_base_gem
|
|
installer = Gem::Installer.at @gem, :build_root => build_root
|
|
|
|
assert_equal @spec, installer.install
|
|
end
|
|
|
|
def test_install_missing_dirs
|
|
installer = setup_base_installer
|
|
|
|
FileUtils.rm_rf File.join(Gem.dir, "doc")
|
|
FileUtils.rm_rf File.join(Gem.dir, "specifications")
|
|
|
|
use_ui @ui do
|
|
installer.install
|
|
end
|
|
|
|
assert_directory_exists File.join(Gem.dir, "doc")
|
|
assert_directory_exists File.join(Gem.dir, "specifications")
|
|
|
|
assert_path_exist File.join @gemhome, "cache", @spec.file_name
|
|
assert_path_exist File.join @gemhome, "specifications", @spec.spec_name
|
|
end
|
|
|
|
def test_install_post_build_false
|
|
@spec = util_spec "a"
|
|
|
|
util_build_gem @spec
|
|
|
|
installer = util_installer @spec, @gemhome
|
|
|
|
Gem.post_build do
|
|
false
|
|
end
|
|
|
|
use_ui @ui do
|
|
e = assert_raise Gem::InstallError do
|
|
installer.install
|
|
end
|
|
|
|
location = "#{__FILE__}:#{__LINE__ - 9}"
|
|
|
|
assert_equal "post-build hook at #{location} failed for a-2", e.message
|
|
end
|
|
|
|
spec_file = File.join @gemhome, "specifications", @spec.spec_name
|
|
assert_path_not_exist spec_file
|
|
|
|
gem_dir = File.join @gemhome, "gems", @spec.full_name
|
|
assert_path_not_exist gem_dir
|
|
end
|
|
|
|
def test_install_post_build_nil
|
|
installer = setup_base_installer
|
|
|
|
Gem.post_build do
|
|
nil
|
|
end
|
|
|
|
use_ui @ui do
|
|
installer.install
|
|
end
|
|
|
|
spec_file = File.join @gemhome, "specifications", @spec.spec_name
|
|
assert_path_exist spec_file
|
|
|
|
gem_dir = File.join @gemhome, "gems", @spec.full_name
|
|
assert_path_exist gem_dir
|
|
end
|
|
|
|
def test_install_pre_install_false
|
|
@spec = util_spec "a"
|
|
|
|
util_build_gem @spec
|
|
|
|
installer = util_installer @spec, @gemhome
|
|
|
|
Gem.pre_install do
|
|
false
|
|
end
|
|
|
|
use_ui @ui do
|
|
e = assert_raise Gem::InstallError do
|
|
installer.install
|
|
end
|
|
|
|
location = "#{__FILE__}:#{__LINE__ - 9}"
|
|
|
|
assert_equal "pre-install hook at #{location} failed for a-2", e.message
|
|
end
|
|
|
|
spec_file = File.join @gemhome, "specifications", @spec.spec_name
|
|
assert_path_not_exist spec_file
|
|
end
|
|
|
|
def test_install_pre_install_nil
|
|
installer = setup_base_installer
|
|
|
|
Gem.pre_install do
|
|
nil
|
|
end
|
|
|
|
use_ui @ui do
|
|
installer.install
|
|
end
|
|
|
|
spec_file = File.join @gemhome, "specifications", @spec.spec_name
|
|
assert_path_exist spec_file
|
|
end
|
|
|
|
def test_install_with_message
|
|
@spec = setup_base_spec
|
|
@spec.post_install_message = "I am a shiny gem!"
|
|
|
|
use_ui @ui do
|
|
path = Gem::Package.build @spec
|
|
|
|
installer = Gem::Installer.at path
|
|
installer.install
|
|
end
|
|
|
|
assert_match %r{I am a shiny gem!}, @ui.output
|
|
end
|
|
|
|
def test_install_with_skipped_message
|
|
@spec = setup_base_spec
|
|
@spec.post_install_message = "I am a shiny gem!"
|
|
|
|
use_ui @ui do
|
|
path = Gem::Package.build @spec
|
|
|
|
installer = Gem::Installer.at path, :post_install_message => false
|
|
installer.install
|
|
end
|
|
|
|
refute_match %r{I am a shiny gem!}, @ui.output
|
|
end
|
|
|
|
def test_install_extension_dir
|
|
gemhome2 = "#{@gemhome}2"
|
|
|
|
@spec = setup_base_spec
|
|
@spec.extensions << "extconf.rb"
|
|
write_file File.join(@tempdir, "extconf.rb") do |io|
|
|
io.write <<-RUBY
|
|
require "mkmf"
|
|
create_makefile("#{@spec.name}")
|
|
RUBY
|
|
end
|
|
|
|
@spec.files += %w[extconf.rb]
|
|
|
|
use_ui @ui do
|
|
path = Gem::Package.build @spec
|
|
|
|
installer = Gem::Installer.at path, :install_dir => gemhome2
|
|
installer.install
|
|
end
|
|
|
|
expected_makefile = File.join gemhome2, "gems", @spec.full_name, "Makefile"
|
|
|
|
assert_path_exist expected_makefile
|
|
end
|
|
|
|
def test_install_extension_dir_is_removed_on_reinstall
|
|
@spec = setup_base_spec
|
|
|
|
@spec.extensions << "extconf.rb"
|
|
write_file File.join(@tempdir, "extconf.rb") do |io|
|
|
io.write <<-RUBY
|
|
require "mkmf"
|
|
create_makefile("#{@spec.name}")
|
|
RUBY
|
|
end
|
|
|
|
@spec.files += %w[extconf.rb]
|
|
|
|
path = Gem::Package.build @spec
|
|
|
|
# Install a gem with an extension
|
|
use_ui @ui do
|
|
installer = Gem::Installer.at path
|
|
installer.install
|
|
end
|
|
|
|
# pretend that a binary file was created as part of the build
|
|
should_be_removed = File.join(@spec.extension_dir, "#{@spec.name}.so")
|
|
write_file should_be_removed do |io|
|
|
io.write "DELETE ME ON REINSTALL"
|
|
end
|
|
assert_path_exist should_be_removed
|
|
|
|
# reinstall the gem, this is also the same as pristine
|
|
use_ui @ui do
|
|
installer = Gem::Installer.at path, :force => true
|
|
installer.install
|
|
end
|
|
|
|
assert_path_not_exist should_be_removed
|
|
end
|
|
|
|
def test_install_user_extension_dir
|
|
@spec = setup_base_spec
|
|
@spec.extensions << "extconf.rb"
|
|
write_file File.join(@tempdir, "extconf.rb") do |io|
|
|
io.write <<-RUBY
|
|
require "mkmf"
|
|
create_makefile("#{@spec.name}")
|
|
RUBY
|
|
end
|
|
|
|
@spec.files += %w[extconf.rb]
|
|
|
|
# Create the non-user ext dir
|
|
expected_extension_dir = @spec.extension_dir.dup
|
|
FileUtils.mkdir_p expected_extension_dir
|
|
|
|
use_ui @ui do
|
|
path = Gem::Package.build @spec
|
|
|
|
installer = Gem::Installer.at path, :user_install => true
|
|
installer.install
|
|
end
|
|
|
|
expected_makefile = File.join Gem.user_dir, "gems", @spec.full_name, "Makefile"
|
|
|
|
assert_path_exist expected_makefile
|
|
assert_path_exist expected_extension_dir
|
|
assert_path_not_exist File.join expected_extension_dir, "gem_make.out"
|
|
end
|
|
|
|
def test_find_lib_file_after_install
|
|
pend "extensions don't quite work on jruby" if Gem.java_platform?
|
|
|
|
@spec = setup_base_spec
|
|
@spec.extensions << "extconf.rb"
|
|
write_file File.join(@tempdir, "extconf.rb") do |io|
|
|
io.write <<-RUBY
|
|
require "mkmf"
|
|
|
|
CONFIG['CC'] = '$(TOUCH) $@ ||'
|
|
CONFIG['LDSHARED'] = '$(TOUCH) $@ ||'
|
|
$ruby = '#{Gem.ruby}'
|
|
|
|
create_makefile("#{@spec.name}")
|
|
RUBY
|
|
end
|
|
|
|
write_file File.join(@tempdir, "depend")
|
|
|
|
write_file File.join(@tempdir, "a.c") do |io|
|
|
io.write <<-C
|
|
#include <ruby.h>
|
|
void Init_a() { }
|
|
C
|
|
end
|
|
|
|
Dir.mkdir File.join(@tempdir, "lib")
|
|
write_file File.join(@tempdir, "lib", "b.rb") do |io|
|
|
io.write "# b.rb"
|
|
end
|
|
|
|
@spec.files += %w[extconf.rb lib/b.rb depend a.c]
|
|
|
|
use_ui @ui do
|
|
path = Gem::Package.build @spec
|
|
|
|
installer = Gem::Installer.at path
|
|
installer.install
|
|
end
|
|
|
|
expected = File.join @spec.full_require_paths.find {|path|
|
|
File.exist? File.join path, "b.rb"
|
|
}, "b.rb"
|
|
assert_equal expected, @spec.matches_for_glob("b.rb").first
|
|
end
|
|
|
|
def test_install_extension_and_script
|
|
pend "Makefile creation crashes on jruby" if Gem.java_platform?
|
|
pend if RUBY_PLATFORM.include?("mswin") && ENV.key?("GITHUB_ACTIONS") # not working from the beginning
|
|
|
|
@spec = setup_base_spec
|
|
@spec.extensions << "extconf.rb"
|
|
write_file File.join(@tempdir, "extconf.rb") do |io|
|
|
io.write <<-RUBY
|
|
require "mkmf"
|
|
create_makefile("#{@spec.name}")
|
|
RUBY
|
|
end
|
|
|
|
rb = File.join("lib", "#{@spec.name}.rb")
|
|
@spec.files += [rb]
|
|
write_file File.join(@tempdir, rb) do |io|
|
|
io.write <<-RUBY
|
|
# #{@spec.name}.rb
|
|
RUBY
|
|
end
|
|
|
|
Dir.mkdir(File.join("lib", @spec.name))
|
|
rb2 = File.join("lib", @spec.name, "#{@spec.name}.rb")
|
|
@spec.files << rb2
|
|
write_file File.join(@tempdir, rb2) do |io|
|
|
io.write <<-RUBY
|
|
# #{@spec.name}/#{@spec.name}.rb
|
|
RUBY
|
|
end
|
|
|
|
assert_path_not_exist File.join @spec.gem_dir, rb
|
|
assert_path_not_exist File.join @spec.gem_dir, rb2
|
|
use_ui @ui do
|
|
path = Gem::Package.build @spec
|
|
|
|
installer = Gem::Installer.at path
|
|
installer.install
|
|
end
|
|
assert_path_exist File.join @spec.gem_dir, rb
|
|
assert_path_exist File.join @spec.gem_dir, rb2
|
|
end
|
|
|
|
def test_install_extension_flat
|
|
pend "extensions don't quite work on jruby" if Gem.java_platform?
|
|
|
|
begin
|
|
@spec = setup_base_spec
|
|
@spec.require_paths = ["."]
|
|
|
|
@spec.extensions << "extconf.rb"
|
|
|
|
write_file File.join(@tempdir, "extconf.rb") do |io|
|
|
io.write <<-RUBY
|
|
require "mkmf"
|
|
|
|
CONFIG['CC'] = '$(TOUCH) $@ ||'
|
|
CONFIG['LDSHARED'] = '$(TOUCH) $@ ||'
|
|
$ruby = '#{Gem.ruby}'
|
|
|
|
create_makefile("#{@spec.name}")
|
|
RUBY
|
|
end
|
|
|
|
# empty depend file for no auto dependencies
|
|
@spec.files += %W[depend #{@spec.name}.c].each do |file|
|
|
write_file File.join(@tempdir, file)
|
|
end
|
|
|
|
so = File.join(@spec.gem_dir, "#{@spec.name}.#{RbConfig::CONFIG["DLEXT"]}")
|
|
assert_path_not_exist so
|
|
use_ui @ui do
|
|
path = Gem::Package.build @spec
|
|
|
|
installer = Gem::Installer.at path
|
|
installer.install
|
|
end
|
|
assert_path_exist so
|
|
rescue
|
|
puts "-" * 78
|
|
puts File.read File.join(@gemhome, "gems", "a-2", "Makefile")
|
|
puts "-" * 78
|
|
|
|
path = File.join(@gemhome, "gems", "a-2", "gem_make.out")
|
|
|
|
if File.exist?(path)
|
|
puts File.read(path)
|
|
puts "-" * 78
|
|
end
|
|
|
|
raise
|
|
end
|
|
end
|
|
|
|
def test_installation_satisfies_dependency_eh
|
|
installer = setup_base_installer
|
|
|
|
util_spec "a"
|
|
|
|
dep = Gem::Dependency.new "a", ">= 2"
|
|
assert installer.installation_satisfies_dependency?(dep)
|
|
|
|
dep = Gem::Dependency.new "a", "> 2"
|
|
refute installer.installation_satisfies_dependency?(dep)
|
|
end
|
|
|
|
def test_installation_satisfies_dependency_eh_development
|
|
installer = setup_base_installer
|
|
installer.options[:development] = true
|
|
installer.options[:dev_shallow] = true
|
|
|
|
util_spec "a"
|
|
|
|
dep = Gem::Dependency.new "a", :development
|
|
assert installer.installation_satisfies_dependency?(dep)
|
|
end
|
|
|
|
def test_pre_install_checks_dependencies
|
|
installer = setup_base_installer
|
|
@spec.add_dependency "b", "> 5"
|
|
installer = util_setup_gem
|
|
installer.force = false
|
|
|
|
use_ui @ui do
|
|
assert_raise Gem::InstallError do
|
|
installer.install
|
|
end
|
|
end
|
|
end
|
|
|
|
def test_pre_install_checks_dependencies_ignore
|
|
installer = util_setup_installer
|
|
@spec.add_dependency "b", "> 5"
|
|
installer.ignore_dependencies = true
|
|
|
|
build_rake_in do
|
|
use_ui @ui do
|
|
assert installer.pre_install_checks
|
|
end
|
|
end
|
|
end
|
|
|
|
def test_pre_install_checks_dependencies_install_dir
|
|
gemhome2 = "#{@gemhome}2"
|
|
|
|
@gem = setup_base_gem
|
|
@spec.add_dependency "d"
|
|
|
|
quick_gem "d", 2
|
|
|
|
gem = File.join @gemhome, @spec.file_name
|
|
|
|
FileUtils.mv @gemhome, gemhome2
|
|
FileUtils.mkdir @gemhome
|
|
|
|
FileUtils.mv File.join(gemhome2, "cache", @spec.file_name), gem
|
|
|
|
# Don't leak any already activated gems into the installer, require
|
|
# that it work everything out on it's own.
|
|
Gem::Specification.reset
|
|
|
|
installer = Gem::Installer.at gem, :install_dir => gemhome2
|
|
|
|
build_rake_in do
|
|
use_ui @ui do
|
|
assert installer.pre_install_checks
|
|
end
|
|
end
|
|
end
|
|
|
|
def test_pre_install_checks_malicious_name
|
|
spec = util_spec "../malicious", "1"
|
|
def spec.full_name # so the spec is buildable
|
|
"malicious-1"
|
|
end
|
|
def spec.validate(packaging, strict); end
|
|
|
|
util_build_gem spec
|
|
|
|
gem = File.join(@gemhome, "cache", spec.file_name)
|
|
|
|
use_ui @ui do
|
|
installer = Gem::Installer.at gem
|
|
e = assert_raise Gem::InstallError do
|
|
installer.pre_install_checks
|
|
end
|
|
assert_equal "#<Gem::Specification name=../malicious version=1> has an invalid name", e.message
|
|
end
|
|
end
|
|
|
|
def test_pre_install_checks_malicious_name_before_eval
|
|
spec = util_spec "malicious\n::Object.const_set(:FROM_EVAL, true)#", "1"
|
|
def spec.full_name # so the spec is buildable
|
|
"malicious-1"
|
|
end
|
|
def spec.validate(*args); end
|
|
|
|
util_build_gem spec
|
|
|
|
gem = File.join(@gemhome, "cache", spec.file_name)
|
|
|
|
use_ui @ui do
|
|
installer = Gem::Installer.at gem
|
|
e = assert_raise Gem::InstallError do
|
|
installer.pre_install_checks
|
|
end
|
|
assert_equal "#<Gem::Specification name=malicious\n::Object.const_set(:FROM_EVAL, true)# version=1> has an invalid name", e.message
|
|
end
|
|
refute defined?(::Object::FROM_EVAL)
|
|
end
|
|
|
|
def test_pre_install_checks_malicious_require_paths_before_eval
|
|
spec = util_spec "malicious", "1"
|
|
def spec.full_name # so the spec is buildable
|
|
"malicious-1"
|
|
end
|
|
def spec.validate(*args); end
|
|
spec.require_paths = ["malicious\n``"]
|
|
|
|
util_build_gem spec
|
|
|
|
gem = File.join(@gemhome, "cache", spec.file_name)
|
|
|
|
use_ui @ui do
|
|
installer = Gem::Installer.at gem
|
|
e = assert_raise Gem::InstallError do
|
|
installer.pre_install_checks
|
|
end
|
|
assert_equal "#<Gem::Specification name=malicious version=1> has an invalid require_paths", e.message
|
|
end
|
|
end
|
|
|
|
def test_pre_install_checks_malicious_extensions_before_eval
|
|
pend "mswin environment disallow to create file contained the carriage return code." if Gem.win_platform?
|
|
|
|
spec = util_spec "malicious", "1"
|
|
def spec.full_name # so the spec is buildable
|
|
"malicious-1"
|
|
end
|
|
def spec.validate(*args); end
|
|
spec.extensions = ["malicious\n``"]
|
|
|
|
util_build_gem spec
|
|
|
|
gem = File.join(@gemhome, "cache", spec.file_name)
|
|
|
|
use_ui @ui do
|
|
installer = Gem::Installer.at gem
|
|
e = assert_raise Gem::InstallError do
|
|
installer.pre_install_checks
|
|
end
|
|
assert_equal "#<Gem::Specification name=malicious version=1> has an invalid extensions", e.message
|
|
end
|
|
end
|
|
|
|
def test_pre_install_checks_malicious_specification_version_before_eval
|
|
spec = util_spec "malicious", "1"
|
|
def spec.full_name # so the spec is buildable
|
|
"malicious-1"
|
|
end
|
|
def spec.validate(*args); end
|
|
spec.specification_version = "malicious\n``"
|
|
|
|
util_build_gem spec
|
|
|
|
gem = File.join(@gemhome, "cache", spec.file_name)
|
|
|
|
use_ui @ui do
|
|
installer = Gem::Installer.at gem
|
|
e = assert_raise Gem::InstallError do
|
|
installer.pre_install_checks
|
|
end
|
|
assert_equal "#<Gem::Specification name=malicious version=1> has an invalid specification_version", e.message
|
|
end
|
|
end
|
|
|
|
def test_pre_install_checks_malicious_dependencies_before_eval
|
|
spec = util_spec "malicious", "1"
|
|
def spec.full_name # so the spec is buildable
|
|
"malicious-1"
|
|
end
|
|
def spec.validate(*args); end
|
|
spec.add_dependency "b\nfoo", "> 5"
|
|
|
|
util_build_gem spec
|
|
|
|
gem = File.join(@gemhome, "cache", spec.file_name)
|
|
|
|
use_ui @ui do
|
|
installer = Gem::Installer.at gem
|
|
installer.ignore_dependencies = true
|
|
e = assert_raise Gem::InstallError do
|
|
installer.pre_install_checks
|
|
end
|
|
assert_equal "#<Gem::Specification name=malicious version=1> has an invalid dependencies", e.message
|
|
end
|
|
end
|
|
|
|
def test_pre_install_checks_malicious_platform_before_eval
|
|
gem_with_ill_formated_platform = File.expand_path("packages/ill-formatted-platform-1.0.0.10.gem", __dir__)
|
|
|
|
installer = Gem::Installer.at(
|
|
gem_with_ill_formated_platform,
|
|
:install_dir => @gem_home,
|
|
:user_install => false,
|
|
:force => true
|
|
)
|
|
|
|
use_ui @ui do
|
|
e = assert_raise Gem::InstallError do
|
|
installer.pre_install_checks
|
|
end
|
|
|
|
assert_equal "x86-mswin32\n system('id > /tmp/nyangawa')# is an invalid platform", e.message
|
|
assert_empty @ui.output
|
|
end
|
|
end
|
|
|
|
def test_shebang
|
|
load_relative "no" do
|
|
installer = setup_base_installer
|
|
|
|
util_make_exec @spec, "#!/usr/bin/ruby"
|
|
|
|
shebang = installer.shebang "executable"
|
|
|
|
assert_equal "#!#{Gem.ruby}", shebang
|
|
end
|
|
end
|
|
|
|
def test_process_options
|
|
installer = setup_base_installer
|
|
|
|
assert_nil installer.build_root
|
|
assert_equal File.join(@gemhome, "bin"), installer.bin_dir
|
|
assert_equal @gemhome, installer.gem_home
|
|
end
|
|
|
|
def test_process_options_build_root
|
|
build_root = File.join @tempdir, "build_root"
|
|
bin_dir = File.join(build_root, @gemhome.gsub(/^[a-zA-Z]:/, ""), "bin")
|
|
gem_home = File.join(build_root, @gemhome.gsub(/^[a-zA-Z]:/, ""))
|
|
plugins_dir = File.join(build_root, @gemhome.gsub(/^[a-zA-Z]:/, ""), "plugins")
|
|
|
|
@gem = setup_base_gem
|
|
installer = use_ui(@ui) { Gem::Installer.at @gem, :build_root => build_root }
|
|
|
|
assert_equal build_root, installer.build_root
|
|
assert_equal bin_dir, installer.bin_dir
|
|
assert_equal gem_home, installer.gem_home
|
|
|
|
errors = @ui.error.split("\n")
|
|
|
|
assert_equal "WARNING: You build with buildroot.", errors.shift
|
|
assert_equal " Build root: #{build_root}", errors.shift
|
|
assert_equal " Bin dir: #{bin_dir}", errors.shift
|
|
assert_equal " Gem home: #{gem_home}", errors.shift
|
|
assert_equal " Plugins dir: #{plugins_dir}", errors.shift
|
|
end
|
|
|
|
def test_shebang_arguments
|
|
load_relative "no" do
|
|
installer = setup_base_installer
|
|
|
|
util_make_exec @spec, "#!/usr/bin/ruby -ws"
|
|
|
|
shebang = installer.shebang "executable"
|
|
|
|
assert_equal "#!#{Gem.ruby} -ws", shebang
|
|
end
|
|
end
|
|
|
|
def test_shebang_arguments_with_load_relative
|
|
load_relative "yes" do
|
|
installer = setup_base_installer
|
|
|
|
util_make_exec @spec, "#!/usr/bin/ruby -ws"
|
|
|
|
shebang = installer.shebang "executable"
|
|
|
|
shebang_lines = shebang.split "\n"
|
|
|
|
assert_equal "#!/bin/sh", shebang_lines.shift
|
|
assert_includes shebang_lines, "#!#{Gem.ruby} -ws"
|
|
end
|
|
end
|
|
|
|
def test_shebang_empty
|
|
load_relative "no" do
|
|
installer = setup_base_installer
|
|
|
|
util_make_exec @spec, ""
|
|
|
|
shebang = installer.shebang "executable"
|
|
assert_equal "#!#{Gem.ruby}", shebang
|
|
end
|
|
end
|
|
|
|
def test_shebang_env
|
|
load_relative "no" do
|
|
installer = setup_base_installer
|
|
|
|
util_make_exec @spec, "#!/usr/bin/env ruby"
|
|
|
|
shebang = installer.shebang "executable"
|
|
|
|
assert_equal "#!#{Gem.ruby}", shebang
|
|
end
|
|
end
|
|
|
|
def test_shebang_env_arguments
|
|
load_relative "no" do
|
|
installer = setup_base_installer
|
|
|
|
util_make_exec @spec, "#!/usr/bin/env ruby -ws"
|
|
|
|
shebang = installer.shebang "executable"
|
|
|
|
assert_equal "#!#{Gem.ruby} -ws", shebang
|
|
end
|
|
end
|
|
|
|
def test_shebang_env_arguments_with_load_relative
|
|
load_relative "yes" do
|
|
installer = setup_base_installer
|
|
|
|
util_make_exec @spec, "#!/usr/bin/env ruby -ws"
|
|
|
|
shebang = installer.shebang "executable"
|
|
|
|
shebang_lines = shebang.split "\n"
|
|
|
|
assert_equal "#!/bin/sh", shebang_lines.shift
|
|
assert_includes shebang_lines, "#!#{Gem.ruby} -ws"
|
|
end
|
|
end
|
|
|
|
def test_shebang_env_shebang
|
|
installer = setup_base_installer
|
|
|
|
util_make_exec @spec, ""
|
|
installer.env_shebang = true
|
|
|
|
shebang = installer.shebang "executable"
|
|
|
|
bin_env = get_bin_env
|
|
|
|
assert_equal("#!#{bin_env} #{RbConfig::CONFIG['ruby_install_name']}",
|
|
shebang)
|
|
end
|
|
|
|
def test_shebang_nested
|
|
load_relative "no" do
|
|
installer = setup_base_installer
|
|
|
|
util_make_exec @spec, "#!/opt/local/ruby/bin/ruby"
|
|
|
|
shebang = installer.shebang "executable"
|
|
|
|
assert_equal "#!#{Gem.ruby}", shebang
|
|
end
|
|
end
|
|
|
|
def test_shebang_nested_arguments
|
|
load_relative "no" do
|
|
installer = setup_base_installer
|
|
|
|
util_make_exec @spec, "#!/opt/local/ruby/bin/ruby -ws"
|
|
|
|
shebang = installer.shebang "executable"
|
|
|
|
assert_equal "#!#{Gem.ruby} -ws", shebang
|
|
end
|
|
end
|
|
|
|
def test_shebang_nested_arguments_with_load_relative
|
|
load_relative "yes" do
|
|
installer = setup_base_installer
|
|
|
|
util_make_exec @spec, "#!/opt/local/ruby/bin/ruby -ws"
|
|
|
|
shebang = installer.shebang "executable"
|
|
|
|
shebang_lines = shebang.split "\n"
|
|
|
|
assert_equal "#!/bin/sh", shebang_lines.shift
|
|
assert_includes shebang_lines, "#!#{Gem.ruby} -ws"
|
|
end
|
|
end
|
|
|
|
def test_shebang_version
|
|
load_relative "no" do
|
|
installer = setup_base_installer
|
|
|
|
util_make_exec @spec, "#!/usr/bin/ruby18"
|
|
|
|
shebang = installer.shebang "executable"
|
|
|
|
assert_equal "#!#{Gem.ruby}", shebang
|
|
end
|
|
end
|
|
|
|
def test_shebang_version_arguments
|
|
load_relative "no" do
|
|
installer = setup_base_installer
|
|
|
|
util_make_exec @spec, "#!/usr/bin/ruby18 -ws"
|
|
|
|
shebang = installer.shebang "executable"
|
|
|
|
assert_equal "#!#{Gem.ruby} -ws", shebang
|
|
end
|
|
end
|
|
|
|
def test_shebang_version_arguments_with_load_relative
|
|
load_relative "yes" do
|
|
installer = setup_base_installer
|
|
|
|
util_make_exec @spec, "#!/usr/bin/ruby18 -ws"
|
|
|
|
shebang = installer.shebang "executable"
|
|
|
|
shebang_lines = shebang.split "\n"
|
|
|
|
assert_equal "#!/bin/sh", shebang_lines.shift
|
|
assert_includes shebang_lines, "#!#{Gem.ruby} -ws"
|
|
end
|
|
end
|
|
|
|
def test_shebang_version_env
|
|
load_relative "no" do
|
|
installer = setup_base_installer
|
|
|
|
util_make_exec @spec, "#!/usr/bin/env ruby18"
|
|
|
|
shebang = installer.shebang "executable"
|
|
|
|
assert_equal "#!#{Gem.ruby}", shebang
|
|
end
|
|
end
|
|
|
|
def test_shebang_version_env_arguments
|
|
load_relative "no" do
|
|
installer = setup_base_installer
|
|
|
|
util_make_exec @spec, "#!/usr/bin/env ruby18 -ws"
|
|
|
|
shebang = installer.shebang "executable"
|
|
|
|
assert_equal "#!#{Gem.ruby} -ws", shebang
|
|
end
|
|
end
|
|
|
|
def test_shebang_version_env_arguments_with_load_relative
|
|
load_relative "yes" do
|
|
installer = setup_base_installer
|
|
|
|
util_make_exec @spec, "#!/usr/bin/env ruby18 -ws"
|
|
|
|
shebang = installer.shebang "executable"
|
|
|
|
shebang_lines = shebang.split "\n"
|
|
|
|
assert_equal "#!/bin/sh", shebang_lines.shift
|
|
assert_includes shebang_lines, "#!#{Gem.ruby} -ws"
|
|
end
|
|
end
|
|
|
|
def test_shebang_custom
|
|
installer = setup_base_installer
|
|
|
|
conf = Gem::ConfigFile.new []
|
|
conf[:custom_shebang] = "test"
|
|
|
|
Gem.configuration = conf
|
|
|
|
util_make_exec @spec, "#!/usr/bin/ruby"
|
|
|
|
shebang = installer.shebang "executable"
|
|
|
|
assert_equal "#!test", shebang
|
|
end
|
|
|
|
def get_bin_env
|
|
if win_platform?
|
|
""
|
|
else
|
|
%w[/usr/bin/env /bin/env].find {|f| File.executable?(f) }
|
|
end
|
|
end
|
|
|
|
def test_shebang_custom_with_expands
|
|
installer = setup_base_installer
|
|
|
|
bin_env = get_bin_env
|
|
conf = Gem::ConfigFile.new []
|
|
conf[:custom_shebang] = "1 $env 2 $ruby 3 $exec 4 $name"
|
|
|
|
Gem.configuration = conf
|
|
|
|
util_make_exec @spec, "#!/usr/bin/ruby"
|
|
|
|
shebang = installer.shebang "executable"
|
|
|
|
assert_equal "#!1 #{bin_env} 2 #{Gem.ruby} 3 executable 4 a", shebang
|
|
end
|
|
|
|
def test_shebang_custom_with_expands_and_arguments
|
|
installer = setup_base_installer
|
|
|
|
bin_env = get_bin_env
|
|
conf = Gem::ConfigFile.new []
|
|
conf[:custom_shebang] = "1 $env 2 $ruby 3 $exec"
|
|
|
|
Gem.configuration = conf
|
|
|
|
util_make_exec @spec, "#!/usr/bin/ruby -ws"
|
|
|
|
shebang = installer.shebang "executable"
|
|
|
|
assert_equal "#!1 #{bin_env} 2 #{Gem.ruby} -ws 3 executable", shebang
|
|
end
|
|
|
|
def test_unpack
|
|
installer = util_setup_installer
|
|
|
|
dest = File.join @gemhome, "gems", @spec.full_name
|
|
|
|
Gem::Deprecate.skip_during do
|
|
installer.unpack dest
|
|
end
|
|
|
|
assert_path_exist File.join dest, "lib", "code.rb"
|
|
assert_path_exist File.join dest, "bin", "executable"
|
|
end
|
|
|
|
def test_write_build_info_file
|
|
installer = setup_base_installer
|
|
|
|
assert_path_not_exist @spec.build_info_file
|
|
|
|
installer.build_args = %w[
|
|
--with-libyaml-dir /usr/local/Cellar/libyaml/0.1.4
|
|
]
|
|
|
|
installer.write_build_info_file
|
|
|
|
assert_path_exist @spec.build_info_file
|
|
|
|
expected = "--with-libyaml-dir\n/usr/local/Cellar/libyaml/0.1.4\n"
|
|
|
|
assert_equal expected, File.read(@spec.build_info_file)
|
|
end
|
|
|
|
def test_write_build_info_file_empty
|
|
installer = setup_base_installer
|
|
|
|
assert_path_not_exist @spec.build_info_file
|
|
|
|
installer.write_build_info_file
|
|
|
|
assert_path_not_exist @spec.build_info_file
|
|
end
|
|
|
|
def test_write_build_info_file_install_dir
|
|
@gem = setup_base_gem
|
|
installer = Gem::Installer.at @gem, :install_dir => "#{@gemhome}2"
|
|
|
|
installer.build_args = %w[
|
|
--with-libyaml-dir /usr/local/Cellar/libyaml/0.1.4
|
|
]
|
|
|
|
installer.write_build_info_file
|
|
|
|
assert_path_not_exist @spec.build_info_file
|
|
assert_path_exist \
|
|
File.join("#{@gemhome}2", "build_info", "#{@spec.full_name}.info")
|
|
end
|
|
|
|
def test_write_cache_file
|
|
@gem = setup_base_gem
|
|
cache_file = File.join @gemhome, "cache", @spec.file_name
|
|
gem = File.join @gemhome, @spec.file_name
|
|
|
|
FileUtils.mv cache_file, gem
|
|
assert_path_not_exist cache_file
|
|
|
|
installer = Gem::Installer.at gem
|
|
installer.gem_home = @gemhome
|
|
|
|
installer.write_cache_file
|
|
|
|
assert_path_exist cache_file
|
|
end
|
|
|
|
def test_write_spec
|
|
@spec = setup_base_spec
|
|
FileUtils.rm @spec.spec_file
|
|
assert_path_not_exist @spec.spec_file
|
|
|
|
installer = Gem::Installer.for_spec @spec
|
|
installer.gem_home = @gemhome
|
|
|
|
installer.write_spec
|
|
|
|
assert_path_exist @spec.spec_file
|
|
|
|
loaded = Gem::Specification.load @spec.spec_file
|
|
|
|
assert_equal @spec, loaded
|
|
|
|
assert_equal Gem.rubygems_version, @spec.installed_by_version
|
|
end
|
|
|
|
def test_write_spec_writes_cached_spec
|
|
@spec = setup_base_spec
|
|
FileUtils.rm @spec.spec_file
|
|
assert_path_not_exist @spec.spec_file
|
|
|
|
@spec.files = %w[a.rb b.rb c.rb]
|
|
|
|
installer = Gem::Installer.for_spec @spec
|
|
installer.gem_home = @gemhome
|
|
|
|
installer.write_spec
|
|
|
|
# cached specs have no file manifest:
|
|
@spec.files = []
|
|
|
|
assert_equal @spec, eval(File.read(@spec.spec_file))
|
|
end
|
|
|
|
def test_dir
|
|
installer = setup_base_installer
|
|
|
|
assert_match %r{/gemhome/gems/a-2$}, installer.dir
|
|
end
|
|
|
|
def test_default_gem_loaded_from
|
|
spec = util_spec "a"
|
|
installer = Gem::Installer.for_spec spec, :install_as_default => true
|
|
installer.install
|
|
assert_predicate spec, :default_gem?
|
|
end
|
|
|
|
def test_default_gem_without_wrappers
|
|
installer = setup_base_installer
|
|
|
|
FileUtils.rm_rf File.join(Gem.default_dir, "specifications")
|
|
|
|
installer.wrappers = false
|
|
installer.options[:install_as_default] = true
|
|
installer.gem_dir = @spec.gem_dir
|
|
|
|
use_ui @ui do
|
|
installer.install
|
|
end
|
|
|
|
assert_directory_exists File.join(@spec.gem_dir, "bin")
|
|
installed_exec = File.join @spec.gem_dir, "bin", "executable"
|
|
assert_path_exist installed_exec
|
|
|
|
assert_directory_exists File.join(Gem.default_dir, "specifications")
|
|
assert_directory_exists File.join(Gem.default_dir, "specifications", "default")
|
|
|
|
default_spec = eval File.read File.join(Gem.default_dir, "specifications", "default", "a-2.gemspec")
|
|
assert_equal Gem::Version.new("2"), default_spec.version
|
|
assert_equal ["bin/executable"], default_spec.files
|
|
|
|
assert_directory_exists util_inst_bindir
|
|
|
|
installed_exec = File.join util_inst_bindir, "executable"
|
|
assert_path_exist installed_exec
|
|
|
|
wrapper = File.read installed_exec
|
|
|
|
if symlink_supported?
|
|
refute_match %r{generated by RubyGems}, wrapper
|
|
else # when symlink not supported, it warns and fallbacks back to installing wrapper
|
|
assert_match %r{Unable to use symlinks, installing wrapper}, @ui.error
|
|
assert_match %r{generated by RubyGems}, wrapper
|
|
end
|
|
end
|
|
|
|
def test_default_gem_with_wrappers
|
|
installer = setup_base_installer
|
|
|
|
installer.wrappers = true
|
|
installer.options[:install_as_default] = true
|
|
installer.gem_dir = @spec.gem_dir
|
|
|
|
use_ui @ui do
|
|
installer.install
|
|
end
|
|
|
|
assert_directory_exists util_inst_bindir
|
|
|
|
installed_exec = File.join util_inst_bindir, "executable"
|
|
assert_path_exist installed_exec
|
|
|
|
wrapper = File.read installed_exec
|
|
assert_match %r{generated by RubyGems}, wrapper
|
|
end
|
|
|
|
def test_default_gem_with_exe_as_bindir
|
|
@spec = quick_gem "c" do |spec|
|
|
util_make_exec spec, "#!/usr/bin/ruby", "exe"
|
|
end
|
|
|
|
util_build_gem @spec
|
|
|
|
@spec.cache_file
|
|
|
|
installer = util_installer @spec, @gemhome
|
|
|
|
installer.options[:install_as_default] = true
|
|
installer.gem_dir = @spec.gem_dir
|
|
|
|
use_ui @ui do
|
|
installer.install
|
|
end
|
|
|
|
assert_directory_exists File.join(@spec.gem_dir, "exe")
|
|
installed_exec = File.join @spec.gem_dir, "exe", "executable"
|
|
assert_path_exist installed_exec
|
|
|
|
assert_directory_exists File.join(Gem.default_dir, "specifications")
|
|
assert_directory_exists File.join(Gem.default_dir, "specifications", "default")
|
|
|
|
default_spec = eval File.read File.join(Gem.default_dir, "specifications", "default", "c-2.gemspec")
|
|
assert_equal Gem::Version.new("2"), default_spec.version
|
|
assert_equal ["exe/executable"], default_spec.files
|
|
end
|
|
|
|
def test_default_gem_to_specific_install_dir
|
|
@gem = setup_base_gem
|
|
installer = util_installer @spec, "#{@gemhome}2"
|
|
installer.options[:install_as_default] = true
|
|
|
|
use_ui @ui do
|
|
installer.install
|
|
end
|
|
|
|
assert_directory_exists File.join("#{@gemhome}2", "specifications")
|
|
assert_directory_exists File.join("#{@gemhome}2", "specifications", "default")
|
|
|
|
default_spec = eval File.read File.join("#{@gemhome}2", "specifications", "default", "a-2.gemspec")
|
|
assert_equal Gem::Version.new("2"), default_spec.version
|
|
assert_equal ["bin/executable"], default_spec.files
|
|
end
|
|
|
|
def test_package_attribute
|
|
gem = quick_gem "c" do |spec|
|
|
util_make_exec spec, "#!/usr/bin/ruby", "exe"
|
|
end
|
|
|
|
installer = util_installer(gem, @gemhome)
|
|
assert_respond_to(installer, :package)
|
|
assert_kind_of(Gem::Package, installer.package)
|
|
end
|
|
|
|
def test_gem_attribute
|
|
gem = quick_gem "c" do |spec|
|
|
util_make_exec spec, "#!/usr/bin/ruby", "exe"
|
|
end
|
|
|
|
installer = util_installer(gem, @gemhome)
|
|
assert_respond_to(installer, :gem)
|
|
assert_kind_of(String, installer.gem)
|
|
end
|
|
|
|
private
|
|
|
|
def util_execless
|
|
@spec = util_spec "z"
|
|
util_build_gem @spec
|
|
|
|
util_installer @spec, @gemhome
|
|
end
|
|
|
|
def util_conflict_executable(wrappers)
|
|
conflict = quick_gem "conflict" do |spec|
|
|
util_make_exec spec
|
|
end
|
|
|
|
util_build_gem conflict
|
|
|
|
installer = util_installer conflict, @gemhome
|
|
installer.wrappers = wrappers
|
|
installer.generate_bin
|
|
end
|
|
|
|
def mask
|
|
0100755
|
|
end
|
|
|
|
def load_relative(value)
|
|
orig_LIBRUBY_RELATIVE = RbConfig::CONFIG["LIBRUBY_RELATIVE"]
|
|
RbConfig::CONFIG["LIBRUBY_RELATIVE"] = value
|
|
|
|
yield
|
|
ensure
|
|
RbConfig::CONFIG["LIBRUBY_RELATIVE"] = orig_LIBRUBY_RELATIVE
|
|
end
|
|
end
|