libgems 0.0.1

data/test/insure_session.rb

@@ -0,0 +1,43 @@
+require 'libgems'
+
+def install_session
+  path_to_gem = File.join("redist", "session.gem")
+  begin
+    LibGems::Installer.new(path_to_gem).install
+  rescue Errno::EACCES => ex
+    puts
+    puts "*****************************************************************"
+    puts "Unable to install LibGems 'Session'."
+    puts "Reason:  #{ex.message}"
+    puts "Try running:"
+    puts
+    puts "   gem -Li #{path_to_gem}"
+    puts
+    puts "with the appropriate admin privileges."
+    puts "*****************************************************************"
+    puts
+    exit
+  end
+  gem 'session'
+end
+
+begin
+  require 'session'
+rescue LoadError => e
+  puts
+  puts "Required LibGems 'Session' missing."
+  puts "We can attempt to install from the #{LibGems::NAME} Distribution,"
+  puts "but installation may require admin privileges on your system."
+  puts
+  print "Install now from #{LibGems::NAME} distribution? [Yn]"
+  answer = gets
+  if(answer =~ /^y/i || answer =~ /^[^a-zA-Z0-9]$/) then
+    install_session
+    puts
+    puts "Retry running the functional tests."
+    exit(0)
+  else
+    puts "Test cancelled...quitting"
+    exit(1)
+  end
+end

data/test/mockgemui.rb

@@ -0,0 +1,56 @@
+require 'stringio'
+require 'libgems/user_interaction'
+
+class MockGemUi < LibGems::StreamUI
+  class TermError < RuntimeError; end
+
+  module TTY
+
+    attr_accessor :tty
+
+    def tty?()
+      @tty = true unless defined?(@tty)
+      @tty
+    end
+
+  end
+
+  def initialize(input = "")
+    ins = StringIO.new input
+    outs = StringIO.new
+    errs = StringIO.new
+
+    ins.extend TTY
+    outs.extend TTY
+    errs.extend TTY
+
+    super ins, outs, errs
+
+    @terminated = false
+  end
+
+  def input
+    @ins.string
+  end
+
+  def output
+    @outs.string
+  end
+
+  def error
+    @errs.string
+  end
+
+  def terminated?
+    @terminated
+  end
+
+  def terminate_interaction(status=0)
+    @terminated = true
+
+    raise TermError unless status == 0
+    raise LibGems::SystemExitException, status
+  end
+
+end
+

data/test/plugin/exception/libgems_plugin.rb

@@ -0,0 +1,2 @@
+TestGem::TEST_PLUGIN_EXCEPTION = :loaded
+raise Exception.new('boom')

data/test/plugin/load/libgems_plugin.rb

@@ -0,0 +1 @@
+TestGem::TEST_PLUGIN_LOAD = :loaded

data/test/plugin/standarderror/libgems_plugin.rb

@@ -0,0 +1,2 @@
+TestGem::TEST_PLUGIN_STANDARDERROR = :loaded
+raise StandardError.new('boom')

data/test/private_key.pem

@@ -0,0 +1,27 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIIEpAIBAAKCAQEAm24C6xixiAxO+i1f3L8XRMwrmLkt6BvT60mZ7g8HsklH3af7
+KNHA6vo/G6sujs2UsNO4HY8BTEneiVOXXWQlcsJ+Z5wEPlIu4zFueAmLefx+n9lE
+ulNIUDoyUenKX4spoMRnX8k4lXL05ho/6JFq0JdDY2DmAaQ4vvTz5mh9kZiybtHQ
+fzcpbA51uY+sjdQRCPDHyUUfh0SmWJlLYMwcBdVeCiGUPBLi+iP5x1btO4uiJK6Q
+IMaV1H3SUCYtKGQKl7qwFd8k8ZBcHYOtmK61tupg3vqWQc0em6SxPj5lws8+1MVK
+twBNIDx24jF4ntxBRNKMZ7FN5SHbobAgDYkPAQIDAQABAoIBAGQilgK8X/PUajVH
+clEXU3hhSV0VQHwfIYKeYms6h6zXBVPKW0dLC0zXeDztJgueasMZQ67XaPCrTpGO
+px/l2zJ6F1HM8/bqn4aDXDY9f/xRLYryQRMBgL8fHzgitNylHWaT4j2Vt7yg2SI9
+mxrMRNKqASJPVR+Nm3l6+n9gpjVb99wEucWplPPHI6KhXLYPZOqSwt+zaH5roz3k
+UQmMs0Bs4hF1SzVl0n+KNoXHOwswVrmBWXgWvm2OhnwY2e26jfejc8toJc/ShAJ7
+C9exnrdimcgEKbd22Sum4G00CDYhcrG5LHHqkgwifcAEVctrvBZBZHGgpxlO8a8U
+eF2Vr7kCgYEAykdrBlzp7Fn9xzUInBQ3NXTTYAq51lpuJdmHQmPuTSY0buoHkd9f
+xbUCZ2qR9QAesrx4hI0qGLetc8IOKDoWx2rPepCCvO3Kx61o1SB5fAvBue03qVoq
+HqACX3Uk24Em8zAz9xuP13ETH/wU7sUbUxRHMCre6ZDmlxn4g5l+Nl8CgYEAxLVl
+22yBx0dfRr3UsHY9rxll2gIlnfnYfiJzq8wetzt/TfztRV5ILz7FyWqL5d7IoqkA
+fT2V4HAasRJASnKohwJe7z5M/H2ExwkGNFvY+jefb2CoUl5WouK9AlhbqBk3zmHi
+sY5GqQkAp/kHMntEin+sErJw6mkgAGdser3a9p8CgYEAqi31w++tunRnxw4+RRnY
+7Pdx0k6T1NxV6TAe1ONAHNY0rM/mOHqml65W7GzDiU1lhlh8SIB/VzZJDqfHw15D
+xdh94A7uf0bMILwrA4wDyTIW9Xa3Kpq57vQNqwPiU25QN69pOM+Ob+IpBfLOJafc
++kOINOUMj5Kh/aQS6Zzci58CgYEAk24dlFKEBjbRCvU2FrfYTYcsljPru7ZJc2gg
+588J6m0WYf5CWy5pzbcviGFpzvSlzXv7GOLylQ+QgcxbETFUbDPzsT4xd0AgJwj1
+dIKuYgMUZOa94VZBer2TydEtiRS1heJJhKhM/1329u4nXceTvHYqIq1JAfeee48I
+eAoZtaMCgYBz1FjWFQnMTD5nmyPEEZneoBPAR5+9jwOps+IYOoHtazoMFszzd0qo
+JZW3Ihn9KRrVSxfFApKS/ZwjiZ+tJUk7DE/v/0l0sszefY7s8b0pL1lpeZSoL71e
+QoG1WLXUiDV3BRlmyOAF1h3p12KRTLgwubN51ajECwcs3QwE+ZT8Gg==
+-----END RSA PRIVATE KEY-----

data/test/public_cert.pem

@@ -0,0 +1,20 @@
+-----BEGIN CERTIFICATE-----
+MIIDNjCCAh6gAwIBAgIBADANBgkqhkiG9w0BAQUFADBBMRAwDgYDVQQDDAdkcmJy
+YWluMRgwFgYKCZImiZPyLGQBGRYIc2VnbWVudDcxEzARBgoJkiaJk/IsZAEZFgNu
+ZXQwHhcNMDcxMjIxMDIwNDE0WhcNMDgxMjIwMDIwNDE0WjBBMRAwDgYDVQQDDAdk
+cmJyYWluMRgwFgYKCZImiZPyLGQBGRYIc2VnbWVudDcxEzARBgoJkiaJk/IsZAEZ
+FgNuZXQwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCbbgLrGLGIDE76
+LV/cvxdEzCuYuS3oG9PrSZnuDweySUfdp/so0cDq+j8bqy6OzZSw07gdjwFMSd6J
+U5ddZCVywn5nnAQ+Ui7jMW54CYt5/H6f2US6U0hQOjJR6cpfiymgxGdfyTiVcvTm
+Gj/okWrQl0NjYOYBpDi+9PPmaH2RmLJu0dB/NylsDnW5j6yN1BEI8MfJRR+HRKZY
+mUtgzBwF1V4KIZQ8EuL6I/nHVu07i6IkrpAgxpXUfdJQJi0oZAqXurAV3yTxkFwd
+g62YrrW26mDe+pZBzR6bpLE+PmXCzz7UxUq3AE0gPHbiMXie3EFE0oxnsU3lIduh
+sCANiQ8BAgMBAAGjOTA3MAkGA1UdEwQCMAAwCwYDVR0PBAQDAgSwMB0GA1UdDgQW
+BBS5k4Z75VSpdM0AclG2UvzFA/VW5DANBgkqhkiG9w0BAQUFAAOCAQEAHagT4lfX
+kP/hDaiwGct7XPuVGbrOsKRVD59FF5kETBxEc9UQ1clKWngf8JoVuEoKD774dW19
+bU0GOVWO+J6FMmT/Cp7nuFJ79egMf/gy4gfUfQMuvfcr6DvZUPIs9P/TlK59iMYF
+DIOQ3DxdF3rMzztNUCizN4taVscEsjCcgW6WkUJnGdqlu3OHWpQxZBJkBTjPCoc6
+UW6on70SFPmAy/5Cq0OJNGEWBfgD9q7rrs/X8GGwUWqXb85RXnUVi/P8Up75E0ag
+14jEc90kN+C7oI/AGCBN0j6JnEtYIEJZibjjDJTSMWlUKKkj30kq7hlUC2CepJ4v
+x52qPcexcYZR7w==
+-----END CERTIFICATE-----

data/test/rubygems_plugin.rb

@@ -0,0 +1,21 @@
+require 'libgems/command_manager'
+
+##
+# This is an example of exactly what NOT to do.
+#
+# DO NOT include code like this in your rubygems_plugin.rb
+
+class LibGems::Commands::InterruptCommand < LibGems::Command
+
+  def initialize
+    super('interrupt', 'Raises an Interrupt Exception', {})
+  end
+
+  def execute
+    raise Interrupt, "Interrupt exception"
+  end
+
+end
+
+LibGems::CommandManager.instance.register_command :interrupt
+

data/test/simple_gem.rb

@@ -0,0 +1,66 @@
+SIMPLE_GEM = <<-GEMDATA
+        MD5SUM = "b12a4d48febeb2289c539c2574c4b6f8"
+        if $0 == __FILE__
+          require 'optparse'
+
+          options = {}
+          ARGV.options do |opts|
+            opts.on_tail("--help", "show this message") {puts opts; exit}
+            opts.on('--dir=DIRNAME', "Installation directory for the LibGems") {|options[:directory]|}
+            opts.on('--force', "Force LibGems to intall, bypassing dependency checks") {|options[:force]|}
+            opts.on('--gen-rdoc', "Generate RDoc documentation for the LibGems") {|options[:gen_rdoc]|}
+            opts.parse!
+          end
+
+          require 'libgems'
+          @directory = options[:directory] || LibGems.dir
+          @force = options[:force]
+
+          gem = LibGems::Installer.new(__FILE__).install(@force, @directory)
+          if options[:gen_rdoc]
+            LibGems::DocManager.new(gem).generate_rdoc
+          end
+end
+
+__END__
+--- !ruby/object:LibGems::Specification
+rubygems_version: "1.0"
+name: testing
+version: !ruby/object:LibGems::Version
+  version: 1.2.3
+date: 2004-03-18 22:01:52.859121 -05:00
+platform:
+summary: This exercise the gem testing stuff.
+require_paths:
+  - lib
+files:
+  - lib/foo.rb
+  - lib/test
+  - lib/test.rb
+  - lib/test/wow.rb
+autorequire: test
+test_suite_file: foo
+requirements:
+  - a computer processor
+---
+-
+  size: 109
+  mode: 420
+  path: lib/foo.rb
+-
+  size: 0
+  mode: 420
+  path: lib/test.rb
+-
+  size: 15
+  mode: 420
+  path: lib/test/wow.rb
+---
+eJwVjDEKgDAUQ/eeIpsKguhY3ARPoHMp9quF0mL7e39/h5DwQpLpqz4TOqbC
+U42eO6WuYEvBntIhECuaaX1KqXXLmy2kAEc32szExK+PjyBAlpTZyK0N/Twu
+g1CKTjX9BGAj1w==
+---
+eJwDAAAAAAE=
+---
+eJwrKC0pVlAvzy9XyE3MU+cCACwiBP4=
+GEMDATA

data/test/test_config.rb

@@ -0,0 +1,12 @@
+require File.expand_path('../gemutilities', __FILE__)
+require 'libgems'
+
+class TestConfig < RubyGemTestCase
+
+  def test_datadir
+    datadir = RbConfig::CONFIG['datadir']
+    assert_equal "#{datadir}/xyz", RbConfig.datadir('xyz')
+  end
+
+end
+

data/test/test_gem.rb

@@ -0,0 +1,780 @@
+require File.expand_path('../gemutilities', __FILE__)
+require 'libgems'
+require 'libgems/gem_openssl'
+require 'libgems/installer'
+require 'pathname'
+require 'tmpdir'
+
+class TestGem < RubyGemTestCase
+
+  def setup
+    super
+
+    @additional = %w[a b].map { |d| File.join @tempdir, d }
+    @default_dir_re = if RUBY_VERSION > '1.9' then
+                        %r|/.*?[Rr]uby.*?/[Gg]ems/[0-9.]+|
+                      else
+                        %r|/[Rr]uby/[Gg]ems/[0-9.]+|
+                      end
+
+    util_remove_interrupt_command
+  end
+
+  def test_self_all_load_paths
+    util_make_gems
+
+    expected = [
+      File.join(@gemhome, *%W[gems #{@a1.full_name} lib]),
+      File.join(@gemhome, *%W[gems #{@a2.full_name} lib]),
+      File.join(@gemhome, *%W[gems #{@a3a.full_name} lib]),
+      File.join(@gemhome, *%W[gems #{@a_evil9.full_name} lib]),
+      File.join(@gemhome, *%W[gems #{@b2.full_name} lib]),
+      File.join(@gemhome, *%W[gems #{@c1_2.full_name} lib]),
+      File.join(@gemhome, *%W[gems #{@pl1.full_name} lib]),
+    ]
+
+    assert_equal expected, LibGems.all_load_paths.sort
+  end
+
+  def test_self_available?
+    util_make_gems
+    assert(LibGems.available?("a"))
+    assert(LibGems.available?("a", "1"))
+    assert(LibGems.available?("a", ">1"))
+    assert(!LibGems.available?("monkeys"))
+  end
+
+  def test_self_bin_path_bin_name
+    util_exec_gem
+    assert_equal @abin_path, LibGems.bin_path('a', 'abin')
+  end
+
+  def test_self_bin_path_bin_name_version
+    util_exec_gem
+    assert_equal @abin_path, LibGems.bin_path('a', 'abin', '4')
+  end
+
+  def test_self_bin_path_name
+    util_exec_gem
+    assert_equal @exec_path, LibGems.bin_path('a')
+  end
+
+  def test_self_bin_path_name_version
+    util_exec_gem
+    assert_equal @exec_path, LibGems.bin_path('a', nil, '4')
+  end
+
+  def test_self_bin_path_nonexistent_binfile
+    quick_gem 'a', '2' do |s|
+      s.executables = ['exec']
+    end
+    assert_raises(LibGems::GemNotFoundException) do
+      LibGems.bin_path('a', 'other', '2')
+    end
+  end
+
+  def test_self_bin_path_no_bin_file
+    quick_gem 'a', '1'
+    assert_raises(LibGems::Exception) do
+      LibGems.bin_path('a', nil, '1')
+    end
+  end
+
+  def test_self_bin_path_not_found
+    assert_raises(LibGems::GemNotFoundException) do
+      LibGems.bin_path('non-existent')
+    end
+  end
+
+  def test_self_bin_path_bin_file_gone_in_latest
+    util_exec_gem
+    quick_gem 'a', '10' do |s|
+      s.executables = []
+      s.default_executable = nil
+    end
+    # Should not find a-10's non-abin (bug)
+    assert_equal @abin_path, LibGems.bin_path('a', 'abin')
+  end
+
+  def test_self_bindir
+    assert_equal File.join(@gemhome, 'bin'), LibGems.bindir
+    assert_equal File.join(@gemhome, 'bin'), LibGems.bindir(LibGems.dir)
+    assert_equal File.join(@gemhome, 'bin'), LibGems.bindir(Pathname.new(LibGems.dir))
+  end
+
+  def test_self_bindir_default_dir
+    default = LibGems.default_dir
+    bindir = if defined?(RUBY_FRAMEWORK_VERSION) then
+               '/usr/bin'
+             else
+               RbConfig::CONFIG['bindir']
+             end
+
+    assert_equal bindir, LibGems.bindir(default)
+    assert_equal bindir, LibGems.bindir(Pathname.new(default))
+  end
+
+  def test_self_clear_paths
+    LibGems.dir
+    LibGems.path
+    searcher = LibGems.searcher
+    source_index = LibGems.source_index
+
+    LibGems.clear_paths
+
+    assert_equal nil, LibGems.instance_variable_get(:@gem_home)
+    assert_equal nil, LibGems.instance_variable_get(:@gem_path)
+    refute_equal searcher, LibGems.searcher
+    refute_equal source_index.object_id, LibGems.source_index.object_id
+  end
+
+  def test_self_configuration
+    expected = LibGems::ConfigFile.new []
+    LibGems.configuration = nil
+
+    assert_equal expected, LibGems.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 = quick_gem 'foo' do |s| s.files = %w[data/foo.txt] end
+      install_gem foo
+    end
+
+    LibGems.source_index = nil
+
+    gem 'foo'
+
+    expected = File.join @gemhome, 'gems', foo.full_name, 'data', 'foo'
+
+    assert_equal expected, LibGems.datadir('foo')
+  end
+
+  def test_self_datadir_nonexistent_package
+    assert_nil LibGems.datadir('xyzzy')
+  end
+
+  def test_self_default_dir
+    assert_match @default_dir_re, LibGems.default_dir
+  end
+
+  def test_self_default_exec_format
+    orig_RUBY_INSTALL_NAME = LibGems::ConfigMap[:ruby_install_name]
+    LibGems::ConfigMap[:ruby_install_name] = 'ruby'
+
+    assert_equal '%s', LibGems.default_exec_format
+  ensure
+    LibGems::ConfigMap[:ruby_install_name] = orig_RUBY_INSTALL_NAME
+  end
+
+  def test_self_default_exec_format_18
+    orig_RUBY_INSTALL_NAME = LibGems::ConfigMap[:ruby_install_name]
+    LibGems::ConfigMap[:ruby_install_name] = 'ruby18'
+
+    assert_equal '%s18', LibGems.default_exec_format
+  ensure
+    LibGems::ConfigMap[:ruby_install_name] = orig_RUBY_INSTALL_NAME
+  end
+
+  def test_self_default_exec_format_jruby
+    orig_RUBY_INSTALL_NAME = LibGems::ConfigMap[:ruby_install_name]
+    LibGems::ConfigMap[:ruby_install_name] = 'jruby'
+
+    assert_equal 'j%s', LibGems.default_exec_format
+  ensure
+    LibGems::ConfigMap[:ruby_install_name] = orig_RUBY_INSTALL_NAME
+  end
+
+  def test_self_default_sources
+    assert_equal %w[http://rubygems.org/], LibGems.default_sources
+  end
+
+  def test_self_dir
+    assert_equal @gemhome, LibGems.dir
+  end
+
+  def test_self_ensure_gem_directories
+    FileUtils.rm_r @gemhome
+    LibGems.use_paths @gemhome
+
+    LibGems.ensure_gem_subdirectories @gemhome
+
+    assert File.directory?(File.join(@gemhome, "cache"))
+  end
+
+  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"
+    LibGems.use_paths gemdir
+
+    LibGems.ensure_gem_subdirectories gemdir
+
+    assert File.directory?("#{gemdir}/cache")
+  end
+
+  unless win_platform? then # 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
+      LibGems.use_paths gemdir
+
+      LibGems.ensure_gem_subdirectories gemdir
+
+      refute File.exist?("#{gemdir}/cache")
+    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
+      LibGems.use_paths(gemdir)
+
+      LibGems.ensure_gem_subdirectories gemdir
+
+      refute File.exist?("#{gemdir}/cache")
+    ensure
+      FileUtils.chmod 0600, parent
+    end
+  end
+
+  def test_ensure_ssl_available
+    orig_Gem_ssl_available = LibGems.ssl_available?
+
+    LibGems.ssl_available = true
+    LibGems.ensure_ssl_available
+
+    LibGems.ssl_available = false
+    e = assert_raises LibGems::Exception do LibGems.ensure_ssl_available end
+    assert_equal 'SSL is not installed on this system', e.message
+  ensure
+    LibGems.ssl_available = orig_Gem_ssl_available
+  end
+
+  def test_self_find_files
+    discover_path = File.join 'lib', 'foo', 'discover.rb'
+    cwd = File.expand_path '..', __FILE__
+    $LOAD_PATH.unshift cwd.dup
+
+    foo1 = quick_gem 'foo', '1' do |s|
+      s.files << discover_path
+    end
+
+    foo2 = quick_gem 'foo', '2' do |s|
+      s.files << discover_path
+    end
+
+    path = File.join 'gems', foo1.full_name, discover_path
+    write_file(path) { |fp| fp.puts "# #{path}" }
+
+    path = File.join 'gems', foo2.full_name, discover_path
+    write_file(path) { |fp| fp.puts "# #{path}" }
+
+    @fetcher = LibGems::FakeFetcher.new
+    LibGems::RemoteFetcher.fetcher = @fetcher
+
+    LibGems.source_index = util_setup_spec_fetcher foo1, foo2
+
+    LibGems.searcher = nil
+
+    expected = [
+      File.expand_path('../foo/discover.rb', __FILE__),
+      File.join(foo2.full_gem_path, discover_path),
+      File.join(foo1.full_gem_path, discover_path),
+    ]
+
+    assert_equal expected, LibGems.find_files('foo/discover')
+  ensure
+    assert_equal cwd, $LOAD_PATH.shift
+  end
+
+  def test_self_latest_load_paths
+    util_make_gems
+
+    expected = [
+      File.join(@gemhome, *%W[gems #{@a3a.full_name} lib]),
+      File.join(@gemhome, *%W[gems #{@a_evil9.full_name} lib]),
+      File.join(@gemhome, *%W[gems #{@b2.full_name} lib]),
+      File.join(@gemhome, *%W[gems #{@c1_2.full_name} lib]),
+      File.join(@gemhome, *%W[gems #{@pl1.full_name} lib]),
+    ]
+
+    assert_equal expected, LibGems.latest_load_paths.sort
+  end
+
+  def test_self_loaded_specs
+    foo = quick_gem 'foo'
+    install_gem foo
+    LibGems.source_index = nil
+
+    LibGems.activate 'foo'
+
+    assert_equal true, LibGems.loaded_specs.keys.include?('foo')
+  end
+
+  def test_self_path
+    assert_equal [LibGems.dir], LibGems.path
+  end
+
+  def test_self_path_default
+    if defined? APPLE_GEM_HOME
+      orig_APPLE_GEM_HOME = APPLE_GEM_HOME
+      Object.send :remove_const, :APPLE_GEM_HOME
+    end
+    orig_GEM_HOME = ENV.delete 'GEM_HOME'
+    orig_GEM_PATH = ENV.delete 'GEM_PATH'
+
+    LibGems.instance_variable_set :@gem_path, nil
+
+    assert_equal [LibGems.default_path, LibGems.dir].flatten, LibGems.path
+  ensure
+    Object.const_set :APPLE_GEM_HOME, orig_APPLE_GEM_HOME
+    ENV['GEM_HOME'] = orig_GEM_HOME
+    ENV['GEM_PATH'] = orig_GEM_PATH
+  end
+
+  unless win_platform?
+    def test_self_path_APPLE_GEM_HOME
+      orig_GEM_HOME = ENV.delete 'GEM_HOME'
+      orig_GEM_PATH = ENV.delete 'GEM_PATH'
+
+      LibGems.clear_paths
+      apple_gem_home = File.join @tempdir, 'apple_gem_home'
+      LibGems.const_set :APPLE_GEM_HOME, apple_gem_home
+
+      assert_includes LibGems.path, apple_gem_home
+    ensure
+      LibGems.send :remove_const, :APPLE_GEM_HOME
+      ENV['GEM_HOME'] = orig_GEM_HOME
+      ENV['GEM_PATH'] = orig_GEM_PATH
+    end
+
+    def test_self_path_APPLE_GEM_HOME_GEM_PATH
+      LibGems.clear_paths
+      ENV['LIBGEMS_PATH'] = @gemhome
+      apple_gem_home = File.join @tempdir, 'apple_gem_home'
+      LibGems.const_set :APPLE_GEM_HOME, apple_gem_home
+
+      refute LibGems.path.include?(apple_gem_home)
+    ensure
+      LibGems.send :remove_const, :APPLE_GEM_HOME
+    end
+  end
+
+  def test_self_path_ENV_PATH
+    LibGems.send :set_paths, nil
+    path_count = LibGems.path.size
+    LibGems.clear_paths
+
+    ENV['LIBGEMS_PATH'] = @additional.join(File::PATH_SEPARATOR)
+
+    assert_equal @additional, LibGems.path[0,2]
+
+    assert_equal path_count + @additional.size, LibGems.path.size,
+                 "extra path components: #{LibGems.path[2..-1].inspect}"
+    assert_equal LibGems.dir, LibGems.path.last
+  end
+
+  def test_self_path_duplicate
+    LibGems.clear_paths
+    util_ensure_gem_dirs
+    dirs = @additional + [@gemhome] + [File.join(@tempdir, 'a')]
+
+    ENV['LIBGEMS_HOME'] = @gemhome
+    ENV['LIBGEMS_PATH'] = dirs.join File::PATH_SEPARATOR
+
+    assert_equal @gemhome, LibGems.dir
+
+    paths = [LibGems.dir]
+    assert_equal @additional + paths, LibGems.path
+  end
+
+  def test_self_path_overlap
+    LibGems.clear_paths
+
+    util_ensure_gem_dirs
+    ENV['LIBGEMS_HOME'] = @gemhome
+    ENV['LIBGEMS_PATH'] = @additional.join(File::PATH_SEPARATOR)
+
+    assert_equal @gemhome, LibGems.dir
+
+    paths = [LibGems.dir]
+    assert_equal @additional + paths, LibGems.path
+  end
+
+  def test_self_platforms
+    assert_equal [LibGems::Platform::RUBY, LibGems::Platform.local], LibGems.platforms
+  end
+
+  def test_self_prefix
+    file_name = File.expand_path __FILE__
+
+    prefix = File.dirname File.dirname(file_name)
+    prefix = File.dirname prefix if File.basename(prefix) == 'test'
+
+    assert_equal prefix, LibGems.prefix
+  end
+
+  def test_self_prefix_libdir
+    orig_libdir = LibGems::ConfigMap[:libdir]
+
+    file_name = File.expand_path __FILE__
+    prefix = File.dirname File.dirname(file_name)
+    prefix = File.dirname prefix if File.basename(prefix) == 'test'
+
+    LibGems::ConfigMap[:libdir] = prefix
+
+    assert_nil LibGems.prefix
+  ensure
+    LibGems::ConfigMap[:libdir] = orig_libdir
+  end
+
+  def test_self_prefix_sitelibdir
+    orig_sitelibdir = LibGems::ConfigMap[:sitelibdir]
+
+    file_name = File.expand_path __FILE__
+    prefix = File.dirname File.dirname(file_name)
+    prefix = File.dirname prefix if File.basename(prefix) == 'test'
+
+    LibGems::ConfigMap[:sitelibdir] = prefix
+
+    assert_nil LibGems.prefix
+  ensure
+    LibGems::ConfigMap[:sitelibdir] = orig_sitelibdir
+  end
+
+  def test_self_refresh
+    util_make_gems
+
+    a1_spec = File.join @gemhome, "specifications", @a1.spec_name
+
+    FileUtils.mv a1_spec, @tempdir
+
+    refute LibGems.source_index.gems.include?(@a1.full_name)
+
+    FileUtils.mv File.join(@tempdir, @a1.spec_name), a1_spec
+
+    LibGems.refresh
+
+    assert_includes LibGems.source_index.gems, @a1.full_name
+    assert_equal nil, LibGems.instance_variable_get(:@searcher)
+  end
+
+  def test_self_required_location
+    util_make_gems
+
+    assert_equal File.join(@tempdir, *%w[gemhome gems c-1.2 lib code.rb]),
+                 LibGems.required_location("c", "code.rb")
+    assert_equal File.join(@tempdir, *%w[gemhome gems a-1 lib code.rb]),
+                 LibGems.required_location("a", "code.rb", "< 2")
+    assert_equal File.join(@tempdir, *%w[gemhome gems a-2 lib code.rb]),
+                 LibGems.required_location("a", "code.rb", "= 2")
+  end
+
+  def test_self_ruby_escaping_spaces_in_path
+    orig_ruby = LibGems.ruby
+    orig_bindir = LibGems::ConfigMap[:bindir]
+    orig_ruby_install_name = LibGems::ConfigMap[:ruby_install_name]
+    orig_exe_ext = LibGems::ConfigMap[:EXEEXT]
+
+    LibGems::ConfigMap[:bindir] = "C:/Ruby 1.8/bin"
+    LibGems::ConfigMap[:ruby_install_name] = "ruby"
+    LibGems::ConfigMap[:EXEEXT] = ".exe"
+    LibGems.instance_variable_set("@ruby", nil)
+
+    assert_equal "\"C:/Ruby 1.8/bin/ruby.exe\"", LibGems.ruby
+  ensure
+    LibGems.instance_variable_set("@ruby", orig_ruby)
+    LibGems::ConfigMap[:bindir] = orig_bindir
+    LibGems::ConfigMap[:ruby_install_name] = orig_ruby_install_name
+    LibGems::ConfigMap[:EXEEXT] = orig_exe_ext
+  end
+
+  def test_self_ruby_path_without_spaces
+    orig_ruby = LibGems.ruby
+    orig_bindir = LibGems::ConfigMap[:bindir]
+    orig_ruby_install_name = LibGems::ConfigMap[:ruby_install_name]
+    orig_exe_ext = LibGems::ConfigMap[:EXEEXT]
+
+    LibGems::ConfigMap[:bindir] = "C:/Ruby18/bin"
+    LibGems::ConfigMap[:ruby_install_name] = "ruby"
+    LibGems::ConfigMap[:EXEEXT] = ".exe"
+    LibGems.instance_variable_set("@ruby", nil)
+
+    assert_equal "C:/Ruby18/bin/ruby.exe", LibGems.ruby
+  ensure
+    LibGems.instance_variable_set("@ruby", orig_ruby)
+    LibGems::ConfigMap[:bindir] = orig_bindir
+    LibGems::ConfigMap[:ruby_install_name] = orig_ruby_install_name
+    LibGems::ConfigMap[:EXEEXT] = orig_exe_ext
+  end
+
+  def test_self_ruby_version_1_8_5
+    util_set_RUBY_VERSION '1.8.5'
+
+    assert_equal LibGems::Version.new('1.8.5'), LibGems.ruby_version
+  ensure
+    util_restore_RUBY_VERSION
+  end
+
+  def test_self_ruby_version_1_8_6p287
+    util_set_RUBY_VERSION '1.8.6', 287
+
+    assert_equal LibGems::Version.new('1.8.6.287'), LibGems.ruby_version
+  ensure
+    util_restore_RUBY_VERSION
+  end
+
+  def test_self_ruby_version_1_9_2dev_r23493
+    util_set_RUBY_VERSION '1.9.2', -1, 23493
+
+    assert_equal LibGems::Version.new('1.9.2.dev.23493'), LibGems.ruby_version
+  ensure
+    util_restore_RUBY_VERSION
+  end
+
+  def test_self_searcher
+    assert_kind_of LibGems::GemPathSearcher, LibGems.searcher
+  end
+
+  def test_self_set_paths
+    other = File.join @tempdir, 'other'
+    path = [@userhome, other].join File::PATH_SEPARATOR
+    LibGems.send :set_paths, path
+
+    assert_equal [@userhome, other, @gemhome], LibGems.path
+  end
+
+  def test_self_set_paths_nonexistent_home
+    ENV['LIBGEMS_HOME'] = @gemhome
+    LibGems.clear_paths
+
+    other = File.join @tempdir, 'other'
+
+    ENV['HOME'] = other
+
+    LibGems.send :set_paths, other
+
+    assert_equal [other, @gemhome], LibGems.path
+  end
+
+  def test_self_source_index
+    assert_kind_of LibGems::SourceIndex, LibGems.source_index
+  end
+
+  def test_self_sources
+    assert_equal %w[http://gems.example.com/], LibGems.sources
+  end
+
+  def test_ssl_available_eh
+    orig_Gem_ssl_available = LibGems.ssl_available?
+
+    LibGems.ssl_available = true
+    assert_equal true, LibGems.ssl_available?
+
+    LibGems.ssl_available = false
+    assert_equal false, LibGems.ssl_available?
+  ensure
+    LibGems.ssl_available = orig_Gem_ssl_available
+  end
+
+  def test_self_use_paths
+    util_ensure_gem_dirs
+
+    LibGems.use_paths @gemhome, @additional
+
+    assert_equal @gemhome, LibGems.dir
+    assert_equal @additional + [LibGems.dir], LibGems.path
+  end
+
+  def test_self_user_dir
+    assert_equal File.join(@userhome, '.gem', LibGems.ruby_engine,
+                           LibGems::ConfigMap[:ruby_version]), LibGems.user_dir
+  end
+
+  def test_self_user_home
+    if ENV['HOME'] then
+      assert_equal ENV['HOME'], LibGems.user_home
+    else
+      assert true, 'count this test'
+    end
+  end
+
+  if LibGems.win_platform? then
+    def test_self_user_home_userprofile
+      skip 'Ruby 1.9 properly handles ~ path expansion' unless '1.9' > RUBY_VERSION
+
+      LibGems.clear_paths
+
+      # safe-keep env variables
+      orig_home, orig_user_profile = ENV['HOME'], ENV['USERPROFILE']
+
+      # prepare for the test
+      ENV.delete('HOME')
+      ENV['USERPROFILE'] = "W:\\Users\\RubyUser"
+
+      assert_equal 'W:/Users/RubyUser', LibGems.user_home
+
+    ensure
+      ENV['HOME'] = orig_home
+      ENV['USERPROFILE'] = orig_user_profile
+    end
+
+    def test_self_user_home_user_drive_and_path
+      skip 'Ruby 1.9 properly handles ~ path expansion' unless '1.9' > RUBY_VERSION
+
+      LibGems.clear_paths
+
+      # safe-keep env variables
+      orig_home, orig_user_profile = ENV['HOME'], ENV['USERPROFILE']
+      orig_home_drive, orig_home_path = ENV['HOMEDRIVE'], ENV['HOMEPATH']
+
+      # prepare the environment
+      ENV.delete('HOME')
+      ENV.delete('USERPROFILE')
+      ENV['HOMEDRIVE'] = 'Z:'
+      ENV['HOMEPATH'] = "\\Users\\RubyUser"
+
+      assert_equal 'Z:/Users/RubyUser', LibGems.user_home
+
+    ensure
+      ENV['HOME'] = orig_home
+      ENV['USERPROFILE'] = orig_user_profile
+      ENV['HOMEDRIVE'] = orig_home_drive
+      ENV['HOMEPATH'] = orig_home_path
+    end
+  end
+
+  def test_load_plugins
+    ["libgems", "rubygems"].each do |type|
+      TestGem.send :remove_const, :TEST_SPEC_PLUGIN_LOAD if defined?(TEST_SPEC_PLUGIN_LOAD)
+
+      plugin_path = File.join "lib", "#{type}_plugin.rb"
+
+      Dir.chdir @tempdir do
+        FileUtils.mkdir_p 'lib'
+        File.open plugin_path, "w" do |fp|
+          fp.puts "TestGem::TEST_SPEC_PLUGIN_LOAD = :loaded"
+        end
+
+        foo = quick_gem "foo-#{type}", '1' do |s|
+          s.files << plugin_path
+        end
+
+        install_gem foo
+      end
+
+      LibGems.source_index = nil
+
+      gem "foo-#{type}"
+
+      LibGems.load_plugins
+
+      assert_equal :loaded, TEST_SPEC_PLUGIN_LOAD
+    end
+  end
+
+  def test_load_env_plugins
+    with_plugin('load') { LibGems.load_env_plugins }
+    assert_equal :loaded, TEST_PLUGIN_LOAD
+
+    util_remove_interrupt_command
+
+    # Should attempt to cause a StandardError
+    with_plugin('standarderror') { LibGems.load_env_plugins }
+    assert_equal :loaded, TEST_PLUGIN_STANDARDERROR
+
+    util_remove_interrupt_command
+
+    # Should attempt to cause an Exception
+    with_plugin('exception') { LibGems.load_env_plugins }
+    assert_equal :loaded, TEST_PLUGIN_EXCEPTION
+  end
+
+  def with_plugin(path)
+    test_plugin_path = File.expand_path "../plugin/#{path}", __FILE__
+
+    # 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_io do
+      yield
+    end
+  ensure
+    $LOAD_PATH.delete test_plugin_path
+  end
+
+  def util_ensure_gem_dirs
+    LibGems.ensure_gem_subdirectories @gemhome
+    @additional.each do |dir|
+      LibGems.ensure_gem_subdirectories @gemhome
+    end
+  end
+
+  def util_exec_gem
+    spec, _ = quick_gem 'a', '4' do |s|
+      s.default_executable = 'exec'
+      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'
+  end
+
+  def util_set_RUBY_VERSION(version, patchlevel = nil, revision = nil)
+    if LibGems.instance_variables.include? :@ruby_version or
+       LibGems.instance_variables.include? '@ruby_version' then
+      LibGems.send :remove_instance_variable, :@ruby_version
+    end
+
+    @RUBY_VERSION    = RUBY_VERSION
+    @RUBY_PATCHLEVEL = RUBY_PATCHLEVEL if defined?(RUBY_PATCHLEVEL)
+    @RUBY_REVISION   = RUBY_REVISION   if defined?(RUBY_REVISION)
+
+    Object.send :remove_const, :RUBY_VERSION
+    Object.send :remove_const, :RUBY_PATCHLEVEL if defined?(RUBY_PATCHLEVEL)
+    Object.send :remove_const, :RUBY_REVISION   if defined?(RUBY_REVISION)
+
+    Object.const_set :RUBY_VERSION,    version
+    Object.const_set :RUBY_PATCHLEVEL, patchlevel if patchlevel
+    Object.const_set :RUBY_REVISION,   revision   if revision
+  end
+
+  def util_restore_RUBY_VERSION
+    Object.send :remove_const, :RUBY_VERSION
+    Object.send :remove_const, :RUBY_PATCHLEVEL if defined?(RUBY_PATCHLEVEL)
+    Object.send :remove_const, :RUBY_REVISION   if defined?(RUBY_REVISION)
+
+    Object.const_set :RUBY_VERSION,    @RUBY_VERSION
+    Object.const_set :RUBY_PATCHLEVEL, @RUBY_PATCHLEVEL if
+      defined?(@RUBY_PATCHLEVEL)
+    Object.const_set :RUBY_REVISION,   @RUBY_REVISION   if
+      defined?(@RUBY_REVISION)
+  end
+
+  def util_remove_interrupt_command
+    LibGems::Commands.send :remove_const, :InterruptCommand if
+      LibGems::Commands.const_defined? :InterruptCommand
+  end
+
+end
+