spring 0.0.8 → 1.0.0

data/test/acceptance/app_test.rb

@@ -1,19 +1,34 @@
+# encoding: utf-8
 require 'helper'
 require 'io/wait'
 require "timeout"
 require "spring/sid"
 require "spring/env"
-require "pty"
 
 class AppTest < ActiveSupport::TestCase
+  DEFAULT_SPEEDUP = 0.8
+  DEFAULT_TIMEOUT = ENV['CI'] ? 30 : 10
+
+  def rails_version
+    ENV['RAILS_VERSION'] || '~> 4.0.0'
+  end
+
+  def rails_3?
+    rails_version.split(" ").last =~ /^3/
+  end
+
   def app_root
-    Pathname.new("#{TEST_ROOT}/apps/rails-3-2")
+    Pathname.new("#{TEST_ROOT}/apps/rails-#{rails_version.scan(/\d/)[0..1].join("-")}")
   end
 
   def gem_home
     app_root.join "vendor/gems/#{RUBY_VERSION}"
   end
 
+  def user_home
+    app_root.join "user_home"
+  end
+
   def spring
     gem_home.join "bin/spring"
   end
@@ -30,12 +45,27 @@ class AppTest < ActiveSupport::TestCase
     @stderr ||= IO.pipe
   end
 
+  def log_file
+    @log_file ||= File.open("/tmp/spring.log", "w+")
+  end
+
+  def env
+    @env ||= {
+      "GEM_HOME"   => gem_home.to_s,
+      "GEM_PATH"   => "",
+      "HOME"       => user_home.to_s,
+      "RAILS_ENV"  => nil,
+      "RACK_ENV"   => nil,
+      "SPRING_LOG" => log_file.path
+    }
+  end
+
   def app_run(command, opts = {})
     start_time = Time.now
 
     Bundler.with_clean_env do
       Process.spawn(
-        { "GEM_HOME" => gem_home.to_s, "GEM_PATH" => "" },
+        env,
         command.to_s,
         out:   stdout.last,
         err:   stderr.last,
@@ -44,106 +74,173 @@ class AppTest < ActiveSupport::TestCase
       )
     end
 
-    _, status = Timeout.timeout(opts.fetch(:timeout, 10)) { Process.wait2 }
+    _, status = Timeout.timeout(opts.fetch(:timeout, DEFAULT_TIMEOUT)) { Process.wait2 }
 
-    stdout, stderr = read_streams
-    puts dump_streams(command, stdout, stderr) if ENV["SPRING_DEBUG"]
+    if pid = spring_env.pid
+      @server_pid = pid
+      lines = `ps -A -o ppid= -o pid= | egrep '^\\s*#{@server_pid}'`.lines
+      @application_pids = lines.map { |l| l.split.last.to_i }
+    end
+
+    output = read_streams
+    puts dump_streams(command, output) if ENV["SPRING_DEBUG"]
 
     @times << (Time.now - start_time) if @times
 
-    {
-      status: status,
-      stdout: stdout,
-      stderr: stderr,
-    }
+    output.merge(status: status, command: command)
   rescue Timeout::Error => e
-    raise e, "Output:\n\n#{dump_streams(command, *read_streams)}"
+    raise e, "Output:\n\n#{dump_streams(command, read_streams)}"
   end
 
   def read_streams
-    [stdout, stderr].map(&:first).map do |stream|
-      output = ""
-      output << stream.readpartial(10240) while IO.select([stream], [], [], 0.1)
-      output
+    {
+      stdout: read_stream(stdout.first),
+      stderr: read_stream(stderr.first),
+      log:    read_stream(log_file)
+    }
+  end
+
+  def read_stream(stream)
+    output = ""
+    while IO.select([stream], [], [], 0.5) && !stream.eof?
+      output << stream.readpartial(10240)
     end
+    output
   end
 
-  def dump_streams(command, stdout, stderr)
+  def dump_streams(command, streams)
     output = "$ #{command}\n"
 
-    unless stdout.chomp.empty?
-      output << "--- stdout ---\n"
-      output << "#{stdout.chomp}\n"
-    end
-
-    unless stderr.chomp.empty?
-      output << "--- stderr ---\n"
-      output << "#{stderr.chomp}\n"
+    streams.each do |name, stream|
+      unless stream.chomp.empty?
+        output << "--- #{name} ---\n"
+        output << "#{stream.chomp}\n"
+      end
     end
 
     output << "\n"
     output
   end
 
+  def alive?(pid)
+    Process.kill 0, pid
+    true
+  rescue Errno::ESRCH
+    false
+  end
+
   def await_reload
-    sleep 0.4
+    raise "no pid" if @application_pids.nil? || @application_pids.empty?
+
+    Timeout.timeout(DEFAULT_TIMEOUT) do
+      sleep 0.1 while @application_pids.any? { |p| alive?(p) }
+    end
+  end
+
+  def debug(artifacts)
+    artifacts = artifacts.dup
+    artifacts.delete :status
+    dump_streams(artifacts.delete(:command), artifacts)
   end
 
   def assert_output(artifacts, expected)
     expected.each do |stream, output|
       assert artifacts[stream].include?(output),
-             "expected #{stream} to include '#{output}', but it was:\n\n#{artifacts[stream]}"
+             "expected #{stream} to include '#{output}'.\n\n#{debug(artifacts)}"
     end
   end
 
   def assert_success(command, expected_output = nil)
-    artifacts = app_run(command)
-    assert artifacts[:status].success?, "expected successful exit status"
+    artifacts = app_run(*Array(command))
+    assert artifacts[:status].success?, "expected successful exit status\n\n#{debug(artifacts)}"
     assert_output artifacts, expected_output if expected_output
   end
 
   def assert_failure(command, expected_output = nil)
-    artifacts = app_run(command)
-    assert !artifacts[:status].success?, "expected unsuccessful exit status"
+    artifacts = app_run(*Array(command))
+    assert !artifacts[:status].success?, "expected unsuccessful exit status\n\n#{debug(artifacts)}"
     assert_output artifacts, expected_output if expected_output
   end
 
-  def assert_speedup(ratio = 0.6)
-    @times = []
-    yield
-    assert (@times.last / @times.first) < ratio, "#{@times.last} was not less than #{ratio} of #{@times.first}"
-    @times = nil
+  def assert_speedup(ratio = DEFAULT_SPEEDUP)
+    if ENV['CI']
+      yield
+    else
+      @times = []
+      yield
+      assert (@times.last / @times.first) < ratio, "#{@times.last} was not less than #{ratio} of #{@times.first}"
+      @times = nil
+    end
   end
 
   def spring_test_command
-    "#{spring} testunit #{@test}"
+    "#{spring} #{rails_3? ? 'testunit' : 'rake test'} #{@test}"
   end
 
-  @@installed = false
+  def generate_app
+    Bundler.with_clean_env do
+      # Sporadic SSL errors keep causing test failures so there are anti-SSL workarounds here
 
-  setup do
-    @test                = "#{app_root}/test/functional/posts_controller_test.rb"
-    @test_contents       = File.read(@test)
-    @controller          = "#{app_root}/app/controllers/posts_controller.rb"
-    @controller_contents = File.read(@controller)
+      assert system("(gem list rails --installed --version '#{rails_version}' || " \
+                      "gem install rails --clear-sources --source http://rubygems.org --version '#{rails_version}') > /dev/null")
+
+      # Have to shell out otherwise bundler prevents us finding the gem
+      version = `ruby -e 'puts Gem::Specification.find_by_name("rails", "#{rails_version}").version'`.chomp
+
+      assert system("rails _#{version}_ new #{app_root} --skip-bundle --skip-javascript --skip-sprockets > /dev/null")
 
-    unless @@installed
       FileUtils.mkdir_p(gem_home)
-      system "gem build spring.gemspec 2>/dev/null 1>/dev/null"
-      app_run "gem install ../../../spring-#{Spring::VERSION}.gem"
-      app_run "(gem list bundler | grep bundler) || gem install bundler #{'--pre' if RUBY_VERSION >= "2.0"}", timeout: nil
-      app_run "bundle check || bundle update", timeout: nil
-      app_run "bundle exec rake db:migrate db:test:clone"
-      @@installed = true
+      FileUtils.mkdir_p(user_home)
+      FileUtils.rm_rf("#{app_root}/test/performance/")
+
+      if rails_3?
+        File.write(
+          "#{app_root}/Gemfile",
+          File.read("#{app_root}/Gemfile") + "gem 'spring-commands-testunit'\n"
+        )
+      end
+
+      File.write(
+        "#{app_root}/Gemfile",
+        File.read("#{app_root}/Gemfile").sub("https://rubygems.org", "http://rubygems.org")
+      )
+    end
+  end
+
+  def install
+    generate_app unless app_root.exist?
+
+    assert system("gem build spring.gemspec 2>/dev/null 1>/dev/null")
+
+    assert_success ["gem install ../../../spring-#{Spring::VERSION}.gem", timeout: nil]
+    assert_success ["(gem list bundler | grep bundler) || gem install bundler", timeout: nil]
+    assert_success ["bundle check || bundle update", timeout: nil]
+
+    unless File.exist?(@controller)
+      assert_success "bundle exec rails g scaffold post title:string"
     end
 
-    FileUtils.rm_rf "#{app_root}/bin"
+    assert_success "bundle exec rake db:migrate db:test:clone"
+    @@installed = true
+  end
+
+  @@installed = false
+
+  setup do
+    @test       = "#{app_root}/test/#{rails_3? ? 'functional' : 'controllers'}/posts_controller_test.rb"
+    @controller = "#{app_root}/app/controllers/posts_controller.rb"
+
+    install unless @@installed
+
+    @test_contents       = File.read(@test)
+    @controller_contents = File.read(@controller)
   end
 
   teardown do
     app_run "#{spring} stop"
-    File.write(@test,       @test_contents)
+    File.write(@test, @test_contents)
     File.write(@controller, @controller_contents)
+    FileUtils.rm_f("#{app_root}/config/spring.rb")
   end
 
   test "basic" do
@@ -206,15 +303,13 @@ class AppTest < ActiveSupport::TestCase
     File.write(@test, @test_contents.sub("get :index", "Foo.omg"))
 
     await_reload
-
-    assert_speedup do
-      2.times { assert_failure spring_test_command, stdout: "RuntimeError: omg" }
-    end
+    assert_failure spring_test_command, stdout: "RuntimeError: omg"
   ensure
     File.write(application, application_contents)
   end
 
   test "app gets reloaded when preloaded files change (polling watcher)" do
+    env["RAILS_ENV"] = "test"
     assert_success "#{spring} rails runner 'puts Spring.watcher.class'", stdout: "Polling"
     assert_app_reloaded
   end
@@ -223,10 +318,15 @@ class AppTest < ActiveSupport::TestCase
     begin
       gemfile = app_root.join("Gemfile")
       gemfile_contents = gemfile.read
-      File.write(gemfile, gemfile_contents.sub(%{# gem 'listen'}, %{gem 'listen'}))
-      app_run "bundle install", timeout: nil
+      File.write(gemfile, gemfile_contents + "\ngem 'listen', '~> 1.0'")
+
+      File.write("#{app_root}/config/spring.rb", "Spring.watch_method = :listen")
 
+      assert_success ["bundle install", timeout: nil]
+
+      env["RAILS_ENV"] = "test"
       assert_success "#{spring} rails runner 'puts Spring.watcher.class'", stdout: "Listen"
+
       assert_app_reloaded
     ensure
       File.write(gemfile, gemfile_contents)
@@ -247,8 +347,6 @@ class AppTest < ActiveSupport::TestCase
       assert_failure spring_test_command
 
       File.write(application, application_contents)
-      await_reload
-
       assert_success spring_test_command
     ensure
       File.write(application, application_contents)
@@ -264,32 +362,61 @@ class AppTest < ActiveSupport::TestCase
   end
 
   test "custom commands" do
+    File.write("#{app_root}/config/spring.rb", <<-CODE)
+      class CustomCommand
+        def call
+          puts "omg"
+        end
+      end
+
+      Spring.register_command "custom", CustomCommand.new
+    CODE
+
     assert_success "#{spring} custom", stdout: "omg"
   end
 
   test "binstubs" do
-    app_run "#{spring} binstub rake"
-    app_run "#{spring} binstub rails"
-    assert_success "bin/spring help"
-    assert_success "bin/rake -T", stdout: "rake db:migrate"
-    assert_success "bin/rails runner 'puts %(omg)'", stdout: "omg"
+    begin
+      FileUtils.mv "#{app_root}/bin", "#{app_root}/bin~" if File.exist?("#{app_root}/bin")
+
+      app_run "#{spring} binstub rake"
+      assert_success "bin/rake -T", stdout: "rake db:migrate"
+
+      app_run "#{spring} binstub rake rails"
+      assert_success "bin/rails runner 'puts %(omg)'", stdout: "omg"
+      assert_success "bin/rails server --help", stdout: "Usage: rails server"
+
+      FileUtils.rm ["#{app_root}/bin/rails", "#{app_root}/bin/rake"]
+
+      app_run "#{spring} binstub --all"
+      assert_success "bin/rake -T", stdout: "rake db:migrate"
+      assert_success "bin/rails runner 'puts %(omg)'", stdout: "omg"
+    ensure
+      if File.exist?("#{app_root}/bin~")
+        FileUtils.rm_rf "#{app_root}/bin"
+        FileUtils.mv "#{app_root}/bin~", "#{app_root}/bin"
+      end
+    end
   end
 
   test "after fork callback" do
-    begin
-      config_path = "#{app_root}/config/spring.rb"
-      config_contents = File.read(config_path)
+    File.write("#{app_root}/config/spring.rb", "Spring.after_fork { puts '!callback!' }")
+    assert_success "#{spring} rails runner 'puts 2'", stdout: "!callback!\n2"
+  end
 
-      File.write(config_path, config_contents + "\nSpring.after_fork { puts '!callback!' }")
+  test "global config file evaluated" do
+    begin
+      File.write("#{user_home}/.spring.rb", "Spring.after_fork { puts '!callback!' }")
       assert_success "#{spring} rails runner 'puts 2'", stdout: "!callback!\n2"
     ensure
-      File.write(config_path, config_contents)
+      FileUtils.rm_r("#{user_home}/.spring.rb")
     end
   end
 
   test "missing config/application.rb" do
     begin
       FileUtils.mv app_root.join("config/application.rb"), app_root.join("config/application.rb.bak")
+
       assert_failure "#{spring} rake -T", stderr: "unable to find your config/application.rb"
     ensure
       FileUtils.mv app_root.join("config/application.rb.bak"), app_root.join("config/application.rb")
@@ -307,8 +434,78 @@ class AppTest < ActiveSupport::TestCase
   end
 
   test "runner command sets Rails environment from command-line options" do
-    # Not using "test" environment here to avoid false positives on Travis (where "test" is default)
-    assert_success "#{spring} rails runner -e staging 'puts Rails.env'", stdout: "staging"
-    assert_success "#{spring} rails runner --environment=staging 'puts Rails.env'", stdout: "staging"
+    assert_success "#{spring} rails runner -e production 'puts Rails.env'", stdout: "production"
+    assert_success "#{spring} rails runner --environment=production 'puts Rails.env'", stdout: "production"
+  end
+
+  test "forcing rails env via environment variable" do
+    env['RAILS_ENV'] = 'production'
+    assert_success "#{spring} rake -p 'Rails.env'", stdout: "production"
+  end
+
+  test "setting env vars with rake" do
+    begin
+      File.write("#{app_root}/lib/tasks/env.rake", <<-'CODE')
+      task :print_rails_env => :environment do
+        puts Rails.env
+      end
+
+      task :print_env do
+        ENV.each { |k, v| puts "#{k}=#{v}" }
+      end
+
+      task(:default).clear.enhance [:print_rails_env]
+      CODE
+
+      assert_success "#{spring} rake RAILS_ENV=test print_rails_env", stdout: "test"
+      assert_success "#{spring} rake FOO=bar print_env", stdout: "FOO=bar"
+      assert_success "#{spring} rake", stdout: "test"
+    ensure
+      FileUtils.rm_f("#{app_root}/lib/tasks/env.rake")
+    end
+  end
+
+  test "changing the Gemfile restarts the server" do
+    begin
+      gemfile = app_root.join("Gemfile")
+      gemfile_contents = gemfile.read
+
+      assert_success %(#{spring} rails runner 'require "sqlite3"')
+
+      File.write(gemfile, gemfile_contents.sub(%{gem 'sqlite3'}, %{# gem 'sqlite3'}))
+      app_run "bundle check"
+
+      await_reload
+      assert_failure %(#{spring} rails runner 'require "sqlite3"'), stderr: "sqlite3"
+    ensure
+      File.write(gemfile, gemfile_contents)
+      assert_success "bundle check"
+    end
+  end
+
+  test "changing the environment between runs" do
+    begin
+      application = "#{app_root}/config/application.rb"
+      application_contents = File.read(application)
+
+      File.write(application, "#{application_contents}\nENV['BAR'] = 'bar'")
+
+      env["OMG"] = "1"
+      env["FOO"] = "1"
+      env["RUBYOPT"] = "-rubygems"
+
+      assert_success %(#{spring} rails runner 'p ENV["OMG"]'), stdout: "1"
+      assert_success %(#{spring} rails runner 'p ENV["BAR"]'), stdout: "bar"
+      assert_success %(#{spring} rails runner 'p ENV.key?("BUNDLE_GEMFILE")'), stdout: "true"
+      assert_success %(#{spring} rails runner 'p ENV["RUBYOPT"]'), stdout: "bundler"
+
+      env["OMG"] = "2"
+      env.delete "FOO"
+
+      assert_success %(#{spring} rails runner 'p ENV["OMG"]'), stdout: "2"
+      assert_success %(#{spring} rails runner 'p ENV.key?("FOO")'), stdout: "false"
+    ensure
+      File.write(application, application_contents)
+    end
   end
 end

data/test/apps/.gitignore

@@ -0,0 +1,3 @@
+*
+!template.rb
+!.gitignore

data/test/unit/client/help_test.rb

@@ -41,6 +41,8 @@ class HelpTest < ActiveSupport::TestCase
 
   test "formatted_help generates expected output" do
     expected_output = <<-EOF
+Version: #{Spring::VERSION}
+
 Usage: spring COMMAND [ARGS]
 
 Commands for spring itself:

data/test/unit/commands_test.rb

@@ -2,55 +2,6 @@ require "helper"
 require "spring/commands"
 
 class CommandsTest < ActiveSupport::TestCase
-  test "test command needs a test name" do
-    begin
-      real_stderr = $stderr
-      $stderr = StringIO.new('')
-
-      command = Spring::Commands::TestUnit.new
-      command.call([])
-
-      assert_equal "you need to specify what test to run: spring test TEST_NAME\n", $stderr.string
-    ensure
-      $stderr = real_stderr
-    end
-  end
-
-  test 'children of Command have inheritable accessor named "preload"' do
-    command1, command2 = 2.times.map { Class.new(Spring::Commands::Command) }
-
-    command1.preloads << "foo"
-    assert_equal ["foo"], command1.preloads
-    assert_equal [], command2.preloads
-
-    command2.preloads << "bar"
-    assert_equal ["foo"], command1.preloads
-    assert_equal ["bar"], command2.preloads
-
-    command1.preloads = ["omg"]
-    assert_equal ["omg"], command1.preloads
-    assert_equal ["bar"], command2.preloads
-
-    command3 = Class.new(command1)
-    command3.preloads << "foo"
-    assert_equal ["omg", "foo"], command3.preloads
-    assert_equal ["omg"], command1.preloads
-  end
-
-  test "prints error message when preloaded file does not exist" do
-    begin
-      original_stderr = $stderr
-      $stderr = StringIO.new('')
-      my_command_class = Class.new(Spring::Commands::Command)
-      my_command_class.preloads = %w(i_do_not_exist)
-
-      my_command_class.new.setup
-      assert_match /The #<Class:0x[0-9a-f]+> command tried to preload i_do_not_exist but could not find it./, $stderr.string
-    ensure
-      $stderr = original_stderr
-    end
-  end
-
   test 'console command sets rails environment from command-line option' do
     command = Spring::Commands::RailsConsole.new
     assert_equal 'test', command.env(['test'])
@@ -75,4 +26,12 @@ class CommandsTest < ActiveSupport::TestCase
     command = Spring::Commands::RailsRunner.new
     assert_nil command.env(['puts 1+1'])
   end
+
+  test "rake command has configurable environments" do
+    command = Spring::Commands::Rake.new
+    assert_nil command.env(["foo"])
+    assert_equal "test", command.env(["test"])
+    assert_equal "test", command.env(["test:models"])
+    assert_nil command.env(["test_foo"])
+  end
 end

data/test/unit/watcher_test.rb

@@ -3,7 +3,8 @@ require "tmpdir"
 require "fileutils"
 require "active_support/core_ext/numeric/time"
 require "spring/watcher"
-require "listen"
+require "spring/watcher/polling"
+require "spring/watcher/listen"
 
 module WatcherTests
   LATENCY = 0.001
@@ -41,6 +42,18 @@ module WatcherTests
     assert !watcher.stale?
   end
 
+  def test_starting_with_no_file
+    file = "#{@dir}/omg"
+    touch file, Time.now - 2.seconds
+
+    watcher.start
+    watcher.add file
+
+    assert_not_stale
+    touch file, Time.now
+    assert_stale
+  end
+
   def test_is_stale_when_a_watched_file_is_updated
     file = "#{@dir}/omg"
     touch file, Time.now - 2.seconds
@@ -114,12 +127,14 @@ module WatcherTests
     watcher.add file
     watcher.start
 
+    io = watcher.to_io
+
     Thread.new {
       sleep LATENCY * 3
       touch file, Time.now
     }
 
-    assert IO.select([watcher], [], [], 1), "IO.select timed out before watcher was readable"
+    assert IO.select([io], [], [], 1), "IO.select timed out before watcher was readable"
     assert watcher.stale?
   end
 
@@ -134,6 +149,11 @@ module WatcherTests
     watcher.add "./foo"
     assert_equal ["#{dir}/foo"], watcher.files.to_a
   end
+
+  def test_add_non_existant_file
+    watcher.add './foobar'
+    assert watcher.files.empty?
+  end
 end
 
 class ListenWatcherTest < ActiveSupport::TestCase