test/rubygems/test_gem_installer.rb

   1 #--
   2 # Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others.
   3 # All rights reserved.
   4 # See LICENSE.txt for permissions.
   5 #++
   6
   7 require File.join(File.expand_path(File.dirname(__FILE__)),
   8                   'gem_installer_test_case')
   9
  10 class TestGemInstaller < GemInstallerTestCase
  11
  12   def test_app_script_text
  13     util_make_exec '2', ''
  14
  15     expected = <<-EOF
  16 #!#{Gem.ruby}
  17 #
  18 # This file was generated by RubyGems.
  19 #
  20 # The application 'a' is installed as part of a gem, and
  21 # this file is here to facilitate running it.
  22 #
  23
  24 require 'rubygems'
  25
  26 version = \">= 0\"
  27
  28 if ARGV.first =~ /^_(.*)_$/ and Gem::Version.correct? $1 then
  29   version = $1
  30   ARGV.shift
  31 end
  32
  33 gem 'a', version
  34 load 'my_exec'
  35     EOF
  36
  37     wrapper = @installer.app_script_text 'my_exec'
  38     assert_equal expected, wrapper
  39   end
  40
  41   def test_build_extensions_none
  42     use_ui @ui do
  43       @installer.build_extensions
  44     end
  45
  46     assert_equal '', @ui.output
  47     assert_equal '', @ui.error
  48
  49     assert !File.exist?('gem_make.out')
  50   end
  51
  52   def test_build_extensions_extconf_bad
  53     @spec.extensions << 'extconf.rb'
  54
  55     e = assert_raise Gem::Installer::ExtensionBuildError do
  56       use_ui @ui do
  57         @installer.build_extensions
  58       end
  59     end
  60
  61     assert_match(/\AERROR: Failed to build gem native extension.$/, e.message)
  62
  63     assert_equal "Building native extensions.  This could take a while...\n",
  64                  @ui.output
  65     assert_equal '', @ui.error
  66
  67     gem_make_out = File.join @gemhome, 'gems', @spec.full_name, 'gem_make.out'
  68     expected = <<-EOF
  69 #{Gem.ruby} extconf.rb
  70 #{Gem.ruby}: No such file or directory -- extconf.rb (LoadError)
  71     EOF
  72
  73     assert_equal expected, File.read(gem_make_out)
  74   end
  75
  76   def test_build_extensions_unsupported
  77     @spec.extensions << nil
  78
  79     e = assert_raise Gem::Installer::ExtensionBuildError do
  80       use_ui @ui do
  81         @installer.build_extensions
  82       end
  83     end
  84
  85     assert_match(/^No builder for extension ''$/, e.message)
  86
  87     assert_equal "Building native extensions.  This could take a while...\n",
  88                  @ui.output
  89     assert_equal '', @ui.error
  90
  91     assert_equal "No builder for extension ''\n", File.read('gem_make.out')
  92   ensure
  93     FileUtils.rm_f 'gem_make.out'
  94   end
  95
  96   def test_ensure_dependency
  97     dep = Gem::Dependency.new 'a', '>= 2'
  98     assert @installer.ensure_dependency(@spec, dep)
  99
 100     dep = Gem::Dependency.new 'b', '> 2'
 101     e = assert_raise Gem::InstallError do
 102       @installer.ensure_dependency @spec, dep
 103     end
 104
 105     assert_equal 'a requires b (> 2)', e.message
 106   end
 107
 108   def test_expand_and_validate_gem_dir
 109     @installer.gem_dir = '/nonexistent'
 110     expanded_gem_dir = @installer.send(:expand_and_validate_gem_dir)
 111     if win_platform?
 112       expected = File.expand_path('/nonexistent').downcase
 113       expanded_gem_dir = expanded_gem_dir.downcase
 114     else
 115       expected = '/nonexistent'
 116     end
 117
 118     assert_equal expected, expanded_gem_dir
 119   end
 120
 121   def test_extract_files
 122     format = Object.new
 123     def format.file_entries
 124       [[{'size' => 7, 'mode' => 0400, 'path' => 'thefile'}, 'thefile']]
 125     end
 126
 127     @installer.format = format
 128
 129     @installer.extract_files
 130
 131     assert_equal 'thefile', File.read(File.join(util_gem_dir, 'thefile'))
 132   end
 133
 134   def test_extract_files_bad_dest
 135     @installer.gem_dir = 'somedir'
 136     @installer.format = nil
 137     e = assert_raise ArgumentError do
 138       @installer.extract_files
 139     end
 140
 141     assert_equal 'format required to extract from', e.message
 142   end
 143
 144   def test_extract_files_relative
 145     format = Object.new
 146     def format.file_entries
 147       [[{'size' => 10, 'mode' => 0644, 'path' => '../thefile'}, '../thefile']]
 148     end
 149
 150     @installer.format = format
 151
 152     e = assert_raise Gem::InstallError do
 153       @installer.extract_files
 154     end
 155
 156     assert_equal "attempt to install file into \"../thefile\" under #{util_gem_dir.inspect}",
 157                  e.message
 158     assert_equal false, File.file?(File.join(@tempdir, '../thefile')),
 159                  "You may need to remove this file if you broke the test once"
 160   end
 161
 162   def test_extract_files_absolute
 163     format = Object.new
 164     def format.file_entries
 165       [[{'size' => 8, 'mode' => 0644, 'path' => '/thefile'}, '/thefile']]
 166     end
 167
 168     @installer.format = format
 169
 170     e = assert_raise Gem::InstallError do
 171       @installer.extract_files
 172     end
 173
 174     assert_equal 'attempt to install file into "/thefile"', e.message
 175     assert_equal false, File.file?(File.join('/thefile')),
 176                  "You may need to remove this file if you broke the test once"
 177   end
 178
 179   def test_generate_bin_bindir
 180     @installer.wrappers = true
 181
 182     @spec.executables = ["my_exec"]
 183     @spec.bindir = '.'
 184
 185     exec_file = @installer.formatted_program_filename "my_exec"
 186     exec_path = File.join util_gem_dir(@spec.version), exec_file
 187     File.open exec_path, 'w' do |f|
 188       f.puts '#!/usr/bin/ruby'
 189     end
 190
 191     @installer.gem_dir = util_gem_dir
 192
 193     @installer.generate_bin
 194
 195     assert_equal true, File.directory?(util_inst_bindir)
 196     installed_exec = File.join(util_inst_bindir, "my_exec")
 197     assert_equal true, File.exist?(installed_exec)
 198     assert_equal(0100755, File.stat(installed_exec).mode) unless win_platform?
 199
 200     wrapper = File.read installed_exec
 201     assert_match %r|generated by RubyGems|, wrapper
 202   end
 203
 204   def test_generate_bin_script
 205     @installer.wrappers = true
 206     util_make_exec
 207     @installer.gem_dir = util_gem_dir
 208
 209     @installer.generate_bin
 210     assert_equal true, File.directory?(util_inst_bindir)
 211     installed_exec = File.join(util_inst_bindir, "my_exec")
 212     assert_equal true, File.exist?(installed_exec)
 213     assert_equal(0100755, File.stat(installed_exec).mode) unless win_platform?
 214
 215     wrapper = File.read installed_exec
 216     assert_match %r|generated by RubyGems|, wrapper
 217   end
 218
 219   def test_generate_bin_script_format
 220     @installer.format_executable = true
 221     @installer.wrappers = true
 222     util_make_exec
 223     @installer.gem_dir = util_gem_dir
 224
 225     Gem::Installer.exec_format = 'foo-%s-bar'
 226     @installer.generate_bin
 227     assert_equal true, File.directory?(util_inst_bindir)
 228     installed_exec = File.join util_inst_bindir, 'foo-my_exec-bar'
 229     assert_equal true, File.exist?(installed_exec)
 230   ensure
 231     Gem::Installer.exec_format = nil
 232   end
 233
 234   def test_generate_bin_script_format_disabled
 235     @installer.wrappers = true
 236     util_make_exec
 237     @installer.gem_dir = util_gem_dir
 238
 239     Gem::Installer.exec_format = 'foo-%s-bar'
 240     @installer.generate_bin
 241     assert_equal true, File.directory?(util_inst_bindir)
 242     installed_exec = File.join util_inst_bindir, 'my_exec'
 243     assert_equal true, File.exist?(installed_exec)
 244   ensure
 245     Gem::Installer.exec_format = nil
 246   end
 247
 248   def test_generate_bin_script_install_dir
 249     @installer.wrappers = true
 250     @spec.executables = ["my_exec"]
 251
 252     gem_dir = File.join "#{@gemhome}2", 'gems', @spec.full_name
 253     gem_bindir = File.join gem_dir, 'bin'
 254     FileUtils.mkdir_p gem_bindir
 255     File.open File.join(gem_bindir, "my_exec"), 'w' do |f|
 256       f.puts "#!/bin/ruby"
 257     end
 258
 259     @installer.gem_home = "#{@gemhome}2"
 260     @installer.gem_dir = gem_dir
 261
 262     @installer.generate_bin
 263
 264     installed_exec = File.join("#{@gemhome}2", 'bin', 'my_exec')
 265     assert_equal true, File.exist?(installed_exec)
 266     assert_equal(0100755, File.stat(installed_exec).mode) unless win_platform?
 267
 268     wrapper = File.read installed_exec
 269     assert_match %r|generated by RubyGems|, wrapper
 270   end
 271
 272   def test_generate_bin_script_no_execs
 273     @installer.wrappers = true
 274     @installer.generate_bin
 275     assert_equal false, File.exist?(util_inst_bindir)
 276   end
 277
 278   def test_generate_bin_script_no_perms
 279     @installer.wrappers = true
 280     util_make_exec
 281
 282     Dir.mkdir util_inst_bindir
 283     File.chmod 0000, util_inst_bindir
 284
 285     assert_raises Gem::FilePermissionError do
 286       @installer.generate_bin
 287     end
 288
 289   ensure
 290     File.chmod 0700, util_inst_bindir unless $DEBUG
 291   end
 292
 293   def test_generate_bin_script_no_shebang
 294     @installer.wrappers = true
 295     @spec.executables = ["my_exec"]
 296
 297     gem_dir = File.join @gemhome, 'gems', @spec.full_name
 298     gem_bindir = File.join gem_dir, 'bin'
 299     FileUtils.mkdir_p gem_bindir
 300     File.open File.join(gem_bindir, "my_exec"), 'w' do |f|
 301       f.puts "blah blah blah"
 302     end
 303
 304     @installer.generate_bin
 305
 306     installed_exec = File.join @gemhome, 'bin', 'my_exec'
 307     assert_equal true, File.exist?(installed_exec)
 308     assert_equal 0100755, File.stat(installed_exec).mode unless win_platform?
 309
 310     wrapper = File.read installed_exec
 311     assert_match %r|generated by RubyGems|, wrapper
 312     # HACK some gems don't have #! in their executables, restore 2008/06
 313     #assert_no_match %r|generated by RubyGems|, wrapper
 314   end
 315
 316   def test_generate_bin_symlink
 317     return if win_platform? #Windows FS do not support symlinks
 318
 319     @installer.wrappers = false
 320     util_make_exec
 321     @installer.gem_dir = util_gem_dir
 322
 323     @installer.generate_bin
 324     assert_equal true, File.directory?(util_inst_bindir)
 325     installed_exec = File.join(util_inst_bindir, "my_exec")
 326     assert_equal true, File.symlink?(installed_exec)
 327     assert_equal(File.join(util_gem_dir, "bin", "my_exec"),
 328                  File.readlink(installed_exec))
 329   end
 330
 331   def test_generate_bin_symlink_no_execs
 332     @installer.wrappers = false
 333     @installer.generate_bin
 334     assert_equal false, File.exist?(util_inst_bindir)
 335   end
 336
 337   def test_generate_bin_symlink_no_perms
 338     @installer.wrappers = false
 339     util_make_exec
 340     @installer.gem_dir = util_gem_dir
 341
 342     Dir.mkdir util_inst_bindir
 343     File.chmod 0000, util_inst_bindir
 344
 345     assert_raises Gem::FilePermissionError do
 346       @installer.generate_bin
 347     end
 348
 349   ensure
 350     File.chmod 0700, util_inst_bindir unless $DEBUG
 351   end
 352
 353   def test_generate_bin_symlink_update_newer
 354     return if win_platform? #Windows FS do not support symlinks
 355
 356     @installer.wrappers = false
 357     util_make_exec
 358     @installer.gem_dir = util_gem_dir
 359
 360     @installer.generate_bin
 361     installed_exec = File.join(util_inst_bindir, "my_exec")
 362     assert_equal(File.join(util_gem_dir, "bin", "my_exec"),
 363                  File.readlink(installed_exec))
 364
 365     @spec = Gem::Specification.new do |s|
 366       s.files = ['lib/code.rb']
 367       s.name = "a"
 368       s.version = "3"
 369       s.summary = "summary"
 370       s.description = "desc"
 371       s.require_path = 'lib'
 372     end
 373
 374     util_make_exec '3'
 375     @installer.gem_dir = File.join util_gem_dir('3')
 376     @installer.generate_bin
 377     installed_exec = File.join(util_inst_bindir, "my_exec")
 378     assert_equal(File.join(util_gem_bindir('3'), "my_exec"),
 379                  File.readlink(installed_exec),
 380                  "Ensure symlink moved to latest version")
 381   end
 382
 383   def test_generate_bin_symlink_update_older
 384     return if win_platform? #Windows FS do not support symlinks
 385
 386     @installer.wrappers = false
 387     util_make_exec
 388     @installer.gem_dir = util_gem_dir
 389
 390     @installer.generate_bin
 391     installed_exec = File.join(util_inst_bindir, "my_exec")
 392     assert_equal(File.join(util_gem_dir, "bin", "my_exec"),
 393                  File.readlink(installed_exec))
 394
 395     spec = Gem::Specification.new do |s|
 396       s.files = ['lib/code.rb']
 397       s.name = "a"
 398       s.version = "1"
 399       s.summary = "summary"
 400       s.description = "desc"
 401       s.require_path = 'lib'
 402     end
 403
 404     util_make_exec '1'
 405     @installer.gem_dir = util_gem_dir('1')
 406     @installer.spec = spec
 407
 408     @installer.generate_bin
 409
 410     installed_exec = File.join(util_inst_bindir, "my_exec")
 411     assert_equal(File.join(util_gem_dir('2'), "bin", "my_exec"),
 412                  File.readlink(installed_exec),
 413                  "Ensure symlink not moved")
 414   end
 415
 416   def test_generate_bin_symlink_update_remove_wrapper
 417     return if win_platform? #Windows FS do not support symlinks
 418
 419     @installer.wrappers = true
 420     util_make_exec
 421     @installer.gem_dir = util_gem_dir
 422
 423     @installer.generate_bin
 424     installed_exec = File.join(util_inst_bindir, "my_exec")
 425     assert_equal true, File.exist?(installed_exec)
 426
 427     @spec = Gem::Specification.new do |s|
 428       s.files = ['lib/code.rb']
 429       s.name = "a"
 430       s.version = "3"
 431       s.summary = "summary"
 432       s.description = "desc"
 433       s.require_path = 'lib'
 434     end
 435
 436     @installer.wrappers = false
 437     util_make_exec '3'
 438     @installer.gem_dir = util_gem_dir '3'
 439     @installer.generate_bin
 440     installed_exec = File.join(util_inst_bindir, "my_exec")
 441     assert_equal(File.join(util_gem_dir('3'), "bin", "my_exec"),
 442                  File.readlink(installed_exec),
 443                  "Ensure symlink moved to latest version")
 444   end
 445
 446   def test_generate_bin_symlink_win32
 447     old_win_platform = Gem.win_platform?
 448     Gem.win_platform = true
 449     @installer.wrappers = false
 450     util_make_exec
 451     @installer.gem_dir = util_gem_dir
 452
 453     use_ui @ui do
 454       @installer.generate_bin
 455     end
 456
 457     assert_equal true, File.directory?(util_inst_bindir)
 458     installed_exec = File.join(util_inst_bindir, "my_exec")
 459     assert_equal true, File.exist?(installed_exec)
 460
 461     assert_match(/Unable to use symlinks on Windows, installing wrapper/i,
 462                  @ui.error)
 463
 464     wrapper = File.read installed_exec
 465     assert_match(/generated by RubyGems/, wrapper)
 466   ensure
 467     Gem.win_platform = old_win_platform
 468   end
 469
 470   def test_generate_bin_uses_default_shebang
 471     return if win_platform? #Windows FS do not support symlinks
 472
 473     @installer.wrappers = true
 474     util_make_exec
 475
 476     @installer.generate_bin
 477
 478     default_shebang = File.join(Config::CONFIG['bindir'], Config::CONFIG['ruby_install_name'])
 479     shebang_line = open("#{@gemhome}/bin/my_exec") { |f| f.readlines.first }
 480     assert_match(/\A#!/, shebang_line)
 481     assert_match(/#{default_shebang}/, shebang_line)
 482   end
 483
 484   def test_initialize
 485     spec = quick_gem 'a' do |s| s.platform = Gem::Platform.new 'mswin32' end
 486     gem = File.join @tempdir, "#{spec.full_name}.gem"
 487
 488     util_build_gem spec
 489     FileUtils.mv File.join(@gemhome, 'cache', "#{spec.full_name}.gem"),
 490                  @tempdir
 491
 492     installer = Gem::Installer.new gem
 493
 494     assert_equal File.join(@gemhome, 'gems', spec.full_name), installer.gem_dir
 495   end
 496
 497   def test_install
 498     util_setup_gem
 499
 500     use_ui @ui do
 501       assert_equal @spec, @installer.install
 502     end
 503
 504     gemdir = File.join @gemhome, 'gems', @spec.full_name
 505     assert File.exist?(gemdir)
 506
 507     exe = File.join(gemdir, 'bin', 'executable')
 508     assert File.exist?(exe)
 509     exe_mode = File.stat(exe).mode & 0111
 510     assert_equal 0111, exe_mode, "0%o" % exe_mode unless win_platform?
 511
 512     assert File.exist?(File.join(gemdir, 'lib', 'code.rb'))
 513
 514     assert File.exist?(File.join(gemdir, 'ext', 'a', 'Rakefile'))
 515
 516     spec_file = File.join(@gemhome, 'specifications',
 517                           "#{@spec.full_name}.gemspec")
 518
 519     assert_equal spec_file, @spec.loaded_from
 520     assert File.exist?(spec_file)
 521   end
 522
 523   def test_install_bad_gem
 524     gem = nil
 525
 526     use_ui @ui do
 527       Dir.chdir @tempdir do Gem::Builder.new(@spec).build end
 528       gem = File.join @tempdir, "#{@spec.full_name}.gem"
 529     end
 530
 531     gem_data = File.open gem, 'rb' do |fp| fp.read 1024 end
 532     File.open gem, 'wb' do |fp| fp.write gem_data end
 533
 534     e = assert_raise Gem::InstallError do
 535       use_ui @ui do
 536         @installer = Gem::Installer.new gem
 537         @installer.install
 538       end
 539     end
 540
 541     assert_equal "invalid gem format for #{gem}", e.message
 542   end
 543
 544   def test_install_check_dependencies
 545     @spec.add_dependency 'b', '> 5'
 546     util_setup_gem
 547
 548     use_ui @ui do
 549       assert_raise Gem::InstallError do
 550         @installer.install
 551       end
 552     end
 553   end
 554
 555   def test_install_force
 556     use_ui @ui do
 557       installer = Gem::Installer.new old_ruby_required, :force => true
 558       installer.install
 559     end
 560
 561     gem_dir = File.join(@gemhome, 'gems', 'old_ruby_required-1')
 562     assert File.exist?(gem_dir)
 563   end
 564
 565   def test_install_ignore_dependencies
 566     @spec.add_dependency 'b', '> 5'
 567     util_setup_gem
 568     @installer.ignore_dependencies = true
 569
 570     use_ui @ui do
 571       assert_equal @spec, @installer.install
 572     end
 573
 574     gemdir = File.join @gemhome, 'gems', @spec.full_name
 575     assert File.exist?(gemdir)
 576
 577     exe = File.join(gemdir, 'bin', 'executable')
 578     assert File.exist?(exe)
 579     exe_mode = File.stat(exe).mode & 0111
 580     assert_equal 0111, exe_mode, "0%o" % exe_mode unless win_platform?
 581     assert File.exist?(File.join(gemdir, 'lib', 'code.rb'))
 582
 583     assert File.exist?(File.join(@gemhome, 'specifications',
 584                                  "#{@spec.full_name}.gemspec"))
 585   end
 586
 587   def test_install_missing_dirs
 588     FileUtils.rm_f File.join(Gem.dir, 'cache')
 589     FileUtils.rm_f File.join(Gem.dir, 'docs')
 590     FileUtils.rm_f File.join(Gem.dir, 'specifications')
 591
 592     use_ui @ui do
 593       Dir.chdir @tempdir do Gem::Builder.new(@spec).build end
 594       gem = File.join @tempdir, "#{@spec.full_name}.gem"
 595
 596       @installer.install
 597     end
 598
 599     File.directory? File.join(Gem.dir, 'cache')
 600     File.directory? File.join(Gem.dir, 'docs')
 601     File.directory? File.join(Gem.dir, 'specifications')
 602
 603     assert File.exist?(File.join(@gemhome, 'cache', "#{@spec.full_name}.gem"))
 604     assert File.exist?(File.join(@gemhome, 'specifications',
 605                                  "#{@spec.full_name}.gemspec"))
 606   end
 607
 608   def test_install_with_message
 609     @spec.post_install_message = 'I am a shiny gem!'
 610
 611     use_ui @ui do
 612       Dir.chdir @tempdir do Gem::Builder.new(@spec).build end
 613
 614       @installer.install
 615     end
 616
 617     assert_match %r|I am a shiny gem!|, @ui.output
 618   end
 619
 620   def test_install_writable
 621     util_setup_gem
 622
 623     orig_mode = File.stat(Gem.dir).mode
 624     File.chmod 0000, Gem.dir
 625
 626     e = assert_raise Gem::FilePermissionError do
 627       @installer.install
 628     end
 629
 630     assert_equal "You don't have write permissions into the #{@gemhome} directory.",
 631                  e.message
 632   ensure
 633     File.chmod orig_mode, Gem.dir
 634   end
 635
 636   def test_install_wrong_ruby_version
 637     use_ui @ui do
 638       installer = Gem::Installer.new old_ruby_required
 639       e = assert_raise Gem::InstallError do
 640         installer.install
 641       end
 642       assert_equal 'old_ruby_required requires Ruby version = 1.4.6',
 643                    e.message
 644     end
 645   end
 646
 647   def test_install_wrong_rubygems_version
 648     spec = quick_gem 'old_rubygems_required', '1' do |s|
 649       s.required_rubygems_version = '< 0'
 650     end
 651
 652     util_build_gem spec
 653
 654     gem = File.join @gemhome, 'cache', "#{spec.full_name}.gem"
 655
 656     use_ui @ui do
 657       @installer = Gem::Installer.new gem
 658       e = assert_raise Gem::InstallError do
 659         @installer.install
 660       end
 661       assert_equal 'old_rubygems_required requires RubyGems version < 0',
 662                    e.message
 663     end
 664   end
 665
 666   def test_installation_satisfies_dependency_eh
 667     dep = Gem::Dependency.new 'a', '>= 2'
 668     assert @installer.installation_satisfies_dependency?(dep)
 669
 670     dep = Gem::Dependency.new 'a', '> 2'
 671     assert ! @installer.installation_satisfies_dependency?(dep)
 672   end
 673
 674   def test_shebang
 675     util_make_exec '2', "#!/usr/bin/ruby"
 676
 677     shebang = @installer.shebang 'my_exec'
 678
 679     assert_equal "#!#{Gem.ruby}", shebang
 680   end
 681
 682   def test_shebang_arguments
 683     util_make_exec '2', "#!/usr/bin/ruby -ws"
 684
 685     shebang = @installer.shebang 'my_exec'
 686
 687     assert_equal "#!#{Gem.ruby} -ws", shebang
 688   end
 689
 690   def test_shebang_empty
 691     util_make_exec '2', ''
 692
 693     shebang = @installer.shebang 'my_exec'
 694     assert_equal "#!#{Gem.ruby}", shebang
 695   end
 696
 697   def test_shebang_env
 698     util_make_exec '2', "#!/usr/bin/env ruby"
 699
 700     shebang = @installer.shebang 'my_exec'
 701
 702     assert_equal "#!#{Gem.ruby}", shebang
 703   end
 704
 705   def test_shebang_env_arguments
 706     util_make_exec '2', "#!/usr/bin/env ruby -ws"
 707
 708     shebang = @installer.shebang 'my_exec'
 709
 710     assert_equal "#!#{Gem.ruby} -ws", shebang
 711   end
 712
 713   def test_shebang_env_shebang
 714     util_make_exec '2', ''
 715     @installer.env_shebang = true
 716
 717     shebang = @installer.shebang 'my_exec'
 718     assert_equal "#!/usr/bin/env #{Gem::ConfigMap[:RUBY_INSTALL_NAME]}", shebang
 719   end
 720
 721   def test_shebang_nested
 722     util_make_exec '2', "#!/opt/local/ruby/bin/ruby"
 723
 724     shebang = @installer.shebang 'my_exec'
 725
 726     assert_equal "#!#{Gem.ruby}", shebang
 727   end
 728
 729   def test_shebang_nested_arguments
 730     util_make_exec '2', "#!/opt/local/ruby/bin/ruby -ws"
 731
 732     shebang = @installer.shebang 'my_exec'
 733
 734     assert_equal "#!#{Gem.ruby} -ws", shebang
 735   end
 736
 737   def test_shebang_version
 738     util_make_exec '2', "#!/usr/bin/ruby18"
 739
 740     shebang = @installer.shebang 'my_exec'
 741
 742     assert_equal "#!#{Gem.ruby}", shebang
 743   end
 744
 745   def test_shebang_version_arguments
 746     util_make_exec '2', "#!/usr/bin/ruby18 -ws"
 747
 748     shebang = @installer.shebang 'my_exec'
 749
 750     assert_equal "#!#{Gem.ruby} -ws", shebang
 751   end
 752
 753   def test_shebang_version_env
 754     util_make_exec '2', "#!/usr/bin/env ruby18"
 755
 756     shebang = @installer.shebang 'my_exec'
 757
 758     assert_equal "#!#{Gem.ruby}", shebang
 759   end
 760
 761   def test_shebang_version_env_arguments
 762     util_make_exec '2', "#!/usr/bin/env ruby18 -ws"
 763
 764     shebang = @installer.shebang 'my_exec'
 765
 766     assert_equal "#!#{Gem.ruby} -ws", shebang
 767   end
 768
 769   def test_unpack
 770     util_setup_gem
 771
 772     dest = File.join @gemhome, 'gems', @spec.full_name
 773
 774     @installer.unpack dest
 775
 776     assert File.exist?(File.join(dest, 'lib', 'code.rb'))
 777     assert File.exist?(File.join(dest, 'bin', 'executable'))
 778   end
 779
 780   def test_write_spec
 781     spec_dir = File.join @gemhome, 'specifications'
 782     spec_file = File.join spec_dir, "#{@spec.full_name}.gemspec"
 783     FileUtils.rm spec_file
 784     assert !File.exist?(spec_file)
 785
 786     @installer.spec = @spec
 787     @installer.gem_home = @gemhome
 788
 789     @installer.write_spec
 790
 791     assert File.exist?(spec_file)
 792     assert_equal @spec, eval(File.read(spec_file))
 793   end
 794
 795   def old_ruby_required
 796     spec = quick_gem 'old_ruby_required', '1' do |s|
 797       s.required_ruby_version = '= 1.4.6'
 798     end
 799
 800     util_build_gem spec
 801
 802     File.join @gemhome, 'cache', "#{spec.full_name}.gem"
 803   end
 804
 805 end
 806