rubygems-update 1.8.30 → 2.0.0.preview2

data/test/rubygems/test_gem_available_set.rb

@@ -0,0 +1,106 @@
+require 'rubygems/test_case'
+require 'rubygems/available_set'
+require 'rubygems/security'
+
+class TestGemAvailableSet < Gem::TestCase
+  def setup
+    super
+
+    @source = Gem::Source.new(@gem_repo)
+  end
+
+  def test_add_and_empty
+    a1, _ = util_gem 'a', '1'
+
+    set = Gem::AvailableSet.new
+    assert set.empty?
+
+    set.add a1, @source
+
+    refute set.empty?
+
+    assert_equal [a1], set.all_specs
+  end
+
+  def test_match_platform
+    a1, _ = util_gem 'a', '1' do |g|
+      g.platform = "something-weird-yep"
+    end
+
+    a1c, _ = util_gem 'a', '2' do |g|
+      g.platform = Gem::Platform.local
+    end
+
+    a2, _ = util_gem 'a', '2'
+
+    set = Gem::AvailableSet.new
+    set.add a1, @source
+    set.add a1c, @source
+    set.add a2, @source
+
+    set.match_platform!
+
+    assert_equal [a1c, a2], set.all_specs
+  end
+
+  def test_best
+    a1, _ = util_gem 'a', '1'
+    a2, _  = util_gem 'a', '2'
+
+    set = Gem::AvailableSet.new
+    set.add a1, @source
+    set.add a2, @source
+
+    set.pick_best!
+
+    assert_equal [a2], set.all_specs
+  end
+
+  def test_remove_installed_bang
+    a1, _ = util_gem 'a', '1'
+
+    a1.activate
+
+    set = Gem::AvailableSet.new
+    set.add a1, @source
+
+    dep = Gem::Dependency.new "a", ">= 0"
+
+    set.remove_installed! dep
+
+    assert set.empty?
+  end
+
+  def test_sorted_normal_versions
+    a1, _ = util_gem 'a', '1'
+    a2, _  = util_gem 'a', '2'
+
+    set = Gem::AvailableSet.new
+    set.add a1, @source
+    set.add a2, @source
+
+    g = set.sorted
+
+    assert_equal a2, g[0].spec
+    assert_equal a1, g[1].spec
+  end
+
+  def test_sorted_respect_pre
+    a1a, _ = util_gem 'a', '1.a'
+    a1,  _ = util_gem 'a', '1'
+    a2a, _ = util_gem 'a', '2.a'
+    a2,  _ = util_gem 'a', '2'
+    a3a, _ = util_gem 'a', '3.a'
+
+    set = Gem::AvailableSet.new
+    set.add a1, @source
+    set.add a1a, @source
+    set.add a3a, @source
+    set.add a2a, @source
+    set.add a2, @source
+
+    g = set.sorted.map { |t| t.spec }
+
+    assert_equal [a3a, a2, a2a, a1, a1a], g
+  end
+end

data/test/rubygems/test_gem_command.rb

@@ -109,6 +109,16 @@ class TestGemCommand < Gem::TestCase
     assert @xopt, "Should have done xopt"
   end
 
+  def test_invoke_with_build_args
+    @cmd.when_invoked { true }
+
+    use_ui @ui do
+      @cmd.invoke_with_build_args ["-x"], ["--awesome=true"]
+    end
+
+    assert_equal ["--awesome=true"], @cmd.options[:build_args]
+  end
+
   # Returning false from the command handler invokes the usage output.
   def test_invoke_with_help
     done = false

data/test/rubygems/test_gem_command_manager.rb

@@ -6,7 +6,47 @@ class TestGemCommandManager < Gem::TestCase
   def setup
     super
 
-    @command_manager = Gem::CommandManager.instance
+    @command_manager = Gem::CommandManager.new
+  end
+
+  def test_find_command
+    command = @command_manager.find_command 'install'
+
+    assert_kind_of Gem::Commands::InstallCommand, command
+
+    command = @command_manager.find_command 'ins'
+
+    assert_kind_of Gem::Commands::InstallCommand, command
+  end
+
+  def test_find_command_ambiguous
+    e = assert_raises Gem::CommandLineError do
+      @command_manager.find_command 'u'
+    end
+
+    assert_equal 'Ambiguous command u matches [uninstall, unpack, update]',
+                 e.message
+  end
+
+  def test_find_command_ambiguous_exact
+    ins_command = Class.new
+    Gem::Commands.send :const_set, :InsCommand, ins_command
+
+    @command_manager.register_command :ins
+
+    command = @command_manager.find_command 'ins'
+
+    assert_kind_of ins_command, command
+  ensure
+    Gem::Commands.send :remove_const, :InsCommand
+  end
+
+  def test_find_command_unknown
+    e = assert_raises Gem::CommandLineError do
+      @command_manager.find_command 'xyz'
+    end
+
+    assert_equal 'Unknown command xyz', e.message
   end
 
   def test_run_interrupt
@@ -14,6 +54,8 @@ class TestGemCommandManager < Gem::TestCase
     $: << File.expand_path("test/rubygems", @@project_dir)
     Gem.load_env_plugins
 
+    @command_manager.register_command :interrupt
+
     use_ui @ui do
       assert_raises Gem::MockGemUi::TermError do
         @command_manager.run 'interrupt'
@@ -54,6 +96,7 @@ class TestGemCommandManager < Gem::TestCase
     assert_match(/invalid option: --bad-arg/i, @ui.error)
   end
 
+  # HACK move to install command test
   def test_process_args_install
     #capture all install options
     use_ui @ui do
@@ -65,7 +108,7 @@ class TestGemCommandManager < Gem::TestCase
 
       #check defaults
       @command_manager.process_args("install")
-      assert_equal true, check_options[:generate_rdoc]
+      assert_equal %w[ri], check_options[:document].sort
       assert_equal false, check_options[:force]
       assert_equal :both, check_options[:domain]
       assert_equal true, check_options[:wrappers]
@@ -77,7 +120,7 @@ class TestGemCommandManager < Gem::TestCase
       check_options = nil
       @command_manager.process_args(
         "install --force --local --rdoc --install-dir . --version 3.0 --no-wrapper --bindir . ")
-      assert_equal true, check_options[:generate_rdoc]
+      assert_equal %w[rdoc ri], check_options[:document].sort
       assert_equal true, check_options[:force]
       assert_equal :local, check_options[:domain]
       assert_equal false, check_options[:wrappers]
@@ -102,6 +145,7 @@ class TestGemCommandManager < Gem::TestCase
     end
   end
 
+  # HACK move to uninstall command test
   def test_process_args_uninstall
     #capture all uninstall options
     check_options = nil
@@ -121,6 +165,7 @@ class TestGemCommandManager < Gem::TestCase
     assert_equal Gem::Requirement.new('3.0'), check_options[:version]
   end
 
+  # HACK move to check command test
   def test_process_args_check
     #capture all check options
     check_options = nil
@@ -131,16 +176,15 @@ class TestGemCommandManager < Gem::TestCase
 
     #check defaults
     @command_manager.process_args("check")
-    assert_equal false, check_options[:verify]
-    assert_equal false, check_options[:alien]
+    assert_equal true, check_options[:alien]
 
     #check settings
     check_options = nil
-    @command_manager.process_args("check --verify foobar --alien")
-    assert_equal "foobar", check_options[:verify]
+    @command_manager.process_args("check foobar --alien")
     assert_equal true, check_options[:alien]
   end
 
+  # HACK move to build command test
   def test_process_args_build
     #capture all build options
     check_options = nil
@@ -159,6 +203,7 @@ class TestGemCommandManager < Gem::TestCase
     assert_equal 'foobar.rb', check_options[:args].first
   end
 
+  # HACK move to query command test
   def test_process_args_query
     #capture all query options
     check_options = nil
@@ -191,6 +236,7 @@ class TestGemCommandManager < Gem::TestCase
     assert_equal :both, check_options[:domain]
   end
 
+  # HACK move to update command test
   def test_process_args_update
     #capture all update options
     check_options = nil
@@ -201,12 +247,12 @@ class TestGemCommandManager < Gem::TestCase
 
     #check defaults
     @command_manager.process_args("update")
-    assert_equal true, check_options[:generate_rdoc]
+    assert_includes check_options[:document], 'rdoc'
 
     #check settings
     check_options = nil
     @command_manager.process_args("update --force --rdoc --install-dir .")
-    assert_equal true, check_options[:generate_rdoc]
+    assert_includes check_options[:document], 'ri'
     assert_equal true, check_options[:force]
     assert_equal Dir.pwd, check_options[:install_dir]
   end

data/test/rubygems/test_gem_commands_build_command.rb

@@ -1,6 +1,6 @@
 require 'rubygems/test_case'
 require 'rubygems/commands/build_command'
-require 'rubygems/format'
+require 'rubygems/package'
 
 class TestGemCommandsBuildCommand < Gem::TestCase
 
@@ -24,16 +24,6 @@ class TestGemCommandsBuildCommand < Gem::TestCase
     util_test_build_gem @gem, gemspec_file
   end
 
-  def test_execute_yaml
-    gemspec_file = File.join(@tempdir, @gem.spec_name)
-
-    File.open gemspec_file, 'w' do |gs|
-      gs.write @gem.to_yaml
-    end
-
-    util_test_build_gem @gem, gemspec_file
-  end
-
   def test_execute_bad_spec
     @gem.date = "2010-11-08"
 
@@ -72,7 +62,7 @@ class TestGemCommandsBuildCommand < Gem::TestCase
     assert_equal "ERROR:  Gemspec file not found: some_gem\n", @ui.error
   end
 
-  def util_test_build_gem(gem, gemspec_file)
+  def util_test_build_gem(gem, gemspec_file, check_licenses=true)
     @cmd.options[:args] = [gemspec_file]
 
     use_ui @ui do
@@ -87,32 +77,34 @@ class TestGemCommandsBuildCommand < Gem::TestCase
     assert_equal "  Version: 2", output.shift
     assert_equal "  File: some_gem-2.gem", output.shift
     assert_equal [], output
-    assert_equal '', @ui.error
+
+    if check_licenses
+      assert_equal "WARNING:  licenses is empty\n", @ui.error
+    end
 
     gem_file = File.join @tempdir, File.basename(gem.cache_file)
     assert File.exist?(gem_file)
 
-    spec = Gem::Format.from_file_by_path(gem_file).spec
+    spec = Gem::Package.new(gem_file).spec
 
     assert_equal "some_gem", spec.name
     assert_equal "this is a summary", spec.summary
   end
 
   def test_execute_force
-    @gem.instance_variable_set :@required_rubygems_version, nil
-
     gemspec_file = File.join(@tempdir, @gem.spec_name)
 
+    @gem.send :remove_instance_variable, :@rubygems_version
+
     File.open gemspec_file, 'w' do |gs|
-      gs.write @gem.to_yaml
+      gs.write @gem.to_ruby
     end
 
     @cmd.options[:args] = [gemspec_file]
     @cmd.options[:force] = true
 
-    util_test_build_gem @gem, gemspec_file
+    util_test_build_gem @gem, gemspec_file, false
   end
 
-
 end
 

data/test/rubygems/test_gem_commands_cert_command.rb

@@ -8,117 +8,516 @@ end
 
 class TestGemCommandsCertCommand < Gem::TestCase
 
+  ALTERNATE_CERT = load_cert 'alternate'
+
+  ALTERNATE_KEY_FILE = key_path 'alternate'
+  PRIVATE_KEY_FILE   = key_path 'private'
+  PUBLIC_KEY_FILE    = key_path 'public'
+
+  ALTERNATE_CERT_FILE = cert_path 'alternate'
+  CHILD_CERT_FILE     = cert_path 'child'
+  PUBLIC_CERT_FILE    = cert_path 'public'
+
   def setup
     super
 
-    @orig_security_trust_dir = Gem::Security::OPT[:trust_dir]
-    Gem::Security::OPT[:trust_dir] = @tempdir
-
     @cmd = Gem::Commands::CertCommand.new
 
-    root = File.expand_path(File.dirname(__FILE__), @@project_dir)
+    @trust_dir = Gem::Security.trust_dir
+  end
+
+  def test_certificates_matching
+    @trust_dir.trust_cert PUBLIC_CERT
+    @trust_dir.trust_cert ALTERNATE_CERT
 
-    FileUtils.cp File.join(root, 'data', 'gem-private_key.pem'), @tempdir
-    FileUtils.cp File.join(root, 'data', 'gem-public_cert.pem'), @tempdir
+    matches = @cmd.certificates_matching ''
 
-    @cert_file_name = File.join @tempdir, 'gem-public_cert.pem'
-    @pkey_file_name = File.join @tempdir, 'gem-private_key.pem'
+    # HACK OpenSSL::X509::Certificate#== is Object#==, so do this the hard way
+    match = matches.next
+    assert_equal ALTERNATE_CERT.to_pem, match.first.to_pem
+    assert_equal @trust_dir.cert_path(ALTERNATE_CERT), match.last
+
+    match = matches.next
+    assert_equal PUBLIC_CERT.to_pem, match.first.to_pem
+    assert_equal @trust_dir.cert_path(PUBLIC_CERT), match.last
+
+    assert_raises StopIteration do
+      matches.next
+    end
   end
 
-  def teardown
-    Gem::Security::OPT[:trust_dir] = @orig_security_trust_dir
+  def test_certificates_matching_filter
+    @trust_dir.trust_cert PUBLIC_CERT
+    @trust_dir.trust_cert ALTERNATE_CERT
 
-    super
+    matches = @cmd.certificates_matching 'alternate'
+
+    match = matches.next
+    assert_equal ALTERNATE_CERT.to_pem, match.first.to_pem
+    assert_equal @trust_dir.cert_path(ALTERNATE_CERT), match.last
+
+    assert_raises StopIteration do
+      matches.next
+    end
   end
 
   def test_execute_add
+    @cmd.handle_options %W[--add #{PUBLIC_CERT_FILE}]
+
     use_ui @ui do
-      @cmd.send :handle_options, %W[--add #{@cert_file_name}]
+      @cmd.execute
     end
 
-    assert_equal "Added '/CN=rubygems/DC=example/DC=com'\n", @ui.output
-    assert_equal '', @ui.error
+    cert_path = @trust_dir.cert_path PUBLIC_CERT
+
+    assert_path_exists cert_path
+
+    assert_equal "Added '/CN=nobody/DC=example'\n", @ui.output
+    assert_empty @ui.error
+  end
+
+  def test_execute_add_twice
+    self.class.cert_path 'alternate'
+
+    @cmd.handle_options %W[
+      --add #{PUBLIC_CERT_FILE}
+      --add #{ALTERNATE_CERT_FILE}
+    ]
+
+    use_ui @ui do
+      @cmd.execute
+    end
+
+    expected = <<-EXPECTED
+Added '/CN=nobody/DC=example'
+Added '/CN=alternate/DC=example'
+    EXPECTED
+
+    assert_equal expected, @ui.output
+    assert_empty @ui.error
   end
 
   def test_execute_build
-    FileUtils.rm @cert_file_name
-    FileUtils.rm @pkey_file_name
+    @cmd.handle_options %W[--build nobody@example.com]
 
     use_ui @ui do
-      Dir.chdir @tempdir do
-        @cmd.send :handle_options, %W[--build nobody@example.com]
-      end
+      @cmd.execute
     end
 
     output = @ui.output.split "\n"
 
-    assert_equal 'Public Cert: gem-public_cert.pem', output.shift
-    assert_equal 'Private Key: gem-private_key.pem', output.shift
-    assert_equal 'Don\'t forget to move the key file to somewhere private...',
+    assert_equal "Certificate: #{File.join @tempdir, 'gem-public_cert.pem'}",
+                 output.shift
+    assert_equal "Private Key: #{File.join @tempdir, 'gem-private_key.pem'}",
                  output.shift
-    assert_equal [], output
 
-    assert_equal '', @ui.error
+    assert_equal "Don't forget to move the key file to somewhere private!",
+                 output.shift
+
+    assert_empty output
+    assert_empty @ui.error
+
+    assert_path_exists File.join(@tempdir, 'gem-private_key.pem')
+    assert_path_exists File.join(@tempdir, 'gem-public_cert.pem')
+  end
+
+  def test_execute_build_key
+    @cmd.handle_options %W[
+      --build nobody@example.com
+      --private-key #{PRIVATE_KEY_FILE}
+    ]
+
+    use_ui @ui do
+      @cmd.execute
+    end
+
+    output = @ui.output.split "\n"
+
+    assert_equal "Certificate: #{File.join @tempdir, 'gem-public_cert.pem'}",
+                 output.shift
+    assert_equal "Private Key: #{File.join @tempdir, 'gem-private_key.pem'}",
+                 output.shift
+
+    assert_equal "Don't forget to move the key file to somewhere private!",
+                 output.shift
+
+    assert_empty output
+    assert_empty @ui.error
+
+    assert_path_exists File.join(@tempdir, 'gem-public_cert.pem')
+
+    private_key_file = File.join @tempdir, 'gem-private_key.pem'
+    assert_path_exists private_key_file
 
-    assert File.exist?(File.join(@tempdir, 'gem-private_key.pem'))
-    assert File.exist?(File.join(@tempdir, 'gem-public_cert.pem'))
+    assert_equal PRIVATE_KEY.to_pem, File.read(private_key_file)
   end
 
   def test_execute_certificate
     use_ui @ui do
-      @cmd.send :handle_options, %W[--certificate #{@cert_file_name}]
+      @cmd.handle_options %W[--certificate #{PUBLIC_CERT_FILE}]
     end
 
     assert_equal '', @ui.output
     assert_equal '', @ui.error
 
-    assert_equal File.read(@cert_file_name),
-                 @cmd.options[:issuer_cert].to_s
+    assert_equal PUBLIC_CERT.to_pem, @cmd.options[:issuer_cert].to_pem
   end
 
   def test_execute_list
+    @trust_dir.trust_cert PUBLIC_CERT
+    @trust_dir.trust_cert ALTERNATE_CERT
+
+    @cmd.handle_options %W[--list]
+
     use_ui @ui do
-      @cmd.send :handle_options, %W[--list]
+      @cmd.execute
     end
 
-    assert_equal "/CN=rubygems/DC=example/DC=com\n", @ui.output
-    assert_equal '', @ui.error
+    assert_equal "/CN=alternate/DC=example\n/CN=nobody/DC=example\n",
+                 @ui.output
+    assert_empty @ui.error
+  end
+
+  def test_execute_list_filter
+    @trust_dir.trust_cert PUBLIC_CERT
+    @trust_dir.trust_cert ALTERNATE_CERT
+
+    @cmd.handle_options %W[--list nobody]
+
+    use_ui @ui do
+      @cmd.execute
+    end
+
+    assert_equal "/CN=nobody/DC=example\n", @ui.output
+    assert_empty @ui.error
   end
 
   def test_execute_private_key
     use_ui @ui do
-      @cmd.send :handle_options, %W[--private-key #{@pkey_file_name}]
+      @cmd.send :handle_options, %W[--private-key #{PRIVATE_KEY_FILE}]
     end
 
     assert_equal '', @ui.output
     assert_equal '', @ui.error
 
-    assert_equal File.read(@pkey_file_name),
-                 @cmd.options[:issuer_key].to_s
+    assert_equal PRIVATE_KEY.to_pem, @cmd.options[:key].to_pem
   end
 
   def test_execute_remove
+    @trust_dir.trust_cert PUBLIC_CERT
+
+    cert_path = @trust_dir.cert_path PUBLIC_CERT
+
+    assert_path_exists cert_path
+
+    @cmd.handle_options %W[--remove nobody]
+
+    use_ui @ui do
+      @cmd.execute
+    end
+
+    assert_equal "Removed '/CN=nobody/DC=example'\n", @ui.output
+    assert_equal '', @ui.error
+
+    refute_path_exists cert_path
+  end
+
+  def test_execute_remove_multiple
+    @trust_dir.trust_cert PUBLIC_CERT
+    @trust_dir.trust_cert ALTERNATE_CERT
+
+    public_path = @trust_dir.cert_path PUBLIC_CERT
+    alternate_path = @trust_dir.cert_path ALTERNATE_CERT
+
+    assert_path_exists public_path
+    assert_path_exists alternate_path
+
+    @cmd.handle_options %W[--remove example]
+
     use_ui @ui do
-      @cmd.send :handle_options, %W[--remove rubygems]
+      @cmd.execute
     end
 
-    assert_equal "Removed '/CN=rubygems/DC=example/DC=com'\n", @ui.output
+    expected = <<-EXPECTED
+Removed '/CN=alternate/DC=example'
+Removed '/CN=nobody/DC=example'
+    EXPECTED
+
+    assert_equal expected, @ui.output
     assert_equal '', @ui.error
 
-    refute File.exist?(@cert_file_name)
+    refute_path_exists public_path
+    refute_path_exists alternate_path
+  end
+
+  def test_execute_remove_twice
+    @trust_dir.trust_cert PUBLIC_CERT
+    @trust_dir.trust_cert ALTERNATE_CERT
+
+    public_path = @trust_dir.cert_path PUBLIC_CERT
+    alternate_path = @trust_dir.cert_path ALTERNATE_CERT
+
+    assert_path_exists public_path
+    assert_path_exists alternate_path
+
+    @cmd.handle_options %W[--remove nobody --remove alternate]
+
+    use_ui @ui do
+      @cmd.execute
+    end
+
+    expected = <<-EXPECTED
+Removed '/CN=nobody/DC=example'
+Removed '/CN=alternate/DC=example'
+    EXPECTED
+
+    assert_equal expected, @ui.output
+    assert_equal '', @ui.error
+
+    refute_path_exists public_path
+    refute_path_exists alternate_path
   end
 
   def test_execute_sign
+    path = File.join @tempdir, 'cert.pem'
+    Gem::Security.write ALTERNATE_CERT, path, 0600
+
+    assert_equal '/CN=alternate/DC=example', ALTERNATE_CERT.issuer.to_s
+
+    @cmd.handle_options %W[
+      --private-key #{PRIVATE_KEY_FILE}
+      --certificate #{PUBLIC_CERT_FILE}
+
+      --sign #{path}
+    ]
+
     use_ui @ui do
-      @cmd.send :handle_options, %W[
-        -K #{@pkey_file_name} -C #{@cert_file_name} --sign #{@cert_file_name}
-      ]
+      @cmd.execute
     end
 
     assert_equal '', @ui.output
     assert_equal '', @ui.error
 
-    # HACK this test sucks
+    cert = OpenSSL::X509::Certificate.new File.read path
+
+    assert_equal '/CN=nobody/DC=example', cert.issuer.to_s
+
+    mask = 0100600 & (~File.umask)
+
+    assert_equal mask, File.stat(path).mode unless win_platform?
+  end
+
+  def test_execute_sign_default
+    private_key_path = File.join Gem.user_home, 'gem-private_key.pem'
+    Gem::Security.write PRIVATE_KEY, private_key_path
+
+    public_cert_path = File.join Gem.user_home, 'gem-public_cert.pem'
+    Gem::Security.write PUBLIC_CERT, public_cert_path
+
+    path = File.join @tempdir, 'cert.pem'
+    Gem::Security.write ALTERNATE_CERT, path, 0600
+
+    assert_equal '/CN=alternate/DC=example', ALTERNATE_CERT.issuer.to_s
+
+    @cmd.handle_options %W[--sign #{path}]
+
+    use_ui @ui do
+      @cmd.execute
+    end
+
+    assert_equal '', @ui.output
+    assert_equal '', @ui.error
+
+    cert = OpenSSL::X509::Certificate.new File.read path
+
+    assert_equal '/CN=nobody/DC=example', cert.issuer.to_s
+
+    mask = 0100600 & (~File.umask)
+
+    assert_equal mask, File.stat(path).mode unless win_platform?
+  end
+
+  def test_execute_sign_no_cert
+    private_key_path = File.join Gem.user_home, 'gem-private_key.pem'
+    Gem::Security.write PRIVATE_KEY, private_key_path
+
+    path = File.join @tempdir, 'cert.pem'
+    Gem::Security.write ALTERNATE_CERT, path, 0600
+
+    assert_equal '/CN=alternate/DC=example', ALTERNATE_CERT.issuer.to_s
+
+    @cmd.handle_options %W[--sign #{path}]
+
+    use_ui @ui do
+      assert_raises Gem::MockGemUi::TermError do
+        @cmd.execute
+      end
+    end
+
+    assert_equal '', @ui.output
+
+    expected = <<-EXPECTED
+ERROR:  --certificate not specified and ~/.gem/gem-public_cert.pem does not exist
+    EXPECTED
+
+    assert_equal expected, @ui.error
+  end
+
+  def test_execute_sign_no_key
+    public_cert_path = File.join Gem.user_home, 'gem-public_cert.pem'
+    Gem::Security.write PUBLIC_CERT, public_cert_path
+
+    path = File.join @tempdir, 'cert.pem'
+    Gem::Security.write ALTERNATE_CERT, path, 0600
+
+    assert_equal '/CN=alternate/DC=example', ALTERNATE_CERT.issuer.to_s
+
+    @cmd.handle_options %W[--sign #{path}]
+
+    use_ui @ui do
+      assert_raises Gem::MockGemUi::TermError do
+        @cmd.execute
+      end
+    end
+
+    assert_equal '', @ui.output
+
+    expected = <<-EXPECTED
+ERROR:  --private-key not specified and ~/.gem/gem-private_key.pem does not exist
+    EXPECTED
+
+    assert_equal expected, @ui.error
+  end
+
+  def test_handle_options
+    @cmd.handle_options %W[
+      --add #{PUBLIC_CERT_FILE}
+      --add #{ALTERNATE_CERT_FILE}
+
+      --remove nobody
+      --remove example
+
+      --list
+      --list example
+
+      --build nobody@example
+      --build other@example
+    ]
+
+    assert_equal [PUBLIC_CERT.to_pem, ALTERNATE_CERT.to_pem],
+                 @cmd.options[:add].map { |cert| cert.to_pem }
+
+    assert_equal %w[nobody example], @cmd.options[:remove]
+
+    assert_equal %w[nobody@example other@example],
+                 @cmd.options[:build].map { |name| name.to_s }
+
+    assert_equal ['', 'example'], @cmd.options[:list]
+  end
+
+  def test_handle_options_add_bad
+    nonexistent = File.join @tempdir, 'nonexistent'
+    e = assert_raises OptionParser::InvalidArgument do
+      @cmd.handle_options %W[--add #{nonexistent}]
+    end
+
+    assert_equal "invalid argument: --add #{nonexistent}: does not exist",
+                 e.message
+
+    bad = File.join @tempdir, 'bad'
+    FileUtils.touch bad
+
+    e = assert_raises OptionParser::InvalidArgument do
+      @cmd.handle_options %W[--add #{bad}]
+    end
+
+    assert_equal "invalid argument: --add #{bad}: invalid X509 certificate",
+                 e.message
+  end
+
+  def test_handle_options_certificate
+    nonexistent = File.join @tempdir, 'nonexistent'
+    e = assert_raises OptionParser::InvalidArgument do
+      @cmd.handle_options %W[--certificate #{nonexistent}]
+    end
+
+    assert_equal "invalid argument: " \
+                 "--certificate #{nonexistent}: does not exist",
+                 e.message
+
+    bad = File.join @tempdir, 'bad'
+    FileUtils.touch bad
+
+    e = assert_raises OptionParser::InvalidArgument do
+      @cmd.handle_options %W[--certificate #{bad}]
+    end
+
+    assert_equal "invalid argument: " \
+                 "--certificate #{bad}: invalid X509 certificate",
+                 e.message
+  end
+
+  def test_handle_options_key_bad
+    nonexistent = File.join @tempdir, 'nonexistent'
+    e = assert_raises OptionParser::InvalidArgument do
+      @cmd.handle_options %W[--private-key #{nonexistent}]
+    end
+
+    assert_equal "invalid argument: " \
+                 "--private-key #{nonexistent}: does not exist",
+                 e.message
+
+    bad = File.join @tempdir, 'bad'
+    FileUtils.touch bad
+
+    e = assert_raises OptionParser::InvalidArgument do
+      @cmd.handle_options %W[--private-key #{bad}]
+    end
+
+    assert_equal "invalid argument: --private-key #{bad}: invalid RSA key",
+                 e.message
+
+    e = assert_raises OptionParser::InvalidArgument do
+      @cmd.handle_options %W[--private-key #{PUBLIC_KEY_FILE}]
+    end
+
+    assert_equal "invalid argument: " \
+                 "--private-key #{PUBLIC_KEY_FILE}: private key not found",
+                 e.message
+  end
+
+  def test_handle_options_sign
+    @cmd.handle_options %W[
+      --private-key #{ALTERNATE_KEY_FILE}
+      --private-key #{PRIVATE_KEY_FILE}
+
+      --certificate #{ALTERNATE_CERT_FILE}
+      --certificate #{PUBLIC_CERT_FILE}
+
+      --sign #{ALTERNATE_CERT_FILE}
+      --sign #{CHILD_CERT_FILE}
+    ]
+
+    assert_equal PRIVATE_KEY.to_pem, @cmd.options[:key].to_pem
+    assert_equal PUBLIC_CERT.to_pem, @cmd.options[:issuer_cert].to_pem
+
+    assert_equal [ALTERNATE_CERT_FILE, CHILD_CERT_FILE], @cmd.options[:sign]
+  end
+
+  def test_handle_options_sign_nonexistent
+    nonexistent = File.join @tempdir, 'nonexistent'
+    e = assert_raises OptionParser::InvalidArgument do
+      @cmd.handle_options %W[
+        --private-key #{ALTERNATE_KEY_FILE}
+
+        --certificate #{ALTERNATE_CERT_FILE}
+
+        --sign #{nonexistent}
+      ]
+    end
+
+    assert_equal "invalid argument: --sign #{nonexistent}: does not exist",
+                 e.message
   end
 
 end if defined? OpenSSL