зеркало из https://github.com/github/ruby.git
2150 строки
54 KiB
Ruby
2150 строки
54 KiB
Ruby
# coding: US-ASCII
|
|
require_relative "helper"
|
|
require "rubygems"
|
|
require "rubygems/command"
|
|
require "rubygems/installer"
|
|
require "pathname"
|
|
require "tmpdir"
|
|
require "rbconfig"
|
|
|
|
class TestGem < Gem::TestCase
|
|
PLUGINS_LOADED = [] # rubocop:disable Style/MutableConstant
|
|
|
|
PROJECT_DIR = File.expand_path("../..", __dir__).tap(&Gem::UNTAINT)
|
|
|
|
def setup
|
|
super
|
|
|
|
PLUGINS_LOADED.clear
|
|
|
|
common_installer_setup
|
|
|
|
@additional = %w[a b].map {|d| File.join @tempdir, d }
|
|
|
|
util_remove_interrupt_command
|
|
end
|
|
|
|
def test_self_finish_resolve
|
|
a1 = util_spec "a", "1", "b" => "> 0"
|
|
b1 = util_spec "b", "1", "c" => ">= 1"
|
|
b2 = util_spec "b", "2", "c" => ">= 2"
|
|
c1 = util_spec "c", "1"
|
|
c2 = util_spec "c", "2"
|
|
|
|
install_specs c1, c2, b1, b2, a1
|
|
|
|
a1.activate
|
|
|
|
assert_equal %w[a-1], loaded_spec_names
|
|
assert_equal ["b (> 0)"], unresolved_names
|
|
|
|
Gem.finish_resolve
|
|
|
|
assert_equal %w[a-1 b-2 c-2], loaded_spec_names
|
|
assert_equal [], unresolved_names
|
|
end
|
|
|
|
def test_self_finish_resolve_wtf
|
|
a1 = util_spec "a", "1", "b" => "> 0", "d" => "> 0" # this
|
|
b1 = util_spec "b", "1", { "c" => ">= 1" }, "lib/b.rb" # this
|
|
b2 = util_spec "b", "2", { "c" => ">= 2" }, "lib/b.rb"
|
|
c1 = util_spec "c", "1" # this
|
|
c2 = util_spec "c", "2"
|
|
d1 = util_spec "d", "1", { "c" => "< 2" }, "lib/d.rb"
|
|
d2 = util_spec "d", "2", { "c" => "< 2" }, "lib/d.rb" # this
|
|
|
|
install_specs c1, c2, b1, b2, d1, d2, a1
|
|
|
|
a1.activate
|
|
|
|
assert_equal %w[a-1], loaded_spec_names
|
|
assert_equal ["b (> 0)", "d (> 0)"], unresolved_names
|
|
|
|
Gem.finish_resolve
|
|
|
|
assert_equal %w[a-1 b-1 c-1 d-2], loaded_spec_names
|
|
assert_equal [], unresolved_names
|
|
end
|
|
|
|
def test_self_finish_resolve_respects_loaded_specs
|
|
a1 = util_spec "a", "1", "b" => "> 0"
|
|
b1 = util_spec "b", "1", "c" => ">= 1"
|
|
b2 = util_spec "b", "2", "c" => ">= 2"
|
|
c1 = util_spec "c", "1"
|
|
c2 = util_spec "c", "2"
|
|
|
|
install_specs c1, c2, b1, b2, a1
|
|
|
|
a1.activate
|
|
c1.activate
|
|
|
|
assert_equal %w[a-1 c-1], loaded_spec_names
|
|
assert_equal ["b (> 0)"], unresolved_names
|
|
|
|
Gem.finish_resolve
|
|
|
|
assert_equal %w[a-1 b-1 c-1], loaded_spec_names
|
|
assert_equal [], unresolved_names
|
|
end
|
|
|
|
def test_self_install
|
|
spec_fetcher do |f|
|
|
f.gem "a", 1
|
|
f.spec "a", 2
|
|
end
|
|
|
|
gemhome2 = "#{@gemhome}2"
|
|
|
|
installed = Gem.install "a", "= 1", :install_dir => gemhome2
|
|
|
|
assert_equal %w[a-1], installed.map {|spec| spec.full_name }
|
|
|
|
assert_path_exist File.join(gemhome2, "gems", "a-1")
|
|
end
|
|
|
|
def test_self_install_in_rescue
|
|
spec_fetcher do |f|
|
|
f.gem "a", 1
|
|
f.spec "a", 2
|
|
end
|
|
|
|
gemhome2 = "#{@gemhome}2"
|
|
|
|
installed =
|
|
begin
|
|
raise "Error"
|
|
rescue StandardError
|
|
Gem.install "a", "= 1", :install_dir => gemhome2
|
|
end
|
|
assert_equal %w[a-1], installed.map {|spec| spec.full_name }
|
|
end
|
|
|
|
def test_self_install_permissions
|
|
assert_self_install_permissions
|
|
end
|
|
|
|
def test_self_install_permissions_umask_0
|
|
umask = File.umask(0)
|
|
assert_self_install_permissions
|
|
ensure
|
|
File.umask(umask)
|
|
end
|
|
|
|
def test_self_install_permissions_umask_077
|
|
umask = File.umask(077)
|
|
assert_self_install_permissions
|
|
ensure
|
|
File.umask(umask)
|
|
end
|
|
|
|
def test_self_install_permissions_with_format_executable
|
|
assert_self_install_permissions(format_executable: true)
|
|
end
|
|
|
|
def test_self_install_permissions_with_format_executable_and_non_standard_ruby_install_name
|
|
Gem::Installer.exec_format = nil
|
|
ruby_install_name "ruby27" do
|
|
assert_self_install_permissions(format_executable: true)
|
|
end
|
|
ensure
|
|
Gem::Installer.exec_format = nil
|
|
end
|
|
|
|
def assert_self_install_permissions(format_executable: false)
|
|
mask = win_platform? ? 0700 : 0777
|
|
options = {
|
|
:dir_mode => 0500,
|
|
:prog_mode => win_platform? ? 0410 : 0510,
|
|
:data_mode => 0640,
|
|
:wrappers => true,
|
|
:format_executable => format_executable,
|
|
}
|
|
Dir.chdir @tempdir do
|
|
Dir.mkdir "bin"
|
|
Dir.mkdir "data"
|
|
|
|
File.write "bin/foo", "#!/usr/bin/env ruby\n"
|
|
File.chmod 0755, "bin/foo"
|
|
|
|
File.write "data/foo.txt", "blah\n"
|
|
|
|
spec_fetcher do |f|
|
|
f.gem "foo", 1 do |s|
|
|
s.executables = ["foo"]
|
|
s.files = %w[bin/foo data/foo.txt]
|
|
end
|
|
end
|
|
Gem.install "foo", Gem::Requirement.default, options
|
|
end
|
|
|
|
prog_mode = (options[:prog_mode] & mask).to_s(8)
|
|
dir_mode = (options[:dir_mode] & mask).to_s(8)
|
|
data_mode = (options[:data_mode] & mask).to_s(8)
|
|
prog_name = "foo"
|
|
prog_name = RbConfig::CONFIG["ruby_install_name"].sub("ruby", "foo") if options[:format_executable]
|
|
expected = {
|
|
"bin/#{prog_name}" => prog_mode,
|
|
"gems/foo-1" => dir_mode,
|
|
"gems/foo-1/bin" => dir_mode,
|
|
"gems/foo-1/data" => dir_mode,
|
|
"gems/foo-1/bin/foo" => prog_mode,
|
|
"gems/foo-1/data/foo.txt" => data_mode,
|
|
}
|
|
# add Windows script
|
|
expected["bin/#{prog_name}.bat"] = mask.to_s(8) if win_platform?
|
|
result = {}
|
|
Dir.chdir @gemhome do
|
|
expected.each_key do |n|
|
|
result[n] = (File.stat(n).mode & mask).to_s(8)
|
|
end
|
|
end
|
|
assert_equal(expected, result)
|
|
ensure
|
|
File.chmod(0755, *Dir.glob(@gemhome + "/gems/**/").map {|path| path.tap(&Gem::UNTAINT) })
|
|
end
|
|
|
|
def test_require_missing
|
|
assert_raise ::LoadError do
|
|
require "test_require_missing"
|
|
end
|
|
end
|
|
|
|
def test_require_does_not_glob
|
|
a1 = util_spec "a", "1", nil, "lib/a1.rb"
|
|
|
|
install_specs a1
|
|
|
|
assert_raise ::LoadError do
|
|
require "a*"
|
|
end
|
|
|
|
assert_equal [], loaded_spec_names
|
|
end
|
|
|
|
def test_self_bin_path_active
|
|
a1 = util_spec "a", "1" do |s|
|
|
s.executables = ["exec"]
|
|
end
|
|
|
|
util_spec "a", "2" do |s|
|
|
s.executables = ["exec"]
|
|
end
|
|
|
|
a1.activate
|
|
|
|
assert_match "a-1/bin/exec", Gem.bin_path("a", "exec", ">= 0")
|
|
end
|
|
|
|
def test_self_bin_path_picking_newest
|
|
a1 = util_spec "a", "1" do |s|
|
|
s.executables = ["exec"]
|
|
end
|
|
|
|
a2 = util_spec "a", "2" do |s|
|
|
s.executables = ["exec"]
|
|
end
|
|
|
|
install_specs a1, a2
|
|
|
|
assert_match "a-2/bin/exec", Gem.bin_path("a", "exec", ">= 0")
|
|
end
|
|
|
|
def test_self_activate_bin_path_no_exec_name
|
|
e = assert_raise ArgumentError do
|
|
Gem.activate_bin_path "a"
|
|
end
|
|
|
|
assert_equal "you must supply exec_name", e.message
|
|
end
|
|
|
|
def test_activate_bin_path_resolves_eagerly
|
|
a1 = util_spec "a", "1" do |s|
|
|
s.executables = ["exec"]
|
|
s.add_dependency "b"
|
|
end
|
|
|
|
b1 = util_spec "b", "1" do |s|
|
|
s.add_dependency "c", "2"
|
|
end
|
|
|
|
b2 = util_spec "b", "2" do |s|
|
|
s.add_dependency "c", "1"
|
|
end
|
|
|
|
c1 = util_spec "c", "1"
|
|
c2 = util_spec "c", "2"
|
|
|
|
install_specs c1, c2, b1, b2, a1
|
|
|
|
Gem.activate_bin_path("a", "exec", ">= 0")
|
|
|
|
# If we didn't eagerly resolve, this would activate c-2 and then the
|
|
# finish_resolve would cause a conflict
|
|
gem "c"
|
|
Gem.finish_resolve
|
|
|
|
assert_equal %w[a-1 b-2 c-1], loaded_spec_names
|
|
end
|
|
|
|
def test_activate_bin_path_does_not_error_if_a_gem_thats_not_finally_activated_has_orphaned_dependencies
|
|
a1 = util_spec "a", "1" do |s|
|
|
s.executables = ["exec"]
|
|
s.add_dependency "b"
|
|
end
|
|
|
|
b1 = util_spec "b", "1" do |s|
|
|
s.add_dependency "c", "1"
|
|
end
|
|
|
|
b2 = util_spec "b", "2" do |s|
|
|
s.add_dependency "c", "2"
|
|
end
|
|
|
|
c2 = util_spec "c", "2"
|
|
|
|
install_specs c2, b1, b2, a1
|
|
|
|
# c1 is missing, but not needed for activation, so we should not get any errors here
|
|
|
|
Gem.activate_bin_path("a", "exec", ">= 0")
|
|
|
|
assert_equal %w[a-1 b-2 c-2], loaded_spec_names
|
|
end
|
|
|
|
def test_activate_bin_path_raises_a_meaningful_error_if_a_gem_thats_finally_activated_has_orphaned_dependencies
|
|
a1 = util_spec "a", "1" do |s|
|
|
s.executables = ["exec"]
|
|
s.add_dependency "b"
|
|
end
|
|
|
|
b1 = util_spec "b", "1" do |s|
|
|
s.add_dependency "c", "1"
|
|
end
|
|
|
|
b2 = util_spec "b", "2" do |s|
|
|
s.add_dependency "c", "2"
|
|
end
|
|
|
|
c1 = util_spec "c", "1"
|
|
|
|
install_specs c1, b1, b2, a1
|
|
|
|
# c2 is missing, and b2 which has it as a dependency will be activated, so we should get an error about the orphaned dependency
|
|
|
|
e = assert_raise Gem::UnsatisfiableDependencyError do
|
|
load Gem.activate_bin_path("a", "exec", ">= 0")
|
|
end
|
|
|
|
assert_equal "Unable to resolve dependency: 'b (>= 0)' requires 'c (= 2)'", e.message
|
|
end
|
|
|
|
def test_activate_bin_path_in_debug_mode
|
|
a1 = util_spec "a", "1" do |s|
|
|
s.executables = ["exec"]
|
|
end
|
|
|
|
install_specs a1
|
|
|
|
require "open3"
|
|
output, status = Open3.capture2e(
|
|
{ "GEM_HOME" => Gem.paths.home, "DEBUG_RESOLVER" => "1" },
|
|
*ruby_with_rubygems_in_load_path, "-e", "\"Gem.activate_bin_path('a', 'exec', '>= 0')\""
|
|
)
|
|
|
|
assert status.success?, output
|
|
end
|
|
|
|
def test_activate_bin_path_selects_exact_bundler_version_if_present
|
|
bundler_latest = util_spec "bundler", "2.0.1" do |s|
|
|
s.executables = ["bundle"]
|
|
end
|
|
|
|
bundler_previous = util_spec "bundler", "2.0.0" do |s|
|
|
s.executables = ["bundle"]
|
|
end
|
|
|
|
install_specs bundler_latest, bundler_previous
|
|
|
|
File.open("Gemfile.lock", "w") do |f|
|
|
f.write <<-L.gsub(/ {8}/, "")
|
|
GEM
|
|
remote: https://rubygems.org/
|
|
specs:
|
|
|
|
PLATFORMS
|
|
ruby
|
|
|
|
DEPENDENCIES
|
|
|
|
BUNDLED WITH
|
|
2.0.0
|
|
L
|
|
end
|
|
|
|
File.open("Gemfile", "w") {|f| f.puts('source "https://rubygems.org"') }
|
|
|
|
load Gem.activate_bin_path("bundler", "bundle", ">= 0.a")
|
|
|
|
assert_equal %w[bundler-2.0.0], loaded_spec_names
|
|
end
|
|
|
|
def test_activate_bin_path_respects_underscore_selection_if_given
|
|
bundler_latest = util_spec "bundler", "2.0.1" do |s|
|
|
s.executables = ["bundle"]
|
|
end
|
|
|
|
bundler_previous = util_spec "bundler", "1.17.3" do |s|
|
|
s.executables = ["bundle"]
|
|
end
|
|
|
|
install_specs bundler_latest, bundler_previous
|
|
|
|
File.open("Gemfile.lock", "w") do |f|
|
|
f.write <<-L.gsub(/ {8}/, "")
|
|
GEM
|
|
remote: https://rubygems.org/
|
|
specs:
|
|
|
|
PLATFORMS
|
|
ruby
|
|
|
|
DEPENDENCIES
|
|
|
|
BUNDLED WITH
|
|
2.0.1
|
|
L
|
|
end
|
|
|
|
File.open("Gemfile", "w") {|f| f.puts('source "https://rubygems.org"') }
|
|
|
|
load Gem.activate_bin_path("bundler", "bundle", "= 1.17.3")
|
|
|
|
assert_equal %w[bundler-1.17.3], loaded_spec_names
|
|
end
|
|
|
|
def test_activate_bin_path_gives_proper_error_for_bundler_when_underscore_selection_given
|
|
File.open("Gemfile.lock", "w") do |f|
|
|
f.write <<-L.gsub(/ {8}/, "")
|
|
GEM
|
|
remote: https://rubygems.org/
|
|
specs:
|
|
|
|
PLATFORMS
|
|
ruby
|
|
|
|
DEPENDENCIES
|
|
|
|
BUNDLED WITH
|
|
2.1.4
|
|
L
|
|
end
|
|
|
|
File.open("Gemfile", "w") {|f| f.puts('source "https://rubygems.org"') }
|
|
|
|
e = assert_raise Gem::GemNotFoundException do
|
|
load Gem.activate_bin_path("bundler", "bundle", "= 2.2.8")
|
|
end
|
|
|
|
assert_equal "can't find gem bundler (= 2.2.8) with executable bundle", e.message
|
|
end
|
|
|
|
def test_self_bin_path_no_exec_name
|
|
e = assert_raise ArgumentError do
|
|
Gem.bin_path "a"
|
|
end
|
|
|
|
assert_equal "you must supply exec_name", e.message
|
|
end
|
|
|
|
def test_self_bin_path_bin_name
|
|
install_specs util_exec_gem
|
|
assert_equal @abin_path, Gem.bin_path("a", "abin")
|
|
end
|
|
|
|
def test_self_bin_path_bin_name_version
|
|
install_specs util_exec_gem
|
|
assert_equal @abin_path, Gem.bin_path("a", "abin", "4")
|
|
end
|
|
|
|
def test_self_bin_path_nonexistent_binfile
|
|
util_spec "a", "2" do |s|
|
|
s.executables = ["exec"]
|
|
end
|
|
assert_raise(Gem::GemNotFoundException) do
|
|
Gem.bin_path("a", "other", "2")
|
|
end
|
|
end
|
|
|
|
def test_self_bin_path_no_bin_file
|
|
util_spec "a", "1"
|
|
assert_raise(ArgumentError) do
|
|
Gem.bin_path("a", nil, "1")
|
|
end
|
|
end
|
|
|
|
def test_self_bin_path_not_found
|
|
assert_raise(Gem::GemNotFoundException) do
|
|
Gem.bin_path("non-existent", "blah")
|
|
end
|
|
end
|
|
|
|
def test_self_bin_path_bin_file_gone_in_latest
|
|
install_specs util_exec_gem
|
|
spec = util_spec "a", "10" do |s|
|
|
s.executables = []
|
|
end
|
|
install_specs spec
|
|
assert_equal @abin_path, Gem.bin_path("a", "abin")
|
|
end
|
|
|
|
def test_self_bindir
|
|
assert_equal File.join(@gemhome, "bin"), Gem.bindir
|
|
assert_equal File.join(@gemhome, "bin"), Gem.bindir(Gem.dir)
|
|
assert_equal File.join(@gemhome, "bin"), Gem.bindir(Pathname.new(Gem.dir))
|
|
end
|
|
|
|
def test_self_bindir_default_dir
|
|
default = Gem.default_dir
|
|
|
|
assert_equal Gem.default_bindir, Gem.bindir(default)
|
|
end
|
|
|
|
def test_self_clear_paths
|
|
assert_match(/gemhome$/, Gem.dir)
|
|
assert_match(/gemhome$/, Gem.path.first)
|
|
|
|
Gem.clear_paths
|
|
|
|
assert_nil Gem::Specification.send(:class_variable_get, :@@all)
|
|
end
|
|
|
|
def test_self_configuration
|
|
expected = Gem::ConfigFile.new []
|
|
Gem.configuration = nil
|
|
|
|
assert_equal expected, Gem.configuration
|
|
end
|
|
|
|
def test_self_datadir
|
|
foo = nil
|
|
|
|
Dir.chdir @tempdir do
|
|
FileUtils.mkdir_p "data"
|
|
File.open File.join("data", "foo.txt"), "w" do |fp|
|
|
fp.puts "blah"
|
|
end
|
|
|
|
foo = util_spec "foo" do |s|
|
|
s.files = %w[data/foo.txt]
|
|
end
|
|
|
|
install_gem foo
|
|
end
|
|
|
|
gem "foo"
|
|
|
|
expected = File.join @gemhome, "gems", foo.full_name, "data", "foo"
|
|
|
|
assert_equal expected, Gem::Specification.find_by_name("foo").datadir
|
|
end
|
|
|
|
def test_self_datadir_nonexistent_package
|
|
assert_raise(Gem::MissingSpecError) do
|
|
Gem::Specification.find_by_name("xyzzy").datadir
|
|
end
|
|
end
|
|
|
|
def test_self_default_exec_format
|
|
ruby_install_name "ruby" do
|
|
assert_equal "%s", Gem.default_exec_format
|
|
end
|
|
end
|
|
|
|
def test_self_default_exec_format_18
|
|
ruby_install_name "ruby18" do
|
|
assert_equal "%s18", Gem.default_exec_format
|
|
end
|
|
end
|
|
|
|
def test_self_default_exec_format_jruby
|
|
ruby_install_name "jruby" do
|
|
assert_equal "j%s", Gem.default_exec_format
|
|
end
|
|
end
|
|
|
|
def test_default_path
|
|
vendordir(File.join(@tempdir, "vendor")) do
|
|
FileUtils.rm_rf Gem.user_home
|
|
|
|
expected = [Gem.default_dir]
|
|
|
|
assert_equal expected, Gem.default_path
|
|
end
|
|
end
|
|
|
|
def test_default_path_missing_vendor
|
|
vendordir(nil) do
|
|
FileUtils.rm_rf Gem.user_home
|
|
|
|
expected = [Gem.default_dir]
|
|
|
|
assert_equal expected, Gem.default_path
|
|
end
|
|
end
|
|
|
|
def test_default_path_user_home
|
|
vendordir(File.join(@tempdir, "vendor")) do
|
|
expected = [Gem.user_dir, Gem.default_dir]
|
|
|
|
assert_equal expected, Gem.default_path
|
|
end
|
|
end
|
|
|
|
def test_default_path_vendor_dir
|
|
vendordir(File.join(@tempdir, "vendor")) do
|
|
FileUtils.mkdir_p Gem.vendor_dir
|
|
|
|
FileUtils.rm_rf Gem.user_home
|
|
|
|
expected = [Gem.default_dir, Gem.vendor_dir]
|
|
|
|
assert_equal expected, Gem.default_path
|
|
end
|
|
end
|
|
|
|
def test_self_default_sources
|
|
assert_equal %w[https://rubygems.org/], Gem.default_sources
|
|
end
|
|
|
|
def test_self_use_gemdeps
|
|
with_local_bundler_at(Gem.dir) do
|
|
with_rubygems_gemdeps("-") do
|
|
FileUtils.mkdir_p "detect/a/b"
|
|
FileUtils.mkdir_p "detect/a/Isolate"
|
|
|
|
FileUtils.touch "detect/Isolate"
|
|
|
|
begin
|
|
Dir.chdir "detect/a/b"
|
|
|
|
Gem.use_gemdeps
|
|
|
|
assert_equal add_bundler_full_name([]), loaded_spec_names
|
|
ensure
|
|
Dir.chdir @tempdir
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
def test_self_dir
|
|
assert_equal @gemhome, Gem.dir
|
|
end
|
|
|
|
def test_self_ensure_gem_directories
|
|
FileUtils.rm_r @gemhome
|
|
Gem.use_paths @gemhome
|
|
|
|
Gem.ensure_gem_subdirectories @gemhome
|
|
|
|
assert_path_exist File.join @gemhome, "build_info"
|
|
assert_path_exist File.join @gemhome, "cache"
|
|
assert_path_exist File.join @gemhome, "doc"
|
|
assert_path_exist File.join @gemhome, "extensions"
|
|
assert_path_exist File.join @gemhome, "gems"
|
|
assert_path_exist File.join @gemhome, "specifications"
|
|
end
|
|
|
|
def test_self_ensure_gem_directories_permissions
|
|
FileUtils.rm_r @gemhome
|
|
Gem.use_paths @gemhome
|
|
|
|
Gem.ensure_gem_subdirectories @gemhome, 0750
|
|
|
|
assert_directory_exists File.join(@gemhome, "cache")
|
|
|
|
assert_equal 0750, File::Stat.new(@gemhome).mode & 0777
|
|
assert_equal 0750, File::Stat.new(File.join(@gemhome, "cache")).mode & 0777
|
|
end unless win_platform?
|
|
|
|
def test_self_ensure_gem_directories_safe_permissions
|
|
FileUtils.rm_r @gemhome
|
|
Gem.use_paths @gemhome
|
|
|
|
old_umask = File.umask
|
|
File.umask 0
|
|
Gem.ensure_gem_subdirectories @gemhome
|
|
|
|
assert_equal 0, File::Stat.new(@gemhome).mode & 002
|
|
assert_equal 0, File::Stat.new(File.join(@gemhome, "cache")).mode & 002
|
|
ensure
|
|
File.umask old_umask
|
|
end unless win_platform?
|
|
|
|
def test_self_ensure_gem_directories_missing_parents
|
|
gemdir = File.join @tempdir, "a/b/c/gemdir"
|
|
FileUtils.rm_rf File.join(@tempdir, "a") rescue nil
|
|
refute File.exist?(File.join(@tempdir, "a")),
|
|
"manually remove #{File.join @tempdir, 'a'}, tests are broken"
|
|
Gem.use_paths gemdir
|
|
|
|
Gem.ensure_gem_subdirectories gemdir
|
|
|
|
assert_directory_exists util_cache_dir
|
|
end
|
|
|
|
unless win_platform? || Process.uid.zero? # only for FS that support write protection
|
|
def test_self_ensure_gem_directories_write_protected
|
|
gemdir = File.join @tempdir, "egd"
|
|
FileUtils.rm_r gemdir rescue nil
|
|
refute File.exist?(gemdir), "manually remove #{gemdir}, tests are broken"
|
|
FileUtils.mkdir_p gemdir
|
|
FileUtils.chmod 0400, gemdir
|
|
Gem.use_paths gemdir
|
|
|
|
Gem.ensure_gem_subdirectories gemdir
|
|
|
|
refute File.exist?(util_cache_dir)
|
|
ensure
|
|
FileUtils.chmod 0600, gemdir
|
|
end
|
|
|
|
def test_self_ensure_gem_directories_write_protected_parents
|
|
parent = File.join(@tempdir, "egd")
|
|
gemdir = "#{parent}/a/b/c"
|
|
|
|
FileUtils.rm_r parent rescue nil
|
|
refute File.exist?(parent), "manually remove #{parent}, tests are broken"
|
|
FileUtils.mkdir_p parent
|
|
FileUtils.chmod 0400, parent
|
|
Gem.use_paths(gemdir)
|
|
|
|
Gem.ensure_gem_subdirectories gemdir
|
|
|
|
refute File.exist? File.join(gemdir, "gems")
|
|
ensure
|
|
FileUtils.chmod 0600, parent
|
|
end
|
|
|
|
def test_self_ensure_gem_directories_non_existent_paths
|
|
Gem.ensure_gem_subdirectories "/proc/0123456789/bogus" # should not raise
|
|
Gem.ensure_gem_subdirectories "classpath:/bogus/x" # JRuby embed scenario
|
|
end
|
|
end
|
|
|
|
def test_self_extension_dir_shared
|
|
enable_shared "yes" do
|
|
assert_equal Gem.ruby_api_version, Gem.extension_api_version
|
|
end
|
|
end
|
|
|
|
def test_self_extension_dir_static
|
|
enable_shared "no" do
|
|
assert_equal "#{Gem.ruby_api_version}-static", Gem.extension_api_version
|
|
end
|
|
end
|
|
|
|
def test_self_find_files
|
|
cwd = File.expand_path("test/rubygems", PROJECT_DIR)
|
|
$LOAD_PATH.unshift cwd
|
|
|
|
discover_path = File.join "lib", "sff", "discover.rb"
|
|
|
|
foo1, foo2 = %w[1 2].map do |version|
|
|
spec = quick_gem "sff", version do |s|
|
|
s.files << discover_path
|
|
end
|
|
|
|
write_file(File.join "gems", spec.full_name, discover_path) do |fp|
|
|
fp.puts "# #{spec.full_name}"
|
|
end
|
|
|
|
spec
|
|
end
|
|
|
|
Gem.refresh
|
|
|
|
expected = [
|
|
File.expand_path("test/rubygems/sff/discover.rb", PROJECT_DIR),
|
|
File.join(foo2.full_gem_path, discover_path),
|
|
File.join(foo1.full_gem_path, discover_path),
|
|
]
|
|
|
|
assert_equal expected, Gem.find_files("sff/discover")
|
|
assert_equal expected, Gem.find_files("sff/**.rb"), "[ruby-core:31730]"
|
|
ensure
|
|
assert_equal cwd, $LOAD_PATH.shift
|
|
end
|
|
|
|
def test_self_find_files_with_gemfile
|
|
with_local_bundler_at(Gem.dir) do
|
|
cwd = File.expand_path("test/rubygems", PROJECT_DIR)
|
|
actual_load_path = $LOAD_PATH.unshift(cwd).dup
|
|
|
|
discover_path = File.join "lib", "sff", "discover.rb"
|
|
|
|
foo1, _ = %w[1 2].map do |version|
|
|
spec = quick_gem "sff", version do |s|
|
|
s.files << discover_path
|
|
end
|
|
|
|
write_file(File.join "gems", spec.full_name, discover_path) do |fp|
|
|
fp.puts "# #{spec.full_name}"
|
|
end
|
|
|
|
spec
|
|
end
|
|
Gem.refresh
|
|
|
|
write_file(File.join Dir.pwd, "Gemfile") do |fp|
|
|
fp.puts "source 'https://rubygems.org'"
|
|
fp.puts "gem '#{foo1.name}', '#{foo1.version}'"
|
|
end
|
|
Gem.use_gemdeps(File.join Dir.pwd, "Gemfile")
|
|
|
|
expected = [
|
|
File.expand_path("test/rubygems/sff/discover.rb", PROJECT_DIR),
|
|
File.join(foo1.full_gem_path, discover_path),
|
|
].sort
|
|
|
|
assert_equal expected, Gem.find_files("sff/discover").sort
|
|
assert_equal expected, Gem.find_files("sff/**.rb").sort, "[ruby-core:31730]"
|
|
assert_equal cwd, actual_load_path.shift
|
|
end
|
|
end
|
|
|
|
def test_self_find_latest_files
|
|
cwd = File.expand_path("test/rubygems", PROJECT_DIR)
|
|
$LOAD_PATH.unshift cwd
|
|
|
|
discover_path = File.join "lib", "sff", "discover.rb"
|
|
|
|
_, foo2 = %w[1 2].map do |version|
|
|
spec = quick_gem "sff", version do |s|
|
|
s.files << discover_path
|
|
end
|
|
|
|
write_file(File.join "gems", spec.full_name, discover_path) do |fp|
|
|
fp.puts "# #{spec.full_name}"
|
|
end
|
|
|
|
spec
|
|
end
|
|
|
|
Gem.refresh
|
|
|
|
expected = [
|
|
File.expand_path("test/rubygems/sff/discover.rb", PROJECT_DIR),
|
|
File.join(foo2.full_gem_path, discover_path),
|
|
]
|
|
|
|
assert_equal expected, Gem.find_latest_files("sff/discover")
|
|
assert_equal expected, Gem.find_latest_files("sff/**.rb"), "[ruby-core:31730]"
|
|
ensure
|
|
assert_equal cwd, $LOAD_PATH.shift
|
|
end
|
|
|
|
def test_self_latest_spec_for
|
|
gems = spec_fetcher do |fetcher|
|
|
fetcher.spec "a", 1
|
|
fetcher.spec "a", "3.a"
|
|
fetcher.spec "a", 2
|
|
end
|
|
|
|
spec = Gem.latest_spec_for "a"
|
|
|
|
assert_equal gems["a-2"], spec
|
|
end
|
|
|
|
def test_self_latest_spec_for_multiple_sources
|
|
uri = "https://example.sample.com/"
|
|
source = Gem::Source.new(uri)
|
|
source_list = Gem::SourceList.new
|
|
source_list << Gem::Source.new(@uri)
|
|
source_list << source
|
|
Gem.sources.replace source_list
|
|
|
|
spec_fetcher(uri) do |fetcher|
|
|
fetcher.spec "a", 1.1
|
|
end
|
|
|
|
gems = spec_fetcher do |fetcher|
|
|
fetcher.spec "a", 1
|
|
fetcher.spec "a", "3.a"
|
|
fetcher.spec "a", 2
|
|
end
|
|
spec = Gem.latest_spec_for "a"
|
|
assert_equal gems["a-2"], spec
|
|
end
|
|
|
|
def test_self_latest_rubygems_version
|
|
spec_fetcher do |fetcher|
|
|
fetcher.spec "rubygems-update", "1.8.23"
|
|
fetcher.spec "rubygems-update", "1.8.24"
|
|
fetcher.spec "rubygems-update", "2.0.0.preview3"
|
|
end
|
|
|
|
version = Gem.latest_rubygems_version
|
|
|
|
assert_equal Gem::Version.new("1.8.24"), version
|
|
end
|
|
|
|
def test_self_latest_version_for
|
|
spec_fetcher do |fetcher|
|
|
fetcher.spec "a", 1
|
|
fetcher.spec "a", 2
|
|
fetcher.spec "a", "3.a"
|
|
end
|
|
|
|
version = Gem.latest_version_for "a"
|
|
|
|
assert_equal Gem::Version.new(2), version
|
|
end
|
|
|
|
def test_self_latest_version_for_multiple_sources
|
|
uri = "https://example.sample.com/"
|
|
source = Gem::Source.new(uri)
|
|
source_list = Gem::SourceList.new
|
|
source_list << Gem::Source.new(@uri)
|
|
source_list << source
|
|
Gem.sources.replace source_list
|
|
|
|
spec_fetcher(uri) do |fetcher|
|
|
fetcher.spec "a", 1.1
|
|
end
|
|
|
|
spec_fetcher do |fetcher|
|
|
fetcher.spec "a", 1
|
|
fetcher.spec "a", 2
|
|
fetcher.spec "a", "3.a"
|
|
end
|
|
|
|
version = Gem.latest_version_for "a"
|
|
|
|
assert_equal Gem::Version.new(2), version
|
|
end
|
|
|
|
def test_self_loaded_specs
|
|
foo = util_spec "foo"
|
|
install_gem foo
|
|
|
|
foo.activate
|
|
|
|
assert_equal true, Gem.loaded_specs.keys.include?("foo")
|
|
end
|
|
|
|
def test_self_path
|
|
assert_equal [Gem.dir], Gem.path
|
|
end
|
|
|
|
def test_self_path_default
|
|
ENV.delete "GEM_HOME"
|
|
ENV.delete "GEM_PATH"
|
|
|
|
Gem.instance_variable_set :@paths, nil
|
|
|
|
assert_equal [Gem.default_path, Gem.dir].flatten.uniq, Gem.path
|
|
end
|
|
|
|
def test_self_path_ENV_PATH
|
|
path_count = Gem.path.size
|
|
Gem.clear_paths
|
|
|
|
ENV["GEM_PATH"] = @additional.join(File::PATH_SEPARATOR)
|
|
|
|
assert_equal @additional, Gem.path[0,2]
|
|
|
|
assert_equal path_count + @additional.size, Gem.path.size,
|
|
"extra path components: #{Gem.path[2..-1].inspect}"
|
|
assert_equal Gem.dir, Gem.path.last
|
|
end
|
|
|
|
def test_self_path_duplicate
|
|
Gem.clear_paths
|
|
util_ensure_gem_dirs
|
|
dirs = @additional + [@gemhome] + [File.join(@tempdir, "a")]
|
|
|
|
ENV["GEM_HOME"] = @gemhome
|
|
ENV["GEM_PATH"] = dirs.join File::PATH_SEPARATOR
|
|
|
|
assert_equal @gemhome, Gem.dir
|
|
|
|
paths = [Gem.dir]
|
|
assert_equal @additional + paths, Gem.path
|
|
end
|
|
|
|
def test_self_path_overlap
|
|
Gem.clear_paths
|
|
|
|
util_ensure_gem_dirs
|
|
ENV["GEM_HOME"] = @gemhome
|
|
ENV["GEM_PATH"] = @additional.join(File::PATH_SEPARATOR)
|
|
|
|
assert_equal @gemhome, Gem.dir
|
|
|
|
paths = [Gem.dir]
|
|
assert_equal @additional + paths, Gem.path
|
|
end
|
|
|
|
def test_self_platforms
|
|
assert_equal [Gem::Platform::RUBY, Gem::Platform.local], Gem.platforms
|
|
end
|
|
|
|
def test_self_prefix
|
|
assert_equal PROJECT_DIR, Gem.prefix
|
|
end
|
|
|
|
def test_self_prefix_libdir
|
|
orig_libdir = RbConfig::CONFIG["libdir"]
|
|
RbConfig::CONFIG["libdir"] = PROJECT_DIR
|
|
|
|
assert_nil Gem.prefix
|
|
ensure
|
|
RbConfig::CONFIG["libdir"] = orig_libdir
|
|
end
|
|
|
|
def test_self_prefix_sitelibdir
|
|
orig_sitelibdir = RbConfig::CONFIG["sitelibdir"]
|
|
RbConfig::CONFIG["sitelibdir"] = PROJECT_DIR
|
|
|
|
assert_nil Gem.prefix
|
|
ensure
|
|
RbConfig::CONFIG["sitelibdir"] = orig_sitelibdir
|
|
end
|
|
|
|
def test_self_read_binary
|
|
File.open "test", "w" do |io|
|
|
io.write "\xCF\x80"
|
|
end
|
|
|
|
assert_equal ["\xCF", "\x80"], Gem.read_binary("test").chars.to_a
|
|
|
|
pend "chmod not supported" if Gem.win_platform?
|
|
|
|
begin
|
|
File.chmod 0444, "test"
|
|
|
|
assert_equal ["\xCF", "\x80"], Gem.read_binary("test").chars.to_a
|
|
ensure
|
|
File.chmod 0644, "test"
|
|
end
|
|
end
|
|
|
|
def test_self_refresh
|
|
util_make_gems
|
|
|
|
a1_spec = @a1.spec_file
|
|
moved_path = File.join @tempdir, File.basename(a1_spec)
|
|
|
|
FileUtils.mv a1_spec, moved_path
|
|
|
|
Gem.refresh
|
|
|
|
refute_includes Gem::Specification.all_names, @a1.full_name
|
|
|
|
FileUtils.mv moved_path, a1_spec
|
|
|
|
Gem.refresh
|
|
|
|
assert_includes Gem::Specification.all_names, @a1.full_name
|
|
end
|
|
|
|
def test_self_refresh_keeps_loaded_specs_activated
|
|
util_make_gems
|
|
|
|
a1_spec = @a1.spec_file
|
|
moved_path = File.join @tempdir, File.basename(a1_spec)
|
|
|
|
FileUtils.mv a1_spec, moved_path
|
|
|
|
Gem.refresh
|
|
|
|
s = Gem::Specification.first
|
|
s.activate
|
|
|
|
Gem.refresh
|
|
|
|
Gem::Specification.each {|spec| assert spec.activated? if spec == s }
|
|
|
|
Gem.loaded_specs.delete(s)
|
|
Gem.refresh
|
|
end
|
|
|
|
def test_self_ruby_escaping_spaces_in_path
|
|
with_clean_path_to_ruby do
|
|
with_rb_config_ruby("C:/Ruby 1.8/bin/ruby.exe") do
|
|
assert_equal "\"C:/Ruby 1.8/bin/ruby.exe\"", Gem.ruby
|
|
end
|
|
end
|
|
end
|
|
|
|
def test_self_ruby_path_without_spaces
|
|
with_clean_path_to_ruby do
|
|
with_rb_config_ruby("C:/Ruby18/bin/ruby.exe") do
|
|
assert_equal "C:/Ruby18/bin/ruby.exe", Gem.ruby
|
|
end
|
|
end
|
|
end
|
|
|
|
def test_self_ruby_api_version
|
|
orig_ruby_version, RbConfig::CONFIG["ruby_version"] = RbConfig::CONFIG["ruby_version"], "1.2.3"
|
|
|
|
Gem.instance_variable_set :@ruby_api_version, nil
|
|
|
|
assert_equal "1.2.3", Gem.ruby_api_version
|
|
ensure
|
|
Gem.instance_variable_set :@ruby_api_version, nil
|
|
|
|
RbConfig::CONFIG["ruby_version"] = orig_ruby_version
|
|
end
|
|
|
|
def test_self_env_requirement
|
|
ENV["GEM_REQUIREMENT_FOO"] = ">= 1.2.3"
|
|
ENV["GEM_REQUIREMENT_BAR"] = "1.2.3"
|
|
ENV["GEM_REQUIREMENT_BAZ"] = "abcd"
|
|
|
|
assert_equal Gem::Requirement.create(">= 1.2.3"), Gem.env_requirement("foo")
|
|
assert_equal Gem::Requirement.create("1.2.3"), Gem.env_requirement("bAr")
|
|
assert_raise(Gem::Requirement::BadRequirementError) { Gem.env_requirement("baz") }
|
|
assert_equal Gem::Requirement.default, Gem.env_requirement("qux")
|
|
end
|
|
|
|
def test_self_ruby_version_with_non_mri_implementations
|
|
util_set_RUBY_VERSION "2.5.0", 0, 60928, "jruby 9.2.0.0 (2.5.0) 2018-05-24 81156a8 OpenJDK 64-Bit Server VM 25.171-b11 on 1.8.0_171-8u171-b11-0ubuntu0.16.04.1-b11 [linux-x86_64]"
|
|
|
|
assert_equal Gem::Version.new("2.5.0"), Gem.ruby_version
|
|
ensure
|
|
util_restore_RUBY_VERSION
|
|
end
|
|
|
|
def test_self_ruby_version_with_svn_prerelease
|
|
util_set_RUBY_VERSION "2.6.0", -1, 63539, "ruby 2.6.0preview2 (2018-05-31 trunk 63539) [x86_64-linux]"
|
|
|
|
assert_equal Gem::Version.new("2.6.0.preview2"), Gem.ruby_version
|
|
ensure
|
|
util_restore_RUBY_VERSION
|
|
end
|
|
|
|
def test_self_ruby_version_with_git_prerelease
|
|
util_set_RUBY_VERSION "2.7.0", -1, "b563439274a402e33541f5695b1bfd4ac1085638", "ruby 2.7.0preview3 (2019-11-23 master b563439274) [x86_64-linux]"
|
|
|
|
assert_equal Gem::Version.new("2.7.0.preview3"), Gem.ruby_version
|
|
ensure
|
|
util_restore_RUBY_VERSION
|
|
end
|
|
|
|
def test_self_ruby_version_with_non_mri_implementations_with_mri_prerelase_compatibility
|
|
util_set_RUBY_VERSION "2.6.0", -1, 63539, "weirdjruby 9.2.0.0 (2.6.0preview2) 2018-05-24 81156a8 OpenJDK 64-Bit Server VM 25.171-b11 on 1.8.0_171-8u171-b11-0ubuntu0.16.04.1-b11 [linux-x86_64]", "weirdjruby", "9.2.0.0"
|
|
|
|
assert_equal Gem::Version.new("2.6.0.preview2"), Gem.ruby_version
|
|
ensure
|
|
util_restore_RUBY_VERSION
|
|
end
|
|
|
|
def test_self_ruby_version_with_svn_trunk
|
|
util_set_RUBY_VERSION "1.9.2", -1, 23493, "ruby 1.9.2dev (2009-05-20 trunk 23493) [x86_64-linux]"
|
|
|
|
assert_equal Gem::Version.new("1.9.2.dev"), Gem.ruby_version
|
|
ensure
|
|
util_restore_RUBY_VERSION
|
|
end
|
|
|
|
def test_self_ruby_version_with_git_master
|
|
util_set_RUBY_VERSION "2.7.0", -1, "5de284ec78220e75643f89b454ce999da0c1c195", "ruby 2.7.0dev (2019-12-23T01:37:30Z master 5de284ec78) [x86_64-linux]"
|
|
|
|
assert_equal Gem::Version.new("2.7.0.dev"), Gem.ruby_version
|
|
ensure
|
|
util_restore_RUBY_VERSION
|
|
end
|
|
|
|
def test_self_rubygems_version
|
|
assert_equal Gem::Version.new(Gem::VERSION), Gem.rubygems_version
|
|
end
|
|
|
|
def test_self_paths_eq
|
|
other = File.join @tempdir, "other"
|
|
path = [@userhome, other].join File::PATH_SEPARATOR
|
|
|
|
#
|
|
# FIXME remove after fixing test_case
|
|
#
|
|
ENV["GEM_HOME"] = @gemhome
|
|
Gem.paths = { "GEM_PATH" => path }
|
|
|
|
assert_equal [@userhome, other, @gemhome], Gem.path
|
|
end
|
|
|
|
def test_self_paths_eq_nonexistent_home
|
|
ENV["GEM_HOME"] = @gemhome
|
|
Gem.clear_paths
|
|
|
|
other = File.join @tempdir, "other"
|
|
|
|
ENV["HOME"] = other
|
|
|
|
Gem.paths = { "GEM_PATH" => other }
|
|
|
|
assert_equal [other, @gemhome], Gem.path
|
|
end
|
|
|
|
def test_self_post_build
|
|
assert_equal 1, Gem.post_build_hooks.length
|
|
|
|
Gem.post_build {|installer| }
|
|
|
|
assert_equal 2, Gem.post_build_hooks.length
|
|
end
|
|
|
|
def test_self_post_install
|
|
assert_equal 1, Gem.post_install_hooks.length
|
|
|
|
Gem.post_install {|installer| }
|
|
|
|
assert_equal 2, Gem.post_install_hooks.length
|
|
end
|
|
|
|
def test_self_done_installing
|
|
assert_empty Gem.done_installing_hooks
|
|
|
|
Gem.done_installing {|gems| }
|
|
|
|
assert_equal 1, Gem.done_installing_hooks.length
|
|
end
|
|
|
|
def test_self_post_reset
|
|
assert_empty Gem.post_reset_hooks
|
|
|
|
Gem.post_reset {}
|
|
|
|
assert_equal 1, Gem.post_reset_hooks.length
|
|
end
|
|
|
|
def test_self_post_uninstall
|
|
assert_equal 1, Gem.post_uninstall_hooks.length
|
|
|
|
Gem.post_uninstall {|installer| }
|
|
|
|
assert_equal 2, Gem.post_uninstall_hooks.length
|
|
end
|
|
|
|
def test_self_pre_install
|
|
assert_equal 1, Gem.pre_install_hooks.length
|
|
|
|
Gem.pre_install {|installer| }
|
|
|
|
assert_equal 2, Gem.pre_install_hooks.length
|
|
end
|
|
|
|
def test_self_pre_reset
|
|
assert_empty Gem.pre_reset_hooks
|
|
|
|
Gem.pre_reset {}
|
|
|
|
assert_equal 1, Gem.pre_reset_hooks.length
|
|
end
|
|
|
|
def test_self_pre_uninstall
|
|
assert_equal 1, Gem.pre_uninstall_hooks.length
|
|
|
|
Gem.pre_uninstall {|installer| }
|
|
|
|
assert_equal 2, Gem.pre_uninstall_hooks.length
|
|
end
|
|
|
|
def test_self_sources
|
|
assert_equal %w[http://gems.example.com/], Gem.sources
|
|
Gem.sources = nil
|
|
Gem.configuration.sources = %w[http://test.example.com/]
|
|
assert_equal %w[http://test.example.com/], Gem.sources
|
|
end
|
|
|
|
def test_try_activate_returns_true_for_activated_specs
|
|
b = util_spec "b", "1.0" do |spec|
|
|
spec.files << "lib/b.rb"
|
|
end
|
|
install_specs b
|
|
|
|
assert Gem.try_activate("b"), "try_activate should return true"
|
|
assert Gem.try_activate("b"), "try_activate should still return true"
|
|
end
|
|
|
|
def test_spec_order_is_consistent
|
|
b1 = util_spec "b", "1.0"
|
|
b2 = util_spec "b", "2.0"
|
|
b3 = util_spec "b", "3.0"
|
|
|
|
install_specs b1, b2, b3
|
|
|
|
specs1 = Gem::Specification.stubs.find_all {|s| s.name == "b" }
|
|
Gem::Specification.reset
|
|
specs2 = Gem::Specification.stubs_for("b")
|
|
assert_equal specs1.map(&:version), specs2.map(&:version)
|
|
end
|
|
|
|
def test_self_try_activate_missing_dep
|
|
b = util_spec "b", "1.0"
|
|
a = util_spec "a", "1.0", "b" => ">= 1.0"
|
|
|
|
install_specs b, a
|
|
uninstall_gem b
|
|
|
|
a_file = File.join a.gem_dir, "lib", "a_file.rb"
|
|
|
|
write_file a_file do |io|
|
|
io.puts "# a_file.rb"
|
|
end
|
|
|
|
e = assert_raise Gem::MissingSpecError do
|
|
Gem.try_activate "a_file"
|
|
end
|
|
|
|
assert_match %r{Could not find 'b' }, e.message
|
|
assert_match %r{at: #{a.spec_file}}, e.message
|
|
end
|
|
|
|
def test_self_try_activate_missing_prerelease
|
|
b = util_spec "b", "1.0rc1"
|
|
a = util_spec "a", "1.0rc1", "b" => "1.0rc1"
|
|
|
|
install_specs b, a
|
|
uninstall_gem b
|
|
|
|
a_file = File.join a.gem_dir, "lib", "a_file.rb"
|
|
|
|
write_file a_file do |io|
|
|
io.puts "# a_file.rb"
|
|
end
|
|
|
|
e = assert_raise Gem::MissingSpecError do
|
|
Gem.try_activate "a_file"
|
|
end
|
|
|
|
assert_match %r{Could not find 'b' \(= 1.0rc1\)}, e.message
|
|
end
|
|
|
|
def test_self_try_activate_missing_extensions
|
|
spec = util_spec "ext", "1" do |s|
|
|
s.extensions = %w[ext/extconf.rb]
|
|
s.mark_version
|
|
s.installed_by_version = v("2.2")
|
|
end
|
|
|
|
# write the spec without install to simulate a failed install
|
|
write_file spec.spec_file do |io|
|
|
io.write spec.to_ruby_for_cache
|
|
end
|
|
|
|
_, err = capture_output do
|
|
refute Gem.try_activate "nonexistent"
|
|
end
|
|
|
|
expected = "Ignoring ext-1 because its extensions are not built. " +
|
|
"Try: gem pristine ext --version 1\n"
|
|
|
|
assert_equal expected, err
|
|
end
|
|
|
|
def test_self_use_paths_with_nils
|
|
orig_home = ENV.delete "GEM_HOME"
|
|
orig_path = ENV.delete "GEM_PATH"
|
|
Gem.use_paths nil, nil
|
|
assert_equal Gem.default_dir, Gem.paths.home
|
|
path = (Gem.default_path + [Gem.paths.home]).uniq
|
|
assert_equal path, Gem.paths.path
|
|
ensure
|
|
ENV["GEM_HOME"] = orig_home
|
|
ENV["GEM_PATH"] = orig_path
|
|
end
|
|
|
|
def test_setting_paths_does_not_warn_about_unknown_keys
|
|
stdout, stderr = capture_output do
|
|
Gem.paths = { "foo" => [],
|
|
"bar" => Object.new,
|
|
"GEM_HOME" => Gem.paths.home,
|
|
"GEM_PATH" => "foo" }
|
|
end
|
|
assert_equal ["foo", Gem.paths.home], Gem.paths.path
|
|
assert_equal "", stderr
|
|
assert_equal "", stdout
|
|
end
|
|
|
|
def test_setting_paths_does_not_mutate_parameter_object
|
|
Gem.paths = { "GEM_HOME" => Gem.paths.home,
|
|
"GEM_PATH" => "foo" }.freeze
|
|
assert_equal ["foo", Gem.paths.home], Gem.paths.path
|
|
end
|
|
|
|
def test_deprecated_paths=
|
|
stdout, stderr = capture_output do
|
|
Gem.paths = { "GEM_HOME" => Gem.paths.home,
|
|
"GEM_PATH" => [Gem.paths.home, "foo"] }
|
|
end
|
|
assert_equal [Gem.paths.home, "foo"], Gem.paths.path
|
|
assert_match(/Array values in the parameter to `Gem.paths=` are deprecated.\nPlease use a String or nil/m, stderr)
|
|
assert_equal "", stdout
|
|
end
|
|
|
|
def test_self_use_paths
|
|
util_ensure_gem_dirs
|
|
|
|
Gem.use_paths @gemhome, @additional
|
|
|
|
assert_equal @gemhome, Gem.dir
|
|
assert_equal @additional + [Gem.dir], Gem.path
|
|
end
|
|
|
|
def test_self_user_dir
|
|
parts = [@userhome, ".gem", Gem.ruby_engine]
|
|
parts << RbConfig::CONFIG["ruby_version"] unless RbConfig::CONFIG["ruby_version"].empty?
|
|
|
|
FileUtils.mkdir_p File.join(parts)
|
|
|
|
assert_equal File.join(parts), Gem.user_dir
|
|
end
|
|
|
|
def test_self_user_home
|
|
if ENV["HOME"]
|
|
assert_equal ENV["HOME"], Gem.user_home
|
|
else
|
|
assert true, "count this test"
|
|
end
|
|
end
|
|
|
|
def test_self_needs
|
|
a = util_spec "a", "1"
|
|
b = util_spec "b", "1", "c" => nil
|
|
c = util_spec "c", "2"
|
|
|
|
install_specs a, c, b
|
|
|
|
Gem.needs do |r|
|
|
r.gem "a"
|
|
r.gem "b", "= 1"
|
|
end
|
|
|
|
activated = Gem::Specification.map {|x| x.full_name }
|
|
|
|
assert_equal %w[a-1 b-1 c-2], activated.sort
|
|
end
|
|
|
|
def test_self_needs_picks_up_unresolved_deps
|
|
a = util_spec "a", "1"
|
|
b = util_spec "b", "1", "c" => nil
|
|
c = util_spec "c", "2"
|
|
d = util_spec "d", "1", { "e" => "= 1" }, "lib/d#{$$}.rb"
|
|
e = util_spec "e", "1"
|
|
|
|
install_specs a, c, b, e, d
|
|
|
|
Gem.needs do |r|
|
|
r.gem "a"
|
|
r.gem "b", "= 1"
|
|
|
|
require "d#{$$}"
|
|
end
|
|
|
|
assert_equal %w[a-1 b-1 c-2 d-1 e-1], loaded_spec_names
|
|
end
|
|
|
|
def test_self_gunzip
|
|
input = "\x1F\x8B\b\0\xED\xA3\x1AQ\0\x03\xCBH" +
|
|
"\xCD\xC9\xC9\a\0\x86\xA6\x106\x05\0\0\0"
|
|
|
|
output = Gem::Util.gunzip input
|
|
|
|
assert_equal "hello", output
|
|
assert_equal Encoding::BINARY, output.encoding
|
|
end
|
|
|
|
def test_self_gzip
|
|
input = "hello"
|
|
|
|
output = Gem::Util.gzip input
|
|
|
|
zipped = StringIO.new output
|
|
|
|
assert_equal "hello", Zlib::GzipReader.new(zipped).read
|
|
assert_equal Encoding::BINARY, output.encoding
|
|
end
|
|
|
|
def test_self_vendor_dir
|
|
vendordir(File.join(@tempdir, "vendor")) do
|
|
expected =
|
|
File.join RbConfig::CONFIG["vendordir"], "gems",
|
|
RbConfig::CONFIG["ruby_version"]
|
|
|
|
assert_equal expected, Gem.vendor_dir
|
|
end
|
|
end
|
|
|
|
def test_self_vendor_dir_ENV_GEM_VENDOR
|
|
ENV["GEM_VENDOR"] = File.join @tempdir, "vendor", "gems"
|
|
|
|
assert_equal ENV["GEM_VENDOR"], Gem.vendor_dir
|
|
refute Gem.vendor_dir.frozen?
|
|
end
|
|
|
|
def test_self_vendor_dir_missing
|
|
vendordir(nil) do
|
|
assert_nil Gem.vendor_dir
|
|
end
|
|
end
|
|
|
|
def test_load_plugins
|
|
plugin_path = File.join "lib", "rubygems_plugin.rb"
|
|
|
|
Dir.chdir @tempdir do
|
|
FileUtils.mkdir_p "lib"
|
|
File.open plugin_path, "w" do |fp|
|
|
fp.puts "class TestGem; PLUGINS_LOADED << 'plugin'; end"
|
|
end
|
|
|
|
foo1 = util_spec "foo", "1" do |s|
|
|
s.files << plugin_path
|
|
end
|
|
|
|
install_gem foo1
|
|
|
|
foo2 = util_spec "foo", "2" do |s|
|
|
s.files << plugin_path
|
|
end
|
|
|
|
install_gem foo2
|
|
end
|
|
|
|
Gem::Specification.reset
|
|
|
|
gem "foo"
|
|
|
|
Gem.load_plugins
|
|
|
|
assert_equal %w[plugin], PLUGINS_LOADED
|
|
end
|
|
|
|
def test_load_user_installed_plugins
|
|
plugin_path = File.join "lib", "rubygems_plugin.rb"
|
|
|
|
Dir.chdir @tempdir do
|
|
FileUtils.mkdir_p "lib"
|
|
File.open plugin_path, "w" do |fp|
|
|
fp.puts "class TestGem; PLUGINS_LOADED << 'plugin'; end"
|
|
end
|
|
|
|
foo = util_spec "foo", "1" do |s|
|
|
s.files << plugin_path
|
|
end
|
|
|
|
install_gem_user foo
|
|
end
|
|
|
|
Gem.paths = { "GEM_PATH" => [Gem.dir, Gem.user_dir].join(File::PATH_SEPARATOR) }
|
|
|
|
gem "foo"
|
|
|
|
Gem.load_plugins
|
|
|
|
assert_equal %w[plugin], PLUGINS_LOADED
|
|
end
|
|
|
|
def test_load_env_plugins
|
|
with_plugin("load") { Gem.load_env_plugins }
|
|
assert_equal :loaded, TEST_PLUGIN_LOAD rescue nil
|
|
|
|
util_remove_interrupt_command
|
|
|
|
# Should attempt to cause a StandardError
|
|
with_plugin("standarderror") { Gem.load_env_plugins }
|
|
assert_equal :loaded, TEST_PLUGIN_STANDARDERROR rescue nil
|
|
|
|
util_remove_interrupt_command
|
|
|
|
# Should attempt to cause an Exception
|
|
with_plugin("exception") { Gem.load_env_plugins }
|
|
assert_equal :loaded, TEST_PLUGIN_EXCEPTION rescue nil
|
|
end
|
|
|
|
def test_gem_path_ordering
|
|
refute_equal Gem.dir, Gem.user_dir
|
|
|
|
write_file File.join(@tempdir, "lib", "g.rb") {|fp| fp.puts "" }
|
|
write_file File.join(@tempdir, "lib", "m.rb") {|fp| fp.puts "" }
|
|
|
|
g = util_spec "g", "1", nil, "lib/g.rb"
|
|
m = util_spec "m", "1", nil, "lib/m.rb"
|
|
|
|
install_gem g, :install_dir => Gem.dir
|
|
m0 = install_gem m, :install_dir => Gem.dir
|
|
m1 = install_gem m, :install_dir => Gem.user_dir
|
|
|
|
assert_equal m0.gem_dir, File.join(Gem.dir, "gems", "m-1")
|
|
assert_equal m1.gem_dir, File.join(Gem.user_dir, "gems", "m-1")
|
|
|
|
tests = [
|
|
[:dir0, [ Gem.dir, Gem.user_dir], m0],
|
|
[:dir1, [ Gem.user_dir, Gem.dir], m1],
|
|
]
|
|
|
|
tests.each do |_name, _paths, expected|
|
|
Gem.use_paths _paths.first, _paths
|
|
Gem::Specification.reset
|
|
Gem.searcher = nil
|
|
|
|
assert_equal Gem::Dependency.new("m","1").to_specs,
|
|
Gem::Dependency.new("m","1").to_specs.sort
|
|
|
|
assert_equal \
|
|
[expected.gem_dir],
|
|
Gem::Dependency.new("m","1").to_specs.map(&:gem_dir).sort,
|
|
"Wrong specs for #{_name}"
|
|
|
|
spec = Gem::Dependency.new("m","1").to_spec
|
|
|
|
assert_equal \
|
|
File.join(_paths.first, "gems", "m-1"),
|
|
spec.gem_dir,
|
|
"Wrong spec before require for #{_name}"
|
|
refute spec.activated?, "dependency already activated for #{_name}"
|
|
|
|
gem "m"
|
|
|
|
spec = Gem::Dependency.new("m","1").to_spec
|
|
assert spec.activated?, "dependency not activated for #{_name}"
|
|
|
|
assert_equal \
|
|
File.join(_paths.first, "gems", "m-1"),
|
|
spec.gem_dir,
|
|
"Wrong spec after require for #{_name}"
|
|
|
|
spec.instance_variable_set :@activated, false
|
|
Gem.loaded_specs.delete(spec.name)
|
|
$:.delete(File.join(spec.gem_dir, "lib"))
|
|
end
|
|
end
|
|
|
|
def test_gem_path_ordering_short
|
|
write_file File.join(@tempdir, "lib", "g.rb") {|fp| fp.puts "" }
|
|
write_file File.join(@tempdir, "lib", "m.rb") {|fp| fp.puts "" }
|
|
|
|
g = util_spec "g", "1", nil, "lib/g.rb"
|
|
m = util_spec "m", "1", nil, "lib/m.rb"
|
|
|
|
install_gem g, :install_dir => Gem.dir
|
|
install_gem m, :install_dir => Gem.dir
|
|
install_gem m, :install_dir => Gem.user_dir
|
|
|
|
Gem.use_paths Gem.dir, [ Gem.dir, Gem.user_dir]
|
|
|
|
assert_equal \
|
|
File.join(Gem.dir, "gems", "m-1"),
|
|
Gem::Dependency.new("m","1").to_spec.gem_dir,
|
|
"Wrong spec selected"
|
|
end
|
|
|
|
def test_auto_activation_of_specific_gemdeps_file
|
|
with_local_bundler_at(Gem.dir) do
|
|
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"
|
|
|
|
install_specs a, b, c
|
|
|
|
path = File.join @tempdir, "gem.deps.rb"
|
|
|
|
File.open path, "w" do |f|
|
|
f.puts "gem 'a'"
|
|
f.puts "gem 'b'"
|
|
f.puts "gem 'c'"
|
|
end
|
|
|
|
with_rubygems_gemdeps(path) do
|
|
Gem.use_gemdeps
|
|
|
|
assert_equal add_bundler_full_name(%W[a-1 b-1 c-1]), loaded_spec_names
|
|
end
|
|
end
|
|
end
|
|
|
|
def test_auto_activation_of_used_gemdeps_file
|
|
with_local_bundler_at(Gem.dir) do
|
|
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"
|
|
|
|
install_specs a, b, c
|
|
|
|
path = File.join @tempdir, "gem.deps.rb"
|
|
|
|
File.open path, "w" do |f|
|
|
f.puts "gem 'a'"
|
|
f.puts "gem 'b'"
|
|
f.puts "gem 'c'"
|
|
end
|
|
|
|
with_rubygems_gemdeps("-") do
|
|
expected_specs = [a, b, util_spec("bundler", Bundler::VERSION), c].compact.map(&:full_name)
|
|
|
|
Gem.use_gemdeps
|
|
|
|
assert_equal expected_specs, loaded_spec_names
|
|
end
|
|
end
|
|
end
|
|
|
|
def add_bundler_full_name(names)
|
|
names << "bundler-#{Bundler::VERSION}".freeze
|
|
names.sort!
|
|
names
|
|
end
|
|
|
|
def test_looks_for_gemdeps_files_automatically_from_binstubs
|
|
path = File.join(@tempdir, "gd-tmp")
|
|
|
|
with_local_bundler_at(path) do
|
|
a = util_spec "a", "1" do |s|
|
|
s.executables = %w[foo]
|
|
s.bindir = "exe"
|
|
end
|
|
|
|
write_file File.join(@tempdir, "exe", "foo") do |fp|
|
|
fp.puts "puts Gem.loaded_specs.values.map(&:full_name).sort"
|
|
end
|
|
|
|
b = util_spec "b", "1", nil, "lib/b.rb"
|
|
c = util_spec "c", "1", nil, "lib/c.rb"
|
|
|
|
install_specs a, b, c
|
|
|
|
install_gem a, :install_dir => path
|
|
install_gem b, :install_dir => path
|
|
install_gem c, :install_dir => path
|
|
|
|
ENV["GEM_PATH"] = path
|
|
|
|
with_rubygems_gemdeps("-") do
|
|
new_PATH = [File.join(path, "bin"), ENV["PATH"]].join(File::PATH_SEPARATOR)
|
|
new_RUBYOPT = "-I#{rubygems_path} -I#{bundler_path}"
|
|
|
|
path = File.join @tempdir, "gem.deps.rb"
|
|
|
|
File.open path, "w" do |f|
|
|
f.puts "gem 'a'"
|
|
end
|
|
out0 = with_path_and_rubyopt(new_PATH, new_RUBYOPT) do
|
|
IO.popen("foo", &:read).split(/\n/)
|
|
end
|
|
|
|
File.open path, "a" do |f|
|
|
f.puts "gem 'b'"
|
|
f.puts "gem 'c'"
|
|
end
|
|
out = with_path_and_rubyopt(new_PATH, new_RUBYOPT) do
|
|
IO.popen("foo", &:read).split(/\n/)
|
|
end
|
|
|
|
assert_equal ["b-1", "c-1"], out - out0
|
|
end
|
|
end
|
|
end
|
|
|
|
def test_looks_for_gemdeps_files_automatically_from_binstubs_in_parent_dir
|
|
path = File.join(@tempdir, "gd-tmp")
|
|
|
|
with_local_bundler_at(path) do
|
|
pend "IO.popen has issues on JRuby when passed :chdir" if Gem.java_platform?
|
|
|
|
a = util_spec "a", "1" do |s|
|
|
s.executables = %w[foo]
|
|
s.bindir = "exe"
|
|
end
|
|
|
|
write_file File.join(@tempdir, "exe", "foo") do |fp|
|
|
fp.puts "puts Gem.loaded_specs.values.map(&:full_name).sort"
|
|
end
|
|
|
|
b = util_spec "b", "1", nil, "lib/b.rb"
|
|
c = util_spec "c", "1", nil, "lib/c.rb"
|
|
|
|
install_specs a, b, c
|
|
|
|
install_gem a, :install_dir => path
|
|
install_gem b, :install_dir => path
|
|
install_gem c, :install_dir => path
|
|
|
|
ENV["GEM_PATH"] = path
|
|
|
|
with_rubygems_gemdeps("-") do
|
|
Dir.mkdir "sub1"
|
|
|
|
new_PATH = [File.join(path, "bin"), ENV["PATH"]].join(File::PATH_SEPARATOR)
|
|
new_RUBYOPT = "-I#{rubygems_path} -I#{bundler_path}"
|
|
|
|
path = File.join @tempdir, "gem.deps.rb"
|
|
|
|
File.open path, "w" do |f|
|
|
f.puts "gem 'a'"
|
|
end
|
|
out0 = with_path_and_rubyopt(new_PATH, new_RUBYOPT) do
|
|
IO.popen("foo", :chdir => "sub1", &:read).split(/\n/)
|
|
end
|
|
|
|
File.open path, "a" do |f|
|
|
f.puts "gem 'b'"
|
|
f.puts "gem 'c'"
|
|
end
|
|
out = with_path_and_rubyopt(new_PATH, new_RUBYOPT) do
|
|
IO.popen("foo", :chdir => "sub1", &:read).split(/\n/)
|
|
end
|
|
|
|
Dir.rmdir "sub1"
|
|
|
|
assert_equal ["b-1", "c-1"], out - out0
|
|
end
|
|
end
|
|
end
|
|
|
|
def test_register_default_spec
|
|
Gem.clear_default_specs
|
|
|
|
old_style = Gem::Specification.new do |spec|
|
|
spec.files = ["foo.rb", "bar.rb"]
|
|
end
|
|
|
|
Gem.register_default_spec old_style
|
|
|
|
assert_equal old_style, Gem.find_unresolved_default_spec("foo.rb")
|
|
assert_equal old_style, Gem.find_unresolved_default_spec("bar.rb")
|
|
assert_nil Gem.find_unresolved_default_spec("baz.rb")
|
|
|
|
Gem.clear_default_specs
|
|
|
|
new_style = Gem::Specification.new do |spec|
|
|
spec.files = ["lib/foo.rb", "ext/bar.rb", "bin/exec", "README"]
|
|
spec.require_paths = ["lib", "ext"]
|
|
end
|
|
|
|
Gem.register_default_spec new_style
|
|
|
|
assert_equal new_style, Gem.find_unresolved_default_spec("foo.rb")
|
|
assert_equal new_style, Gem.find_unresolved_default_spec("bar.rb")
|
|
assert_nil Gem.find_unresolved_default_spec("exec")
|
|
assert_nil Gem.find_unresolved_default_spec("README")
|
|
end
|
|
|
|
def test_register_default_spec_old_style_with_folder_starting_with_lib
|
|
Gem.clear_default_specs
|
|
|
|
old_style = Gem::Specification.new do |spec|
|
|
spec.files = ["libexec/bundle", "foo.rb", "bar.rb"]
|
|
end
|
|
|
|
Gem.register_default_spec old_style
|
|
|
|
assert_equal old_style, Gem.find_unresolved_default_spec("foo.rb")
|
|
end
|
|
|
|
def test_use_gemdeps
|
|
with_local_bundler_at(Gem.dir) do
|
|
gem_deps_file = "gem.deps.rb".tap(&Gem::UNTAINT)
|
|
spec = util_spec "a", 1
|
|
install_specs spec
|
|
|
|
spec = Gem::Specification.find {|s| s == spec }
|
|
refute spec.activated?
|
|
|
|
File.open gem_deps_file, "w" do |io|
|
|
io.write 'gem "a"'
|
|
end
|
|
|
|
assert_nil Gem.gemdeps
|
|
|
|
Gem.use_gemdeps gem_deps_file
|
|
|
|
assert_equal add_bundler_full_name(%W[a-1]), loaded_spec_names
|
|
refute_nil Gem.gemdeps
|
|
end
|
|
end
|
|
|
|
def test_use_gemdeps_ENV
|
|
with_local_bundler_at(Gem.dir) do
|
|
with_rubygems_gemdeps(nil) do
|
|
spec = util_spec "a", 1
|
|
|
|
refute spec.activated?
|
|
|
|
File.open "gem.deps.rb", "w" do |io|
|
|
io.write 'gem "a"'
|
|
end
|
|
|
|
Gem.use_gemdeps
|
|
|
|
refute spec.activated?
|
|
end
|
|
end
|
|
end
|
|
|
|
def test_use_gemdeps_argument_missing
|
|
with_local_bundler_at(Gem.dir) do
|
|
e = assert_raise ArgumentError do
|
|
Gem.use_gemdeps "gem.deps.rb"
|
|
end
|
|
|
|
assert_equal "Unable to find gem dependencies file at gem.deps.rb",
|
|
e.message
|
|
end
|
|
end
|
|
|
|
def test_use_gemdeps_argument_missing_match_ENV
|
|
with_local_bundler_at(Gem.dir) do
|
|
with_rubygems_gemdeps("gem.deps.rb") do
|
|
e = assert_raise ArgumentError do
|
|
Gem.use_gemdeps "gem.deps.rb"
|
|
end
|
|
|
|
assert_equal "Unable to find gem dependencies file at gem.deps.rb",
|
|
e.message
|
|
end
|
|
end
|
|
end
|
|
|
|
def test_use_gemdeps_automatic
|
|
with_local_bundler_at(Gem.dir) do
|
|
with_rubygems_gemdeps("-") do
|
|
spec = util_spec "a", 1
|
|
install_specs spec
|
|
spec = Gem::Specification.find {|s| s == spec }
|
|
|
|
refute spec.activated?
|
|
|
|
File.open "Gemfile", "w" do |io|
|
|
io.write 'gem "a"'
|
|
end
|
|
|
|
Gem.use_gemdeps
|
|
|
|
assert_equal add_bundler_full_name(%W[a-1]), loaded_spec_names
|
|
end
|
|
end
|
|
end
|
|
|
|
def test_use_gemdeps_automatic_missing
|
|
with_local_bundler_at(Gem.dir) do
|
|
with_rubygems_gemdeps("-") do
|
|
Gem.use_gemdeps
|
|
|
|
assert true # count
|
|
end
|
|
end
|
|
end
|
|
|
|
def test_use_gemdeps_disabled
|
|
with_local_bundler_at(Gem.dir) do
|
|
with_rubygems_gemdeps("") do
|
|
spec = util_spec "a", 1
|
|
|
|
refute spec.activated?
|
|
|
|
File.open "gem.deps.rb", "w" do |io|
|
|
io.write 'gem "a"'
|
|
end
|
|
|
|
Gem.use_gemdeps
|
|
|
|
refute spec.activated?
|
|
end
|
|
end
|
|
end
|
|
|
|
def test_use_gemdeps_missing_gem
|
|
with_local_bundler_at(Gem.dir) do
|
|
with_rubygems_gemdeps("x") do
|
|
File.open "x", "w" do |io|
|
|
io.write 'gem "a"'
|
|
end
|
|
|
|
expected = <<-EXPECTED
|
|
Could not find gem 'a' in locally installed gems.
|
|
You may need to `bundle install` to install missing gems
|
|
|
|
EXPECTED
|
|
|
|
Gem::Deprecate.skip_during do
|
|
actual_stdout, actual_stderr = capture_output do
|
|
Gem.use_gemdeps
|
|
end
|
|
assert_empty actual_stdout
|
|
assert_equal(expected, actual_stderr)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
def test_use_gemdeps_specific
|
|
with_local_bundler_at(Gem.dir) do
|
|
with_rubygems_gemdeps("x") do
|
|
spec = util_spec "a", 1
|
|
install_specs spec
|
|
|
|
spec = Gem::Specification.find {|s| s == spec }
|
|
refute spec.activated?
|
|
|
|
File.open "x", "w" do |io|
|
|
io.write 'gem "a"'
|
|
end
|
|
|
|
Gem.use_gemdeps
|
|
|
|
assert_equal add_bundler_full_name(%W[a-1]), loaded_spec_names
|
|
end
|
|
end
|
|
end
|
|
|
|
def test_operating_system_defaults
|
|
operating_system_defaults = Gem.operating_system_defaults
|
|
|
|
assert operating_system_defaults != nil
|
|
assert operating_system_defaults.is_a? Hash
|
|
end
|
|
|
|
def test_platform_defaults
|
|
platform_defaults = Gem.platform_defaults
|
|
|
|
assert platform_defaults != nil
|
|
assert platform_defaults.is_a? Hash
|
|
end
|
|
|
|
# Ensure that `Gem.source_date_epoch` is consistent even if
|
|
# $SOURCE_DATE_EPOCH has not been set.
|
|
def test_default_source_date_epoch_doesnt_change
|
|
old_epoch = ENV["SOURCE_DATE_EPOCH"]
|
|
ENV["SOURCE_DATE_EPOCH"] = nil
|
|
|
|
# Unfortunately, there is no real way to test this aside from waiting
|
|
# enough for `Time.now.to_i` to change -- which is a whole second.
|
|
#
|
|
# Fortunately, we only need to do this once.
|
|
a = Gem.source_date_epoch
|
|
sleep 1
|
|
b = Gem.source_date_epoch
|
|
assert_equal a, b
|
|
ensure
|
|
ENV["SOURCE_DATE_EPOCH"] = old_epoch
|
|
end
|
|
|
|
private
|
|
|
|
def ruby_install_name(name)
|
|
with_clean_path_to_ruby do
|
|
orig_RUBY_INSTALL_NAME = RbConfig::CONFIG["ruby_install_name"]
|
|
RbConfig::CONFIG["ruby_install_name"] = name
|
|
|
|
begin
|
|
yield
|
|
ensure
|
|
if orig_RUBY_INSTALL_NAME
|
|
RbConfig::CONFIG["ruby_install_name"] = orig_RUBY_INSTALL_NAME
|
|
else
|
|
RbConfig::CONFIG.delete "ruby_install_name"
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
def with_rb_config_ruby(path)
|
|
rb_config_singleton_class = class << RbConfig; self; end
|
|
orig_path = RbConfig.ruby
|
|
|
|
redefine_method(rb_config_singleton_class, :ruby, path)
|
|
|
|
yield
|
|
ensure
|
|
redefine_method(rb_config_singleton_class, :ruby, orig_path)
|
|
end
|
|
|
|
def redefine_method(base, method, new_result)
|
|
base.alias_method(method, method)
|
|
base.define_method(method) { new_result }
|
|
end
|
|
|
|
def with_plugin(path)
|
|
test_plugin_path = File.expand_path("test/rubygems/plugin/#{path}",
|
|
PROJECT_DIR)
|
|
|
|
# A single test plugin should get loaded once only, in order to preserve
|
|
# sane test semantics.
|
|
refute_includes $LOAD_PATH, test_plugin_path
|
|
$LOAD_PATH.unshift test_plugin_path
|
|
|
|
capture_output do
|
|
yield
|
|
end
|
|
ensure
|
|
$LOAD_PATH.delete test_plugin_path
|
|
end
|
|
|
|
def util_ensure_gem_dirs
|
|
Gem.ensure_gem_subdirectories @gemhome
|
|
|
|
#
|
|
# FIXME what does this solve precisely? -ebh
|
|
#
|
|
@additional.each do |dir|
|
|
Gem.ensure_gem_subdirectories @gemhome
|
|
end
|
|
end
|
|
|
|
def util_exec_gem
|
|
spec, _ = util_spec "a", "4" do |s|
|
|
s.executables = ["exec", "abin"]
|
|
end
|
|
|
|
@exec_path = File.join spec.full_gem_path, spec.bindir, "exec"
|
|
@abin_path = File.join spec.full_gem_path, spec.bindir, "abin"
|
|
spec
|
|
end
|
|
|
|
def util_remove_interrupt_command
|
|
Gem::Commands.send :remove_const, :InterruptCommand if
|
|
Gem::Commands.const_defined? :InterruptCommand
|
|
end
|
|
|
|
def util_cache_dir
|
|
File.join Gem.dir, "cache"
|
|
end
|
|
|
|
def with_path_and_rubyopt(path_value, rubyopt_value)
|
|
path, ENV["PATH"] = ENV["PATH"], path_value
|
|
rubyopt, ENV["RUBYOPT"] = ENV["RUBYOPT"], rubyopt_value
|
|
|
|
yield
|
|
ensure
|
|
ENV["PATH"] = path
|
|
ENV["RUBYOPT"] = rubyopt
|
|
end
|
|
|
|
def with_rubygems_gemdeps(value)
|
|
rubygems_gemdeps, ENV["RUBYGEMS_GEMDEPS"] = ENV["RUBYGEMS_GEMDEPS"], value
|
|
|
|
yield
|
|
ensure
|
|
ENV["RUBYGEMS_GEMDEPS"] = rubygems_gemdeps
|
|
end
|
|
|
|
def with_local_bundler_at(path)
|
|
require "bundler"
|
|
|
|
# If bundler gemspec exists, pretend it's installed
|
|
bundler_gemspec = File.expand_path("../../bundler/bundler.gemspec", __dir__)
|
|
if File.exist?(bundler_gemspec)
|
|
target_gemspec_location = "#{path}/specifications/bundler-#{Bundler::VERSION}.gemspec"
|
|
|
|
FileUtils.mkdir_p File.dirname(target_gemspec_location)
|
|
|
|
File.write target_gemspec_location, Gem::Specification.load(bundler_gemspec).to_ruby_for_cache
|
|
end
|
|
|
|
yield
|
|
ensure
|
|
Bundler.reset!
|
|
end
|
|
end
|