# class Gem::TestCase

RubyGemTestCase provides a variety of methods for testing rubygems and gem-related behavior in a sandbox. Through RubyGemTestCase you can install and uninstall gems, fetch remote gems through a stub fetcher and be assured your normal set of gems is not affected.

Tests are always run at a safe level of 1.

### Public Class Methods

make_command() click to toggle source

Returns the make command for the current platform. For versions of Ruby built on MS Windows with VC++ or Borland it will return 'nmake'. On all other platforms, including Cygwin, it will return 'make'.

    # File lib/rubygems/test_case.rb, line 1247
    def self.make_command
      ENV["make"] || ENV["MAKE"] || (vc_windows? ? 'nmake' : 'make')
    end

process_based_port() click to toggle source

Allows tests to use a random (but controlled) port number instead of a hardcoded one. This helps CI tools when running parallels builds on the same builder slave.

    # File lib/rubygems/test_case.rb, line 1280
    def self.process_based_port
      @@process_based_port ||= 8000 + $$ % 1000
    end

rubybin() click to toggle source

Finds the path to the Ruby executable

    # File lib/rubygems/test_case.rb, line 1313
    def self.rubybin
      ruby = ENV["RUBY"]
      return ruby if ruby
      ruby = "ruby"
      rubyexe = "#{ruby}.exe"

      3.times do
        if File.exist? ruby and File.executable? ruby and !File.directory? ruby
          return File.expand_path(ruby)
        end
        if File.exist? rubyexe and File.executable? rubyexe
          return File.expand_path(rubyexe)
        end
        ruby = File.join("..", ruby)
      end

      begin
        require "rbconfig"
        File.join(RbConfig::CONFIG["bindir"],
                  RbConfig::CONFIG["ruby_install_name"] +
                  RbConfig::CONFIG["EXEEXT"])
      rescue LoadError
        "ruby"
      end
    end

vc_windows?() click to toggle source

Returns whether or not we're on a version of Ruby built with VC++ (or Borland) versus Cygwin, Mingw, etc.

    # File lib/rubygems/test_case.rb, line 1230
    def self.vc_windows?
      RUBY_PLATFORM.match('mswin')
    end

win_platform?() click to toggle source

Is this test being run on a Windows platform?

    # File lib/rubygems/test_case.rb, line 1215
    def self.win_platform?
      Gem.win_platform?
    end

### Public Instance Methods

add_to_fetcher(spec, path=nil, repo=@gem_repo) click to toggle source

Add `spec` to +@fetcher+ serving the data in the file `path`. `repo` indicates which repo to make `spec` appear to be in.

    # File lib/rubygems/test_case.rb, line 1092
    def add_to_fetcher(spec, path=nil, repo=@gem_repo)
      path ||= spec.cache_file
      @fetcher.data["#{@gem_repo}gems/#{spec.file_name}"] = read_binary(path)
    end

all_spec_names() click to toggle source

    # File lib/rubygems/test_case.rb, line 662
    def all_spec_names
      Gem::Specification.map(&:full_name)
    end

ask_if_ok(spec) click to toggle source

    # File lib/rubygems/test_case.rb, line 603
    def ask_if_ok(spec)
      true
    end

assert_activate(expected, *specs) click to toggle source

    # File lib/rubygems/test_case.rb, line 118
    def assert_activate(expected, *specs)
      specs.each do |spec|
        case spec
        when String then
          Gem::Specification.find_by_name(spec).activate
        when Gem::Specification then
          spec.activate
        else
          flunk spec.inspect
        end
      end

      loaded = Gem.loaded_specs.values.map(&:full_name)

      assert_equal expected.sort, loaded.sort if expected
    end

assert_contains_make_command(target, output, msg = nil) { |make, line| ... } click to toggle source

    # File lib/rubygems/test_case.rb, line 192
    def assert_contains_make_command(target, output, msg = nil)
      if output.match(/\n/)
        msg = message(msg) {
          'Expected output containing make command "%s": %s' % [
            ('%s %s' % [make_command, target]).rstrip,
            output.inspect
          ]
        }
      else
        msg = message(msg) {
          'Expected make command "%s": %s' % [
            ('%s %s' % [make_command, target]).rstrip,
            output.inspect
          ]
        }
      end

      assert scan_make_command_lines(output).any? { |line|
        make = parse_make_command_line(line)

        if make[:targets].include?(target)
          yield make, line if block_given?
          true
        else
          false
        end
      }, msg
    end

assert_path_exists(path, msg = nil) click to toggle source

TODO: move to minitest

    # File lib/rubygems/test_case.rb, line 136
    def assert_path_exists(path, msg = nil)
      msg = message(msg) { "Expected path '#{path}' to exist" }
      assert File.exist?(path), msg
    end

build_rake_in(good=true) { |rake| ... } click to toggle source

Allows the proper version of `rake` to be used for the test.

    # File lib/rubygems/test_case.rb, line 1294
    def build_rake_in(good=true)
      gem_ruby = Gem.ruby
      Gem.ruby = @@ruby
      env_rake = ENV["rake"]
      rake = (good ? @@good_rake : @@bad_rake)
      ENV["rake"] = rake
      yield rake
    ensure
      Gem.ruby = gem_ruby
      if env_rake
        ENV["rake"] = env_rake
      else
        ENV.delete("rake")
      end
    end

common_installer_setup() click to toggle source

    # File lib/rubygems/test_case.rb, line 474
    def common_installer_setup
      common_installer_teardown

      Gem.post_build do |installer|
        @post_build_hook_arg = installer
        true
      end

      Gem.post_install do |installer|
        @post_install_hook_arg = installer
      end

      Gem.post_uninstall do |uninstaller|
        @post_uninstall_hook_arg = uninstaller
      end

      Gem.pre_install do |installer|
        @pre_install_hook_arg = installer
        true
      end

      Gem.pre_uninstall do |uninstaller|
        @pre_uninstall_hook_arg = uninstaller
      end
    end

common_installer_teardown() click to toggle source

    # File lib/rubygems/test_case.rb, line 500
    def common_installer_teardown
      Gem.post_build_hooks.clear
      Gem.post_install_hooks.clear
      Gem.done_installing_hooks.clear
      Gem.post_reset_hooks.clear
      Gem.post_uninstall_hooks.clear
      Gem.pre_install_hooks.clear
      Gem.pre_reset_hooks.clear
      Gem.pre_uninstall_hooks.clear
    end

create_tmpdir() click to toggle source

creates a temporary directory with hax TODO: deprecate and remove

    # File lib/rubygems/test_case.rb, line 613
    def create_tmpdir
      tmpdir = nil
      Dir.chdir Dir.tmpdir do tmpdir = Dir.pwd end # HACK OSX /private/tmp
      tmpdir = File.join tmpdir, "test_rubygems_#{$$}"
      FileUtils.mkdir_p tmpdir
      return tmpdir
    end

enable_shared(value) { || ... } click to toggle source

Sets the ENABLE_SHARED entry in RbConfig::CONFIG to `value` and restores the original value when the block ends

    # File lib/rubygems/test_case.rb, line 145
    def enable_shared(value)
      enable_shared = RbConfig::CONFIG['ENABLE_SHARED']
      RbConfig::CONFIG['ENABLE_SHARED'] = value

      yield
    ensure
      if enable_shared
        RbConfig::CONFIG['enable_shared'] = enable_shared
      else
        RbConfig::CONFIG.delete 'enable_shared'
      end
    end

git_gem(name = 'a', version = 1) { |specification| ... } click to toggle source

A `git_gem` is used with a gem dependencies file. The gem created here has no files, just a gem specification for the given `name` and `version`.

Yields the `specification` to the block, if given

    # File lib/rubygems/test_case.rb, line 517
    def git_gem(name = 'a', version = 1)
      have_git?

      directory = File.join 'git', name
      directory = File.expand_path directory

      git_spec = Gem::Specification.new name, version do |specification|
        yield specification if block_given?
      end

      FileUtils.mkdir_p directory

      gemspec = "#{name}.gemspec"

      File.open File.join(directory, gemspec), 'w' do |io|
        io.write git_spec.to_ruby
      end

      head = nil

      Dir.chdir directory do
        unless File.exist? '.git'
          system @git, 'init', '--quiet'
          system @git, 'config', 'user.name',  'RubyGems Tests'
          system @git, 'config', 'user.email', 'rubygems@example'
        end

        system @git, 'add', gemspec
        system @git, 'commit', '-a', '-m', 'a non-empty commit message', '--quiet'
        head = Gem::Util.popen(@git, 'rev-parse', 'master').strip
      end

      return name, git_spec.version, directory, head
    end

have_git?() click to toggle source

Skips this test unless you have a git executable

    # File lib/rubygems/test_case.rb, line 555
    def have_git?
      return if in_path? @git

      skip 'cannot find git executable, use GIT environment variable to set'
    end

install_default_gems(*specs) click to toggle source

Installs the provided default specs including writing the spec file

    # File lib/rubygems/test_case.rb, line 768
    def install_default_gems(*specs)
      install_default_specs(*specs)

      specs.each do |spec|
        File.open spec.loaded_from, 'w' do |io|
          io.write spec.to_ruby_for_cache
        end
      end
    end

install_default_specs(*specs) click to toggle source

Install the provided default specs

    # File lib/rubygems/test_case.rb, line 781
    def install_default_specs(*specs)
      specs.each do |spec|
        installer = Gem::Installer.for_spec(spec, :install_as_default => true)
        installer.install
        Gem.register_default_spec(spec)
      end
    end

install_gem(spec, options = {}) click to toggle source

Builds and installs the `Gem::Specification` `spec`

    # File lib/rubygems/test_case.rb, line 572
    def install_gem(spec, options = {})
      require 'rubygems/installer'

      gem = File.join @tempdir, "gems", "#{spec.full_name}.gem"

      unless File.exist? gem
        use_ui Gem::MockGemUi.new do
          Dir.chdir @tempdir do
            Gem::Package.build spec
          end
        end

        gem = File.join(@tempdir, File.basename(spec.cache_file)).untaint
      end

      Gem::Installer.at(gem, options.merge({:wrappers => true})).install
    end

install_gem_user(spec) click to toggle source

Builds and installs the `Gem::Specification` `spec` into the user dir

    # File lib/rubygems/test_case.rb, line 593
    def install_gem_user(spec)
      install_gem spec, :user_install => true
    end

install_specs(*specs) click to toggle source

Install the provided specs

    # File lib/rubygems/test_case.rb, line 757
    def install_specs(*specs)
      specs.each do |spec|
        Gem::Installer.for_spec(spec).install
      end

      Gem.searcher = nil
    end

loaded_spec_names() click to toggle source

    # File lib/rubygems/test_case.rb, line 789
    def loaded_spec_names
      Gem.loaded_specs.values.map(&:full_name).sort
    end

make_command() click to toggle source

Returns the make command for the current platform. For versions of Ruby built on MS Windows with VC++ or Borland it will return 'nmake'. On all other platforms, including Cygwin, it will return 'make'.

    # File lib/rubygems/test_case.rb, line 1256
    def make_command
      ENV["make"] || ENV["MAKE"] || (vc_windows? ? 'nmake' : 'make')
    end

mu_pp(obj) click to toggle source

Enables pretty-print for all tests

    # File lib/rubygems/test_case.rb, line 624
    def mu_pp(obj)
      s = String.new
      s = PP.pp obj, s
      s = s.force_encoding(Encoding.default_external)
      s.chomp
    end

new_default_spec(name, version, deps = nil, *files) click to toggle source

    # File lib/rubygems/test_case.rb, line 853
    def new_default_spec(name, version, deps = nil, *files)
      spec = util_spec name, version, deps

      spec.loaded_from = File.join(@default_spec_dir, spec.spec_name)
      spec.files = files

      lib_dir = File.join(@tempdir, "default_gems", "lib")
      $LOAD_PATH.unshift(lib_dir)
      files.each do |file|
        rb_path = File.join(lib_dir, file)
        FileUtils.mkdir_p(File.dirname(rb_path))
        File.open(rb_path, "w") do |rb|
          rb << "# #{file}"
        end
      end

      spec
    end

nmake_found?() click to toggle source

Returns whether or not the nmake command could be found.

    # File lib/rubygems/test_case.rb, line 1263
    def nmake_found?
      system('nmake /? 1>NUL 2>&1')
    end

parse_make_command_line(line) click to toggle source

    # File lib/rubygems/test_case.rb, line 168
    def parse_make_command_line(line)
      command, *args = line.shellsplit

      targets = []
      macros = {}

      args.each do |arg|
        case arg
        when /\A(\w+)=/
          macros[$1] = $'
        else
          targets << arg
        end
      end

      targets << '' if targets.empty?

      {
        :command => command,
        :targets => targets,
        :macros => macros,
      }
    end

process_based_port() click to toggle source

See `::process_based_port`

    # File lib/rubygems/test_case.rb, line 1287
    def process_based_port
      self.class.process_based_port
    end

quick_gem(name, version='2') { |s| ... } click to toggle source

Creates a `Gem::Specification` with a minimum of extra work. `name` and `version` are the gem's name and version, platform, author, email, homepage, summary and description are defaulted. The specification is yielded for customization.

The gem is added to the installed gems in +@gemhome+ and the runtime.

Use this with `write_file` to build an installed gem.

    # File lib/rubygems/test_case.rb, line 676
    def quick_gem(name, version='2')
      require 'rubygems/specification'

      spec = Gem::Specification.new do |s|
        s.platform    = Gem::Platform::RUBY
        s.name        = name
        s.version     = version
        s.author      = 'A User'
        s.email       = 'example@example.com'
        s.homepage    = 'http://example.com'
        s.summary     = "this is a summary"
        s.description = "This is a test description"

        yield(s) if block_given?
      end

      Gem::Specification.map # HACK: force specs to (re-)load before we write

      written_path = write_file spec.spec_file do |io|
        io.write spec.to_ruby_for_cache
      end

      spec.loaded_from = spec.loaded_from = written_path

      Gem::Specification.reset

      return spec
    end

read_binary(path) click to toggle source

Reads a binary file at `path`

    # File lib/rubygems/test_case.rb, line 643
    def read_binary(path)
      Gem.read_binary path
    end

read_cache(path) click to toggle source

Reads a `Marshal` file at `path`

    # File lib/rubygems/test_case.rb, line 634
    def read_cache(path)
      File.open path.dup.untaint, 'rb' do |io|
        Marshal.load io.read
      end
    end

refute_path_exists(path, msg = nil) click to toggle source

TODO: move to minitest

    # File lib/rubygems/test_case.rb, line 159
    def refute_path_exists(path, msg = nil)
      msg = message(msg) { "Expected path '#{path}' to not exist" }
      refute File.exist?(path), msg
    end

save_loaded_features() { || ... } click to toggle source

    # File lib/rubygems/test_case.rb, line 797
    def save_loaded_features
      old_loaded_features = $LOADED_FEATURES.dup
      yield
    ensure
      prefix = File.dirname(__FILE__) + "/"
      new_features = ($LOADED_FEATURES - old_loaded_features)
      old_loaded_features.concat(new_features.select {|f| f.rindex(prefix, 0)})
      $LOADED_FEATURES.replace old_loaded_features
    end

scan_make_command_lines(output) click to toggle source

    # File lib/rubygems/test_case.rb, line 164
    def scan_make_command_lines(output)
      output.scan(/^#{Regexp.escape make_command}(?:[[:blank:]].*)?$/)
    end

setup() click to toggle source

`setup` prepares a sandboxed location to install gems. All installs are directed to a temporary directory. All install plugins are removed.

If the `RUBY` environment variable is set the given path is used for `Gem::ruby`. The local platform is set to `i386-mswin32` for Windows or `i686-darwin8.10.1` otherwise.

If the `KEEP_FILES` environment variable is set the files will not be removed from `/tmp/test_rubygems_#{$$}.#{Time.now.to_i}`.

Calls superclass method

    # File lib/rubygems/test_case.rb, line 241
    def setup
      super

      @orig_gem_home   = ENV['GEM_HOME']
      @orig_gem_path   = ENV['GEM_PATH']
      @orig_gem_vendor = ENV['GEM_VENDOR']
      @orig_gem_spec_cache = ENV['GEM_SPEC_CACHE']
      @orig_rubygems_gemdeps = ENV['RUBYGEMS_GEMDEPS']
      @orig_bundle_gemfile   = ENV['BUNDLE_GEMFILE']
      @orig_rubygems_host = ENV['RUBYGEMS_HOST']
      ENV.keys.find_all { |k| k.start_with?('GEM_REQUIREMENT_') }.each do |k|
        ENV.delete k
      end
      @orig_gem_env_requirements = ENV.to_hash

      ENV['GEM_VENDOR'] = nil
      ENV['SOURCE_DATE_EPOCH'] = nil

      @current_dir = Dir.pwd
      @fetcher     = nil

      if Gem::USE_BUNDLER_FOR_GEMDEPS
        Bundler.ui                     = Bundler::UI::Silent.new
      end
      @back_ui                       = Gem::DefaultUserInteraction.ui
      @ui                            = Gem::MockGemUi.new
      # This needs to be a new instance since we call use_ui(@ui) when we want to
      # capture output
      Gem::DefaultUserInteraction.ui = Gem::MockGemUi.new

      tmpdir = File.expand_path Dir.tmpdir
      tmpdir.untaint

      if ENV['KEEP_FILES']
        @tempdir = File.join(tmpdir, "test_rubygems_#{$$}.#{Time.now.to_i}")
      else
        @tempdir = File.join(tmpdir, "test_rubygems_#{$$}")
      end
      @tempdir.untaint

      FileUtils.mkdir_p @tempdir

      # This makes the tempdir consistent on OS X.
      # File.expand_path Dir.tmpdir                      #=> "/var/..."
      # Dir.chdir Dir.tmpdir do File.expand_path '.' end #=> "/private/var/..."
      # TODO use File#realpath above instead of #expand_path once 1.8 support is
      # dropped.
      Dir.chdir @tempdir do
        @tempdir = File.expand_path '.'
        @tempdir.untaint
      end

      # This makes the tempdir consistent on Windows.
      # Dir.tmpdir may return short path name, but Dir[Dir.tmpdir] returns long
      # path name. https://bugs.ruby-lang.org/issues/10819
      # File.expand_path or File.realpath doesn't convert path name to long path
      # name. Only Dir[] (= Dir.glob) works.
      # Short and long path name is specific to Windows filesystem.
      if win_platform?
        @tempdir = Dir[@tempdir][0]
        @tempdir.untaint
      end

      @gemhome  = File.join @tempdir, 'gemhome'
      @userhome = File.join @tempdir, 'userhome'
      ENV["GEM_SPEC_CACHE"] = File.join @tempdir, 'spec_cache'

      @orig_ruby = if ENV['RUBY']
                     ruby = Gem.ruby
                     Gem.ruby = ENV['RUBY']
                     ruby
                   end

      @git = ENV['GIT'] || 'git'

      Gem.ensure_gem_subdirectories @gemhome

      @orig_LOAD_PATH = $LOAD_PATH.dup
      $LOAD_PATH.map! { |s|
        expand_path = File.expand_path(s)
        if expand_path != s
          expand_path.untaint
          if s.instance_variable_defined?(:@gem_prelude_index)
            expand_path.instance_variable_set(:@gem_prelude_index, expand_path)
          end
          expand_path.freeze if s.frozen?
          s = expand_path
        end
        s
      }

      Dir.chdir @tempdir

      @orig_ENV_HOME = ENV['HOME']
      ENV['HOME'] = @userhome
      Gem.instance_variable_set :@user_home, nil
      Gem.instance_variable_set :@gemdeps, nil
      Gem.instance_variable_set :@env_requirements_by_name, nil
      Gem.send :remove_instance_variable, :@ruby_version if
        Gem.instance_variables.include? :@ruby_version

      FileUtils.mkdir_p @gemhome
      FileUtils.mkdir_p @userhome

      @orig_gem_private_key_passphrase = ENV['GEM_PRIVATE_KEY_PASSPHRASE']
      ENV['GEM_PRIVATE_KEY_PASSPHRASE'] = PRIVATE_KEY_PASSPHRASE

      @default_dir = File.join @tempdir, 'default'
      @default_spec_dir = File.join @default_dir, "specifications", "default"
      Gem.instance_variable_set :@default_dir, @default_dir
      FileUtils.mkdir_p @default_spec_dir

      # We use Gem::Specification.reset the first time only so that if there
      # are unresolved deps that leak into the whole test suite, they're at least
      # reported once.
      if @@initial_reset
        Gem::Specification.unresolved_deps.clear # done to avoid cross-test warnings
      else
        @@initial_reset = true
        Gem::Specification.reset
      end
      Gem.use_paths(@gemhome)

      Gem::Security.reset

      Gem.loaded_specs.clear
      Gem.clear_default_specs
      Gem::Specification.unresolved_deps.clear
      if Gem::USE_BUNDLER_FOR_GEMDEPS
        Bundler.reset!
      end

      Gem.configuration.verbose = true
      Gem.configuration.update_sources = true

      Gem::RemoteFetcher.fetcher = Gem::FakeFetcher.new

      @gem_repo = "http://gems.example.com/"
      @uri = URI.parse @gem_repo
      Gem.sources.replace [@gem_repo]

      Gem.searcher = nil
      Gem::SpecFetcher.fetcher = nil
      @orig_BASERUBY = RbConfig::CONFIG['BASERUBY']
      RbConfig::CONFIG['BASERUBY'] = RbConfig::CONFIG['ruby_install_name']

      @orig_arch = RbConfig::CONFIG['arch']

      if win_platform?
        util_set_arch 'i386-mswin32'
      else
        util_set_arch 'i686-darwin8.10.1'
      end

      @orig_hooks = {}
      %w[post_install_hooks done_installing_hooks post_uninstall_hooks pre_uninstall_hooks pre_install_hooks pre_reset_hooks post_reset_hooks post_build_hooks].each do |name|
        @orig_hooks[name] = Gem.send(name).dup
      end

      @marshal_version = "#{Marshal::MAJOR_VERSION}.#{Marshal::MINOR_VERSION}"
      @orig_LOADED_FEATURES = $LOADED_FEATURES.dup
    end

teardown() click to toggle source

`teardown` restores the process to its original state and removes the tempdir unless the `KEEP_FILES` environment variable was set.

    # File lib/rubygems/test_case.rb, line 408
    def teardown
      $LOAD_PATH.replace @orig_LOAD_PATH if @orig_LOAD_PATH
      if @orig_LOADED_FEATURES
        if @orig_LOAD_PATH
          paths = @orig_LOAD_PATH.map {|path| File.join(File.expand_path(path), "/")}
          ($LOADED_FEATURES - @orig_LOADED_FEATURES).each do |feat|
            unless paths.any? {|path| feat.start_with?(path)}
              $LOADED_FEATURES.delete(feat)
            end
          end
        else
          $LOADED_FEATURES.replace @orig_LOADED_FEATURES
        end
      end

      if @orig_BASERUBY
        RbConfig::CONFIG['BASERUBY'] = @orig_BASERUBY
      else
        RbConfig::CONFIG.delete('BASERUBY')
      end
      RbConfig::CONFIG['arch'] = @orig_arch

      if defined? Gem::RemoteFetcher
        Gem::RemoteFetcher.fetcher = nil
      end

      Dir.chdir @current_dir

      FileUtils.rm_rf @tempdir unless ENV['KEEP_FILES']

      ENV.clear
      @orig_gem_env_requirements.each do |k,v|
        ENV[k] = v
      end

      ENV['GEM_HOME']   = @orig_gem_home
      ENV['GEM_PATH']   = @orig_gem_path
      ENV['GEM_VENDOR'] = @orig_gem_vendor
      ENV['GEM_SPEC_CACHE'] = @orig_gem_spec_cache
      ENV['RUBYGEMS_GEMDEPS'] = @orig_rubygems_gemdeps
      ENV['BUNDLE_GEMFILE']   = @orig_bundle_gemfile
      ENV['RUBYGEMS_HOST'] = @orig_rubygems_host

      Gem.ruby = @orig_ruby if @orig_ruby

      if @orig_ENV_HOME
        ENV['HOME'] = @orig_ENV_HOME
      else
        ENV.delete 'HOME'
      end

      Gem.instance_variable_set :@default_dir, nil

      ENV['GEM_PRIVATE_KEY_PASSPHRASE'] = @orig_gem_private_key_passphrase

      Gem::Specification._clear_load_cache
      Gem::Specification.unresolved_deps.clear
      Gem::refresh

      @orig_hooks.each do |name, hooks|
        Gem.send(name).replace hooks
      end

      @back_ui.close
    end

uninstall_gem(spec) click to toggle source

Uninstalls the `Gem::Specification` `spec`

    # File lib/rubygems/test_case.rb, line 599
    def uninstall_gem(spec)
      require 'rubygems/uninstaller'

      Class.new(Gem::Uninstaller) {
        def ask_if_ok(spec)
          true
        end
      }.new(spec.name, :executables => true, :user_install => true).uninstall
    end

unresolved_names() click to toggle source

    # File lib/rubygems/test_case.rb, line 793
    def unresolved_names
      Gem::Specification.unresolved_deps.values.map(&:to_s).sort
    end

util_build_gem(spec) click to toggle source

Builds a gem from `spec` and places it in `File.join @gemhome, 'cache'`. Automatically creates files based on `spec.files`

    # File lib/rubygems/test_case.rb, line 718
    def util_build_gem(spec)
      dir = spec.gem_dir
      FileUtils.mkdir_p dir

      Dir.chdir dir do
        spec.files.each do |file|
          next if File.exist? file
          FileUtils.mkdir_p File.dirname(file)
          File.open file, 'w' do |fp| fp.puts "# #{file}" end
        end

        use_ui Gem::MockGemUi.new do
          Gem::Package.build spec
        end

        cache = spec.cache_file
        FileUtils.mv File.basename(cache), cache
      end
    end

util_clear_RUBY_VERSION() click to toggle source

    # File lib/rubygems/test_case.rb, line 1203
    def util_clear_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.send :remove_const, :RUBY_DESCRIPTION    if defined?(RUBY_DESCRIPTION)
      Object.send :remove_const, :RUBY_ENGINE
      Object.send :remove_const, :RUBY_ENGINE_VERSION if defined?(RUBY_ENGINE_VERSION)
    end

util_clear_gems() click to toggle source

Removes all installed gems from +@gemhome+.

    # File lib/rubygems/test_case.rb, line 746
    def util_clear_gems
      FileUtils.rm_rf File.join(@gemhome, "gems") # TODO: use Gem::Dirs
      FileUtils.mkdir File.join(@gemhome, "gems")
      FileUtils.rm_rf File.join(@gemhome, "specifications")
      FileUtils.mkdir File.join(@gemhome, "specifications")
      Gem::Specification.reset
    end

util_gem(name, version, deps = nil, &block) click to toggle source

Creates a gem with `name`, `version` and `deps`. The specification will be yielded before gem creation for customization. The gem will be placed in `File.join @tempdir, 'gems'`. The specification and .gem file location are returned.

    # File lib/rubygems/test_case.rb, line 926
    def util_gem(name, version, deps = nil, &block)
      # TODO: deprecate
      raise "deps or block, not both" if deps and block

      if deps
        block = proc do |s|
          # Since Hash#each is unordered in 1.8, sort
          # the keys and iterate that way so the tests are
          # deterministic on all implementations.
          deps.keys.sort.each do |n|
            s.add_dependency n, (deps[n] || '>= 0')
          end
        end
      end

      spec = quick_gem(name, version, &block)

      util_build_gem spec

      cache_file = File.join @tempdir, 'gems', "#{spec.original_name}.gem"
      FileUtils.mkdir_p File.dirname cache_file
      FileUtils.mv spec.cache_file, cache_file
      FileUtils.rm spec.spec_file

      spec.loaded_from = nil

      [spec, cache_file]
    end

util_gzip(data) click to toggle source

Gzips `data`.

    # File lib/rubygems/test_case.rb, line 958
    def util_gzip(data)
      out = StringIO.new

      Zlib::GzipWriter.wrap out do |io|
        io.write data
      end

      out.string
    end

util_make_gems(prerelease = false) click to toggle source

Creates several default gems which all have a lib/code.rb file. The gems are not installed but are available in the cache dir.

+@a1+

  gem a version 1, this is the best-described gem.

+@a2+

  gem a version 2

+@a3a

  gem a version 3.a

+@a_evil9+

  gem a_evil version 9, use this to ensure similarly-named gems don't collide with a.

+@b2+

  gem b version 2

+@c1_2+

  gem c version 1.2

+@pl1+

  gem pl version 1, this gem has a legacy platform of i386-linux.

Additional `prerelease` gems may also be created:

+@a2_pre+

  gem a version 2.a

TODO: nuke this and fix tests. this should speed up a lot

    # File lib/rubygems/test_case.rb, line 986
      def util_make_gems(prerelease = false)
        @a1 = quick_gem 'a', '1' do |s|
          s.files = %w[lib/code.rb]
          s.require_paths = %w[lib]
          s.date = Gem::Specification::TODAY - 86400
          s.homepage = 'http://a.example.com'
          s.email = %w[example@example.com example2@example.com]
          s.authors = %w[Example Example2]
          s.description = <<-DESC
    This line is really, really long.  So long, in fact, that it is more than eighty characters long!  The purpose of this line is for testing wrapping behavior because sometimes people don't wrap their text to eighty characters.  Without the wrapping, the text might not look good in the RSS feed.

    Also, a list:
      * An entry that\'s actually kind of sort
      * an entry that\'s really long, which will probably get wrapped funny.  That's ok, somebody wasn't thinking straight when they made it more than eighty characters.
          DESC
        end

        init = proc do |s|
          s.files = %w[lib/code.rb]
          s.require_paths = %w[lib]
        end

        @a2      = quick_gem('a', '2',      &init)
        @a3a     = quick_gem('a', '3.a',    &init)
        @a_evil9 = quick_gem('a_evil', '9', &init)
        @b2      = quick_gem('b', '2',      &init)
        @c1_2    = quick_gem('c', '1.2',    &init)
        @x       = quick_gem('x', '1',      &init)
        @dep_x   = quick_gem('dep_x', '1') do |s|
          s.files = %w[lib/code.rb]
          s.require_paths = %w[lib]
          s.add_dependency 'x', '>= 1'
        end

        @pl1     = quick_gem 'pl', '1' do |s| # l for legacy
          s.files = %w[lib/code.rb]
          s.require_paths = %w[lib]
          s.platform = Gem::Platform.new 'i386-linux'
          s.instance_variable_set :@original_platform, 'i386-linux'
        end

        if prerelease
          @a2_pre = quick_gem('a', '2.a', &init)
          write_file File.join(*%W[gems #{@a2_pre.original_name} lib code.rb])
          util_build_gem @a2_pre
        end

        write_file File.join(*%W[gems #{@a1.original_name}      lib code.rb])
        write_file File.join(*%W[gems #{@a2.original_name}      lib code.rb])
        write_file File.join(*%W[gems #{@a3a.original_name}     lib code.rb])
        write_file File.join(*%W[gems #{@a_evil9.original_name} lib code.rb])
        write_file File.join(*%W[gems #{@b2.original_name}      lib code.rb])
        write_file File.join(*%W[gems #{@c1_2.original_name}    lib code.rb])
        write_file File.join(*%W[gems #{@pl1.original_name}     lib code.rb])
        write_file File.join(*%W[gems #{@x.original_name}       lib code.rb])
        write_file File.join(*%W[gems #{@dep_x.original_name}   lib code.rb])

        [@a1, @a2, @a3a, @a_evil9, @b2, @c1_2, @pl1, @x, @dep_x].each do |spec|
          util_build_gem spec
        end

        FileUtils.rm_r File.join(@gemhome, "gems", @pl1.original_name)
      end

util_remove_gem(spec) click to toggle source

    # File lib/rubygems/test_case.rb, line 738
    def util_remove_gem(spec)
      FileUtils.rm_rf spec.cache_file
      FileUtils.rm_rf spec.spec_file
    end

util_restore_RUBY_VERSION() click to toggle source

    # File lib/rubygems/test_case.rb, line 1188
    def util_restore_RUBY_VERSION
      util_clear_RUBY_VERSION

      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)
      Object.const_set :RUBY_DESCRIPTION,    @RUBY_DESCRIPTION if
        defined?(@RUBY_DESCRIPTION)
      Object.const_set :RUBY_ENGINE,         @RUBY_ENGINE
      Object.const_set :RUBY_ENGINE_VERSION, @RUBY_ENGINE_VERSION if
        defined?(@RUBY_ENGINE_VERSION)
    end

util_set_RUBY_VERSION(version, patchlevel = nil, revision = nil, description = nil, engine = "ruby", engine_version = nil) click to toggle source

    # File lib/rubygems/test_case.rb, line 1165
    def util_set_RUBY_VERSION(version, patchlevel = nil, revision = nil, description = nil, engine = "ruby", engine_version = nil)
      if Gem.instance_variables.include? :@ruby_version or
         Gem.instance_variables.include? '@ruby_version'
        Gem.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)
      @RUBY_DESCRIPTION    = RUBY_DESCRIPTION    if defined?(RUBY_DESCRIPTION)
      @RUBY_ENGINE         = RUBY_ENGINE
      @RUBY_ENGINE_VERSION = RUBY_ENGINE_VERSION if defined?(RUBY_ENGINE_VERSION)

      util_clear_RUBY_VERSION

      Object.const_set :RUBY_VERSION,        version
      Object.const_set :RUBY_PATCHLEVEL,     patchlevel     if patchlevel
      Object.const_set :RUBY_REVISION,       revision       if revision
      Object.const_set :RUBY_DESCRIPTION,    description    if description
      Object.const_set :RUBY_ENGINE,         engine
      Object.const_set :RUBY_ENGINE_VERSION, engine_version if engine_version
    end

util_set_arch(arch) click to toggle source

`Set` the platform to `arch`

    # File lib/rubygems/test_case.rb, line 1053
    def util_set_arch(arch)
      RbConfig::CONFIG['arch'] = arch
      platform = Gem::Platform.new arch

      Gem.instance_variable_set :@platforms, nil
      Gem::Platform.instance_variable_set :@local, nil

      platform
    end

util_setup_fake_fetcher(prerelease = false) click to toggle source

Sets up a fake fetcher using the gems from `util_make_gems`. Optionally additional `prerelease` gems may be included.

Gems created by this method may be fetched using `Gem::RemoteFetcher`.

    # File lib/rubygems/test_case.rb, line 1069
    def util_setup_fake_fetcher(prerelease = false)
      require 'zlib'
      require 'socket'
      require 'rubygems/remote_fetcher'

      @fetcher = Gem::FakeFetcher.new

      util_make_gems(prerelease)
      Gem::Specification.reset

      @all_gems = [@a1, @a2, @a3a, @a_evil9, @b2, @c1_2].sort
      @all_gem_names = @all_gems.map { |gem| gem.full_name }

      gem_names = [@a1.full_name, @a2.full_name, @a3a.full_name, @b2.full_name]
      @gem_names = gem_names.sort.join("\n")

      Gem::RemoteFetcher.fetcher = @fetcher
    end

util_setup_spec_fetcher(*specs) click to toggle source

Sets up `Gem::SpecFetcher` to return information from the gems in `specs`. Best used with +@all_gems+ from `util_setup_fake_fetcher`.

    # File lib/rubygems/test_case.rb, line 1101
    def util_setup_spec_fetcher(*specs)
      all_specs = Gem::Specification.to_a + specs
      Gem::Specification._resort! all_specs

      spec_fetcher = Gem::SpecFetcher.fetcher

      prerelease, all = all_specs.partition { |spec| spec.version.prerelease?  }
      latest = Gem::Specification._latest_specs all_specs

      spec_fetcher.specs[@uri] = []
      all.each do |spec|
        spec_fetcher.specs[@uri] << spec.name_tuple
      end

      spec_fetcher.latest_specs[@uri] = []
      latest.each do |spec|
        spec_fetcher.latest_specs[@uri] << spec.name_tuple
      end

      spec_fetcher.prerelease_specs[@uri] = []
      prerelease.each do |spec|
        spec_fetcher.prerelease_specs[@uri] << spec.name_tuple
      end

      # HACK for test_download_to_cache
      unless Gem::RemoteFetcher === @fetcher
        v = Gem.marshal_version

        specs = all.map { |spec| spec.name_tuple }
        s_zip = util_gzip Marshal.dump Gem::NameTuple.to_basic specs

        latest_specs = latest.map do |spec|
          spec.name_tuple
        end

        l_zip = util_gzip Marshal.dump Gem::NameTuple.to_basic latest_specs

        prerelease_specs = prerelease.map { |spec| spec.name_tuple }
        p_zip = util_gzip Marshal.dump Gem::NameTuple.to_basic prerelease_specs

        @fetcher.data["#{@gem_repo}specs.#{v}.gz"]            = s_zip
        @fetcher.data["#{@gem_repo}latest_specs.#{v}.gz"]     = l_zip
        @fetcher.data["#{@gem_repo}prerelease_specs.#{v}.gz"] = p_zip

        v = Gem.marshal_version

        all_specs.each do |spec|
          path = "#{@gem_repo}quick/Marshal.#{v}/#{spec.original_name}.gemspec.rz"
          data = Marshal.dump spec
          data_deflate = Zlib::Deflate.deflate data
          @fetcher.data[path] = data_deflate
        end
      end

      nil # force errors
    end

util_spec(name, version = 2, deps = nil, *files) { |specification| ... } click to toggle source

Creates a spec with `name`, `version`. `deps` can specify the dependency or a `block` can be given for full customization of the specification.

    # File lib/rubygems/test_case.rb, line 876
    def util_spec(name, version = 2, deps = nil, *files) # :yields: specification
      raise "deps or block, not both" if deps and block_given?

      spec = Gem::Specification.new do |s|
        s.platform    = Gem::Platform::RUBY
        s.name        = name
        s.version     = version
        s.author      = 'A User'
        s.email       = 'example@example.com'
        s.homepage    = 'http://example.com'
        s.summary     = "this is a summary"
        s.description = "This is a test description"

        s.files.push(*files) unless files.empty?

        yield s if block_given?
      end

      if deps
        # Since Hash#each is unordered in 1.8, sort the keys and iterate that
        # way so the tests are deterministic on all implementations.
        deps.keys.sort.each do |n|
          spec.add_dependency n, (deps[n] || '>= 0')
        end
      end

      unless files.empty?
        write_file spec.spec_file do |io|
          io.write spec.to_ruby_for_cache
        end

        util_build_gem spec

        cache_file = File.join @tempdir, 'gems', "#{spec.full_name}.gem"
        FileUtils.mkdir_p File.dirname cache_file
        FileUtils.mv spec.cache_file, cache_file
        FileUtils.rm spec.spec_file
      end

      Gem::Specification.reset

      return spec
    end

util_zip(data) click to toggle source

Deflates `data`

    # File lib/rubygems/test_case.rb, line 1161
    def util_zip(data)
      Zlib::Deflate.deflate data
    end

vc_windows?() click to toggle source

Returns whether or not we're on a version of Ruby built with VC++ (or Borland) versus Cygwin, Mingw, etc.

    # File lib/rubygems/test_case.rb, line 1238
    def vc_windows?
      RUBY_PLATFORM.match('mswin')
    end

wait_for_child_process_to_exit() click to toggle source

In case we're building docs in a background process, this method waits for that process to exit (or if it's already been reaped, or never happened, swallows the Errno::ECHILD error).

    # File lib/rubygems/test_case.rb, line 1270
    def wait_for_child_process_to_exit
      Process.wait if Process.respond_to?(:fork)
    rescue Errno::ECHILD
    end

win_platform?() click to toggle source

Is this test being run on a Windows platform?

    # File lib/rubygems/test_case.rb, line 1222
    def win_platform?
      Gem.win_platform?
    end

write_file(path) { |io| ... } click to toggle source

Writes a binary file to `path` which is relative to +@gemhome+

    # File lib/rubygems/test_case.rb, line 650
    def write_file(path)
      path = File.join @gemhome, path unless Pathname.new(path).absolute?
      dir = File.dirname path
      FileUtils.mkdir_p dir unless File.directory? dir

      File.open path, 'wb' do |io|
        yield io if block_given?
      end

      path
    end