← Back to branch summary

~ubuntu-branches/ubuntu/quantal/ruby1.9.1/quantal

« back to all changes in this revision

Viewing changes to test/rubygems/test_gem_installer.rb

  • Committer: Bazaar Package Importer
  • Author(s): Lucas Nussbaum
  • Date: 2011-09-24 19:16:17 UTC
  • mfrom: (1.1.8 upstream) (13.1.7 experimental)
  • Revision ID: james.westby@ubuntu.com-20110924191617-o1qz4rcmqjot8zuy
Tags: 1.9.3~rc1-1
http://bugs.debian.org/639959
* New upstream release: 1.9.3 RC1.
  + Includes load.c fixes. Closes: #639959.
* Upload to unstable.

Show diffs side-by-side

added added

removed removed

Lines of Context:
test/rubygems/test_gem_installer.rb
1
 
require_relative 'gem_installer_test_case'
2
 
 
3
 
class TestGemInstaller < GemInstallerTestCase
 
1
require 'rubygems/installer_test_case'
 
2
 
 
3
class TestGemInstaller < Gem::InstallerTestCase
 
4
 
 
5
  def setup
 
6
    super
 
7
 
 
8
    if __name__ !~ /^test_install(_|$)/ then
 
9
      @gemhome = @installer_tmp
 
10
      Gem.use_paths @installer_tmp
 
11
 
 
12
      @spec = Gem::Specification.find_by_name 'a'
 
13
      @user_spec = Gem::Specification.find_by_name 'b'
 
14
 
 
15
      @installer.spec = @spec
 
16
      @installer.gem_home = @installer_tmp
 
17
      @installer.gem_dir = @spec.gem_dir
 
18
      @user_installer.spec = @user_spec
 
19
      @user_installer.gem_home = @installer_tmp
 
20
    end
 
21
  end
 
22
 
4
23
 
5
24
  def test_app_script_text
6
 
    util_make_exec '2', ''
 
25
    @spec.version = 2
 
26
    util_make_exec @spec, ''
7
27
 
8
28
    expected = <<-EOF
9
29
#!#{Gem.ruby}
24
44
end
25
45
 
26
46
gem 'a', version
27
 
load Gem.bin_path('a', 'my_exec', version)
 
47
load Gem.bin_path('a', 'executable', version)
28
48
    EOF
29
49
 
30
 
    wrapper = @installer.app_script_text 'my_exec'
 
50
    wrapper = @installer.app_script_text 'executable'
31
51
    assert_equal expected, wrapper
32
52
  end
33
53
 
58
78
    assert_equal '', @ui.error
59
79
 
60
80
    gem_make_out = File.join @gemhome, 'gems', @spec.full_name, 'gem_make.out'
61
 
    expected = <<-EOF
62
 
#{Gem.ruby} extconf.rb
63
 
#{Gem.ruby}: No such file or directory -- extconf.rb (LoadError)
64
 
    EOF
65
81
 
66
82
    assert_match %r%#{Regexp.escape Gem.ruby} extconf\.rb%,
67
83
                 File.read(gem_make_out)
70
86
  end
71
87
 
72
88
  def test_build_extensions_unsupported
 
89
    gem_make_out = File.join @gemhome, 'gems', @spec.full_name, 'gem_make.out'
73
90
    @spec.extensions << nil
74
91
 
75
92
    e = assert_raises Gem::Installer::ExtensionBuildError do
78
95
      end
79
96
    end
80
97
 
81
 
    assert_match(/^No builder for extension ''$/, e.message)
 
98
    assert_match(/^\s*No builder for extension ''$/, e.message)
82
99
 
83
100
    assert_equal "Building native extensions.  This could take a while...\n",
84
101
                 @ui.output
85
102
    assert_equal '', @ui.error
86
103
 
87
 
    assert_equal "No builder for extension ''\n", File.read('gem_make.out')
 
104
    assert_equal "No builder for extension ''\n", File.read(gem_make_out)
88
105
  ensure
89
 
    FileUtils.rm_f 'gem_make.out'
 
106
    FileUtils.rm_f gem_make_out
90
107
  end
91
108
 
92
109
  def test_ensure_dependency
98
115
      @installer.ensure_dependency @spec, dep
99
116
    end
100
117
 
101
 
    assert_equal 'a requires b (> 2, runtime)', e.message
 
118
    assert_equal 'a requires b (> 2)', e.message
102
119
  end
103
120
 
104
121
  def test_extract_files
105
122
    format = Object.new
106
123
    def format.file_entries
107
 
      [[{'size' => 7, 'mode' => 0400, 'path' => 'thefile'}, 'thefile']]
 
124
      [[{'size' => 7, 'mode' => 0400, 'path' => 'thefile'}, 'content']]
108
125
    end
109
126
 
110
127
    @installer.format = format
112
129
    @installer.extract_files
113
130
 
114
131
    thefile_path = File.join(util_gem_dir, 'thefile')
115
 
    assert_equal 'thefile', File.read(thefile_path)
 
132
    assert_equal 'content', File.read(thefile_path)
116
133
 
117
134
    unless Gem.win_platform? then
118
135
      assert_equal 0400, File.stat(thefile_path).mode & 0777
141
158
      @installer.extract_files
142
159
    end
143
160
 
144
 
    assert_equal "attempt to install file into \"../thefile\" under #{util_gem_dir.inspect}",
145
 
                 e.message
 
161
    dir = util_gem_dir
 
162
    expected = "attempt to install file into \"../thefile\" under #{dir}"
 
163
    assert_equal expected, e.message
146
164
    assert_equal false, File.file?(File.join(@tempdir, '../thefile')),
147
165
                 "You may need to remove this file if you broke the test once"
148
166
  end
159
177
      @installer.extract_files
160
178
    end
161
179
 
162
 
    assert_equal 'attempt to install file into "/thefile"', e.message
 
180
    assert_equal 'attempt to install file into /thefile', e.message
163
181
    assert_equal false, File.file?(File.join('/thefile')),
164
182
                 "You may need to remove this file if you broke the test once"
165
183
  end
167
185
  def test_generate_bin_bindir
168
186
    @installer.wrappers = true
169
187
 
170
 
    @spec.executables = ["my_exec"]
 
188
    @spec.executables = %w[executable]
171
189
    @spec.bindir = '.'
172
190
 
173
 
    exec_file = @installer.formatted_program_filename "my_exec"
174
 
    exec_path = File.join util_gem_dir(@spec.version), exec_file
 
191
    exec_file = @installer.formatted_program_filename 'executable'
 
192
    exec_path = File.join util_gem_dir(@spec), exec_file
175
193
    File.open exec_path, 'w' do |f|
176
194
      f.puts '#!/usr/bin/ruby'
177
195
    end
181
199
    @installer.generate_bin
182
200
 
183
201
    assert_equal true, File.directory?(util_inst_bindir)
184
 
    installed_exec = File.join(util_inst_bindir, "my_exec")
 
202
    installed_exec = File.join(util_inst_bindir, 'executable')
185
203
    assert_equal true, File.exist?(installed_exec)
186
 
    assert_equal(0100755, File.stat(installed_exec).mode) unless win_platform?
 
204
    assert_equal mask, File.stat(installed_exec).mode unless win_platform?
187
205
 
188
206
    wrapper = File.read installed_exec
189
207
    assert_match %r|generated by RubyGems|, wrapper
190
208
  end
191
209
 
 
210
  def test_generate_bin_bindir_with_user_install_warning
 
211
    bin_dir = Gem.win_platform? ? File.expand_path(ENV["WINDIR"]) : "/usr/bin"
 
212
 
 
213
    options = {
 
214
      :bin_dir => bin_dir,
 
215
      :install_dir => "/non/existant"
 
216
    }
 
217
 
 
218
    inst = Gem::Installer.new nil, options
 
219
 
 
220
    Gem::Installer.path_warning = false
 
221
 
 
222
    use_ui @ui do
 
223
      inst.check_that_user_bin_dir_is_in_path
 
224
    end
 
225
 
 
226
    assert_equal "", @ui.error
 
227
  end
 
228
 
192
229
  def test_generate_bin_script
193
230
    @installer.wrappers = true
194
231
    util_make_exec
196
233
 
197
234
    @installer.generate_bin
198
235
    assert_equal true, File.directory?(util_inst_bindir)
199
 
    installed_exec = File.join(util_inst_bindir, "my_exec")
 
236
    installed_exec = File.join(util_inst_bindir, 'executable')
200
237
    assert_equal true, File.exist?(installed_exec)
201
 
    assert_equal(0100755, File.stat(installed_exec).mode) unless win_platform?
 
238
    assert_equal mask, File.stat(installed_exec).mode unless win_platform?
202
239
 
203
240
    wrapper = File.read installed_exec
204
241
    assert_match %r|generated by RubyGems|, wrapper
213
250
    Gem::Installer.exec_format = 'foo-%s-bar'
214
251
    @installer.generate_bin
215
252
    assert_equal true, File.directory?(util_inst_bindir)
216
 
    installed_exec = File.join util_inst_bindir, 'foo-my_exec-bar'
 
253
    installed_exec = File.join util_inst_bindir, 'foo-executable-bar'
217
254
    assert_equal true, File.exist?(installed_exec)
218
255
  ensure
219
256
    Gem::Installer.exec_format = nil
227
264
    Gem::Installer.exec_format = 'foo-%s-bar'
228
265
    @installer.generate_bin
229
266
    assert_equal true, File.directory?(util_inst_bindir)
230
 
    installed_exec = File.join util_inst_bindir, 'my_exec'
 
267
    installed_exec = File.join util_inst_bindir, 'executable'
231
268
    assert_equal true, File.exist?(installed_exec)
232
269
  ensure
233
270
    Gem::Installer.exec_format = nil
235
272
 
236
273
  def test_generate_bin_script_install_dir
237
274
    @installer.wrappers = true
238
 
    @spec.executables = ["my_exec"]
 
275
    @spec.executables = %w[executable]
239
276
 
240
 
    gem_dir = File.join "#{@gemhome}2", 'gems', @spec.full_name
 
277
    gem_dir = File.join("#{@gemhome}2", "gems", @spec.full_name)
241
278
    gem_bindir = File.join gem_dir, 'bin'
242
279
    FileUtils.mkdir_p gem_bindir
243
 
    File.open File.join(gem_bindir, "my_exec"), 'w' do |f|
 
280
    File.open File.join(gem_bindir, 'executable'), 'w' do |f|
244
281
      f.puts "#!/bin/ruby"
245
282
    end
246
283
 
249
286
 
250
287
    @installer.generate_bin
251
288
 
252
 
    installed_exec = File.join("#{@gemhome}2", 'bin', 'my_exec')
 
289
    installed_exec = File.join("#{@gemhome}2", "bin", 'executable')
253
290
    assert_equal true, File.exist?(installed_exec)
254
 
    assert_equal(0100755, File.stat(installed_exec).mode) unless win_platform?
 
291
    assert_equal mask, File.stat(installed_exec).mode unless win_platform?
255
292
 
256
293
    wrapper = File.read installed_exec
257
294
    assert_match %r|generated by RubyGems|, wrapper
258
295
  end
259
296
 
260
297
  def test_generate_bin_script_no_execs
 
298
    util_execless
 
299
 
261
300
    @installer.wrappers = true
262
301
    @installer.generate_bin
263
 
    assert_equal false, File.exist?(util_inst_bindir)
 
302
 
 
303
    refute File.exist?(util_inst_bindir), 'bin dir was created when not needed'
264
304
  end
265
305
 
266
306
  def test_generate_bin_script_no_perms
272
312
    if win_platform?
273
313
      skip('test_generate_bin_script_no_perms skipped on MS Windows')
274
314
    else
275
 
      File.chmod 0000, util_inst_bindir
 
315
      FileUtils.chmod 0000, util_inst_bindir
276
316
 
277
317
      assert_raises Gem::FilePermissionError do
278
318
        @installer.generate_bin
279
319
      end
280
320
    end
281
321
  ensure
282
 
    File.chmod 0700, util_inst_bindir unless $DEBUG
 
322
    FileUtils.chmod 0755, util_inst_bindir unless ($DEBUG or win_platform?)
283
323
  end
284
324
 
285
325
  def test_generate_bin_script_no_shebang
286
326
    @installer.wrappers = true
287
 
    @spec.executables = ["my_exec"]
 
327
    @spec.executables = %w[executable]
288
328
 
289
329
    gem_dir = File.join @gemhome, 'gems', @spec.full_name
290
330
    gem_bindir = File.join gem_dir, 'bin'
291
331
    FileUtils.mkdir_p gem_bindir
292
 
    File.open File.join(gem_bindir, "my_exec"), 'w' do |f|
 
332
    File.open File.join(gem_bindir, 'executable'), 'w' do |f|
293
333
      f.puts "blah blah blah"
294
334
    end
295
335
 
296
336
    @installer.generate_bin
297
337
 
298
 
    installed_exec = File.join @gemhome, 'bin', 'my_exec'
 
338
    installed_exec = File.join @gemhome, 'bin', 'executable'
299
339
    assert_equal true, File.exist?(installed_exec)
300
 
    assert_equal 0100755, File.stat(installed_exec).mode unless win_platform?
 
340
    assert_equal mask, File.stat(installed_exec).mode unless win_platform?
301
341
 
302
342
    wrapper = File.read installed_exec
303
343
    assert_match %r|generated by RubyGems|, wrapper
309
349
    @installer.wrappers = true
310
350
    util_make_exec
311
351
    @installer.gem_dir = util_gem_dir
312
 
    installed_exec = File.join(util_inst_bindir, "my_exec")
 
352
    installed_exec = File.join(util_inst_bindir, 'executable')
313
353
 
314
 
    real_exec = File.join util_gem_dir, 'bin', 'my_exec'
 
354
    real_exec = File.join util_gem_dir, 'bin', 'executable'
315
355
 
316
356
    # fake --no-wrappers for previous install
317
357
    unless Gem.win_platform? then
322
362
    @installer.generate_bin
323
363
    assert_equal true, File.directory?(util_inst_bindir)
324
364
    assert_equal true, File.exist?(installed_exec)
325
 
    assert_equal(0100755, File.stat(installed_exec).mode) unless win_platform?
 
365
    assert_equal mask, File.stat(installed_exec).mode unless win_platform?
326
366
 
327
367
    assert_match %r|generated by RubyGems|, File.read(installed_exec)
328
368
 
339
379
 
340
380
    @installer.generate_bin
341
381
    assert_equal true, File.directory?(util_inst_bindir)
342
 
    installed_exec = File.join(util_inst_bindir, "my_exec")
 
382
    installed_exec = File.join util_inst_bindir, 'executable'
343
383
    assert_equal true, File.symlink?(installed_exec)
344
 
    assert_equal(File.join(util_gem_dir, "bin", "my_exec"),
 
384
    assert_equal(File.join(util_gem_dir, 'bin', 'executable'),
345
385
                 File.readlink(installed_exec))
346
386
  end
347
387
 
348
388
  def test_generate_bin_symlink_no_execs
 
389
    util_execless
 
390
 
349
391
    @installer.wrappers = false
350
392
    @installer.generate_bin
351
 
    assert_equal false, File.exist?(util_inst_bindir)
 
393
 
 
394
    refute File.exist?(util_inst_bindir)
352
395
  end
353
396
 
354
397
  def test_generate_bin_symlink_no_perms
361
404
    if win_platform?
362
405
      skip('test_generate_bin_symlink_no_perms skipped on MS Windows')
363
406
    else
364
 
      File.chmod 0000, util_inst_bindir
 
407
      FileUtils.chmod 0000, util_inst_bindir
365
408
 
366
409
      assert_raises Gem::FilePermissionError do
367
410
        @installer.generate_bin
368
411
      end
369
412
    end
370
413
  ensure
371
 
    File.chmod 0700, util_inst_bindir unless $DEBUG
 
414
    FileUtils.chmod 0755, util_inst_bindir unless ($DEBUG or win_platform?)
372
415
  end
373
416
 
374
417
  def test_generate_bin_symlink_update_newer
379
422
    @installer.gem_dir = util_gem_dir
380
423
 
381
424
    @installer.generate_bin
382
 
    installed_exec = File.join(util_inst_bindir, "my_exec")
383
 
    assert_equal(File.join(util_gem_dir, "bin", "my_exec"),
 
425
    installed_exec = File.join(util_inst_bindir, 'executable')
 
426
    assert_equal(File.join(util_gem_dir, 'bin', 'executable'),
384
427
                 File.readlink(installed_exec))
385
428
 
386
429
    @spec = Gem::Specification.new do |s|
392
435
      s.require_path = 'lib'
393
436
    end
394
437
 
395
 
    util_make_exec '3'
396
 
    @installer.gem_dir = File.join util_gem_dir('3')
 
438
    @spec.version = 3
 
439
    util_make_exec
 
440
    @installer.gem_dir = util_gem_dir @spec
397
441
    @installer.generate_bin
398
 
    installed_exec = File.join(util_inst_bindir, "my_exec")
399
 
    assert_equal(File.join(util_gem_bindir('3'), "my_exec"),
 
442
    installed_exec = File.join(util_inst_bindir, 'executable')
 
443
    assert_equal(@spec.bin_file('executable'),
400
444
                 File.readlink(installed_exec),
401
445
                 "Ensure symlink moved to latest version")
402
446
  end
409
453
    @installer.gem_dir = util_gem_dir
410
454
 
411
455
    @installer.generate_bin
412
 
    installed_exec = File.join(util_inst_bindir, "my_exec")
413
 
    assert_equal(File.join(util_gem_dir, "bin", "my_exec"),
 
456
    installed_exec = File.join(util_inst_bindir, 'executable')
 
457
    assert_equal(File.join(util_gem_dir, 'bin', 'executable'),
414
458
                 File.readlink(installed_exec))
415
459
 
416
460
    spec = Gem::Specification.new do |s|
422
466
      s.require_path = 'lib'
423
467
    end
424
468
 
425
 
    util_make_exec '1'
426
 
    @installer.gem_dir = util_gem_dir('1')
 
469
    util_make_exec
 
470
    one = @spec.dup
 
471
    one.version = 1
 
472
    @installer.gem_dir = util_gem_dir one
427
473
    @installer.spec = spec
428
474
 
429
475
    @installer.generate_bin
430
476
 
431
 
    installed_exec = File.join(util_inst_bindir, "my_exec")
432
 
    assert_equal(File.join(util_gem_dir('2'), "bin", "my_exec"),
 
477
    installed_exec = File.join util_inst_bindir, 'executable'
 
478
    expected = File.join util_gem_dir, 'bin', 'executable'
 
479
    assert_equal(expected,
433
480
                 File.readlink(installed_exec),
434
481
                 "Ensure symlink not moved")
435
482
  end
442
489
    @installer.gem_dir = util_gem_dir
443
490
 
444
491
    @installer.generate_bin
445
 
    installed_exec = File.join(util_inst_bindir, "my_exec")
 
492
    installed_exec = File.join util_inst_bindir, 'executable'
446
493
    assert_equal true, File.exist?(installed_exec)
447
494
 
448
495
    @spec = Gem::Specification.new do |s|
455
502
    end
456
503
 
457
504
    @installer.wrappers = false
458
 
    util_make_exec '3'
459
 
    @installer.gem_dir = util_gem_dir '3'
 
505
    @spec.version = 3
 
506
    util_make_exec
 
507
    @installer.gem_dir = util_gem_dir
460
508
    @installer.generate_bin
461
 
    installed_exec = File.join(util_inst_bindir, "my_exec")
462
 
    assert_equal(File.join(util_gem_dir('3'), "bin", "my_exec"),
 
509
    installed_exec = File.join(util_inst_bindir, 'executable')
 
510
    assert_equal(File.join(util_gem_dir, 'bin', 'executable'),
463
511
                 File.readlink(installed_exec),
464
512
                 "Ensure symlink moved to latest version")
465
513
  end
476
524
    end
477
525
 
478
526
    assert_equal true, File.directory?(util_inst_bindir)
479
 
    installed_exec = File.join(util_inst_bindir, "my_exec")
 
527
    installed_exec = File.join(util_inst_bindir, 'executable')
480
528
    assert_equal true, File.exist?(installed_exec)
481
529
 
482
530
    assert_match(/Unable to use symlinks on Windows, installing wrapper/i,
497
545
    @installer.generate_bin
498
546
 
499
547
    default_shebang = Gem.ruby
500
 
    shebang_line = open("#{@gemhome}/bin/my_exec") { |f| f.readlines.first }
 
548
    shebang_line = open("#{@gemhome}/bin/executable") { |f| f.readlines.first }
501
549
    assert_match(/\A#!/, shebang_line)
502
550
    assert_match(/#{default_shebang}/, shebang_line)
503
551
  end
504
552
 
505
553
  def test_initialize
506
 
    spec = quick_gem 'a' do |s| s.platform = Gem::Platform.new 'mswin32' end
 
554
    spec = quick_spec 'a' do |s| s.platform = Gem::Platform.new 'mswin32' end
507
555
    gem = File.join @tempdir, spec.file_name
508
556
 
509
557
    Dir.mkdir util_inst_bindir
510
558
    util_build_gem spec
511
 
    FileUtils.mv File.join(@gemhome, 'cache', spec.file_name),
512
 
                 @tempdir
 
559
    FileUtils.mv spec.cache_file, @tempdir
513
560
 
514
561
    installer = Gem::Installer.new gem
515
562
 
519
566
  def test_install
520
567
    Dir.mkdir util_inst_bindir
521
568
    util_setup_gem
 
569
    util_clear_gems
522
570
 
 
571
    gemdir     = File.join @gemhome, 'gems', @spec.full_name
523
572
    cache_file = File.join @gemhome, 'cache', @spec.file_name
 
573
    stub_exe   = File.join @gemhome, 'bin', 'executable'
 
574
    rakefile   = File.join gemdir, 'ext', 'a', 'Rakefile'
524
575
 
525
576
    Gem.pre_install do |installer|
526
 
      refute File.exist?(cache_file), 'cache file should not exist yet'
 
577
      refute File.exist?(cache_file), 'cache file must not exist yet'
 
578
      true
 
579
    end
 
580
 
 
581
    Gem.post_build do |installer|
 
582
      assert File.exist?(gemdir), 'gem install dir must exist'
 
583
      assert File.exist?(rakefile), 'gem executable must exist'
 
584
      refute File.exist?(stub_exe), 'gem executable must not exist'
 
585
      true
527
586
    end
528
587
 
529
588
    Gem.post_install do |installer|
530
 
      assert File.exist?(cache_file), 'cache file should exist'
 
589
      assert File.exist?(cache_file), 'cache file must exist'
531
590
    end
532
591
 
 
592
    @newspec = nil
533
593
    build_rake_in do
534
594
      use_ui @ui do
535
 
        assert_equal @spec, @installer.install
 
595
        @newspec = @installer.install
536
596
      end
537
597
    end
538
598
 
539
 
    gemdir = File.join @gemhome, 'gems', @spec.full_name
540
 
    assert File.exist?(gemdir)
541
 
 
542
 
    exe = File.join(gemdir, 'bin', 'executable')
543
 
    assert File.exist?(exe)
 
599
    assert_equal @spec, @newspec
 
600
    assert File.exist? gemdir
 
601
    assert File.exist?(stub_exe), 'gem executable must exist'
 
602
 
 
603
    exe = File.join gemdir, 'bin', 'executable'
 
604
    assert File.exist? exe
 
605
 
544
606
    exe_mode = File.stat(exe).mode & 0111
545
607
    assert_equal 0111, exe_mode, "0%o" % exe_mode unless win_platform?
546
608
 
547
609
    assert File.exist?(File.join(gemdir, 'lib', 'code.rb'))
548
610
 
549
 
    assert File.exist?(File.join(gemdir, 'ext', 'a', 'Rakefile'))
 
611
    assert File.exist? rakefile
550
612
 
551
613
    spec_file = File.join(@gemhome, 'specifications', @spec.spec_name)
552
614
 
553
 
    assert_equal spec_file, @spec.loaded_from
 
615
    assert_equal spec_file, @newspec.loaded_from
554
616
    assert File.exist?(spec_file)
555
617
 
 
618
    assert_same @installer, @post_build_hook_arg
 
619
    assert_same @installer, @post_install_hook_arg
556
620
    assert_same @installer, @pre_install_hook_arg
557
 
    assert_same @installer, @post_install_hook_arg
 
621
  end
 
622
 
 
623
  def test_install_with_no_prior_files
 
624
    Dir.mkdir util_inst_bindir
 
625
    util_clear_gems
 
626
 
 
627
    util_setup_gem
 
628
    build_rake_in do
 
629
      use_ui @ui do
 
630
        assert_equal @spec, @installer.install
 
631
      end
 
632
    end
 
633
 
 
634
    gemdir = File.join(@gemhome, 'gems', @spec.full_name)
 
635
    assert File.exist?(File.join(gemdir, 'lib', 'code.rb'))
 
636
 
 
637
    util_setup_gem
 
638
    # Morph spec to have lib/other.rb instead of code.rb and recreate
 
639
    @spec.files = File.join('lib', 'other.rb')
 
640
    Dir.chdir @tempdir do
 
641
      File.open File.join('lib', 'other.rb'), 'w' do |f| f.puts '1' end
 
642
      use_ui ui do
 
643
        FileUtils.rm @gem
 
644
        Gem::Builder.new(@spec).build
 
645
      end
 
646
    end
 
647
    @installer = Gem::Installer.new @gem
 
648
    build_rake_in do
 
649
      use_ui @ui do
 
650
        assert_equal @spec, @installer.install
 
651
      end
 
652
    end
 
653
 
 
654
    assert File.exist?(File.join(gemdir, 'lib', 'other.rb'))
 
655
    refute(File.exist?(File.join(gemdir, 'lib', 'code.rb')),
 
656
           "code.rb from prior install of same gem shouldn't remain here")
558
657
  end
559
658
 
560
659
  def test_install_bad_gem
593
692
    gemhome2 = "#{@gemhome}2"
594
693
    @spec.add_dependency 'b'
595
694
 
596
 
    b2 = quick_gem 'b', 2
 
695
    quick_gem 'b', 2
597
696
 
598
697
    FileUtils.mv @gemhome, gemhome2
599
 
    Gem.source_index.gems.delete b2.full_name
600
 
    source_index = Gem::SourceIndex.from_gems_in File.join(gemhome2,
601
 
                                                           'specifications')
 
698
 
 
699
    Gem::Specification.dirs = [gemhome2] # TODO: switch all dirs= to use_paths
602
700
 
603
701
    util_setup_gem
604
702
 
605
 
    @installer = Gem::Installer.new @gem, :install_dir => gemhome2,
606
 
                                    :source_index => source_index
 
703
    @installer = Gem::Installer.new @gem, :install_dir => gemhome2
 
704
 
 
705
    gem_home = Gem.dir
607
706
 
608
707
    build_rake_in do
609
708
      use_ui @ui do
612
711
    end
613
712
 
614
713
    assert File.exist?(File.join(gemhome2, 'gems', @spec.full_name))
 
714
    assert_equal gem_home, Gem.dir
615
715
  end
616
716
 
617
717
  def test_install_force
655
755
 
656
756
    use_ui @ui do
657
757
      Dir.chdir @tempdir do Gem::Builder.new(@spec).build end
658
 
      gem = File.join @tempdir, @spec.file_name
659
758
 
660
759
      @installer.install
661
760
    end
668
767
    assert File.exist?(File.join(@gemhome, 'specifications', @spec.spec_name))
669
768
  end
670
769
 
 
770
  def test_install_post_build_false
 
771
    util_clear_gems
 
772
 
 
773
    Gem.post_build do
 
774
      false
 
775
    end
 
776
 
 
777
    use_ui @ui do
 
778
      e = assert_raises Gem::InstallError do
 
779
        @installer.install
 
780
      end
 
781
 
 
782
      location = "#{__FILE__}:#{__LINE__ - 9}"
 
783
 
 
784
      assert_equal "post-build hook at #{location} failed for a-2", e.message
 
785
    end
 
786
 
 
787
    spec_file = File.join @gemhome, 'specifications', @spec.spec_name
 
788
    refute File.exist? spec_file
 
789
 
 
790
    gem_dir = File.join @gemhome, 'gems', @spec.full_name
 
791
    refute File.exist? gem_dir
 
792
  end
 
793
 
 
794
  def test_install_post_build_nil
 
795
    util_clear_gems
 
796
 
 
797
    Gem.post_build do
 
798
      nil
 
799
    end
 
800
 
 
801
    use_ui @ui do
 
802
      @installer.install
 
803
    end
 
804
 
 
805
    spec_file = File.join @gemhome, 'specifications', @spec.spec_name
 
806
    assert File.exist? spec_file
 
807
 
 
808
    gem_dir = File.join @gemhome, 'gems', @spec.full_name
 
809
    assert File.exist? gem_dir
 
810
  end
 
811
 
 
812
  def test_install_pre_install_false
 
813
    util_clear_gems
 
814
 
 
815
    Gem.pre_install do
 
816
      false
 
817
    end
 
818
 
 
819
    use_ui @ui do
 
820
      e = assert_raises Gem::InstallError do
 
821
        @installer.install
 
822
      end
 
823
 
 
824
      location = "#{__FILE__}:#{__LINE__ - 9}"
 
825
 
 
826
      assert_equal "pre-install hook at #{location} failed for a-2", e.message
 
827
    end
 
828
 
 
829
    spec_file = File.join @gemhome, 'specifications', @spec.spec_name
 
830
    refute File.exist? spec_file
 
831
  end
 
832
 
 
833
  def test_install_pre_install_nil
 
834
    util_clear_gems
 
835
 
 
836
    Gem.pre_install do
 
837
      nil
 
838
    end
 
839
 
 
840
    use_ui @ui do
 
841
      @installer.install
 
842
    end
 
843
 
 
844
    spec_file = File.join @gemhome, 'specifications', @spec.spec_name
 
845
    assert File.exist? spec_file
 
846
  end
 
847
 
671
848
  def test_install_with_message
672
849
    @spec.post_install_message = 'I am a shiny gem!'
673
850
 
674
851
    use_ui @ui do
675
 
      Dir.chdir @tempdir do Gem::Builder.new(@spec).build end
 
852
      path = Gem::Builder.new(@spec).build
676
853
 
 
854
      @installer = Gem::Installer.new path
677
855
      @installer.install
678
856
    end
679
857
 
692
870
  end
693
871
 
694
872
  def test_install_wrong_rubygems_version
695
 
    spec = quick_gem 'old_rubygems_required', '1' do |s|
 
873
    spec = quick_spec 'old_rubygems_required', '1' do |s|
696
874
      s.required_rubygems_version = '< 0'
697
875
    end
698
876
 
699
877
    util_build_gem spec
700
878
 
701
 
    gem = File.join @gemhome, 'cache', spec.file_name
 
879
    gem = File.join(@gemhome, 'cache', spec.file_name)
702
880
 
703
881
    use_ui @ui do
704
882
      @installer = Gem::Installer.new gem
719
897
  end
720
898
 
721
899
  def test_shebang
722
 
    util_make_exec '2', "#!/usr/bin/ruby"
 
900
    util_make_exec @spec, "#!/usr/bin/ruby"
723
901
 
724
 
    shebang = @installer.shebang 'my_exec'
 
902
    shebang = @installer.shebang 'executable'
725
903
 
726
904
    assert_equal "#!#{Gem.ruby}", shebang
727
905
  end
728
906
 
729
907
  def test_shebang_arguments
730
 
    util_make_exec '2', "#!/usr/bin/ruby -ws"
 
908
    util_make_exec @spec, "#!/usr/bin/ruby -ws"
731
909
 
732
 
    shebang = @installer.shebang 'my_exec'
 
910
    shebang = @installer.shebang 'executable'
733
911
 
734
912
    assert_equal "#!#{Gem.ruby} -ws", shebang
735
913
  end
736
914
 
737
915
  def test_shebang_empty
738
 
    util_make_exec '2', ''
 
916
    util_make_exec @spec, ''
739
917
 
740
 
    shebang = @installer.shebang 'my_exec'
 
918
    shebang = @installer.shebang 'executable'
741
919
    assert_equal "#!#{Gem.ruby}", shebang
742
920
  end
743
921
 
744
922
  def test_shebang_env
745
 
    util_make_exec '2', "#!/usr/bin/env ruby"
 
923
    util_make_exec @spec, "#!/usr/bin/env ruby"
746
924
 
747
 
    shebang = @installer.shebang 'my_exec'
 
925
    shebang = @installer.shebang 'executable'
748
926
 
749
927
    assert_equal "#!#{Gem.ruby}", shebang
750
928
  end
751
929
 
752
930
  def test_shebang_env_arguments
753
 
    util_make_exec '2', "#!/usr/bin/env ruby -ws"
 
931
    util_make_exec @spec, "#!/usr/bin/env ruby -ws"
754
932
 
755
 
    shebang = @installer.shebang 'my_exec'
 
933
    shebang = @installer.shebang 'executable'
756
934
 
757
935
    assert_equal "#!#{Gem.ruby} -ws", shebang
758
936
  end
759
937
 
760
938
  def test_shebang_env_shebang
761
 
    util_make_exec '2', ''
 
939
    util_make_exec @spec, ''
762
940
    @installer.env_shebang = true
763
941
 
764
 
    shebang = @installer.shebang 'my_exec'
 
942
    shebang = @installer.shebang 'executable'
765
943
 
766
944
    env_shebang = "/usr/bin/env" unless Gem.win_platform?
767
945
 
770
948
  end
771
949
 
772
950
  def test_shebang_nested
773
 
    util_make_exec '2', "#!/opt/local/ruby/bin/ruby"
 
951
    util_make_exec @spec, "#!/opt/local/ruby/bin/ruby"
774
952
 
775
 
    shebang = @installer.shebang 'my_exec'
 
953
    shebang = @installer.shebang 'executable'
776
954
 
777
955
    assert_equal "#!#{Gem.ruby}", shebang
778
956
  end
779
957
 
780
958
  def test_shebang_nested_arguments
781
 
    util_make_exec '2', "#!/opt/local/ruby/bin/ruby -ws"
 
959
    util_make_exec @spec, "#!/opt/local/ruby/bin/ruby -ws"
782
960
 
783
 
    shebang = @installer.shebang 'my_exec'
 
961
    shebang = @installer.shebang 'executable'
784
962
 
785
963
    assert_equal "#!#{Gem.ruby} -ws", shebang
786
964
  end
787
965
 
788
966
  def test_shebang_version
789
 
    util_make_exec '2', "#!/usr/bin/ruby18"
 
967
    util_make_exec @spec, "#!/usr/bin/ruby18"
790
968
 
791
 
    shebang = @installer.shebang 'my_exec'
 
969
    shebang = @installer.shebang 'executable'
792
970
 
793
971
    assert_equal "#!#{Gem.ruby}", shebang
794
972
  end
795
973
 
796
974
  def test_shebang_version_arguments
797
 
    util_make_exec '2', "#!/usr/bin/ruby18 -ws"
 
975
    util_make_exec @spec, "#!/usr/bin/ruby18 -ws"
798
976
 
799
 
    shebang = @installer.shebang 'my_exec'
 
977
    shebang = @installer.shebang 'executable'
800
978
 
801
979
    assert_equal "#!#{Gem.ruby} -ws", shebang
802
980
  end
803
981
 
804
982
  def test_shebang_version_env
805
 
    util_make_exec '2', "#!/usr/bin/env ruby18"
 
983
    util_make_exec @spec, "#!/usr/bin/env ruby18"
806
984
 
807
 
    shebang = @installer.shebang 'my_exec'
 
985
    shebang = @installer.shebang 'executable'
808
986
 
809
987
    assert_equal "#!#{Gem.ruby}", shebang
810
988
  end
811
989
 
812
990
  def test_shebang_version_env_arguments
813
 
    util_make_exec '2', "#!/usr/bin/env ruby18 -ws"
 
991
    util_make_exec @spec, "#!/usr/bin/env ruby18 -ws"
814
992
 
815
 
    shebang = @installer.shebang 'my_exec'
 
993
    shebang = @installer.shebang 'executable'
816
994
 
817
995
    assert_equal "#!#{Gem.ruby} -ws", shebang
818
996
  end
843
1021
    assert_equal @spec, eval(File.read(spec_file))
844
1022
  end
845
1023
 
 
1024
  def test_write_spec_writes_cached_spec
 
1025
    spec_dir = File.join @gemhome, 'specifications'
 
1026
    spec_file = File.join spec_dir, @spec.spec_name
 
1027
    FileUtils.rm spec_file
 
1028
    refute File.exist?(spec_file)
 
1029
 
 
1030
    @spec.files = %w[a.rb b.rb c.rb]
 
1031
 
 
1032
    @installer.spec = @spec
 
1033
    @installer.gem_home = @gemhome
 
1034
 
 
1035
    @installer.write_spec
 
1036
 
 
1037
    # cached specs have no file manifest:
 
1038
    @spec.files = []
 
1039
 
 
1040
    assert_equal @spec, eval(File.read(spec_file))
 
1041
  end
 
1042
 
 
1043
  def test_dir
 
1044
    assert_match @installer.dir, %r!/installer/gems/a-2$!
 
1045
  end
 
1046
 
846
1047
  def old_ruby_required
847
 
    spec = quick_gem 'old_ruby_required', '1' do |s|
 
1048
    spec = quick_spec 'old_ruby_required', '1' do |s|
848
1049
      s.required_ruby_version = '= 1.4.6'
849
1050
    end
850
1051
 
851
1052
    util_build_gem spec
852
1053
 
853
 
    File.join @gemhome, 'cache', spec.file_name
854
 
  end
855
 
 
 
1054
    spec.cache_file
 
1055
  end
 
1056
 
 
1057
  def util_execless
 
1058
    @spec = quick_spec 'z'
 
1059
    util_build_gem @spec
 
1060
 
 
1061
    @installer = util_installer @spec, @gemhome
 
1062
  end
 
1063
 
 
1064
  def mask
 
1065
    0100755 & (~File.umask)
 
1066
  end
856
1067
end
857