# 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

cert_path(cert_name) click to toggle source

Returns the path to the certificate named `cert_name` from `test/rubygems/`.

    # File lib/rubygems/test_case.rb, line 1449
    def self.cert_path cert_name
      if 32 == (Time.at(2**32) rescue 32) then
        cert_file =
          File.expand_path "../../../test/rubygems/#{cert_name}_cert_32.pem",
                           __FILE__

        return cert_file if File.exist? cert_file
      end

      File.expand_path "../../../test/rubygems/#{cert_name}_cert.pem", __FILE__
    end

key_path(key_name) click to toggle source

Returns the path to the key named `key_name` from `test/rubygems`

    # File lib/rubygems/test_case.rb, line 1475
    def self.key_path key_name
      File.expand_path "../../../test/rubygems/#{key_name}_key.pem", __FILE__
    end

load_cert(cert_name) click to toggle source

Loads certificate named `cert_name` from `test/rubygems/`.

    # File lib/rubygems/test_case.rb, line 1437
    def self.load_cert cert_name
      cert_file = cert_path cert_name

      cert = File.read cert_file

      OpenSSL::X509::Certificate.new cert
    end

load_key(key_name, passphrase = nil) click to toggle source

Loads an RSA private key named `key_name` with `passphrase` in `test/rubygems/`

    # File lib/rubygems/test_case.rb, line 1464
    def self.load_key key_name, passphrase = nil
      key_file = key_path key_name

      key = File.read key_file

      OpenSSL::PKey::RSA.new key, passphrase
    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 1169
    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 1202
    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 1235
    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 1152
    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 1137
    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 1030
    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 621
    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 562
    def ask_if_ok spec
      true
    end

assert_activate(expected, *specs) click to toggle source

    # File lib/rubygems/test_case.rb, line 96
    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 170
    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 114
    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 1216
    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 433
    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 459
    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 572
    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

dep(name, *requirements) click to toggle source

Construct a new Gem::Dependency.

    # File lib/rubygems/test_case.rb, line 1268
    def dep name, *requirements
      Gem::Dependency.new name, *requirements
    end

dependency_request(dep, from_name, from_version, parent = nil) click to toggle source

Constructs a Gem::Resolver::DependencyRequest from a Gem::Dependency `dep`, a `from_name` and `from_version` requesting the dependency and a `parent` DependencyRequest

    # File lib/rubygems/test_case.rb, line 1277
    def dependency_request dep, from_name, from_version, parent = nil
      remote = Gem::Source.new @uri

      unless parent then
        parent_dep = dep from_name, from_version
        parent = Gem::Resolver::DependencyRequest.new parent_dep, nil
      end

      spec = Gem::Resolver::IndexSpecification.new \
        nil, from_name, from_version, remote, Gem::Platform::RUBY
      activation = Gem::Resolver::ActivationRequest.new spec, parent

      Gem::Resolver::DependencyRequest.new dep, activation
    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 123
    def enable_shared value
      enable_shared = RbConfig::CONFIG['ENABLE_SHARED']
      RbConfig::CONFIG['ENABLE_SHARED'] = value

      yield
    ensure
      if enable_shared then
        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 476
    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' then
          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 514
    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 725
    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 738
    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 531
    def install_gem spec, options = {}
      require 'rubygems/installer'

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

      unless File.exist? gem then
        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 552
    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 714
    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 746
    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 1178
    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 583
    def mu_pp(obj)
      s = String.new
      s = PP.pp obj, s
      s = s.force_encoding(Encoding.default_external) if defined? Encoding
      s.chomp
    end

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

    # File lib/rubygems/test_case.rb, line 806
    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 1185
    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 146
    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 1209
    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 635
    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 602
    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 593
    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 137
    def refute_path_exists path, msg = nil
      msg = message(msg) { "Expected path '#{path}' to not exist" }
      refute File.exist?(path), msg
    end

req(*requirements) click to toggle source

Constructs a new Gem::Requirement.

    # File lib/rubygems/test_case.rb, line 1295
    def req *requirements
      return requirements.first if Gem::Requirement === requirements.first
      Gem::Requirement.create requirements
    end

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

create_gemspec creates gem specification in given `directory` or '.' for the given `name` and `version`.

Yields the `specification` to the block, if given

    # File lib/rubygems/test_case.rb, line 1360
    def save_gemspec name = 'a', version = 1, directory = '.'
      vendor_spec = Gem::Specification.new name, version do |specification|
        yield specification if block_given?
      end

      File.open File.join(directory, "#{name}.gemspec"), 'w' do |io|
        io.write vendor_spec.to_ruby
      end

      return name, vendor_spec.version, directory
    end

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

    # File lib/rubygems/test_case.rb, line 754
    def save_loaded_features
      old_loaded_features = $LOADED_FEATURES.dup
      yield
    ensure
      $LOADED_FEATURES.replace old_loaded_features
    end

scan_make_command_lines(output) click to toggle source

    # File lib/rubygems/test_case.rb, line 142
    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 219
    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

      @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'] then
        @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'] then
                     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)) == s ? s : expand_path.untaint
      }

      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

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

spec(name, version, &block) click to toggle source

Constructs a new Gem::Specification.

    # File lib/rubygems/test_case.rb, line 1303
    def spec name, version, &block
      Gem::Specification.new name, v(version), &block
    end

spec_fetcher(repository = @gem_repo) { |spec_fetcher_setup| ... } click to toggle source

Creates a SpecFetcher pre-filled with the gems or specs defined in the block.

Yields a `fetcher` object that responds to `spec` and `gem`. `spec` adds a specification to the SpecFetcher while `gem` adds both a specification and the gem data to the RemoteFetcher so the built gem can be downloaded.

If only the a-3 gem is supposed to be downloaded you can save setup time by creating only specs for the other versions:

    spec_fetcher do |fetcher|
      fetcher.spec 'a', 1
      fetcher.spec 'a', 2, 'b' => 3 # dependency on b = 3
      fetcher.gem 'a', 3 do |spec|
        # spec is a Gem::Specification
        # ...
      end
    end

    # File lib/rubygems/test_case.rb, line 1327
    def spec_fetcher repository = @gem_repo
      Gem::TestCase::SpecFetcherSetup.declare self, repository do |spec_fetcher_setup|
        yield spec_fetcher_setup if block_given?
      end
    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 371
    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 then
        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 then
        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

      @back_ui.close
    end

uninstall_gem(spec) click to toggle source

Uninstalls the Gem::Specification `spec`

    # File lib/rubygems/test_case.rb, line 558
    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 750
    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 675
    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_gems() click to toggle source

Removes all installed gems from +@gemhome+.

    # File lib/rubygems/test_case.rb, line 703
    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 864
    def util_gem(name, version, deps = nil, &block)
      # TODO: deprecate
      raise "deps or block, not both" if deps and block

      if deps then
        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 896
    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 924
      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 695
    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 1122
    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

util_set_RUBY_VERSION(version, patchlevel = nil, revision = nil) click to toggle source

    # File lib/rubygems/test_case.rb, line 1103
    def util_set_RUBY_VERSION(version, patchlevel = nil, revision = nil)
      if Gem.instance_variables.include? :@ruby_version or
         Gem.instance_variables.include? '@ruby_version' then
        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)

      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

util_set_arch(arch) click to toggle source

Set the platform to `arch`

    # File lib/rubygems/test_case.rb, line 991
    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 1007
    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 1039
    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 then
        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) { |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 829
    def util_spec name, version = 2, deps = nil # :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"

        yield s if block_given?
      end

      if deps then
        # 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

      Gem::Specification.reset

      return spec
    end

util_zip(data) click to toggle source

Deflates `data`

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

v(string) click to toggle source

Construct a new Gem::Version.

    # File lib/rubygems/test_case.rb, line 1336
    def v string
      Gem::Version.create string
    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 1160
    def vc_windows?
      RUBY_PLATFORM.match('mswin')
    end

vendor_gem(name = 'a', version = 1) click to toggle source

A #vendor_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 1346
    def vendor_gem name = 'a', version = 1
      directory = File.join 'vendor', name

      FileUtils.mkdir_p directory

      save_gemspec name, version, directory
    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 1192
    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 1144
    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 609
    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