rubygems-update 1.0.1 → 1.1.0

data/test/test_gem_package_tar_output.rb

@@ -0,0 +1,104 @@
+#--
+# Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+require File.join(File.expand_path(File.dirname(__FILE__)),
+                  'gem_package_tar_test_case')
+require 'rubygems/package/tar_output'
+
+class TestGemPackageTarOutput < TarTestCase
+
+  def setup
+    super
+
+    @file = File.join @tempdir, 'bla2.tar'
+  end
+
+  def test_self_open
+    open @file, 'wb' do |tar_io|
+      Gem::Package::TarOutput.open tar_io do |tar_writer|
+        tar_writer.add_file_simple 'README', 0, 17 do |io|
+          io.write "This is a README\n"
+        end
+
+        tar_writer.metadata = "This is some metadata\n"
+      end
+    end
+
+    files = util_extract
+
+    name, data = files.shift
+    assert_equal 'data.tar.gz', name
+
+    gz = Zlib::GzipReader.new StringIO.new(data)
+
+    Gem::Package::TarReader.new gz do |tar_reader|
+      tar_reader.each do |entry|
+        assert_equal 'README', entry.full_name
+        assert_equal "This is a README\n", entry.read
+      end
+    end
+
+    gz.close
+
+    name, data = files.shift
+    assert_equal 'metadata.gz', name
+
+    gz = Zlib::GzipReader.new StringIO.new(data)
+    assert_equal "This is some metadata\n", gz.read
+
+    assert files.empty?
+  ensure
+    gz.close if gz
+  end
+
+  if defined? OpenSSL then
+    def test_self_open_signed
+      signer = Gem::Security::Signer.new @private_key, [@public_cert]
+
+      open @file, 'wb' do |tar_io|
+        Gem::Package::TarOutput.open tar_io, signer do |tar_writer|
+          tar_writer.add_file_simple 'README', 0, 17 do |io|
+            io.write "This is a README\n"
+          end
+
+          tar_writer.metadata = "This is some metadata\n"
+        end
+      end
+
+      files = util_extract
+
+      name, data = files.shift
+      assert_equal 'data.tar.gz', name
+
+      name, data = files.shift
+      assert_equal 'metadata.gz', name
+
+      name, data = files.shift
+      assert_equal 'data.tar.gz.sig', name
+
+      name, data = files.shift
+      assert_equal 'metadata.gz.sig', name
+
+      assert files.empty?
+    end
+  end
+
+  def util_extract
+    files = []
+
+    open @file, 'rb' do |io|
+      Gem::Package::TarReader.new io do |tar_reader|
+        tar_reader.each do |entry|
+          files << [entry.full_name, entry.read]
+        end
+      end
+    end
+
+    files
+  end
+
+end
+

data/test/test_gem_package_tar_reader.rb

@@ -0,0 +1,53 @@
+#--
+# Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+require File.join(File.expand_path(File.dirname(__FILE__)),
+                  'gem_package_tar_test_case')
+require 'rubygems/package'
+
+class TestGemPackageTarReader < TarTestCase
+
+  def test_each_entry
+    tar = tar_dir_header "foo", "bar", 0
+    tar << tar_file_header("bar", "baz", 0, 0)
+
+    io = TempIO.new tar
+
+    entries = 0
+
+    Gem::Package::TarReader.new io do |tar_reader|
+      tar_reader.each_entry do |entry|
+        assert_kind_of Gem::Package::TarReader::Entry, entry
+
+        entries += 1
+      end
+    end
+
+    assert_equal 2, entries
+  end
+
+  def test_rewind
+    content = ('a'..'z').to_a.join(" ")
+
+    str = tar_file_header("lib/foo", "", 010644, content.size) + content +
+            "\0" * (512 - content.size)
+    str << "\0" * 1024
+
+    Gem::Package::TarReader.new(TempIO.new(str)) do |tar_reader|
+      3.times do
+        tar_reader.rewind
+        i = 0
+        tar_reader.each_entry do |entry|
+          assert_equal(content, entry.read)
+          i += 1
+        end
+        assert_equal(1, i)
+      end
+    end
+  end
+
+end
+

data/test/test_gem_package_tar_reader_entry.rb

@@ -0,0 +1,116 @@
+#--
+# Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+require File.join(File.expand_path(File.dirname(__FILE__)),
+                  'gem_package_tar_test_case')
+require 'rubygems/package'
+
+class TestGemPackageTarReaderEntry < TarTestCase
+
+  def setup
+    super
+
+    @contents = ('a'..'z').to_a.join * 100
+
+    @tar = ''
+    @tar << tar_file_header("lib/foo", "", 0, @contents.size)
+    @tar << @contents
+    @tar << "\0" * (512 - (@tar.size % 512))
+
+    @entry = util_entry @tar
+  end
+
+  def test_bytes_read
+    assert_equal 0, @entry.bytes_read
+
+    @entry.getc
+
+    assert_equal 1, @entry.bytes_read
+  end
+
+  def test_close
+    @entry.close
+
+    assert @entry.bytes_read
+
+    e = assert_raise IOError do @entry.eof? end
+    assert_equal 'closed Gem::Package::TarReader::Entry', e.message
+
+    e = assert_raise IOError do @entry.getc end
+    assert_equal 'closed Gem::Package::TarReader::Entry', e.message
+
+    e = assert_raise IOError do @entry.pos end
+    assert_equal 'closed Gem::Package::TarReader::Entry', e.message
+
+    e = assert_raise IOError do @entry.read end
+    assert_equal 'closed Gem::Package::TarReader::Entry', e.message
+
+    e = assert_raise IOError do @entry.rewind end
+    assert_equal 'closed Gem::Package::TarReader::Entry', e.message
+  end
+
+  def test_closed_eh
+    @entry.close
+
+    assert @entry.closed?
+  end
+
+  def test_eof_eh
+    @entry.read
+
+    assert @entry.eof?
+  end
+
+  def test_full_name
+    assert_equal 'lib/foo', @entry.full_name
+  end
+
+  def test_getc
+    assert_equal ?a, @entry.getc
+  end
+
+  def test_directory_eh
+    assert_equal false, @entry.directory?
+    assert_equal true, util_dir_entry.directory?
+  end
+
+  def test_file_eh
+    assert_equal true, @entry.file?
+    assert_equal false, util_dir_entry.file?
+  end
+
+  def test_pos
+    assert_equal 0, @entry.pos
+
+    @entry.getc
+
+    assert_equal 1, @entry.pos
+  end
+
+  def test_read
+    assert_equal @contents, @entry.read
+  end
+
+  def test_read_big
+    assert_equal @contents, @entry.read(@contents.size * 2)
+  end
+
+  def test_read_small
+    assert_equal @contents[0...100], @entry.read(100)
+  end
+
+  def test_rewind
+    char = @entry.getc
+
+    @entry.rewind
+
+    assert_equal 0, @entry.pos
+
+    assert_equal char, @entry.getc
+  end
+
+end
+

data/test/test_gem_package_tar_writer.rb

@@ -0,0 +1,151 @@
+#--
+# Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+require File.join(File.expand_path(File.dirname(__FILE__)),
+                  'gem_package_tar_test_case')
+require 'rubygems/package/tar_writer'
+
+class TestTarWriter < TarTestCase
+
+  def setup
+    super
+
+    @data = 'abcde12345'
+    @io = TempIO.new
+    @tar_writer = Gem::Package::TarWriter.new @io
+  end
+
+  def teardown
+    @tar_writer.close unless @tar_writer.closed?
+
+    super
+  end
+
+  def test_add_file
+    @tar_writer.add_file 'x', 0644 do |f| f.write 'a' * 10 end
+
+    assert_headers_equal(tar_file_header('x', '', 0644, 10),
+                         @io.string[0, 512])
+    assert_equal "aaaaaaaaaa#{"\0" * 502}", @io.string[512, 512]
+    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
+
+    assert_headers_equal(tar_file_header('x', '', 0644, 10),
+                         @io.string[0, 512])
+
+    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
+
+    assert_headers_equal tar_file_header('x', '', 0, 100), 
+                         @io.string[0, 512]
+
+    assert_equal "\0" * 512, @io.string[512, 512]
+  end
+
+  def test_add_file_simple_data
+    @tar_writer.add_file_simple("lib/foo/bar", 0, 10) { |f| f.write @data }
+    @tar_writer.flush
+
+    assert_equal @data + ("\0" * (512-@data.size)),
+                 @io.string[512, 512]
+  end
+
+  def test_add_file_simple_size
+    assert_raise Gem::Package::TarWriter::FileOverflow do 
+      @tar_writer.add_file_simple("lib/foo/bar", 0, 10) do |io|
+        io.write "1" * 11
+      end
+    end
+  end
+
+  def test_add_file_unseekable
+    assert_raise Gem::Package::NonSeekableIO do 
+      Gem::Package::TarWriter.new(Object.new).add_file 'x', 0
+    end
+  end
+
+  def test_close
+    @tar_writer.close
+
+    assert_equal "\0" * 1024, @io.string
+
+    e = assert_raise IOError do
+      @tar_writer.close
+    end
+    assert_equal 'closed Gem::Package::TarWriter', e.message
+
+    e = assert_raise IOError do
+      @tar_writer.flush
+    end
+    assert_equal 'closed Gem::Package::TarWriter', e.message
+
+    e = assert_raise IOError do
+      @tar_writer.add_file 'x', 0
+    end
+    assert_equal 'closed Gem::Package::TarWriter', e.message
+
+    e = assert_raise IOError do
+      @tar_writer.add_file_simple 'x', 0, 0
+    end
+    assert_equal 'closed Gem::Package::TarWriter', e.message
+
+    e = assert_raise IOError do
+      @tar_writer.mkdir 'x', 0
+    end
+    assert_equal 'closed Gem::Package::TarWriter', e.message
+  end
+
+  def test_mkdir
+    @tar_writer.mkdir 'foo', 0644
+
+    assert_headers_equal tar_dir_header('foo', '', 0644),
+                         @io.string[0, 512]
+    assert_equal 512, @io.pos
+  end
+
+  def test_split_name
+    assert_equal ['b' * 100, 'a' * 155],
+                 @tar_writer.split_name("#{'a' * 155}/#{'b' * 100}")
+
+    assert_equal ["#{'qwer/' * 19}bla", 'a' * 151],
+                 @tar_writer.split_name("#{'a' * 151}/#{'qwer/' * 19}bla")
+  end
+
+  def test_split_name_too_long_name
+    name = File.join 'a', 'b' * 100
+    assert_equal ['b' * 100, 'a'], @tar_writer.split_name(name)
+
+    assert_raise Gem::Package::TooLongFileName do
+      name = File.join 'a', 'b' * 101
+      @tar_writer.split_name name
+    end
+  end
+
+  def test_split_name_too_long_prefix
+    name = File.join 'a' * 155, 'b'
+    assert_equal ['b', 'a' * 155], @tar_writer.split_name(name)
+
+    assert_raise Gem::Package::TooLongFileName do
+      name = File.join 'a' * 156, 'b'
+      @tar_writer.split_name name
+    end
+  end
+
+  def test_split_name_too_long_total
+    assert_raise Gem::Package::TooLongFileName do
+      @tar_writer.split_name 'a' * 257
+    end
+  end
+
+end
+

data/test/test_gem_remote_fetcher.rb

@@ -97,6 +97,13 @@ gems:
     @server_uri = base_server_uri + "/yaml"
     @server_z_uri = base_server_uri + "/yaml.Z"
 
+    # REFACTOR: copied from test_gem_dependency_installer.rb
+    @gems_dir = File.join @tempdir, 'gems'
+    @cache_dir = File.join @gemhome, 'cache'
+    FileUtils.mkdir @gems_dir
+
+    @a1, @a1_gem = util_gem 'a', '1' do |s| s.executables << 'a_bin' end
+
     Gem::RemoteFetcher.instance_variable_set :@fetcher, nil
   end
 
@@ -156,6 +163,140 @@ gems:
     end
   end
 
+  def util_fuck_with_fetcher data, blow = false
+    fetcher = Gem::RemoteFetcher.fetcher
+    fetcher.instance_variable_set :@test_data, data
+
+    unless blow then
+      def fetcher.fetch_path arg
+        @test_arg = arg
+        @test_data
+      end
+    else
+      def fetcher.fetch_path arg
+        # OMG I'm such an ass
+        class << self; remove_method :fetch_path; end
+        def self.fetch_path arg
+          @test_arg = arg
+          @test_data
+        end
+
+        raise Gem::RemoteFetcher::FetchError, "haha!"
+      end
+    end
+
+    fetcher
+  end
+
+  def test_download
+    a1_data = nil
+    File.open @a1_gem, 'rb' do |fp|
+      a1_data = fp.read
+    end
+
+    fetcher = util_fuck_with_fetcher a1_data
+
+    a1_cache_gem = File.join(@gemhome, 'cache', "#{@a1.full_name}.gem")
+    assert_equal a1_cache_gem, fetcher.download(@a1, 'http://gems.example.com')
+    assert_equal("http://gems.example.com/gems/a-1.gem",
+                 fetcher.instance_variable_get(:@test_arg).to_s)
+    assert File.exist?(a1_cache_gem)
+  end
+
+  def test_download_cached
+    FileUtils.mv @a1_gem, @cache_dir
+
+    inst = Gem::RemoteFetcher.fetcher
+
+    assert_equal File.join(@gemhome, 'cache', "#{@a1.full_name}.gem"),
+                 inst.download(@a1, 'http://gems.example.com')
+  end
+
+  def test_download_local
+    FileUtils.mv @a1_gem, @tempdir
+    local_path = File.join @tempdir, "#{@a1.full_name}.gem"
+    inst = nil
+
+    Dir.chdir @tempdir do
+      inst = Gem::RemoteFetcher.fetcher
+    end
+
+    assert_equal File.join(@gemhome, 'cache', "#{@a1.full_name}.gem"),
+                 inst.download(@a1, local_path)
+  end
+
+  def test_download_install_dir
+    a1_data = nil
+    File.open @a1_gem, 'rb' do |fp|
+      a1_data = fp.read
+    end
+
+    fetcher = util_fuck_with_fetcher a1_data
+
+    install_dir = File.join @tempdir, 'more_gems'
+
+    a1_cache_gem = File.join install_dir, 'cache', "#{@a1.full_name}.gem"
+    actual = fetcher.download(@a1, 'http://gems.example.com', install_dir)
+
+    assert_equal a1_cache_gem, actual
+    assert_equal("http://gems.example.com/gems/a-1.gem",
+                 fetcher.instance_variable_get(:@test_arg).to_s)
+
+    assert File.exist?(a1_cache_gem)
+  end
+
+  unless win_platform? then # File.chmod doesn't work
+    def test_download_local_read_only
+      FileUtils.mv @a1_gem, @tempdir
+      local_path = File.join @tempdir, "#{@a1.full_name}.gem"
+      inst = nil
+      File.chmod 0555, File.join(@gemhome, 'cache')
+
+      Dir.chdir @tempdir do
+        inst = Gem::RemoteFetcher.fetcher
+      end
+
+      assert_equal File.join(@tempdir, "#{@a1.full_name}.gem"),
+        inst.download(@a1, local_path)
+    ensure
+      File.chmod 0755, File.join(@gemhome, 'cache')
+    end
+  end
+
+  def test_download_platform_legacy
+    original_platform = 'old-platform'
+
+    e1, e1_gem = util_gem 'e', '1' do |s|
+      s.platform = Gem::Platform::CURRENT
+      s.instance_variable_set :@original_platform, original_platform
+    end
+
+    e1_data = nil
+    File.open e1_gem, 'rb' do |fp|
+      e1_data = fp.read
+    end
+
+    fetcher = util_fuck_with_fetcher e1_data, :blow_chunks
+
+    e1_cache_gem = File.join(@gemhome, 'cache', "#{e1.full_name}.gem")
+
+    assert_equal e1_cache_gem, fetcher.download(e1, 'http://gems.example.com')
+
+    assert_equal("http://gems.example.com/gems/#{e1.original_name}.gem",
+                 fetcher.instance_variable_get(:@test_arg).to_s)
+    assert File.exist?(e1_cache_gem)
+  end
+
+  def test_download_unsupported
+    inst = Gem::RemoteFetcher.fetcher
+
+    e = assert_raise Gem::InstallError do
+      inst.download @a1, 'ftp://gems.rubyforge.org'
+    end
+
+    assert_equal 'unsupported URI scheme ftp', e.message
+  end
+
   def test_explicit_proxy
     use_ui @ui do
       fetcher = Gem::RemoteFetcher.new @proxy_uri
@@ -232,22 +373,6 @@ gems:
     assert_equal 'EOFError: EOFError reading uri', e.message
   end
 
-  def test_fetch_path_open_uri_http_error
-    fetcher = Gem::RemoteFetcher.new nil
-
-    def fetcher.open_uri_or_path(uri)
-      io = StringIO.new 'went boom'
-      err = OpenURI::HTTPError.new 'error', io
-      raise err
-    end
-
-    e = assert_raise Gem::RemoteFetcher::FetchError do
-      fetcher.fetch_path 'uri'
-    end
-
-    assert_equal "OpenURI::HTTPError: error reading uri\n\twent boom", e.message
-  end
-
   def test_fetch_path_socket_error
     fetcher = Gem::RemoteFetcher.new nil
 
@@ -271,7 +396,7 @@ gems:
       fetcher.fetch_path 'uri'
     end
 
-    assert_match %r|\AErrno::ECONNREFUSED: .* - connect\(2\) reading uri\z|,
+    assert_match %r|ECONNREFUSED:.*connect\(2\) reading uri\z|,
                  e.message
   end
 
@@ -324,6 +449,53 @@ gems:
     end
   end
 
+  def test_open_uri_or_path
+    fetcher = Gem::RemoteFetcher.new nil
+
+    conn = Object.new
+    def conn.started?() true end
+    def conn.request(req)
+      unless defined? @requested then
+        @requested = true
+        res = Net::HTTPRedirection.new nil, 301, nil
+        res.add_field 'Location', 'http://gems.example.com/real_path'
+        res
+      else
+        res = Net::HTTPOK.new nil, 200, nil
+        def res.body() 'real_path' end
+        res
+      end
+    end
+
+    conn = { 'gems.example.com:80' => conn }
+    fetcher.instance_variable_set :@connections, conn
+
+    fetcher.send :open_uri_or_path, 'http://gems.example.com/redirect' do |io|
+      assert_equal 'real_path', io.read
+    end
+  end
+
+  def test_open_uri_or_path_limited_redirects
+    fetcher = Gem::RemoteFetcher.new nil
+
+    conn = Object.new
+    def conn.started?() true end
+    def conn.request(req)
+      res = Net::HTTPRedirection.new nil, 301, nil
+      res.add_field 'Location', 'http://gems.example.com/redirect'
+      res
+    end
+
+    conn = { 'gems.example.com:80' => conn }
+    fetcher.instance_variable_set :@connections, conn
+
+    e = assert_raise Gem::RemoteFetcher::FetchError do
+      fetcher.send :open_uri_or_path, 'http://gems.example.com/redirect'
+    end
+
+    assert_equal 'too many redirects', e.message
+  end
+
   def test_zip
     use_ui @ui do
       self.class.enable_zip = true