libgems 0.0.1

data/test/test_gem_ext_rake_builder.rb

@@ -0,0 +1,81 @@
+require File.expand_path('../gemutilities', __FILE__)
+require 'libgems/ext'
+
+class TestGemExtRakeBuilder < RubyGemTestCase
+  def setup
+    super
+
+    @ext = File.join @tempdir, 'ext'
+    @dest_path = File.join @tempdir, 'prefix'
+
+    FileUtils.mkdir_p @ext
+    FileUtils.mkdir_p @dest_path
+  end
+
+  def test_class_build
+    File.open File.join(@ext, 'mkrf_conf.rb'), 'w' do |mkrf_conf|
+      mkrf_conf.puts <<-EO_MKRF
+        File.open("Rakefile","w") do |f|
+          f.puts "task :default"
+        end
+      EO_MKRF
+    end
+
+    output = []
+    realdir = nil # HACK /tmp vs. /private/tmp
+
+    build_rake_in do
+      Dir.chdir @ext do
+        realdir = Dir.pwd
+        LibGems::Ext::RakeBuilder.build 'mkrf_conf.rb', nil, @dest_path, output
+      end
+    end
+
+    output = output.join "\n"
+
+    expected = [
+      "#{@@ruby} mkrf_conf.rb",
+      "",
+      "#{@@rake} RUBYARCHDIR=#{@dest_path} RUBYLIBDIR=#{@dest_path}",
+      "(in #{realdir})\n"
+    ]
+
+    refute_match %r%^rake failed:%, output
+    assert_match %r%^#{Regexp.escape @@ruby} mkrf_conf\.rb%, output
+    assert_match %r%^#{Regexp.escape @@rake} RUBYARCHDIR=#{Regexp.escape @dest_path} RUBYLIBDIR=#{Regexp.escape @dest_path}%, output
+  end
+
+  def test_class_build_fail
+    File.open File.join(@ext, 'mkrf_conf.rb'), 'w' do |mkrf_conf|
+      mkrf_conf.puts <<-EO_MKRF
+        File.open("Rakefile","w") do |f|
+          f.puts "task :default do abort 'fail' end"
+        end
+        EO_MKRF
+    end
+
+    output = []
+
+    error = assert_raises LibGems::InstallError do
+      build_rake_in do
+        Dir.chdir @ext do
+          LibGems::Ext::RakeBuilder.build "mkrf_conf.rb", nil, @dest_path, output
+        end
+      end
+    end
+
+    expected = <<-EOF.strip
+rake failed:
+
+#{@@ruby} mkrf_conf.rb
+
+#{@@rake} RUBYARCHDIR=#{@dest_path} RUBYLIBDIR=#{@dest_path}
+    EOF
+
+    assert_match %r%^rake failed:%, error.message
+    assert_match %r%^#{Regexp.escape @@ruby} mkrf_conf\.rb%, error.message
+    assert_match %r%^#{Regexp.escape @@rake} RUBYARCHDIR=#{Regexp.escape @dest_path} RUBYLIBDIR=#{Regexp.escape @dest_path}%, error.message
+  end
+
+end
+

data/test/test_gem_format.rb

@@ -0,0 +1,70 @@
+require File.expand_path('../gemutilities', __FILE__)
+require File.expand_path('../simple_gem', __FILE__)
+require 'libgems/format'
+
+class TestGemFormat < RubyGemTestCase
+
+  def setup
+    super
+
+    @simple_gem = SIMPLE_GEM
+  end
+
+  def test_class_from_file_by_path
+    util_make_gems
+
+    gems = Dir[File.join(@gemhome, 'cache', '*.gem')]
+
+    names = [@a1, @a2, @a3a, @a_evil9, @b2, @c1_2, @pl1].map do |spec|
+      spec.original_name
+    end
+
+    gems_n_names = gems.sort.zip names
+
+    gems_n_names.each do |gemfile, name|
+      spec = LibGems::Format.from_file_by_path(gemfile).spec
+
+      assert_equal name, spec.original_name
+    end
+  end
+
+  def test_class_from_file_by_path_empty
+    util_make_gems
+
+    empty_gem = File.join @tempdir, 'empty.gem'
+    FileUtils.touch empty_gem
+
+    assert_nil LibGems::Format.from_file_by_path(empty_gem)
+  end
+
+  def test_class_from_file_by_path_nonexistent
+    assert_raises LibGems::Exception do
+      LibGems::Format.from_file_by_path '/nonexistent'
+    end
+  end
+
+  def test_class_from_io_garbled
+    e = assert_raises LibGems::Package::FormatError do
+      # subtly bogus input
+      LibGems::Format.from_io(StringIO.new(@simple_gem.upcase))
+    end
+
+    assert_equal 'No metadata found!', e.message
+
+    e = assert_raises LibGems::Package::FormatError do
+      # Totally bogus input
+      LibGems::Format.from_io(StringIO.new(@simple_gem.reverse))
+    end
+
+    assert_equal 'No metadata found!', e.message
+
+    e = assert_raises LibGems::Package::FormatError do
+      # This was intentionally screws up YAML parsing.
+      LibGems::Format.from_io(StringIO.new(@simple_gem.gsub(/:/, "boom")))
+    end
+
+    assert_equal 'No metadata found!', e.message
+  end
+
+end
+

data/test/test_gem_gem_path_searcher.rb

@@ -0,0 +1,78 @@
+require File.expand_path('../gemutilities', __FILE__)
+require 'libgems/gem_path_searcher'
+
+class LibGems::GemPathSearcher
+  attr_accessor :gemspecs
+  attr_accessor :lib_dirs
+end
+
+class TestGemGemPathSearcher < RubyGemTestCase
+
+  def setup
+    super
+
+    @foo1 = quick_gem 'foo', '0.1' do |s|
+      s.require_paths << 'lib2'
+      s.files << 'lib/foo.rb'
+    end
+
+    path = File.join 'gems', @foo1.full_name, 'lib', 'foo.rb'
+    write_file(path) { |fp| fp.puts "# #{path}" }
+
+    @foo2 = quick_gem 'foo', '0.2'
+    @bar1 = quick_gem 'bar', '0.1'
+    @bar2 = quick_gem 'bar', '0.2'
+    @nrp = quick_gem 'nil_require_paths', '0.1'
+    @nrp.require_paths = nil
+
+
+    @fetcher = LibGems::FakeFetcher.new
+    LibGems::RemoteFetcher.fetcher = @fetcher
+
+    LibGems.source_index = util_setup_spec_fetcher @foo1, @foo2, @bar1, @bar2
+
+    @gps = LibGems::GemPathSearcher.new
+  end
+
+  def test_find
+    assert_equal @foo1, @gps.find('foo')
+  end
+
+  def test_find_all
+    assert_equal [@foo1], @gps.find_all('foo')
+  end
+
+  def test_init_gemspecs
+    assert_equal [@bar2, @bar1, @foo2, @foo1], @gps.init_gemspecs
+  end
+
+  def test_lib_dirs_for
+    lib_dirs = @gps.lib_dirs_for(@foo1)
+    expected = File.join @gemhome, 'gems', @foo1.full_name, '{lib,lib2}'
+
+    assert_equal expected, lib_dirs
+  end
+
+  def test_lib_dirs_for_nil_require_paths
+    assert_nil @gps.lib_dirs_for(@nrp)
+  end
+
+  def test_matching_file_eh
+    refute @gps.matching_file?(@foo1, 'bar')
+    assert @gps.matching_file?(@foo1, 'foo')
+  end
+
+  def test_matching_files
+    assert_equal [], @gps.matching_files(@foo1, 'bar')
+
+    expected = File.join @foo1.full_gem_path, 'lib', 'foo.rb'
+
+    assert_equal [expected], @gps.matching_files(@foo1, 'foo')
+  end
+
+  def test_matching_files_nil_require_paths
+    assert_empty @gps.matching_files(@nrp, 'foo')
+  end
+
+end
+

data/test/test_gem_gem_runner.rb

@@ -0,0 +1,45 @@
+require File.expand_path('../gemutilities', __FILE__)
+require 'libgems/gem_runner'
+
+class TestGemGemRunner < RubyGemTestCase
+
+  def test_do_configuration
+    LibGems.clear_paths
+
+    temp_conf = File.join @tempdir, '.gemrc'
+
+    other_gem_path = File.join @tempdir, 'other_gem_path'
+    other_gem_home = File.join @tempdir, 'other_gem_home'
+
+    LibGems.ensure_gem_subdirectories other_gem_path
+    LibGems.ensure_gem_subdirectories other_gem_home
+
+    File.open temp_conf, 'w' do |fp|
+      fp.puts "gem: --commands"
+      fp.puts "gemhome: #{other_gem_home}"
+      fp.puts "gempath:"
+      fp.puts "  - #{other_gem_path}"
+      fp.puts "rdoc: --all"
+    end
+
+    gr = LibGems::GemRunner.new
+    gr.send :do_configuration, %W[--config-file #{temp_conf}]
+
+    assert_equal [other_gem_path, other_gem_home], LibGems.path
+    assert_equal %w[--commands], LibGems::Command.extra_args
+    assert_equal %w[--all], LibGems::DocManager.configured_args
+  end
+
+  def test_build_args__are_handled
+    LibGems.clear_paths
+
+    gr = LibGems::GemRunner.new
+    assert_raises(LibGems::SystemExitException) do
+      gr.run(%W[--help -- --build_arg1 --build_arg2])
+    end
+
+    assert_equal %w[--build_arg1 --build_arg2], LibGems::Command.build_args
+  end
+
+end
+

data/test/test_gem_gemcutter_utilities.rb

@@ -0,0 +1,103 @@
+require File.expand_path('../gemutilities', __FILE__)
+require 'libgems'
+require 'libgems/gemcutter_utilities'
+
+class TestGemGemcutterUtilities < RubyGemTestCase
+
+  def setup
+    super
+
+    ENV['RUBYGEMS_HOST'] = nil
+    LibGems.configuration.rubygems_api_key = nil
+
+    @cmd = LibGems::Command.new '', 'summary'
+    @cmd.extend LibGems::GemcutterUtilities
+  end
+
+  def test_sign_in
+    api_key     = 'a5fdbb6ba150cbb83aad2bb2fede64cf040453903'
+    util_sign_in [api_key, 200, 'OK']
+
+    assert_match %r{Enter your rubygems.org credentials.}, @sign_in_ui.output
+    assert @fetcher.last_request["authorization"]
+    assert_match %r{Signed in.}, @sign_in_ui.output
+
+    credentials = YAML.load_file LibGems.configuration.credentials_path
+    assert_equal api_key, credentials[:rubygems_api_key]
+  end
+
+  def test_sign_in_with_host
+    api_key     = 'a5fdbb6ba150cbb83aad2bb2fede64cf040453903'
+    util_sign_in [api_key, 200, 'OK'], 'http://example.com'
+
+    assert_match %r{Enter your rubygems.org credentials.}, @sign_in_ui.output
+    assert @fetcher.last_request["authorization"]
+    assert_match %r{Signed in.}, @sign_in_ui.output
+
+    credentials = YAML.load_file LibGems.configuration.credentials_path
+    assert_equal api_key, credentials[:rubygems_api_key]
+  end
+
+  def test_sign_in_skips_with_existing_credentials
+    api_key     = 'a5fdbb6ba150cbb83aad2bb2fede64cf040453903'
+    LibGems.configuration.rubygems_api_key = api_key
+
+    util_sign_in [api_key, 200, 'OK']
+
+    assert_equal "", @sign_in_ui.output
+  end
+
+  def test_sign_in_with_other_credentials_doesnt_overwrite_other_keys
+    api_key       = 'a5fdbb6ba150cbb83aad2bb2fede64cf040453903'
+    other_api_key = 'f46dbb18bb6a9c97cdc61b5b85c186a17403cdcbf'
+
+    FileUtils.mkdir_p File.dirname(LibGems.configuration.credentials_path)
+    open LibGems.configuration.credentials_path, 'w' do |f|
+      f.write Hash[:other_api_key, other_api_key].to_yaml
+    end
+    util_sign_in [api_key, 200, 'OK']
+
+    assert_match %r{Enter your rubygems.org credentials.}, @sign_in_ui.output
+    assert_match %r{Signed in.}, @sign_in_ui.output
+
+    credentials   = YAML.load_file LibGems.configuration.credentials_path
+    assert_equal api_key, credentials[:rubygems_api_key]
+    assert_equal other_api_key, credentials[:other_api_key]
+  end
+
+  def test_sign_in_with_bad_credentials
+    skip 'Always uses $stdin on windows' if LibGems.win_platform?
+
+    assert_raises MockGemUi::TermError do
+      util_sign_in ['Access Denied.', 403, 'Forbidden']
+    end
+
+    assert_match %r{Enter your rubygems.org credentials.}, @sign_in_ui.output
+    assert_match %r{Access Denied.}, @sign_in_ui.output
+  end
+
+  def util_sign_in response, host = nil
+    skip 'Always uses $stdin on windows' if LibGems.win_platform?
+
+    email    = 'you@example.com'
+    password = 'secret'
+
+    if host
+      ENV['RUBYGEMS_HOST'] = host
+    else
+      host = LibGems.host
+    end
+
+    @fetcher = LibGems::FakeFetcher.new
+    @fetcher.data["#{host}/api/v1/api_key"] = response
+    LibGems::RemoteFetcher.fetcher = @fetcher
+
+    @sign_in_ui = MockGemUi.new "#{email}\n#{password}\n"
+
+    use_ui @sign_in_ui do
+      @cmd.sign_in
+    end
+  end
+
+end
+

data/test/test_gem_indexer.rb

@@ -0,0 +1,673 @@
+require File.expand_path('../gemutilities', __FILE__)
+require 'libgems/indexer'
+
+unless defined?(Builder::XChar) then
+  warn "Gem::Indexer tests are being skipped.  Install builder gem." if $VERBOSE
+end
+
+class TestGemIndexer < RubyGemTestCase
+
+  def setup
+    super
+
+    util_make_gems
+
+    @d2_0 = quick_gem 'd', '2.0' do |s|
+      s.date = LibGems::Specification::TODAY - 86400 * 3
+    end
+    util_build_gem @d2_0
+
+    @d2_0_a = quick_gem 'd', '2.0.a'
+    util_build_gem @d2_0_a
+
+    @d2_0_b = quick_gem 'd', '2.0.b'
+    util_build_gem @d2_0_b
+
+    gems = File.join(@tempdir, 'gems')
+    FileUtils.mkdir_p gems
+    cache_gems = File.join @gemhome, 'cache', '*.gem'
+    FileUtils.mv Dir[cache_gems], gems
+
+    @indexer = LibGems::Indexer.new @tempdir, :rss_title => 'ExampleForge gems',
+                                :rss_host => 'example.com',
+                                :rss_gems_host => 'gems.example.com'
+  end
+
+  def test_initialize
+    assert_equal @tempdir, @indexer.dest_directory
+    assert_equal File.join(Dir.tmpdir, "gem_generate_index_#{$$}"),
+                 @indexer.directory
+
+    indexer = LibGems::Indexer.new @tempdir
+    assert indexer.build_legacy
+    assert indexer.build_modern
+
+    indexer = LibGems::Indexer.new @tempdir, :build_legacy => false,
+                               :build_modern => true
+    refute indexer.build_legacy
+    assert indexer.build_modern
+
+    indexer = LibGems::Indexer.new @tempdir, :build_legacy => true,
+                               :build_modern => false
+    assert indexer.build_legacy
+    refute indexer.build_modern
+  end
+
+  def test_build_indicies
+    spec = quick_gem 'd', '2.0'
+    spec.instance_variable_set :@original_platform, ''
+
+    @indexer.make_temp_directories
+
+    index = LibGems::SourceIndex.new
+    index.add_spec spec
+
+    use_ui @ui do
+      @indexer.build_indicies index
+    end
+
+    specs_path = File.join @indexer.directory, "specs.#{@marshal_version}"
+    specs_dump = LibGems.read_binary specs_path
+    specs = Marshal.load specs_dump
+
+    expected = [
+      ['d',      LibGems::Version.new('2.0'), 'ruby'],
+    ]
+
+    assert_equal expected, specs, 'specs'
+
+    latest_specs_path = File.join @indexer.directory,
+                                  "latest_specs.#{@marshal_version}"
+    latest_specs_dump = LibGems.read_binary latest_specs_path
+    latest_specs = Marshal.load latest_specs_dump
+
+    expected = [
+      ['d',      LibGems::Version.new('2.0'), 'ruby'],
+    ]
+
+    assert_equal expected, latest_specs, 'latest_specs'
+  end
+
+  def test_generate_index
+    use_ui @ui do
+      @indexer.generate_index
+    end
+
+    assert_indexed @tempdir, 'yaml'
+    assert_indexed @tempdir, 'yaml.Z'
+    assert_indexed @tempdir, "Marshal.#{@marshal_version}"
+    assert_indexed @tempdir, "Marshal.#{@marshal_version}.Z"
+
+    quickdir = File.join @tempdir, 'quick'
+    marshal_quickdir = File.join quickdir, "Marshal.#{@marshal_version}"
+
+    assert File.directory?(quickdir)
+    assert File.directory?(marshal_quickdir)
+
+    assert_indexed quickdir, "index"
+    assert_indexed quickdir, "index.rz"
+
+    quick_index = File.read File.join(quickdir, 'index')
+    expected = <<-EOF
+a-1
+a-2
+a-3.a
+a_evil-9
+b-2
+c-1.2
+d-2.0
+d-2.0.a
+d-2.0.b
+pl-1-i386-linux
+    EOF
+
+    assert_equal expected, quick_index
+
+    assert_indexed quickdir, "latest_index"
+    assert_indexed quickdir, "latest_index.rz"
+
+    latest_quick_index = File.read File.join(quickdir, 'latest_index')
+    expected = <<-EOF
+a-2
+a_evil-9
+b-2
+c-1.2
+d-2.0
+pl-1-i386-linux
+    EOF
+
+    assert_equal expected, latest_quick_index
+
+    assert_indexed quickdir, "#{@a1.spec_name}.rz"
+    assert_indexed quickdir, "#{@a2.spec_name}.rz"
+    assert_indexed quickdir, "#{@b2.spec_name}.rz"
+    assert_indexed quickdir, "#{@c1_2.spec_name}.rz"
+
+    assert_indexed quickdir, "#{@pl1.original_name}.gemspec.rz"
+    refute_indexed quickdir, "#{@pl1.spec_name}.rz"
+
+    assert_indexed marshal_quickdir, "#{@a1.spec_name}.rz"
+    assert_indexed marshal_quickdir, "#{@a2.spec_name}.rz"
+
+    refute_indexed quickdir, @c1_2.spec_name
+    refute_indexed marshal_quickdir, @c1_2.spec_name
+
+    assert_indexed @tempdir, "specs.#{@marshal_version}"
+    assert_indexed @tempdir, "specs.#{@marshal_version}.gz"
+
+    assert_indexed @tempdir, "latest_specs.#{@marshal_version}"
+    assert_indexed @tempdir, "latest_specs.#{@marshal_version}.gz"
+
+    expected = <<-EOF
+<?xml version=\"1.0\"?>
+<rss version=\"2.0\">
+  <channel>
+    <title>ExampleForge gems</title>
+    <link>http://example.com</link>
+    <description>Recently released gems from http://example.com</description>
+    <generator>#{LibGems::NAME} v#{LibGems::VERSION} (RubyGems v#{LibGems::GEM_VERSION})</generator>
+    <docs>http://cyber.law.harvard.edu/rss/rss.html</docs>
+    <item>
+      <title>a-2</title>
+      <description>
+&lt;pre&gt;This is a test description&lt;/pre&gt;
+      </description>
+      <author>example@example.com (A User)</author>
+      <guid>a-2</guid>
+      <enclosure url=\"http://gems.example.com/gems/a-2.gem\"
+                 length=\"3072\" type=\"application/octet-stream\" />
+      <pubDate>#{@a2.date.rfc2822}</pubDate>
+      <link>http://example.com</link>
+    </item>
+    <item>
+      <title>a-3.a</title>
+      <description>
+&lt;pre&gt;This is a test description&lt;/pre&gt;
+      </description>
+      <author>example@example.com (A User)</author>
+      <guid>a-3.a</guid>
+      <enclosure url=\"http://gems.example.com/gems/a-3.a.gem\"
+                 length=\"3072\" type=\"application/octet-stream\" />
+      <pubDate>#{@a3a.date.rfc2822}</pubDate>
+      <link>http://example.com</link>
+    </item>
+    <item>
+      <title>a_evil-9</title>
+      <description>
+&lt;pre&gt;This is a test description&lt;/pre&gt;
+      </description>
+      <author>example@example.com (A User)</author>
+      <guid>a_evil-9</guid>
+      <enclosure url=\"http://gems.example.com/gems/a_evil-9.gem\"
+                 length=\"3072\" type=\"application/octet-stream\" />
+      <pubDate>#{@a_evil9.date.rfc2822}</pubDate>
+      <link>http://example.com</link>
+    </item>
+    <item>
+      <title>b-2</title>
+      <description>
+&lt;pre&gt;This is a test description&lt;/pre&gt;
+      </description>
+      <author>example@example.com (A User)</author>
+      <guid>b-2</guid>
+      <enclosure url=\"http://gems.example.com/gems/b-2.gem\"
+                 length=\"3072\" type=\"application/octet-stream\" />
+      <pubDate>#{@b2.date.rfc2822}</pubDate>
+      <link>http://example.com</link>
+    </item>
+    <item>
+      <title>c-1.2</title>
+      <description>
+&lt;pre&gt;This is a test description&lt;/pre&gt;
+      </description>
+      <author>example@example.com (A User)</author>
+      <guid>c-1.2</guid>
+      <enclosure url=\"http://gems.example.com/gems/c-1.2.gem\"
+                 length=\"3072\" type=\"application/octet-stream\" />
+      <pubDate>#{@c1_2.date.rfc2822}</pubDate>
+      <link>http://example.com</link>
+    </item>
+    <item>
+      <title>d-2.0.a</title>
+      <description>
+&lt;pre&gt;This is a test description&lt;/pre&gt;
+      </description>
+      <author>example@example.com (A User)</author>
+      <guid>d-2.0.a</guid>
+      <enclosure url=\"http://gems.example.com/gems/d-2.0.a.gem\"
+                 length=\"3072\" type=\"application/octet-stream\" />
+      <pubDate>#{@d2_0_a.date.rfc2822}</pubDate>
+      <link>http://example.com</link>
+    </item>
+    <item>
+      <title>d-2.0.b</title>
+      <description>
+&lt;pre&gt;This is a test description&lt;/pre&gt;
+      </description>
+      <author>example@example.com (A User)</author>
+      <guid>d-2.0.b</guid>
+      <enclosure url=\"http://gems.example.com/gems/d-2.0.b.gem\"
+                 length=\"3072\" type=\"application/octet-stream\" />
+      <pubDate>#{@d2_0_b.date.rfc2822}</pubDate>
+      <link>http://example.com</link>
+    </item>
+    <item>
+      <title>pl-1-x86-linux</title>
+      <description>
+&lt;pre&gt;This is a test description&lt;/pre&gt;
+      </description>
+      <author>example@example.com (A User)</author>
+      <guid>pl-1-x86-linux</guid>
+      <enclosure url=\"http://gems.example.com/gems/pl-1-x86-linux.gem\"
+                 length=\"3072\" type=\"application/octet-stream\" />
+      <pubDate>#{@pl1.date.rfc2822}</pubDate>
+      <link>http://example.com</link>
+    </item>
+    <item>
+      <title>a-1</title>
+      <description>
+&lt;pre&gt;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.&lt;/pre&gt;
+      </description>
+      <author>example@example.com (Example), example2@example.com (Example2)</author>
+      <guid>a-1</guid>
+      <enclosure url=\"http://gems.example.com/gems/a-1.gem\"
+                 length=\"3584\" type=\"application/octet-stream\" />
+      <pubDate>#{@a1.date.rfc2822}</pubDate>
+      <link>http://a.example.com</link>
+    </item>
+  </channel>
+</rss>
+    EOF
+
+    gems_rss = File.read File.join(@tempdir, 'index.rss')
+
+    assert_equal expected, gems_rss
+  end
+
+  def test_generate_index_legacy
+    @indexer.build_modern = false
+    @indexer.build_legacy = true
+
+    use_ui @ui do
+      @indexer.generate_index
+    end
+
+    assert_indexed @tempdir, 'yaml'
+    assert_indexed @tempdir, 'yaml.Z'
+    assert_indexed @tempdir, "Marshal.#{@marshal_version}"
+    assert_indexed @tempdir, "Marshal.#{@marshal_version}.Z"
+
+    quickdir = File.join @tempdir, 'quick'
+    marshal_quickdir = File.join quickdir, "Marshal.#{@marshal_version}"
+
+    assert File.directory?(quickdir)
+    assert File.directory?(marshal_quickdir)
+
+    assert_indexed quickdir, "index"
+    assert_indexed quickdir, "index.rz"
+
+    assert_indexed quickdir, "latest_index"
+    assert_indexed quickdir, "latest_index.rz"
+
+    assert_indexed quickdir, "#{@a1.spec_name}.rz"
+    assert_indexed quickdir, "#{@a2.spec_name}.rz"
+    assert_indexed quickdir, "#{@b2.spec_name}.rz"
+    assert_indexed quickdir, "#{@c1_2.spec_name}.rz"
+
+    assert_indexed quickdir, "#{@pl1.original_name}.gemspec.rz"
+    refute_indexed quickdir, "#{@pl1.spec_name}.rz"
+
+    assert_indexed marshal_quickdir, "#{@a1.spec_name}.rz"
+    assert_indexed marshal_quickdir, "#{@a2.spec_name}.rz"
+
+    refute_indexed quickdir, "#{@c1_2.spec_name}"
+    refute_indexed marshal_quickdir, "#{@c1_2.spec_name}"
+
+    refute_indexed @tempdir, "specs.#{@marshal_version}"
+    refute_indexed @tempdir, "specs.#{@marshal_version}.gz"
+
+    refute_indexed @tempdir, "latest_specs.#{@marshal_version}"
+    refute_indexed @tempdir, "latest_specs.#{@marshal_version}.gz"
+  end
+
+  def test_generate_index_legacy_back_to_back
+    @indexer.build_modern = true
+    @indexer.build_legacy = true
+
+    use_ui @ui do
+      @indexer.generate_index
+    end
+
+    @indexer = LibGems::Indexer.new @tempdir
+    @indexer.build_modern = false
+    @indexer.build_legacy = true
+
+    use_ui @ui do
+      @indexer.generate_index
+    end
+
+    assert_indexed @tempdir, 'yaml'
+    assert_indexed @tempdir, 'yaml.Z'
+    assert_indexed @tempdir, "Marshal.#{@marshal_version}"
+    assert_indexed @tempdir, "Marshal.#{@marshal_version}.Z"
+
+    quickdir = File.join @tempdir, 'quick'
+    marshal_quickdir = File.join quickdir, "Marshal.#{@marshal_version}"
+
+    assert File.directory?(quickdir)
+    assert File.directory?(marshal_quickdir)
+
+    assert_indexed quickdir, "index"
+    assert_indexed quickdir, "index.rz"
+
+    assert_indexed quickdir, "latest_index"
+    assert_indexed quickdir, "latest_index.rz"
+
+    assert_indexed quickdir, "#{@a1.spec_name}.rz"
+    assert_indexed quickdir, "#{@a2.spec_name}.rz"
+    assert_indexed quickdir, "#{@b2.spec_name}.rz"
+    assert_indexed quickdir, "#{@c1_2.spec_name}.rz"
+
+    assert_indexed quickdir, "#{@pl1.original_name}.gemspec.rz"
+
+    assert_indexed marshal_quickdir, "#{@a1.spec_name}.rz"
+    assert_indexed marshal_quickdir, "#{@a2.spec_name}.rz"
+
+    assert_indexed @tempdir, "specs.#{@marshal_version}"
+    assert_indexed @tempdir, "specs.#{@marshal_version}.gz"
+
+    assert_indexed @tempdir, "latest_specs.#{@marshal_version}"
+    assert_indexed @tempdir, "latest_specs.#{@marshal_version}.gz"
+  end
+
+  def test_generate_index_modern
+    @indexer.build_modern = true
+    @indexer.build_legacy = false
+
+    use_ui @ui do
+      @indexer.generate_index
+    end
+
+    refute_indexed @tempdir, 'yaml'
+    refute_indexed @tempdir, 'yaml.Z'
+    refute_indexed @tempdir, "Marshal.#{@marshal_version}"
+    refute_indexed @tempdir, "Marshal.#{@marshal_version}.Z"
+
+    quickdir = File.join @tempdir, 'quick'
+    marshal_quickdir = File.join quickdir, "Marshal.#{@marshal_version}"
+
+    assert File.directory?(quickdir), 'quickdir should be directory'
+    assert File.directory?(marshal_quickdir)
+
+    refute_indexed quickdir, "index"
+    refute_indexed quickdir, "index.rz"
+
+    refute_indexed quickdir, "latest_index"
+    refute_indexed quickdir, "latest_index.rz"
+
+    refute_indexed quickdir, "#{@a1.spec_name}.rz"
+    refute_indexed quickdir, "#{@a2.spec_name}.rz"
+    refute_indexed quickdir, "#{@b2.spec_name}.rz"
+    refute_indexed quickdir, "#{@c1_2.spec_name}.rz"
+
+    refute_indexed quickdir, "#{@pl1.original_name}.gemspec.rz"
+    refute_indexed quickdir, "#{@pl1.spec_name}.rz"
+
+    assert_indexed marshal_quickdir, "#{@a1.spec_name}.rz"
+    assert_indexed marshal_quickdir, "#{@a2.spec_name}.rz"
+
+    refute_indexed quickdir, "#{@c1_2.spec_name}"
+    refute_indexed marshal_quickdir, "#{@c1_2.spec_name}"
+
+    assert_indexed @tempdir, "specs.#{@marshal_version}"
+    assert_indexed @tempdir, "specs.#{@marshal_version}.gz"
+
+    assert_indexed @tempdir, "latest_specs.#{@marshal_version}"
+    assert_indexed @tempdir, "latest_specs.#{@marshal_version}.gz"
+  end
+
+  def test_generate_index_modern_back_to_back
+    @indexer.build_modern = true
+    @indexer.build_legacy = true
+
+    use_ui @ui do
+      @indexer.generate_index
+    end
+
+    @indexer = LibGems::Indexer.new @tempdir
+    @indexer.build_modern = true
+    @indexer.build_legacy = false
+
+    use_ui @ui do
+      @indexer.generate_index
+    end
+
+    assert_indexed @tempdir, 'yaml'
+    assert_indexed @tempdir, 'yaml.Z'
+    assert_indexed @tempdir, "Marshal.#{@marshal_version}"
+    assert_indexed @tempdir, "Marshal.#{@marshal_version}.Z"
+
+    quickdir = File.join @tempdir, 'quick'
+    marshal_quickdir = File.join quickdir, "Marshal.#{@marshal_version}"
+
+    assert File.directory?(quickdir)
+    assert File.directory?(marshal_quickdir)
+
+    assert_indexed quickdir, "index"
+    assert_indexed quickdir, "index.rz"
+
+    assert_indexed quickdir, "latest_index"
+    assert_indexed quickdir, "latest_index.rz"
+
+    assert_indexed quickdir, "#{@a1.spec_name}.rz"
+    assert_indexed quickdir, "#{@a2.spec_name}.rz"
+    assert_indexed quickdir, "#{@b2.spec_name}.rz"
+    assert_indexed quickdir, "#{@c1_2.spec_name}.rz"
+
+    assert_indexed quickdir, "#{@pl1.original_name}.gemspec.rz"
+
+    assert_indexed marshal_quickdir, "#{@a1.spec_name}.rz"
+    assert_indexed marshal_quickdir, "#{@a2.spec_name}.rz"
+
+    assert_indexed @tempdir, "specs.#{@marshal_version}"
+    assert_indexed @tempdir, "specs.#{@marshal_version}.gz"
+
+    assert_indexed @tempdir, "latest_specs.#{@marshal_version}"
+    assert_indexed @tempdir, "latest_specs.#{@marshal_version}.gz"
+  end
+
+  def test_generate_index_ui
+    use_ui @ui do
+      @indexer.generate_index
+    end
+
+    assert_match %r%^Loading 10 gems from #{Regexp.escape @tempdir}$%,
+                 @ui.output
+    assert_match %r%^\.\.\.\.\.\.\.\.\.\.$%, @ui.output
+    assert_match %r%^Loaded all gems$%, @ui.output
+    assert_match %r%^Generating Marshal quick index gemspecs for 10 gems$%,
+                 @ui.output
+    assert_match %r%^Generating YAML quick index gemspecs for 10 gems$%,
+                 @ui.output
+    assert_match %r%^Complete$%, @ui.output
+    assert_match %r%^Generating specs index$%, @ui.output
+    assert_match %r%^Generating latest specs index$%, @ui.output
+    assert_match %r%^Generating quick index$%, @ui.output
+    assert_match %r%^Generating latest index$%, @ui.output
+    assert_match %r%^Generating prerelease specs index$%, @ui.output
+    assert_match %r%^Generating Marshal master index$%, @ui.output
+    assert_match %r%^Generating YAML master index for 10 gems \(this may take a while\)$%, @ui.output
+    assert_match %r%^Complete$%, @ui.output
+    assert_match %r%^Compressing indicies$%, @ui.output
+
+    assert_equal '', @ui.error
+  end
+
+  def test_generate_index_master
+    use_ui @ui do
+      @indexer.generate_index
+    end
+
+    yaml_path = File.join @tempdir, 'yaml'
+    dump_path = File.join @tempdir, "Marshal.#{@marshal_version}"
+
+    yaml_index = YAML.load_file yaml_path
+    dump_index = Marshal.load LibGems.read_binary(dump_path)
+
+    dump_index.each do |_,gem|
+      gem.send :remove_instance_variable, :@loaded
+    end
+
+    assert_equal yaml_index, dump_index,
+                 "expected YAML and Marshal to produce identical results"
+  end
+
+  def test_generate_index_specs
+    use_ui @ui do
+      @indexer.generate_index
+    end
+
+    specs_path = File.join @tempdir, "specs.#{@marshal_version}"
+
+    specs_dump = LibGems.read_binary specs_path
+    specs = Marshal.load specs_dump
+
+    expected = [
+      ['a',      LibGems::Version.new(1),     'ruby'],
+      ['a',      LibGems::Version.new(2),     'ruby'],
+      ['a_evil', LibGems::Version.new(9),     'ruby'],
+      ['b',      LibGems::Version.new(2),     'ruby'],
+      ['c',      LibGems::Version.new('1.2'), 'ruby'],
+      ['d',      LibGems::Version.new('2.0'), 'ruby'],
+      ['pl',     LibGems::Version.new(1),     'i386-linux'],
+    ]
+
+    assert_equal expected, specs
+
+    assert_same specs[0].first, specs[1].first,
+                'identical names not identical'
+
+    assert_same specs[0][1],    specs[-1][1],
+                'identical versions not identical'
+
+    assert_same specs[0].last, specs[1].last,
+                'identical platforms not identical'
+
+    refute_same specs[1][1], specs[5][1],
+                'different versions not different'
+  end
+
+  def test_generate_index_latest_specs
+    use_ui @ui do
+      @indexer.generate_index
+    end
+
+    latest_specs_path = File.join @tempdir, "latest_specs.#{@marshal_version}"
+
+    latest_specs_dump = LibGems.read_binary latest_specs_path
+    latest_specs = Marshal.load latest_specs_dump
+
+    expected = [
+      ['a',      LibGems::Version.new(2),     'ruby'],
+      ['a_evil', LibGems::Version.new(9),     'ruby'],
+      ['b',      LibGems::Version.new(2),     'ruby'],
+      ['c',      LibGems::Version.new('1.2'), 'ruby'],
+      ['d',      LibGems::Version.new('2.0'), 'ruby'],
+      ['pl',     LibGems::Version.new(1),     'i386-linux'],
+    ]
+
+    assert_equal expected, latest_specs
+
+    assert_same latest_specs[0][1],   latest_specs[2][1],
+                'identical versions not identical'
+
+    assert_same latest_specs[0].last, latest_specs[1].last,
+                'identical platforms not identical'
+  end
+
+  def test_generate_index_prerelease_specs
+    use_ui @ui do
+      @indexer.generate_index
+    end
+
+    prerelease_specs_path = File.join @tempdir, "prerelease_specs.#{@marshal_version}"
+
+    prerelease_specs_dump = LibGems.read_binary prerelease_specs_path
+    prerelease_specs = Marshal.load prerelease_specs_dump
+
+    assert_equal [['a', LibGems::Version.new('3.a'),   'ruby'],
+                  ['d', LibGems::Version.new('2.0.a'), 'ruby'],
+                  ['d', LibGems::Version.new('2.0.b'), 'ruby']],
+                 prerelease_specs
+  end
+
+  def test_update_index
+    use_ui @ui do
+      @indexer.generate_index
+    end
+
+    quickdir = File.join @tempdir, 'quick'
+    marshal_quickdir = File.join quickdir, "Marshal.#{@marshal_version}"
+
+    assert File.directory?(quickdir)
+    assert File.directory?(marshal_quickdir)
+
+    @d2_1 = quick_gem 'd', '2.1'
+    util_build_gem @d2_1
+    @d2_1_tuple = [@d2_1.name, @d2_1.version, @d2_1.original_platform]
+
+    @d2_1_a = quick_gem 'd', '2.2.a'
+    util_build_gem @d2_1_a
+    @d2_1_a_tuple = [@d2_1_a.name, @d2_1_a.version, @d2_1_a.original_platform]
+
+    gems = File.join @tempdir, 'gems'
+    FileUtils.mv File.join(@gemhome, 'cache', @d2_1.file_name), gems
+    FileUtils.mv File.join(@gemhome, 'cache', @d2_1_a.file_name), gems
+
+    use_ui @ui do
+      @indexer.update_index
+    end
+
+    assert_indexed marshal_quickdir, "#{@d2_1.spec_name}.rz"
+
+    specs_index = Marshal.load LibGems.read_binary(@indexer.dest_specs_index)
+
+    assert_includes specs_index, @d2_1_tuple
+    refute_includes specs_index, @d2_1_a_tuple
+
+    latest_specs_index = Marshal.load \
+      LibGems.read_binary(@indexer.dest_latest_specs_index)
+
+    assert_includes latest_specs_index, @d2_1_tuple
+    assert_includes latest_specs_index,
+                    [@d2_0.name, @d2_0.version, @d2_0.original_platform]
+    refute_includes latest_specs_index, @d2_1_a_tuple
+
+    pre_specs_index = Marshal.load \
+      LibGems.read_binary(@indexer.dest_prerelease_specs_index)
+
+    assert_includes pre_specs_index, @d2_1_a_tuple
+    refute_includes pre_specs_index, @d2_1_tuple
+  end
+
+  def assert_indexed(dir, name)
+    file = File.join dir, name
+    assert File.exist?(file), "#{file} does not exist"
+  end
+
+  def refute_indexed(dir, name)
+    file = File.join dir, name
+    refute File.exist?(file), "#{file} exists"
+  end
+
+end if defined?(Builder::XChar)
+