Class: Gem::TestCase (Ruby 2.2.3)
Description: Class : Gem::TestCase - Ruby 2.2.3

- Home
- Core 2.2.3
- Std-lib 2.2.3
- Downloads

Support for the Ruby 2.2 series has ended. See here for reference.

### Home Classes Methods

### In Files

- rubygems/test_case.rb
- rubygems/test_utilities.rb

### Parent

MiniTest::Unit::TestCase

### Namespace

- CLASS Gem::TestCase::SpecFetcherSetup
- CLASS Gem::TestCase::StaticSet

### Methods

- ::cert_path
- ::key_path
- ::load_cert
- ::load_key
- ::make_command
- ::process_based_port
- ::rubybin
- ::vc_windows?
- ::win_platform?
- #add_to_fetcher
- #all_spec_names
- #assert_activate
- #assert_contains_make_command
- #assert_path_exists
- #build_rake_in
- #common_installer_setup
- #common_installer_teardown
- #create_tmpdir
- #dep
- #dependency_request
- #enable_shared
- #git_gem
- #have_git?
- #install_default_gems
- #install_default_specs
- #install_gem
- #install_gem_user
- #install_specs
- #loaded_spec_names
- #make_command
- #mu_pp
- #new_default_spec
- #nmake_found?
- #parse_make_command_line
- #process_based_port
- #quick_gem
- #read_binary
- #read_cache
- #refute_path_exists
- #req
- #save_loaded_features
- #scan_make_command_lines
- #setup
- #spec
- #spec_fetcher
- #teardown
- #uninstall_gem
- #unresolved_names
- #util_build_gem
- #util_clear_gems
- #util_gem
- #util_gzip
- #util_make_gems
- #util_remove_gem
- #util_restore_RUBY_VERSION
- #util_set_RUBY_VERSION
- #util_set_arch
- #util_setup_fake_fetcher
- #util_setup_spec_fetcher
- #util_spec
- #util_zip
- #v
- #vc_windows?
- #vendor_gem
- #wait_for_child_process_to_exit
- #win_platform?
- #write_file

### Included Modules

- Gem::DefaultUserInteraction

### Class/Module Index

Quicksearch

- Gem::AvailableSet
- Gem::BasicSpecification
- Gem::Command
- Gem::CommandLineError
- Gem::CommandManager
- Gem::Commands
- Gem::Commands::BuildCommand
- Gem::Commands::CertCommand
- Gem::Commands::CheckCommand
- Gem::Commands::CleanupCommand
- Gem::Commands::ContentsCommand
- Gem::Commands::DependencyCommand
- Gem::Commands::EnvironmentCommand
- Gem::Commands::FetchCommand
- Gem::Commands::GenerateIndexCommand
- Gem::Commands::HelpCommand
- Gem::Commands::InstallCommand
- Gem::Commands::ListCommand
- Gem::Commands::LockCommand
- Gem::Commands::MirrorCommand
- Gem::Commands::OpenCommand
- Gem::Commands::OutdatedCommand
- Gem::Commands::OwnerCommand
- Gem::Commands::PristineCommand
- Gem::Commands::PushCommand
- Gem::Commands::QueryCommand
- Gem::Commands::RdocCommand
- Gem::Commands::SearchCommand
- Gem::Commands::ServerCommand
- Gem::Commands::SetupCommand
- Gem::Commands::SourcesCommand
- Gem::Commands::SpecificationCommand
- Gem::Commands::StaleCommand
- Gem::Commands::UninstallCommand
- Gem::Commands::UnpackCommand
- Gem::Commands::UpdateCommand
- Gem::Commands::WhichCommand
- Gem::Commands::YankCommand
- Gem::ConfigFile
- Gem::ConfigFile::Psych
- Gem::ConflictError
- Gem::ConsoleUI
- Gem::DefaultUserInteraction
- Gem::Dependency
- Gem::DependencyError
- Gem::DependencyInstaller
- Gem::DependencyList
- Gem::DependencyRemovalException
- Gem::DependencyResolutionError
- Gem::Deprecate
- Gem::Doctor
- Gem::DocumentError
- Gem::EndOfYAMLException
- Gem::ErrorReason
- Gem::Exception
- Gem::Ext
- Gem::Ext::BuildError
- Gem::Ext::Builder
- Gem::Ext::CmakeBuilder
- Gem::Ext::ConfigureBuilder
- Gem::Ext::ExtConfBuilder
- Gem::Ext::RakeBuilder
- Gem::FakeFetcher
- Gem::FilePermissionError
- Gem::FormatException
- Gem::GemNotFoundException
- Gem::GemNotInHomeException
- Gem::GemRunner
- Gem::GemcutterUtilities
- Gem::ImpossibleDependenciesError
- Gem::Indexer
- Gem::InstallError
- Gem::InstallUpdateOptions
- Gem::Installer
- Gem::InstallerTestCase
- Gem::InvalidSpecificationException
- Gem::List
- Gem::LoadError
- Gem::LocalRemoteOptions
- Gem::MockGemUi
- Gem::MockGemUi::InputEOFError
- Gem::MockGemUi::SystemExitException
- Gem::MockGemUi::TTY
- Gem::MockGemUi::TermError
- Gem::NameTuple
- Gem::NoAliasYAMLTree
- Gem::OperationNotSupportedError
- Gem::Package::DigestIO
- Gem::Package::Error
- Gem::Package::FormatError
- Gem::Package::NonSeekableIO
- Gem::Package::Old
- Gem::Package::PathError
- Gem::Package::TarHeader
- Gem::Package::TarInvalidError
- Gem::Package::TarReader
- Gem::Package::TarReader::Entry
- Gem::Package::TarReader::UnexpectedEOF
- Gem::Package::TarTestCase
- Gem::Package::TarWriter
- Gem::Package::TarWriter::BoundedStream
- Gem::Package::TarWriter::FileOverflow
- Gem::Package::TarWriter::RestrictedStream
- Gem::Package::TooLongFileName
- Gem::PackageTask
- Gem::PathSupport
- Gem::Platform
- Gem::PlatformMismatch
- Gem::RemoteError
- Gem::RemoteFetcher
- Gem::RemoteFetcher::FetchError
- Gem::RemoteFetcher::UnknownHostError
- Gem::RemoteInstallationCancelled
- Gem::RemoteInstallationSkipped
- Gem::RemoteSourceException
- Gem::Request::ConnectionPools
- Gem::Request::ConnectionPools::Net
- Gem::RequestSet
- Gem::RequestSet::GemDependencyAPI
- Gem::RequestSet::Lockfile
- Gem::RequestSet::Lockfile::ParseError
- Gem::Requirement
- Gem::Requirement::BadRequirementError
- Gem::Resolver
- Gem::Resolver::APISet
- Gem::Resolver::APISpecification
- Gem::Resolver::ActivationRequest
- Gem::Resolver::BestSet
- Gem::Resolver::ComposedSet
- Gem::Resolver::Conflict
- Gem::Resolver::CurrentSet
- Gem::Resolver::DependencyRequest
- Gem::Resolver::GitSet
- Gem::Resolver::GitSpecification
- Gem::Resolver::IndexSet
- Gem::Resolver::IndexSpecification
- Gem::Resolver::InstalledSpecification
- Gem::Resolver::InstallerSet
- Gem::Resolver::LocalSpecification
- Gem::Resolver::LockSet
- Gem::Resolver::LockSpecification
- Gem::Resolver::RequirementList
- Gem::Resolver::Set
- Gem::Resolver::SpecSpecification
- Gem::Resolver::Specification
- Gem::Resolver::Stats
- Gem::Resolver::VendorSet
- Gem::Resolver::VendorSpecification
- Gem::RubyVersionMismatch
- Gem::Security
- Gem::Security::Exception
- Gem::Security::Policy
- Gem::Security::Signer
- Gem::Security::TrustDir
- Gem::Server
- Gem::SilentUI
- Gem::Source
- Gem::Source::Git
- Gem::Source::Installed
- Gem::Source::Local
- Gem::Source::Lock
- Gem::Source::SpecificFile
- Gem::Source::Vendor
- Gem::SourceFetchProblem
- Gem::SourceList
- Gem::SpecFetcher
- Gem::SpecificGemNotFoundException
- Gem::Specification
- Gem::StreamUI
- Gem::StreamUI::SilentDownloadReporter
- Gem::StreamUI::SilentProgressReporter
- Gem::StreamUI::SimpleProgressReporter
- Gem::StreamUI::VerboseDownloadReporter
- Gem::StreamUI::VerboseProgressReporter
- Gem::StringSink
- Gem::StringSource
- Gem::StubSpecification
- Gem::SystemExitException
- Gem::TestCase
- Gem::TestCase::SpecFetcherSetup
- Gem::TestCase::StaticSet
- Gem::Text
- Gem::Uninstaller
- Gem::UnsatisfiableDependencyError
- Gem::UriFormatter
- Gem::UserInteraction
- Gem::Util
- Gem::Validator
- Gem::VerificationError
- Gem::Version
- Gem::VersionOption
- Kernel
- Object
- OpenSSL
- TempIO
- YAML::Syck
- YAML::Syck

No matching classes.

# 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 rubygems/test_case.rb, line 1374
    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 rubygems/test_case.rb, line 1400
    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 rubygems/test_case.rb, line 1362
    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 rubygems/test_case.rb, line 1389
    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 rubygems/test_case.rb, line 1104
    def self.make_command
      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 rubygems/test_case.rb, line 1137
    def self.process_based_port
      @@process_based_port ||= 8000 + $$ % 1000
    end

rubybin() click to toggle source

Finds the path to the Ruby executable

                   # File rubygems/test_case.rb, line 1170
    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 rubygems/test_case.rb, line 1087
    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 rubygems/test_case.rb, line 1072
    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 rubygems/test_case.rb, line 964
    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 rubygems/test_case.rb, line 557
    def all_spec_names
      Gem::Specification.map(&:full_name)
    end

assert_activate(expected, *specs) click to toggle source

                   # File rubygems/test_case.rb, line 95
    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) click to toggle source

                   # File rubygems/test_case.rb, line 169
    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 rubygems/test_case.rb, line 113
    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) click to toggle source

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

                   # File rubygems/test_case.rb, line 1151
    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 rubygems/test_case.rb, line 372
    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 rubygems/test_case.rb, line 398
    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 rubygems/test_case.rb, line 508
    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 rubygems/test_case.rb, line 1203
    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 rubygems/test_case.rb, line 1212
    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 rubygems/test_case.rb, line 122
    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) 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 rubygems/test_case.rb, line 415
    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"

      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 rubygems/test_case.rb, line 453
    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 rubygems/test_case.rb, line 658
    def install_default_gems(*specs)
      install_default_specs(*specs)

      specs.each do |spec|
        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 rubygems/test_case.rb, line 671
    def install_default_specs(*specs)
      install_specs(*specs)
      specs.each do |spec|
        Gem.register_default_spec(spec)
      end
    end

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

Builds and installs the Gem::Specification `spec`

                   # File rubygems/test_case.rb, line 470
    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.new(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 rubygems/test_case.rb, line 491
    def install_gem_user spec
      install_gem spec, :user_install => true
    end

install_specs(*specs) click to toggle source

Install the provided specs

                   # File rubygems/test_case.rb, line 650
    def install_specs(*specs)
      Gem::Specification.add_specs(*specs)
      Gem.searcher = nil
    end

loaded_spec_names() click to toggle source

                   # File rubygems/test_case.rb, line 678
    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 rubygems/test_case.rb, line 1113
    def make_command
      ENV["make"] || (vc_windows? ? 'nmake' : 'make')
    end

mu_pp(obj) click to toggle source

Enables pretty-print for all tests

                   # File rubygems/test_case.rb, line 519
    def mu_pp(obj)
      s = ''
      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 rubygems/test_case.rb, line 738
    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 rubygems/test_case.rb, line 1120
    def nmake_found?
      system('nmake /? 1>NUL 2>&1')
    end

parse_make_command_line(line) click to toggle source

                   # File rubygems/test_case.rb, line 145
    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 rubygems/test_case.rb, line 1144
    def process_based_port
      self.class.process_based_port
    end

quick_gem(name, version='2') 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 rubygems/test_case.rb, line 571
    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.add_spec spec.for_cache

      return spec
    end

read_binary(path) click to toggle source

Reads a binary file at `path`

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

read_cache(path) click to toggle source

Reads a Marshal file at `path`

                   # File rubygems/test_case.rb, line 529
    def read_cache(path)
      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 rubygems/test_case.rb, line 136
    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 rubygems/test_case.rb, line 1230
    def req *requirements
      return requirements.first if Gem::Requirement === requirements.first
      Gem::Requirement.create requirements
    end

save_loaded_features() click to toggle source

                   # File rubygems/test_case.rb, line 686
    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 rubygems/test_case.rb, line 141
    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}`.

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

      @orig_gem_home   = ENV['GEM_HOME']
      @orig_gem_path   = ENV['GEM_PATH']
      @orig_gem_vendor = ENV['GEM_VENDOR']

      ENV['GEM_VENDOR'] = nil

      @current_dir = Dir.pwd
      @fetcher     = nil
      @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

      @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| File.expand_path(s).untaint }

      Dir.chdir @tempdir

      @orig_ENV_HOME = ENV['HOME']
      ENV['HOME'] = @userhome
      Gem.instance_variable_set :@user_home, 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

      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}"
    end

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

Constructs a new Gem::Specification.

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

spec_fetcher(repository = @gem_repo) 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 rubygems/test_case.rb, line 1262
    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 rubygems/test_case.rb, line 335
    def teardown
      $LOAD_PATH.replace @orig_LOAD_PATH if @orig_LOAD_PATH

      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['GEM_HOME']   = @orig_gem_home
      ENV['GEM_PATH']   = @orig_gem_path
      ENV['GEM_VENDOR'] = @orig_gem_vendor

      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
    end

uninstall_gem(spec) click to toggle source

Uninstalls the Gem::Specification `spec`

                   # File rubygems/test_case.rb, line 497
    def uninstall_gem spec
      require 'rubygems/uninstaller'

      Gem::Uninstaller.new(spec.name,
                           :executables => true, :user_install => true).uninstall
    end

unresolved_names() click to toggle source

                   # File rubygems/test_case.rb, line 682
    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 rubygems/test_case.rb, line 611
    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 rubygems/test_case.rb, line 639
    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 rubygems/test_case.rb, line 798
    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 rubygems/test_case.rb, line 830
    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 rubygems/test_case.rb, line 858
      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 rubygems/test_case.rb, line 631
    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 rubygems/test_case.rb, line 1057
    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 rubygems/test_case.rb, line 1038
    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 rubygems/test_case.rb, line 925
    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 rubygems/test_case.rb, line 941
    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 rubygems/test_case.rb, line 973
    def util_setup_spec_fetcher(*specs)
      specs -= Gem::Specification._all
      Gem::Specification.add_specs(*specs)

      spec_fetcher = Gem::SpecFetcher.fetcher

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

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

      spec_fetcher.latest_specs[@uri] = []
      Gem::Specification.latest_specs.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 = Gem::Specification.latest_specs.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

        Gem::Specification.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) 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 rubygems/test_case.rb, line 761
    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

      spec.loaded_from = spec.spec_file

      Gem::Specification.add_spec spec

      return spec
    end

util_zip(data) click to toggle source

Deflates `data`

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

v(string) click to toggle source

Construct a new Gem::Version.

                   # File rubygems/test_case.rb, line 1271
    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 rubygems/test_case.rb, line 1095
    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 rubygems/test_case.rb, line 1281
    def vendor_gem name = 'a', version = 1
      directory = File.join 'vendor', name

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

      FileUtils.mkdir_p directory

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

      return name, vendor_spec.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 rubygems/test_case.rb, line 1127
    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 rubygems/test_case.rb, line 1079
    def win_platform?
      Gem.win_platform?
    end

write_file(path) click to toggle source

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

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

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

      path
    end