rubygems-update 2.0.17 → 2.1.0.rc.1

data/test/rubygems/test_gem_package_old.rb

@@ -21,6 +21,8 @@ class TestGemPackageOld < Gem::TestCase
   end
 
   def test_contents_security_policy
+    skip 'openssl is missing' unless defined?(OpenSSL::SSL)
+
     @package.security_policy = Gem::Security::AlmostNoSecurity
 
     assert_raises Gem::Security::Exception do
@@ -40,6 +42,8 @@ class TestGemPackageOld < Gem::TestCase
   end
 
   def test_extract_files_security_policy
+    skip 'openssl is missing' unless defined?(OpenSSL::SSL)
+
     @package.security_policy = Gem::Security::AlmostNoSecurity
 
     assert_raises Gem::Security::Exception do
@@ -52,6 +56,8 @@ class TestGemPackageOld < Gem::TestCase
   end
 
   def test_spec_security_policy
+    skip 'openssl is missing' unless defined?(OpenSSL::SSL)
+
     @package.security_policy = Gem::Security::AlmostNoSecurity
 
     assert_raises Gem::Security::Exception do
@@ -60,6 +66,8 @@ class TestGemPackageOld < Gem::TestCase
   end
 
   def test_verify
+    skip 'openssl is missing' unless defined?(OpenSSL::SSL)
+
     assert @package.verify
 
     @package.security_policy = Gem::Security::NoSecurity

data/test/rubygems/test_gem_package_tar_reader.rb

@@ -4,8 +4,8 @@ require 'rubygems/package'
 class TestGemPackageTarReader < Gem::Package::TarTestCase
 
   def test_each_entry
-    tar = tar_dir_header "foo", "bar", 0
-    tar << tar_file_header("bar", "baz", 0, 0)
+    tar = tar_dir_header "foo", "bar", 0, Time.now
+    tar << tar_file_header("bar", "baz", 0, 0, Time.now)
 
     io = TempIO.new tar
 
@@ -25,8 +25,9 @@ class TestGemPackageTarReader < Gem::Package::TarTestCase
   def test_rewind
     content = ('a'..'z').to_a.join(" ")
 
-    str = tar_file_header("lib/foo", "", 010644, content.size) + content +
-            "\0" * (512 - content.size)
+    str =
+      tar_file_header("lib/foo", "", 010644, content.size, Time.now) +
+        content + "\0" * (512 - content.size)
     str << "\0" * 1024
 
     Gem::Package::TarReader.new(TempIO.new(str)) do |tar_reader|
@@ -43,8 +44,8 @@ class TestGemPackageTarReader < Gem::Package::TarTestCase
   end
 
   def test_seek
-    tar = tar_dir_header "foo", "bar", 0
-    tar << tar_file_header("bar", "baz", 0, 0)
+    tar = tar_dir_header "foo", "bar", 0, Time.now
+    tar << tar_file_header("bar", "baz", 0, 0, Time.now)
 
     io = TempIO.new tar
 
@@ -60,8 +61,8 @@ class TestGemPackageTarReader < Gem::Package::TarTestCase
   end
 
   def test_seek_missing
-    tar = tar_dir_header "foo", "bar", 0
-    tar << tar_file_header("bar", "baz", 0, 0)
+    tar = tar_dir_header "foo", "bar", 0, Time.now
+    tar << tar_file_header("bar", "baz", 0, 0, Time.now)
 
     io = TempIO.new tar
 

data/test/rubygems/test_gem_package_tar_reader_entry.rb

@@ -9,7 +9,7 @@ class TestGemPackageTarReaderEntry < Gem::Package::TarTestCase
     @contents = ('a'..'z').to_a.join * 100
 
     @tar = ''
-    @tar << tar_file_header("lib/foo", "", 0, @contents.size)
+    @tar << tar_file_header("lib/foo", "", 0, @contents.size, Time.now)
     @tar << @contents
     @tar << "\0" * (512 - (@tar.size % 512))
 

data/test/rubygems/test_gem_package_tar_writer.rb

@@ -1,5 +1,6 @@
 require 'rubygems/package/tar_test_case'
 require 'rubygems/package/tar_writer'
+require 'minitest/mock'
 
 class TestGemPackageTarWriter < Gem::Package::TarTestCase
 
@@ -18,112 +19,130 @@ class TestGemPackageTarWriter < Gem::Package::TarTestCase
   end
 
   def test_add_file
-    @tar_writer.add_file 'x', 0644 do |f| f.write 'a' * 10 end
+    Time.stub :now, Time.at(1458518157) do
+      @tar_writer.add_file 'x', 0644 do |f| f.write 'a' * 10 end
 
-    assert_headers_equal(tar_file_header('x', '', 0644, 10),
+      assert_headers_equal(tar_file_header('x', '', 0644, 10, Time.now),
                          @io.string[0, 512])
+    end
     assert_equal "aaaaaaaaaa#{"\0" * 502}", @io.string[512, 512]
     assert_equal 1024, @io.pos
   end
 
   def test_add_file_digest
-    digest_algorithms = OpenSSL::Digest::SHA1, OpenSSL::Digest::SHA512
+    digest_algorithms = Digest::SHA1, Digest::SHA512
 
-    digests = @tar_writer.add_file_digest 'x', 0644, digest_algorithms do |io|
-      io.write 'a' * 10
-    end
+    Time.stub :now, Time.at(1458518157) do
+      digests = @tar_writer.add_file_digest 'x', 0644, digest_algorithms do |io|
+        io.write 'a' * 10
+      end
 
-    assert_equal '3495ff69d34671d1e15b33a63c1379fdedd3a32a',
-                 digests['SHA1'].hexdigest
-    assert_equal '4714870aff6c97ca09d135834fdb58a6389a50c1' \
-                 '1fef8ec4afef466fb60a23ac6b7a9c92658f14df' \
-                 '4993d6b40a4e4d8424196afc347e97640d68de61' \
-                 'e1cf14b0',
-                 digests['SHA512'].hexdigest
+      assert_equal '3495ff69d34671d1e15b33a63c1379fdedd3a32a',
+                   digests['SHA1'].hexdigest
+      assert_equal '4714870aff6c97ca09d135834fdb58a6389a50c1' \
+                   '1fef8ec4afef466fb60a23ac6b7a9c92658f14df' \
+                   '4993d6b40a4e4d8424196afc347e97640d68de61' \
+                   'e1cf14b0',
+                   digests['SHA512'].hexdigest
 
-    assert_headers_equal(tar_file_header('x', '', 0644, 10),
+      assert_headers_equal(tar_file_header('x', '', 0644, 10, Time.now),
                          @io.string[0, 512])
+    end
     assert_equal "aaaaaaaaaa#{"\0" * 502}", @io.string[512, 512]
     assert_equal 1024, @io.pos
   end
 
   def test_add_file_digest_multiple
-    digest_algorithms = [OpenSSL::Digest::SHA1, OpenSSL::Digest::SHA512]
+    digest_algorithms = [Digest::SHA1, Digest::SHA512]
 
-    digests = @tar_writer.add_file_digest 'x', 0644, digest_algorithms do |io|
-      io.write 'a' * 10
-    end
+    Time.stub :now, Time.at(1458518157) do
+      digests = @tar_writer.add_file_digest 'x', 0644, digest_algorithms do |io|
+        io.write 'a' * 10
+      end
 
-    assert_equal '3495ff69d34671d1e15b33a63c1379fdedd3a32a',
-                 digests['SHA1'].hexdigest
-    assert_equal '4714870aff6c97ca09d135834fdb58a6389a50c1' \
-                 '1fef8ec4afef466fb60a23ac6b7a9c92658f14df' \
-                 '4993d6b40a4e4d8424196afc347e97640d68de61' \
-                 'e1cf14b0',
-                 digests['SHA512'].hexdigest
+      assert_equal '3495ff69d34671d1e15b33a63c1379fdedd3a32a',
+                   digests['SHA1'].hexdigest
+      assert_equal '4714870aff6c97ca09d135834fdb58a6389a50c1' \
+                   '1fef8ec4afef466fb60a23ac6b7a9c92658f14df' \
+                   '4993d6b40a4e4d8424196afc347e97640d68de61' \
+                   'e1cf14b0',
+                   digests['SHA512'].hexdigest
 
-    assert_headers_equal(tar_file_header('x', '', 0644, 10),
-                         @io.string[0, 512])
+      assert_headers_equal(tar_file_header('x', '', 0644, 10, Time.now),
+                           @io.string[0, 512])
+    end
     assert_equal "aaaaaaaaaa#{"\0" * 502}", @io.string[512, 512]
     assert_equal 1024, @io.pos
   end
 
   def test_add_file_signer
+    skip 'openssl is missing' unless defined?(OpenSSL::SSL)
+
     signer = Gem::Security::Signer.new PRIVATE_KEY, [PUBLIC_CERT]
 
-    @tar_writer.add_file_signed 'x', 0644, signer do |io|
-      io.write 'a' * 10
-    end
+    Time.stub :now, Time.at(1458518157) do
+      @tar_writer.add_file_signed 'x', 0644, signer do |io|
+        io.write 'a' * 10
+      end
+
+      assert_headers_equal(tar_file_header('x', '', 0644, 10, Time.now),
+                           @io.string[0, 512])
 
-    assert_headers_equal(tar_file_header('x', '', 0644, 10),
-                         @io.string[0, 512])
-    assert_equal "aaaaaaaaaa#{"\0" * 502}", @io.string[512, 512]
 
-    digest = signer.digest_algorithm.new
-    digest.update 'a' * 10
+      assert_equal "aaaaaaaaaa#{"\0" * 502}", @io.string[512, 512]
 
-    signature = signer.sign digest.digest
+      digest = signer.digest_algorithm.new
+      digest.update 'a' * 10
 
-    assert_headers_equal(tar_file_header('x.sig', '', 0444, signature.length),
-                         @io.string[1024, 512])
-    assert_equal "#{signature}#{"\0" * (512 - signature.length)}",
-                 @io.string[1536, 512]
+      signature = signer.sign digest.digest
+
+      assert_headers_equal(tar_file_header('x.sig', '', 0444, signature.length,
+                                           Time.now),
+                           @io.string[1024, 512])
+      assert_equal "#{signature}#{"\0" * (512 - signature.length)}",
+                   @io.string[1536, 512]
+
+      assert_equal 2048, @io.pos
+    end
 
-    assert_equal 2048, @io.pos
   end
 
   def test_add_file_signer_empty
     signer = Gem::Security::Signer.new nil, nil
 
-    @tar_writer.add_file_signed 'x', 0644, signer do |io|
-      io.write 'a' * 10
-    end
+    Time.stub :now, Time.at(1458518157) do
 
-    assert_headers_equal(tar_file_header('x', '', 0644, 10),
+      @tar_writer.add_file_signed 'x', 0644, signer do |io|
+        io.write 'a' * 10
+      end
+
+      assert_headers_equal(tar_file_header('x', '', 0644, 10, Time.now),
                          @io.string[0, 512])
+    end
     assert_equal "aaaaaaaaaa#{"\0" * 502}", @io.string[512, 512]
 
-    digest = signer.digest_algorithm.new
-    digest.update 'a' * 10
-
     assert_equal 1024, @io.pos
   end
 
   def test_add_file_simple
-    @tar_writer.add_file_simple 'x', 0644, 10 do |io| io.write "a" * 10 end
+    Time.stub :now, Time.at(1458518157) do
+      @tar_writer.add_file_simple 'x', 0644, 10 do |io| io.write "a" * 10 end
 
-    assert_headers_equal(tar_file_header('x', '', 0644, 10),
+      assert_headers_equal(tar_file_header('x', '', 0644, 10, Time.now),
                          @io.string[0, 512])
+    end
 
     assert_equal "aaaaaaaaaa#{"\0" * 502}", @io.string[512, 512]
     assert_equal 1024, @io.pos
   end
 
   def test_add_file_simple_padding
-    @tar_writer.add_file_simple 'x', 0, 100
+    Time.stub :now, Time.at(1458518157) do
+      @tar_writer.add_file_simple 'x', 0, 100
 
-    assert_headers_equal tar_file_header('x', '', 0, 100),
+      assert_headers_equal tar_file_header('x', '', 0, 100, Time.now),
                          @io.string[0, 512]
+    end
 
     assert_equal "\0" * 512, @io.string[512, 512]
   end
@@ -182,11 +201,14 @@ class TestGemPackageTarWriter < Gem::Package::TarTestCase
   end
 
   def test_mkdir
-    @tar_writer.mkdir 'foo', 0644
+    Time.stub :now, Time.at(1458518157) do
+      @tar_writer.mkdir 'foo', 0644
 
-    assert_headers_equal tar_dir_header('foo', '', 0644),
-                         @io.string[0, 512]
-    assert_equal 512, @io.pos
+      assert_headers_equal tar_dir_header('foo', '', 0644, Time.now),
+                           @io.string[0, 512]
+
+      assert_equal 512, @io.pos
+    end
   end
 
   def test_split_name

data/test/rubygems/test_gem_package_task.rb

@@ -4,37 +4,16 @@ require 'rubygems/package_task'
 
 class TestGemPackageTask < Gem::TestCase
 
-  def setup
-    super
-
-    Rake.application = Rake::Application.new
-    RakeFileUtils.verbose_flag = false
-  end
-
   def test_gem_package
     gem = Gem::Specification.new do |g|
       g.name = "pkgr"
       g.version = "1.2.3"
-
-      g.authors = %w[author]
-      g.files = %w[x]
-      g.summary = 'summary'
+      g.files = Rake::FileList["x"].resolve
     end
-
     pkg = Gem::PackageTask.new(gem)  do |p|
       p.package_files << "y"
     end
-
-    assert_equal %w[x y], pkg.package_files
-
-    Dir.chdir @tempdir do
-      FileUtils.touch 'x'
-      FileUtils.touch 'y'
-
-      Rake.application['package'].invoke
-
-      assert_path_exists 'pkg/pkgr-1.2.3.gem'
-    end
+    assert_equal ["x", "y"], pkg.package_files
   end
 
   def test_gem_package_with_current_platform

data/test/rubygems/test_gem_path_support.rb

@@ -64,4 +64,21 @@ class TestGemPathSupport < Gem::TestCase
   def util_path
     ENV["GEM_PATH"].split(File::PATH_SEPARATOR)
   end
+
+  def test_initialize_spec
+    ENV["GEM_SPEC_CACHE"] = nil
+
+    ps = Gem::PathSupport.new
+    assert_equal Gem.default_spec_cache_dir, ps.spec_cache_dir
+
+    ENV["GEM_SPEC_CACHE"] = 'bar'
+
+    ps = Gem::PathSupport.new
+    assert_equal ENV["GEM_SPEC_CACHE"], ps.spec_cache_dir
+
+    ENV["GEM_SPEC_CACHE"] = File.join @tempdir, 'spec_cache'
+
+    ps = Gem::PathSupport.new "GEM_SPEC_CACHE" => "foo"
+    assert_equal "foo", ps.spec_cache_dir
+  end
 end

data/test/rubygems/test_gem_platform.rb

@@ -186,6 +186,24 @@ class TestGemPlatform < Gem::TestCase
     assert((x86_darwin8 === Gem::Platform.local), 'universal =~ x86')
   end
 
+  def test_equals3_cpu_arm
+    arm   = Gem::Platform.new 'arm-linux'
+    armv5 = Gem::Platform.new 'armv5-linux'
+    armv7 = Gem::Platform.new 'armv7-linux'
+
+    util_set_arch 'armv5-linux'
+    assert((arm   === Gem::Platform.local), 'arm   === armv5')
+    assert((armv5 === Gem::Platform.local), 'armv5 === armv5')
+    refute((armv7 === Gem::Platform.local), 'armv7 === armv5')
+    refute((Gem::Platform.local ===   arm), 'armv5 === arm')
+
+    util_set_arch 'armv7-linux'
+    assert((arm   === Gem::Platform.local), 'arm   === armv7')
+    refute((armv5 === Gem::Platform.local), 'armv5 === armv7')
+    assert((armv7 === Gem::Platform.local), 'armv7 === armv7')
+    refute((Gem::Platform.local ===   arm), 'armv7 === arm')
+  end
+
   def test_equals3_version
     util_set_arch 'i686-darwin8'
 

data/test/rubygems/test_gem_remote_fetcher.rb

@@ -1,7 +1,13 @@
 require 'rubygems/test_case'
-require 'ostruct'
+
 require 'webrick'
-require 'webrick/https'
+begin
+  require 'webrick/https'
+rescue LoadError => e
+  raise unless (e.respond_to?(:path) && e.path == 'openssl') ||
+               e.message =~ / -- openssl$/
+end
+
 require 'rubygems/remote_fetcher'
 require 'rubygems/package'
 require 'minitest/mock'
@@ -69,6 +75,12 @@ gems:
 
   PROXY_DATA = SERVER_DATA.gsub(/0.4.11/, '0.4.2')
 
+  # don't let 1.8 and 1.9 autotest collide
+  RUBY_VERSION =~ /(\d+)\.(\d+)\.(\d+)/
+  # don't let parallel runners collide
+  PROXY_PORT = process_based_port + 100 + $1.to_i * 100 + $2.to_i * 10 + $3.to_i
+  SERVER_PORT = process_based_port + 200 + $1.to_i * 100 + $2.to_i * 10 + $3.to_i
+
   DIR = File.expand_path(File.dirname(__FILE__))
 
   def setup
@@ -81,8 +93,8 @@ gems:
     self.class.enable_yaml = true
     self.class.enable_zip = false
 
-    base_server_uri = "http://localhost:#{self.class.normal_server_port}"
-    @proxy_uri = "http://localhost:#{self.class.proxy_server_port}"
+    base_server_uri = "http://localhost:#{SERVER_PORT}"
+    @proxy_uri = "http://localhost:#{PROXY_PORT}"
 
     @server_uri = base_server_uri + "/yaml"
     @server_z_uri = base_server_uri + "/yaml.Z"
@@ -122,27 +134,7 @@ gems:
 
     refute_nil fetcher
     assert_kind_of Gem::RemoteFetcher, fetcher
-    assert_equal proxy_uri, fetcher.instance_variable_get(:@proxy_uri).to_s
-  end
-
-  def test_self_fetcher_with_proxy_URI
-    proxy_uri = URI.parse 'http://proxy.example.com'
-    Gem.configuration[:http_proxy] = proxy_uri
-    Gem::RemoteFetcher.fetcher = nil
-
-    fetcher = Gem::RemoteFetcher.fetcher
-    refute_nil fetcher
-
-    assert_kind_of Gem::RemoteFetcher, fetcher
-    assert_equal proxy_uri, fetcher.instance_variable_get(:@proxy_uri)
-  end
-
-  def test_escape_auth_info
-    assert_equal 'a%40b%5Cc', @fetcher.escape_auth_info('a@b\c')
-  end
-
-  def test_unescape_auth_info
-    assert_equal 'a@b\c', @fetcher.unescape_auth_info('a%40b%5Cc')
+    assert_equal proxy_uri, fetcher.instance_variable_get(:@proxy).to_s
   end
 
   def test_fetch_size_bad_uri
@@ -157,7 +149,7 @@ gems:
 
   def test_fetch_size_socket_error
     fetcher = Gem::RemoteFetcher.new nil
-    def fetcher.connection_for(uri)
+    def fetcher.request(uri, request_class, last_modified = nil)
       raise SocketError, "tarded"
     end
 
@@ -177,60 +169,15 @@ gems:
   end
 
   def test_api_endpoint
-    uri = URI.parse "http://example.com/foo"
-    target = MiniTest::Mock.new
-    target.expect :target, "gems.example.com"
-
-    dns = MiniTest::Mock.new
-    dns.expect :getresource, target, [String, Object]
-
-    fetch = Gem::RemoteFetcher.new nil, dns
-    assert_equal URI.parse("http://gems.example.com/foo"), fetch.api_endpoint(uri)
-
-    target.verify
-    dns.verify
-  end
-
-  def test_api_endpoint_ignores_trans_domain_values
     uri = URI.parse "http://gems.example.com/foo"
     target = MiniTest::Mock.new
-    target.expect :target, "blah.com"
-
-    dns = MiniTest::Mock.new
-    dns.expect :getresource, target, [String, Object]
-
-    fetch = Gem::RemoteFetcher.new nil, dns
-    assert_equal URI.parse("http://gems.example.com/foo"), fetch.api_endpoint(uri)
-
-    target.verify
-    dns.verify
-  end
-
-  def test_api_endpoint_ignores_trans_domain_values_that_starts_with_original
-    uri = URI.parse "http://example.com/foo"
-    target = MiniTest::Mock.new
-    target.expect :target, "example.combadguy.com"
-
-    dns = MiniTest::Mock.new
-    dns.expect :getresource, target, [String, Object]
-
-    fetch = Gem::RemoteFetcher.new nil, dns
-    assert_equal URI.parse("http://example.com/foo"), fetch.api_endpoint(uri)
-
-    target.verify
-    dns.verify
-  end
-
-  def test_api_endpoint_ignores_trans_domain_values_that_end_with_original
-    uri = URI.parse "http://example.com/foo"
-    target = MiniTest::Mock.new
-    target.expect :target, "badexample.com"
+    target.expect :target, "http://blah.com"
 
     dns = MiniTest::Mock.new
     dns.expect :getresource, target, [String, Object]
 
     fetch = Gem::RemoteFetcher.new nil, dns
-    assert_equal URI.parse("http://example.com/foo"), fetch.api_endpoint(uri)
+    assert_equal URI.parse("http://blah.com/foo"), fetch.api_endpoint(uri)
 
     target.verify
     dns.verify
@@ -461,81 +408,6 @@ gems:
     assert_equal @a2.file_name, File.basename(gem)
   end
 
-  def test_explicit_proxy
-    use_ui @ui do
-      fetcher = Gem::RemoteFetcher.new @proxy_uri
-      assert_equal PROXY_DATA.size, fetcher.fetch_size(@server_uri)
-      assert_data_from_proxy fetcher.fetch_path(@server_uri)
-    end
-  end
-
-  def test_explicit_proxy_with_user_auth
-    use_ui @ui do
-      uri = URI.parse @proxy_uri
-      uri.user, uri.password = 'foo', 'bar'
-      fetcher = Gem::RemoteFetcher.new uri.to_s
-      proxy = fetcher.instance_variable_get("@proxy_uri")
-      assert_equal 'foo', proxy.user
-      assert_equal 'bar', proxy.password
-      assert_data_from_proxy fetcher.fetch_path(@server_uri)
-    end
-
-    use_ui @ui do
-      uri = URI.parse @proxy_uri
-      uri.user, uri.password = 'domain%5Cuser', 'bar'
-      fetcher = Gem::RemoteFetcher.new uri.to_s
-      proxy = fetcher.instance_variable_get("@proxy_uri")
-      assert_equal 'domain\user', fetcher.unescape_auth_info(proxy.user)
-      assert_equal 'bar', proxy.password
-      assert_data_from_proxy fetcher.fetch_path(@server_uri)
-    end
-
-    use_ui @ui do
-      uri = URI.parse @proxy_uri
-      uri.user, uri.password = 'user', 'my%20pass'
-      fetcher = Gem::RemoteFetcher.new uri.to_s
-      proxy = fetcher.instance_variable_get("@proxy_uri")
-      assert_equal 'user', proxy.user
-      assert_equal 'my pass', fetcher.unescape_auth_info(proxy.password)
-      assert_data_from_proxy fetcher.fetch_path(@server_uri)
-    end
-  end
-
-  def test_explicit_proxy_with_user_auth_in_env
-    use_ui @ui do
-      ENV['http_proxy'] = @proxy_uri
-      ENV['http_proxy_user'] = 'foo'
-      ENV['http_proxy_pass'] = 'bar'
-      fetcher = Gem::RemoteFetcher.new nil
-      proxy = fetcher.instance_variable_get("@proxy_uri")
-      assert_equal 'foo', proxy.user
-      assert_equal 'bar', proxy.password
-      assert_data_from_proxy fetcher.fetch_path(@server_uri)
-    end
-
-    use_ui @ui do
-      ENV['http_proxy'] = @proxy_uri
-      ENV['http_proxy_user'] = 'foo\user'
-      ENV['http_proxy_pass'] = 'my bar'
-      fetcher = Gem::RemoteFetcher.new nil
-      proxy = fetcher.instance_variable_get("@proxy_uri")
-      assert_equal 'foo\user', fetcher.unescape_auth_info(proxy.user)
-      assert_equal 'my bar', fetcher.unescape_auth_info(proxy.password)
-      assert_data_from_proxy fetcher.fetch_path(@server_uri)
-    end
-
-    use_ui @ui do
-      ENV['http_proxy'] = @proxy_uri
-      ENV['http_proxy_user'] = 'foo@user'
-      ENV['http_proxy_pass'] = 'my@bar'
-      fetcher = Gem::RemoteFetcher.new nil
-      proxy = fetcher.instance_variable_get("@proxy_uri")
-      assert_equal 'foo@user', fetcher.unescape_auth_info(proxy.user)
-      assert_equal 'my@bar', fetcher.unescape_auth_info(proxy.password)
-      assert_data_from_proxy fetcher.fetch_path(@server_uri)
-    end
-  end
-
   def test_fetch_path_gzip
     fetcher = Gem::RemoteFetcher.new nil
 
@@ -618,22 +490,6 @@ gems:
     assert_equal nil, fetcher.fetch_path(URI.parse(@gem_repo), Time.at(0))
   end
 
-  def test_get_proxy_from_env_auto_normalizes
-    fetcher = Gem::RemoteFetcher.new(nil)
-    ENV['HTTP_PROXY'] = 'fakeurl:12345'
-
-    assert_equal('http://fakeurl:12345', fetcher.get_proxy_from_env.to_s)
-  end
-
-  def test_get_proxy_from_env_empty
-    ENV['HTTP_PROXY'] = ''
-    ENV.delete 'http_proxy'
-
-    fetcher = Gem::RemoteFetcher.new nil
-
-    assert_equal nil, fetcher.send(:get_proxy_from_env)
-  end
-
   def test_implicit_no_proxy
     use_ui @ui do
       ENV['http_proxy'] = 'http://fakeurl:12345'
@@ -669,9 +525,7 @@ gems:
     fetcher = Gem::RemoteFetcher.new nil
     url = 'http://gems.example.com/redirect'
 
-    conn = Object.new
-    def conn.started?() true end
-    def conn.request(req)
+    def fetcher.request(uri, request_class, last_modified = nil)
       url = 'http://gems.example.com/redirect'
       unless defined? @requested then
         @requested = true
@@ -685,9 +539,6 @@ gems:
       end
     end
 
-    conn = { "#{Thread.current.object_id}:gems.example.com:80" => conn }
-    fetcher.instance_variable_set :@connections, conn
-
     data = fetcher.fetch_http URI.parse(url)
 
     assert_equal 'real_path', data
@@ -697,18 +548,13 @@ gems:
     fetcher = Gem::RemoteFetcher.new nil
     url = 'http://gems.example.com/redirect'
 
-    conn = Object.new
-    def conn.started?() true end
-    def conn.request(req)
+    def fetcher.request(uri, request_class, last_modified = nil)
       url = 'http://gems.example.com/redirect'
       res = Net::HTTPMovedPermanently.new nil, 301, nil
       res.add_field 'Location', url
       res
     end
 
-    conn = { "#{Thread.current.object_id}:gems.example.com:80" => conn }
-    fetcher.instance_variable_set :@connections, conn
-
     e = assert_raises Gem::RemoteFetcher::FetchError do
       fetcher.fetch_http URI.parse(url)
     end
@@ -716,14 +562,6 @@ gems:
     assert_equal "too many redirects (#{url})", e.message
   end
 
-  def test_normalize_uri
-    assert_equal 'FILE://example/',  @fetcher.normalize_uri('FILE://example/')
-    assert_equal 'FTP://example/',   @fetcher.normalize_uri('FTP://example/')
-    assert_equal 'HTTP://example/',  @fetcher.normalize_uri('HTTP://example/')
-    assert_equal 'HTTPS://example/', @fetcher.normalize_uri('HTTPS://example/')
-    assert_equal 'http://example/',  @fetcher.normalize_uri('example/')
-  end
-
   def test_observe_no_proxy_env_single_host
     use_ui @ui do
       ENV["http_proxy"] = @proxy_uri
@@ -742,115 +580,15 @@ gems:
     end
   end
 
-  def test_request
-    uri = URI.parse "#{@gem_repo}/specs.#{Gem.marshal_version}"
-    util_stub_connection_for :body => :junk, :code => 200
-
-    response = @fetcher.request uri, Net::HTTP::Get
-
-    assert_equal 200, response.code
-    assert_equal :junk, response.body
-  end
-
-  def test_request_head
-    uri = URI.parse "#{@gem_repo}/specs.#{Gem.marshal_version}"
-    util_stub_connection_for :body => '', :code => 200
-    response = @fetcher.request uri, Net::HTTP::Head
-
-    assert_equal 200, response.code
-    assert_equal '', response.body
-  end
-
-  def test_request_unmodified
-    uri = URI.parse "#{@gem_repo}/specs.#{Gem.marshal_version}"
-    conn = util_stub_connection_for :body => '', :code => 304
-
-    t = Time.now
-    response = @fetcher.request uri, Net::HTTP::Head, t
-
-    assert_equal 304, response.code
-    assert_equal '', response.body
-
-    assert_equal t.rfc2822, conn.payload['if-modified-since']
-  end
-
-  def test_user_agent
-    ua = @fetcher.user_agent
-
-    assert_match %r%^RubyGems/\S+ \S+ Ruby/\S+ \(.*?\)%,          ua
-    assert_match %r%RubyGems/#{Regexp.escape Gem::VERSION}%,      ua
-    assert_match %r% #{Regexp.escape Gem::Platform.local.to_s} %, ua
-    assert_match %r%Ruby/#{Regexp.escape RUBY_VERSION}%,          ua
-    assert_match %r%\(#{Regexp.escape RUBY_RELEASE_DATE} %,       ua
-  end
-
-  def test_user_agent_engine
-    util_save_version
-
-    Object.send :remove_const, :RUBY_ENGINE if defined?(RUBY_ENGINE)
-    Object.send :const_set,    :RUBY_ENGINE, 'vroom'
-
-    ua = @fetcher.user_agent
-
-    assert_match %r%\) vroom%, ua
-  ensure
-    util_restore_version
-  end
-
-  def test_user_agent_engine_ruby
-    util_save_version
-
-    Object.send :remove_const, :RUBY_ENGINE if defined?(RUBY_ENGINE)
-    Object.send :const_set,    :RUBY_ENGINE, 'ruby'
-
-    ua = @fetcher.user_agent
-
-    assert_match %r%\)%, ua
-  ensure
-    util_restore_version
-  end
-
-  def test_user_agent_patchlevel
-    util_save_version
-
-    Object.send :remove_const, :RUBY_PATCHLEVEL
-    Object.send :const_set,    :RUBY_PATCHLEVEL, 5
-
-    ua = @fetcher.user_agent
-
-    assert_match %r% patchlevel 5\)%, ua
-  ensure
-    util_restore_version
-  end
-
-  def test_user_agent_revision
-    util_save_version
-
-    Object.send :remove_const, :RUBY_PATCHLEVEL
-    Object.send :const_set,    :RUBY_PATCHLEVEL, -1
-    Object.send :remove_const, :RUBY_REVISION if defined?(RUBY_REVISION)
-    Object.send :const_set,    :RUBY_REVISION, 6
-
-    ua = @fetcher.user_agent
-
-    assert_match %r% revision 6\)%, ua
-    assert_match %r%Ruby/#{Regexp.escape RUBY_VERSION}dev%, ua
-  ensure
-    util_restore_version
-  end
-
-  def test_user_agent_revision_missing
-    util_save_version
-
-    Object.send :remove_const, :RUBY_PATCHLEVEL
-    Object.send :const_set,    :RUBY_PATCHLEVEL, -1
-    Object.send :remove_const, :RUBY_REVISION if defined?(RUBY_REVISION)
-
-    ua = @fetcher.user_agent
+  def test_request_block
+    fetcher = Gem::RemoteFetcher.new nil
 
-    assert_match %r%\(#{Regexp.escape RUBY_RELEASE_DATE}\)%, ua
-  ensure
-    util_restore_version
+    assert_throws :block_called do
+      fetcher.request URI('http://example'), Net::HTTP::Get do |req|
+        assert_kind_of Net::HTTPGenericRequest, req
+        throw :block_called
+      end
+    end
   end
 
   def test_yaml_error_on_size
@@ -869,6 +607,42 @@ gems:
     end
   end
 
+  def test_ssl_client_cert_auth_connection
+    skip 'openssl is missing' unless defined?(OpenSSL::SSL)
+
+    ssl_server = self.class.start_ssl_server({
+      :SSLVerifyClient =>
+        OpenSSL::SSL::VERIFY_PEER|OpenSSL::SSL::VERIFY_FAIL_IF_NO_PEER_CERT})
+
+    temp_ca_cert = File.join(DIR, 'ca_cert.pem')
+    temp_client_cert = File.join(DIR, 'client.pem')
+
+    with_configured_fetcher(
+      ":ssl_ca_cert: #{temp_ca_cert}\n" +
+      ":ssl_client_cert: #{temp_client_cert}\n") do |fetcher|
+      fetcher.fetch_path("https://localhost:#{ssl_server.config[:Port]}/yaml")
+    end
+  end
+
+  def test_do_not_allow_invalid_client_cert_auth_connection
+    skip 'openssl is missing' unless defined?(OpenSSL::SSL)
+
+    ssl_server = self.class.start_ssl_server({
+      :SSLVerifyClient =>
+        OpenSSL::SSL::VERIFY_PEER|OpenSSL::SSL::VERIFY_FAIL_IF_NO_PEER_CERT})
+
+    temp_ca_cert = File.join(DIR, 'ca_cert.pem')
+    temp_client_cert = File.join(DIR, 'invalid_client.pem')
+
+    with_configured_fetcher(
+      ":ssl_ca_cert: #{temp_ca_cert}\n" +
+      ":ssl_client_cert: #{temp_client_cert}\n") do |fetcher|
+        assert_raises Gem::RemoteFetcher::FetchError do
+          fetcher.fetch_path("https://localhost:#{ssl_server.config[:Port]}/yaml")
+        end
+    end
+  end
+
   def test_do_not_allow_insecure_ssl_connection_by_default
     ssl_server = self.class.start_ssl_server
     with_configured_fetcher do |fetcher|
@@ -908,18 +682,6 @@ gems:
     Gem.configuration = nil
   end
 
-  def util_stub_connection_for hash
-    def @fetcher.connection= conn
-      @conn = conn
-    end
-
-    def @fetcher.connection_for uri
-      @conn
-    end
-
-    @fetcher.connection = Conn.new OpenStruct.new(hash)
-  end
-
   def assert_error(exception_class=Exception)
     got_exception = false
 
@@ -940,20 +702,6 @@ gems:
     assert_match(/0\.4\.2/, data, "Data is not from proxy")
   end
 
-  class Conn
-    attr_accessor :payload
-
-    def initialize(response)
-      @response = response
-      self.payload = nil
-    end
-
-    def request(req)
-      self.payload = req
-      @response
-    end
-  end
-
   class NilLog < WEBrick::Log
     def log(level, data) #Do nothing
     end
@@ -964,24 +712,18 @@ gems:
     attr_accessor :enable_zip, :enable_yaml
 
     def start_servers
-      @normal_server ||= start_server(SERVER_DATA)
-      @proxy_server  ||= start_server(PROXY_DATA)
+      @normal_server ||= start_server(SERVER_PORT, SERVER_DATA)
+      @proxy_server  ||= start_server(PROXY_PORT, PROXY_DATA)
       @enable_yaml = true
       @enable_zip = false
     end
 
-    def normal_server_port
-      @normal_server[:server].config[:Port]
-    end
-
-    def proxy_server_port
-      @proxy_server[:server].config[:Port]
-    end
-
     DIR = File.expand_path(File.dirname(__FILE__))
-    DH_PARAM = OpenSSL::PKey::DH.new(128)
 
     def start_ssl_server(config = {})
+      raise MiniTest::Skip, 'openssl not installed' unless
+        defined?(OpenSSL::SSL)
+
       null_logger = NilLog.new
       server = WEBrick::HTTPServer.new({
         :Port => 0,
@@ -1000,7 +742,7 @@ gems:
       server.mount_proc("/insecure_redirect") { |req, res|
         res.set_redirect(WEBrick::HTTPStatus::MovedPermanently, req.query['to'])
       }
-      server.ssl_context.tmp_dh_callback = proc { DH_PARAM }
+      server.ssl_context.tmp_dh_callback = proc { OpenSSL::PKey::DH.new 128 }
       t = Thread.new do
         begin
           server.start
@@ -1019,49 +761,47 @@ gems:
       server
     end
 
-
-
     private
 
-    def start_server(data)
-      null_logger = NilLog.new
-      s = WEBrick::HTTPServer.new(
-        :Port            => 0,
-        :DocumentRoot    => nil,
-        :Logger          => null_logger,
-        :AccessLog       => null_logger
-        )
-      s.mount_proc("/kill") { |req, res| s.shutdown }
-      s.mount_proc("/yaml") { |req, res|
-        if @enable_yaml
-          res.body = data
-          res['Content-Type'] = 'text/plain'
-          res['content-length'] = data.size
-        else
-          res.status = "404"
-          res.body = "<h1>NOT FOUND</h1>"
-          res['Content-Type'] = 'text/html'
-        end
-      }
-      s.mount_proc("/yaml.Z") { |req, res|
-        if @enable_zip
-          res.body = Zlib::Deflate.deflate(data)
-          res['Content-Type'] = 'text/plain'
-        else
-          res.status = "404"
-          res.body = "<h1>NOT FOUND</h1>"
-          res['Content-Type'] = 'text/html'
-        end
-      }
-      th = Thread.new do
+    def start_server(port, data)
+      Thread.new do
         begin
+          null_logger = NilLog.new
+          s = WEBrick::HTTPServer.new(
+            :Port            => port,
+            :DocumentRoot    => nil,
+            :Logger          => null_logger,
+            :AccessLog       => null_logger
+            )
+          s.mount_proc("/kill") { |req, res| s.shutdown }
+          s.mount_proc("/yaml") { |req, res|
+            if @enable_yaml
+              res.body = data
+              res['Content-Type'] = 'text/plain'
+              res['content-length'] = data.size
+            else
+              res.status = "404"
+              res.body = "<h1>NOT FOUND</h1>"
+              res['Content-Type'] = 'text/html'
+            end
+          }
+          s.mount_proc("/yaml.Z") { |req, res|
+            if @enable_zip
+              res.body = Zlib::Deflate.deflate(data)
+              res['Content-Type'] = 'text/plain'
+            else
+              res.status = "404"
+              res.body = "<h1>NOT FOUND</h1>"
+              res['Content-Type'] = 'text/html'
+            end
+          }
           s.start
         rescue Exception => ex
-          abort "ERROR during server thread: #{ex.message}"
+          abort ex.message
+          puts "ERROR during server thread: #{ex.message}"
         end
       end
-      th[:server] = s
-      th
+      sleep 0.2                 # Give the servers time to startup
     end
 
     def cert(filename)
@@ -1081,24 +821,5 @@ gems:
     assert_equal "/home/skillet", @fetcher.correct_for_windows_path(path)
   end
 
-  def util_save_version
-    @orig_RUBY_ENGINE     = RUBY_ENGINE if defined? RUBY_ENGINE
-    @orig_RUBY_PATCHLEVEL = RUBY_PATCHLEVEL
-    @orig_RUBY_REVISION   = RUBY_REVISION if defined? RUBY_REVISION
-  end
-
-  def util_restore_version
-    Object.send :remove_const, :RUBY_ENGINE if defined?(RUBY_ENGINE)
-    Object.send :const_set,    :RUBY_ENGINE, @orig_RUBY_ENGINE if
-      defined?(@orig_RUBY_ENGINE)
-
-    Object.send :remove_const, :RUBY_PATCHLEVEL
-    Object.send :const_set,    :RUBY_PATCHLEVEL, @orig_RUBY_PATCHLEVEL
-
-    Object.send :remove_const, :RUBY_REVISION if defined?(RUBY_REVISION)
-    Object.send :const_set,    :RUBY_REVISION, @orig_RUBY_REVISION if
-      defined?(@orig_RUBY_REVISION)
-  end
-
 end