rubygems-update 2.6.0 → 3.4.22

data/test/rubygems/test_gem_version.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
-require 'rubygems/test_case'
+
+require_relative "helper"
 require "rubygems/version"
 
 class TestGemVersion < Gem::TestCase
-
   class V < ::Gem::Version
   end
 
@@ -33,17 +33,36 @@ class TestGemVersion < Gem::TestCase
   def test_class_create
     real = Gem::Version.new(1.0)
 
-    assert_same  real, Gem::Version.create(real)
-    assert_nil   Gem::Version.create(nil)
+    assert_same real, Gem::Version.create(real)
+
+    expected = "nil versions are discouraged and will be deprecated in Rubygems 4\n"
+    actual_stdout, actual_stderr = capture_output do
+      assert_nil Gem::Version.create(nil)
+    end
+    assert_empty actual_stdout
+    assert_equal(expected, actual_stderr)
+
     assert_equal v("5.1"), Gem::Version.create("5.1")
 
-    ver = '1.1'.freeze
-    assert_equal v('1.1'), Gem::Version.create(ver)
+    ver = "1.1"
+    assert_equal v("1.1"), Gem::Version.create(ver)
+  end
+
+  def test_class_correct
+    assert_equal true,  Gem::Version.correct?("5.1")
+    assert_equal false, Gem::Version.correct?("an incorrect version")
+
+    expected = "nil versions are discouraged and will be deprecated in Rubygems 4\n"
+    actual_stdout, actual_stderr = capture_output do
+      Gem::Version.correct?(nil)
+    end
+    assert_empty actual_stdout
+    assert_equal(expected, actual_stderr)
   end
 
   def test_class_new_subclass
-    v1 = Gem::Version.new '1'
-    v2 = V.new '1'
+    v1 = Gem::Version.new "1"
+    v2 = V.new "1"
 
     refute_same v1, v2
   end
@@ -65,29 +84,41 @@ class TestGemVersion < Gem::TestCase
   def test_hash
     assert_equal v("1.2").hash, v("1.2").hash
     refute_equal v("1.2").hash, v("1.3").hash
-    refute_equal v("1.2").hash, v("1.2.0").hash
+    assert_equal v("1.2").hash, v("1.2.0").hash
+    assert_equal v("1.2.pre.1").hash, v("1.2.0.pre.1.0").hash
   end
 
   def test_initialize
-    ["1.0", "1.0 ", " 1.0 ", "1.0\n", "\n1.0\n", "1.0".freeze].each do |good|
+    ["1.0", "1.0 ", " 1.0 ", "1.0\n", "\n1.0\n", "1.0"].each do |good|
       assert_version_equal "1.0", good
     end
 
     assert_version_equal "1", 1
   end
 
-  def test_initialize_bad
-    %W[
+  def test_initialize_invalid
+    invalid_versions = %W[
       junk
       1.0\n2.0
       1..2
       1.2\ 3.4
-    ].each do |bad|
-      e = assert_raises ArgumentError, bad do
-        Gem::Version.new bad
+    ]
+
+    # DON'T TOUCH THIS WITHOUT CHECKING CVE-2013-4287
+    invalid_versions << "2.3422222.222.222222222.22222.ads0as.dasd0.ddd2222.2.qd3e."
+
+    invalid_versions.each do |invalid|
+      e = assert_raise ArgumentError, invalid do
+        Gem::Version.new invalid
       end
 
-      assert_equal "Malformed version number string #{bad}", e.message, bad
+      assert_equal "Malformed version number string #{invalid}", e.message, invalid
+    end
+  end
+
+  def test_empty_version
+    ["", "   ", " "].each do |empty|
+      assert_equal "0", Gem::Version.new(empty).version
     end
   end
 
@@ -97,7 +128,10 @@ class TestGemVersion < Gem::TestCase
     assert_prerelease "22.1.50.0.d"
     assert_prerelease "1.2.d.42"
 
-    assert_prerelease '1.A'
+    assert_prerelease "1.A"
+
+    assert_prerelease "1-1"
+    assert_prerelease "1-a"
 
     refute_prerelease "1.2.0"
     refute_prerelease "2.9"
@@ -112,25 +146,50 @@ class TestGemVersion < Gem::TestCase
   end
 
   def test_spaceship
-    assert_equal( 0, v("1.0")       <=> v("1.0.0"))
-    assert_equal( 1, v("1.0")       <=> v("1.0.a"))
-    assert_equal( 1, v("1.8.2")     <=> v("0.0.0"))
-    assert_equal( 1, v("1.8.2")     <=> v("1.8.2.a"))
-    assert_equal( 1, v("1.8.2.b")   <=> v("1.8.2.a"))
-    assert_equal(-1, v("1.8.2.a")   <=> v("1.8.2"))
-    assert_equal( 1, v("1.8.2.a10") <=> v("1.8.2.a9"))
-    assert_equal( 0, v("")          <=> v("0"))
+    assert_equal(0, v("1.0")       <=> v("1.0.0"))
+    assert_equal(1, v("1.0")       <=> v("1.0.a"))
+    assert_equal(1, v("1.8.2")     <=> v("0.0.0"))
+    assert_equal(1, v("1.8.2")     <=> v("1.8.2.a"))
+    assert_equal(1, v("1.8.2.b")   <=> v("1.8.2.a"))
+    assert_equal(-1, v("1.8.2.a") <=> v("1.8.2"))
+    assert_equal(1, v("1.8.2.a10") <=> v("1.8.2.a9"))
+    assert_equal(0, v("")          <=> v("0"))
+
+    assert_equal(0, v("0.beta.1")  <=> v("0.0.beta.1"))
+    assert_equal(-1, v("0.0.beta")  <=> v("0.0.beta.1"))
+    assert_equal(-1, v("0.0.beta")  <=> v("0.beta.1"))
+
+    assert_equal(-1, v("5.a") <=> v("5.0.0.rc2"))
+    assert_equal(1, v("5.x") <=> v("5.0.0.rc2"))
+
+    assert_equal(0, v("1.9.3")  <=> "1.9.3")
+    assert_equal(1, v("1.9.3")  <=> "1.9.2.99")
+    assert_equal(-1, v("1.9.3") <=> "1.9.3.1")
 
     assert_nil v("1.0") <=> "whatever"
   end
 
   def test_approximate_recommendation
     assert_approximate_equal "~> 1.0", "1"
+    assert_approximate_satisfies_itself "1"
+
     assert_approximate_equal "~> 1.0", "1.0"
+    assert_approximate_satisfies_itself "1.0"
+
     assert_approximate_equal "~> 1.2", "1.2"
+    assert_approximate_satisfies_itself "1.2"
+
     assert_approximate_equal "~> 1.2", "1.2.0"
+    assert_approximate_satisfies_itself "1.2.0"
+
     assert_approximate_equal "~> 1.2", "1.2.3"
-    assert_approximate_equal "~> 1.2", "1.2.3.a.4"
+    assert_approximate_satisfies_itself "1.2.3"
+
+    assert_approximate_equal "~> 1.2.a", "1.2.3.a.4"
+    assert_approximate_satisfies_itself "1.2.3.a.4"
+
+    assert_approximate_equal "~> 1.9.a", "1.9.0.dev"
+    assert_approximate_satisfies_itself "1.9.0.dev"
   end
 
   def test_to_s
@@ -148,52 +207,75 @@ class TestGemVersion < Gem::TestCase
 
   # modifying the segments of a version should not affect the segments of the cached version object
   def test_segments
-    v('9.8.7').segments[2] += 1
+    v("9.8.7").segments[2] += 1
 
     refute_version_equal "9.8.8", "9.8.7"
     assert_equal         [9,8,7], v("9.8.7").segments
   end
 
+  def test_canonical_segments
+    assert_equal [1], v("1.0.0").canonical_segments
+    assert_equal [1, "a", 1], v("1.0.0.a.1.0").canonical_segments
+    assert_equal [1, 2, 3, "pre", 1], v("1.2.3-1").canonical_segments
+  end
+
+  def test_frozen_version
+    v = v("1.freeze.test").freeze
+    assert_less_than v, v("1")
+    assert_version_equal v("1"), v.release
+    assert_version_equal v("2"), v.bump
+  end
+
   # Asserts that +version+ is a prerelease.
 
-  def assert_prerelease version
+  def assert_prerelease(version)
     assert v(version).prerelease?, "#{version} is a prerelease"
   end
 
-  # Assert that +expected+ is the "approximate" recommendation for +version".
+  # Assert that +expected+ is the "approximate" recommendation for +version+.
 
-  def assert_approximate_equal expected, version
+  def assert_approximate_equal(expected, version)
     assert_equal expected, v(version).approximate_recommendation
   end
 
+  # Assert that the "approximate" recommendation for +version+ satisfies +version+.
+
+  def assert_approximate_satisfies_itself(version)
+    gem_version = v(version)
+
+    assert Gem::Requirement.new(gem_version.approximate_recommendation).satisfied_by?(gem_version)
+  end
+
   # Assert that bumping the +unbumped+ version yields the +expected+.
 
-  def assert_bumped_version_equal expected, unbumped
+  def assert_bumped_version_equal(expected, unbumped)
     assert_version_equal expected, v(unbumped).bump
   end
 
   # Assert that +release+ is the correct non-prerelease +version+.
 
-  def assert_release_equal release, version
+  def assert_release_equal(release, version)
     assert_version_equal release, v(version).release
   end
 
   # Assert that two versions are equal. Handles strings or
   # Gem::Version instances.
 
-  def assert_version_equal expected, actual
+  def assert_version_equal(expected, actual)
     assert_equal v(expected), v(actual)
+    assert_equal v(expected).hash, v(actual).hash, "since #{actual} == #{expected}, they must have the same hash"
   end
 
   # Assert that two versions are eql?. Checks both directions.
 
-  def assert_version_eql first, second
-    first, second = v(first), v(second)
+  def assert_version_eql(first, second)
+    first = v(first)
+    second = v(second)
     assert first.eql?(second), "#{first} is eql? #{second}"
     assert second.eql?(first), "#{second} is eql? #{first}"
   end
 
-  def assert_less_than left, right
+  def assert_less_than(left, right)
     l = v(left)
     r = v(right)
     assert l < r, "#{left} not less than #{right}"
@@ -201,22 +283,23 @@ class TestGemVersion < Gem::TestCase
 
   # Refute the assumption that +version+ is a prerelease.
 
-  def refute_prerelease version
+  def refute_prerelease(version)
     refute v(version).prerelease?, "#{version} is NOT a prerelease"
   end
 
   # Refute the assumption that two versions are eql?. Checks both
   # directions.
 
-  def refute_version_eql first, second
-    first, second = v(first), v(second)
+  def refute_version_eql(first, second)
+    first = v(first)
+    second = v(second)
     refute first.eql?(second), "#{first} is NOT eql? #{second}"
     refute second.eql?(first), "#{second} is NOT eql? #{first}"
   end
 
   # Refute the assumption that the two versions are equal?.
 
-  def refute_version_equal unexpected, actual
+  def refute_version_equal(unexpected, actual)
     refute_equal v(unexpected), v(actual)
   end
 end

data/test/rubygems/test_gem_version_option.rb

@@ -1,14 +1,14 @@
 # frozen_string_literal: true
-require 'rubygems/test_case'
-require 'rubygems/command'
-require 'rubygems/version_option'
 
-class TestGemVersionOption < Gem::TestCase
+require_relative "helper"
+require "rubygems/command"
+require "rubygems/version_option"
 
+class TestGemVersionOption < Gem::TestCase
   def setup
     super
 
-    @cmd = Gem::Command.new 'dummy', 'dummy'
+    @cmd = Gem::Command.new "dummy", "dummy"
     @cmd.extend Gem::VersionOption
   end
 
@@ -44,8 +44,8 @@ class TestGemVersionOption < Gem::TestCase
 
     expected = [
       Gem::Platform::RUBY,
-      Gem::Platform.new('x86-freebsd6'),
-      Gem::Platform.new('x86-freebsd7'),
+      Gem::Platform.new("x86-freebsd6"),
+      Gem::Platform.new("x86-freebsd7"),
     ]
 
     assert_equal expected, Gem.platforms
@@ -57,7 +57,7 @@ class TestGemVersionOption < Gem::TestCase
     @cmd.handle_options %w[--platform ruby]
 
     expected = [
-      Gem::Platform::RUBY
+      Gem::Platform::RUBY,
     ]
 
     assert_equal expected, Gem.platforms
@@ -70,7 +70,7 @@ class TestGemVersionOption < Gem::TestCase
 
     expected = [
       Gem::Platform::RUBY,
-      Gem::Platform.new('x86-freebsd6'),
+      Gem::Platform.new("x86-freebsd6"),
     ]
 
     assert_equal expected, Gem.platforms
@@ -85,7 +85,7 @@ class TestGemVersionOption < Gem::TestCase
       :args => [],
       :explicit_prerelease => false,
       :prerelease => false,
-      :version => Gem::Requirement.new('> 1'),
+      :version => Gem::Requirement.new("> 1"),
     }
 
     assert_equal expected, @cmd.options
@@ -94,13 +94,28 @@ class TestGemVersionOption < Gem::TestCase
   def test_version_option_compound
     @cmd.add_version_option
 
-    @cmd.handle_options ['--version', '< 1, > 0.9']
+    @cmd.handle_options ["--version", "< 1, > 0.9"]
 
     expected = {
       :args => [],
       :explicit_prerelease => false,
       :prerelease => false,
-      :version => Gem::Requirement.new('< 1', '> 0.9'),
+      :version => Gem::Requirement.new("< 1", "> 0.9"),
+    }
+
+    assert_equal expected, @cmd.options
+  end
+
+  def test_multiple_version_operator_option_compound
+    @cmd.add_version_option
+
+    @cmd.handle_options ["--version", "< 1", "--version", "> 0.9"]
+
+    expected = {
+      :args => [],
+      :explicit_prerelease => false,
+      :prerelease => false,
+      :version => Gem::Requirement.new("< 1", "> 0.9"),
     }
 
     assert_equal expected, @cmd.options
@@ -116,7 +131,7 @@ class TestGemVersionOption < Gem::TestCase
       :args => [],
       :explicit_prerelease => true,
       :prerelease => true,
-      :version => Gem::Requirement.new('> 1'),
+      :version => Gem::Requirement.new("> 1"),
     }
 
     assert_equal expected, @cmd.options
@@ -131,7 +146,7 @@ class TestGemVersionOption < Gem::TestCase
       :args => [],
       :explicit_prerelease => false,
       :prerelease => true,
-      :version => Gem::Requirement.new('> 1.a'),
+      :version => Gem::Requirement.new("> 1.a"),
     }
 
     assert_equal expected, @cmd.options
@@ -142,11 +157,9 @@ class TestGemVersionOption < Gem::TestCase
       :args => [],
       :explicit_prerelease => false,
       :prerelease => false,
-      :version => Gem::Requirement.new('> 1'),
+      :version => Gem::Requirement.new("> 1"),
     }
 
     assert_equal expected, @cmd.options
   end
-
 end
-

data/test/rubygems/test_kernel.rb

@@ -1,86 +1,124 @@
 # frozen_string_literal: true
-require 'rubygems/test_case'
 
-class TestKernel < Gem::TestCase
+require_relative "helper"
 
+class TestGemKernel < Gem::TestCase
   def setup
     super
 
-    @old_path = $:.dup
-
     util_make_gems
-  end
 
-  def teardown
-    super
-
-    $:.replace @old_path
+    without_any_upwards_gemfiles
   end
 
   def test_gem
-    assert gem('a', '= 1'), "Should load"
-    assert $:.any? { |p| %r{a-1/lib} =~ p }
+    assert gem("a", "= 1"), "Should load"
+    assert $:.any? {|p| p.include?("a-1/lib") }
   end
 
   def test_gem_default
-    assert gem('a', '>= 0')
+    assert gem("a", ">= 0")
 
-    assert_equal @a2, Gem.loaded_specs['a']
+    assert_equal @a2, Gem.loaded_specs["a"]
   end
 
   def test_gem_default_re_gem
-    assert gem('a', '=1')
+    assert gem("a", "=1")
 
-    refute gem('a', '>= 0')
+    refute gem("a", ">= 0")
 
-    assert_equal @a1, Gem.loaded_specs['a']
+    assert_equal @a1, Gem.loaded_specs["a"]
   end
 
   def test_gem_re_gem_mismatch
-    assert gem('a', '=1')
+    assert gem("a", "=1")
 
-    assert_raises Gem::LoadError do
-      gem('a', '= 2')
+    assert_raise Gem::LoadError do
+      gem("a", "= 2")
     end
 
-    assert_equal @a1, Gem.loaded_specs['a']
+    assert_equal @a1, Gem.loaded_specs["a"]
   end
 
   def test_gem_redundant
-    assert gem('a', '= 1'), "Should load"
-    refute gem('a', '= 1'), "Should not load"
-    assert_equal 1, $:.select { |p| %r{a-1/lib} =~ p }.size
+    assert gem("a", "= 1"), "Should load"
+    refute gem("a", "= 1"), "Should not load"
+    assert_equal 1, $:.select {|p| p.include?("a-1/lib") }.size
   end
 
   def test_gem_overlapping
-    assert gem('a', '= 1'), "Should load"
-    refute gem('a', '>= 1'), "Should not load"
-    assert_equal 1, $:.select { |p| %r{a-1/lib} =~ p }.size
+    assert gem("a", "= 1"), "Should load"
+    refute gem("a", ">= 1"), "Should not load"
+    assert_equal 1, $:.select {|p| p.include?("a-1/lib") }.size
   end
 
   def test_gem_prerelease
-    quick_gem 'd', '1.1.a'
-    refute gem('d', '>= 1'),   'release requirement must not load prerelease'
-    assert gem('d', '>= 1.a'), 'prerelease requirement may load prerelease'
+    quick_gem "d", "1.1.a"
+    refute gem("d", ">= 1"),   "release requirement must not load prerelease"
+    assert gem("d", ">= 1.a"), "prerelease requirement may load prerelease"
+  end
+
+  def test_gem_env_req
+    ENV["GEM_REQUIREMENT_A"] = "~> 2.0"
+    assert_raise(Gem::MissingSpecVersionError) { gem("a", "= 1") }
+    assert gem("a", "> 1")
+    assert_equal @a2, Gem.loaded_specs["a"]
   end
 
   def test_gem_conflicting
-    assert gem('a', '= 1'), "Should load"
+    assert gem("a", "= 1"), "Should load"
 
-    ex = assert_raises Gem::LoadError do
-      gem 'a', '= 2'
+    ex = assert_raise Gem::LoadError do
+      gem "a", "= 2"
     end
 
     assert_equal "can't activate a-2, already activated a-1", ex.message
     assert_match(/activated a-1/, ex.message)
-    assert_equal 'a', ex.name
+    assert_equal "a", ex.name
 
-    assert $:.any? { |p| %r{a-1/lib} =~ p }
-    refute $:.any? { |p| %r{a-2/lib} =~ p }
+    assert $:.any? {|p| p.include?("a-1/lib") }
+    refute $:.any? {|p| p.include?("a-2/lib") }
   end
 
   def test_gem_not_adding_bin
-    assert gem('a', '= 1'), "Should load"
-    refute $:.any? { |p| %r{a-1/bin} =~ p }
+    assert gem("a", "= 1"), "Should load"
+    refute $:.any? {|p| p.include?("a-1/bin") }
+  end
+
+  def test_gem_failing_inside_require_doesnt_cause_double_exceptions
+    File.write("activate.rb", "gem('a', '= 999')\n")
+
+    require "open3"
+
+    output, _ = Open3.capture2e(
+      { "GEM_HOME" => Gem.paths.home },
+      *ruby_with_rubygems_in_load_path,
+      "-r",
+      "./activate.rb"
+    )
+
+    load_errors = output.split("\n").select {|line| line.include?("Could not find") }
+
+    assert_equal 1, load_errors.size
+  end
+
+  def test_gem_bundler
+    quick_gem "bundler", "1"
+    quick_gem "bundler", "2.a"
+
+    assert gem("bundler")
+    assert $:.any? {|p| p.include?("bundler-1/lib") }
+  end
+
+  def test_gem_bundler_inferred_bundler_version
+    require "rubygems/bundler_version_finder"
+
+    Gem::BundlerVersionFinder.stub(:bundler_version, Gem::Version.new("1")) do
+      quick_gem "bundler", "1"
+      quick_gem "bundler", "2.a"
+
+      assert gem("bundler", ">= 0.a")
+      assert $:.any? {|p| p.include?("bundler-1/lib") }
+    end
   end
 end

data/test/rubygems/test_project_sanity.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative "helper"
+require "open3"
+
+class TestGemProjectSanity < Gem::TestCase
+  def setup
+  end
+
+  def teardown
+  end
+
+  def test_manifest_is_up_to_date
+    pend unless File.exist?("#{root}/Rakefile")
+
+    _, status = Open3.capture2e("rake check_manifest")
+
+    unless status.success?
+      original_contents = File.read("#{root}/Manifest.txt")
+
+      # Update the manifest to see if it fixes the problem
+      Open3.capture2e("rake update_manifest")
+
+      out, status = Open3.capture2e("rake check_manifest")
+
+      # If `rake update_manifest` fixed the problem, that was the original
+      # issue, otherwise it was an unknown error, so print the error output
+      if status.success?
+        File.write("#{root}/Manifest.txt", original_contents)
+
+        raise "Expected Manifest.txt to be up to date, but it's not. Run `rake update_manifest` to sync it."
+      else
+        raise "There was an error running `rake check_manifest`: #{out}"
+      end
+    end
+  end
+
+  def test_require_rubygems_package
+    err, status = Open3.capture2e(*ruby_with_rubygems_in_load_path, "--disable-gems", "-e", "require \"rubygems/package\"")
+
+    assert status.success?, err
+  end
+
+  private
+
+  def root
+    File.expand_path("../..", __dir__)
+  end
+end

data/test/rubygems/test_remote_fetch_error.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative "helper"
+
+class TestGemRemoteFetchError < Gem::TestCase
+  def test_password_redacted
+    error = Gem::RemoteFetcher::FetchError.new("There was an error fetching", "https://user:secret@gemsource.org")
+    refute_match %r{secret}, error.to_s
+  end
+
+  def test_invalid_url
+    error = Gem::RemoteFetcher::FetchError.new("There was an error fetching", "https://::gemsource.org")
+    assert_equal error.to_s, "There was an error fetching (https://::gemsource.org)"
+  end
+
+  def test_to_s
+    error = Gem::RemoteFetcher::FetchError.new("There was an error fetching", "https://gemsource.org")
+    assert_equal error.to_s, "There was an error fetching (https://gemsource.org)"
+  end
+end