spring 1.1.3 → 1.3.0

data/lib/spring/test/acceptance_test.rb

@@ -0,0 +1,346 @@
+# encoding: utf-8
+
+require "io/wait"
+require "timeout"
+require "spring/sid"
+require "spring/client"
+
+module Spring
+  module Test
+    class AcceptanceTest < ActiveSupport::TestCase
+      runnables.delete self # prevent Minitest running this class
+
+      DEFAULT_SPEEDUP = 0.8
+
+      def rails_version
+        ENV['RAILS_VERSION'] || '~> 4.2.0'
+      end
+
+      # Extension point for spring-watchers-listen
+      def generator_klass
+        Spring::Test::ApplicationGenerator
+      end
+
+      def generator
+        @@generator ||= generator_klass.new(rails_version)
+      end
+
+      def app
+        @app ||= Spring::Test::Application.new("#{Spring::Test.root}/apps/tmp")
+      end
+
+      def assert_output(artifacts, expected)
+        expected.each do |stream, output|
+          assert artifacts[stream].include?(output),
+                 "expected #{stream} to include '#{output}'.\n\n#{app.debug(artifacts)}"
+        end
+      end
+
+      def assert_success(command, expected_output = nil)
+        artifacts = app.run(*Array(command))
+        assert artifacts[:status].success?, "expected successful exit status\n\n#{app.debug(artifacts)}"
+        assert_output artifacts, expected_output if expected_output
+      end
+
+      def assert_failure(command, expected_output = nil)
+        artifacts = app.run(*Array(command))
+        assert !artifacts[:status].success?, "expected unsuccessful exit status\n\n#{app.debug(artifacts)}"
+        assert_output artifacts, expected_output if expected_output
+      end
+
+      def assert_speedup(ratio = DEFAULT_SPEEDUP)
+        if ENV['CI']
+          yield
+        else
+          app.with_timing do
+            yield
+            assert app.timing_ratio < ratio, "#{app.last_time} was not less than #{ratio} of #{app.first_time}"
+          end
+        end
+      end
+
+      setup do
+        generator.generate_if_missing
+        generator.install_spring
+        generator.copy_to(app.root)
+      end
+
+      teardown do
+        app.stop_spring
+      end
+
+      test "basic" do
+        assert_speedup do
+          2.times { app.run app.spring_test_command }
+        end
+      end
+
+      test "help message when called without arguments" do
+        assert_success "bin/spring", stdout: 'Usage: spring COMMAND [ARGS]'
+      end
+
+      test "test changes are picked up" do
+        assert_speedup do
+          assert_success app.spring_test_command, stdout: "0 failures"
+
+          File.write(app.test, app.test.read.sub("get :index", "raise 'omg'"))
+          assert_failure app.spring_test_command, stdout: "RuntimeError: omg"
+        end
+      end
+
+      test "code changes are picked up" do
+        assert_speedup do
+          assert_success app.spring_test_command, stdout: "0 failures"
+
+          File.write(app.controller, app.controller.read.sub("@posts = Post.all", "raise 'omg'"))
+          assert_failure app.spring_test_command, stdout: "RuntimeError: omg"
+        end
+      end
+
+      test "code changes in pre-referenced app files are picked up" do
+        File.write(app.path("config/initializers/load_posts_controller.rb"), "PostsController\n")
+
+        assert_speedup do
+          assert_success app.spring_test_command, stdout: "0 failures"
+
+          File.write(app.controller, app.controller.read.sub("@posts = Post.all", "raise 'omg'"))
+          assert_failure app.spring_test_command, stdout: "RuntimeError: omg"
+        end
+      end
+
+      test "app gets reloaded when preloaded files change" do
+        assert_success app.spring_test_command
+
+        File.write(app.application_config, app.application_config.read + <<-CODE)
+          class Foo
+            def self.omg
+              raise "omg"
+            end
+          end
+        CODE
+        File.write(app.test, app.test.read.sub("get :index", "Foo.omg"))
+
+        app.await_reload
+        assert_failure app.spring_test_command, stdout: "RuntimeError: omg"
+      end
+
+      test "app gets reloaded even with a ton of boot output" do
+        limit = UNIXSocket.pair.first.getsockopt(:SOCKET, :SNDBUF).int
+
+        assert_success app.spring_test_command
+        File.write(app.path("config/initializers/verbose.rb"), "#{limit}.times { puts 'x' }")
+
+        app.await_reload
+        assert_success app.spring_test_command
+      end
+
+      test "app recovers when a boot-level error is introduced" do
+        config = app.application_config.read
+
+        assert_success app.spring_test_command
+
+        File.write(app.application_config, "#{config}\nomg")
+        app.await_reload
+
+        assert_failure app.spring_test_command
+
+        File.write(app.application_config, config)
+        assert_success app.spring_test_command
+      end
+
+      test "stop command kills server" do
+        app.run app.spring_test_command
+        assert app.spring_env.server_running?, "The server should be running but it isn't"
+
+        assert_success "bin/spring stop"
+        assert !app.spring_env.server_running?, "The server should not be running but it is"
+      end
+
+      test "custom commands" do
+        # Start spring before setting up the command, to test that it gracefully upgrades itself
+        assert_success "bin/rails runner ''"
+
+        File.write(app.spring_config, <<-CODE)
+          class CustomCommand
+            def call
+              puts "omg"
+            end
+
+            def exec_name
+              "rake"
+            end
+          end
+
+          Spring.register_command "custom", CustomCommand.new
+        CODE
+
+        assert_success "bin/spring custom", stdout: "omg"
+
+        assert_success "bin/spring binstub custom"
+        assert_success "bin/custom", stdout: "omg"
+
+        app.env["DISABLE_SPRING"] = "1"
+        assert_success %{bin/custom -e 'puts "foo"'}, stdout: "foo"
+      end
+
+      test "binstub" do
+        assert_success "bin/rails server --help", stdout: "Usage: rails server" # rails command fallback
+
+        assert_success "#{app.spring} binstub rake", stdout: "bin/rake: spring already present"
+
+        assert_success "#{app.spring} binstub --remove rake", stdout: "bin/rake: spring removed"
+        assert !app.path("bin/rake").read.include?(Spring::Client::Binstub::LOADER)
+        assert_success "bin/rake -T", stdout: "rake db:migrate"
+      end
+
+      test "binstub when spring is uninstalled" do
+        app.run! "gem uninstall --ignore-dependencies spring"
+        File.write(app.gemfile, app.gemfile.read.gsub(/gem 'spring.*/, ""))
+        assert_success "bin/rake -T", stdout: "rake db:migrate"
+      end
+
+      test "binstub upgrade" do
+        File.write(app.path("bin/rake"), <<CODE)
+#!/usr/bin/env ruby
+
+if !Process.respond_to?(:fork) || Gem::Specification.find_all_by_name("spring").empty?
+  exec "bundle", "exec", "rake", *ARGV
+else
+  ARGV.unshift "rake"
+  load Gem.bin_path("spring", "spring")
+end
+CODE
+
+        File.write(app.path("bin/rails"), <<CODE)
+#!/usr/bin/env ruby
+
+if !Process.respond_to?(:fork) || Gem::Specification.find_all_by_name("spring").empty?
+  APP_PATH = File.expand_path('../../config/application',  __FILE__)
+  require_relative '../config/boot'
+  require 'rails/commands'
+else
+  ARGV.unshift "rails"
+  load Gem.bin_path("spring", "spring")
+end
+CODE
+
+        assert_success "bin/spring binstub --all", stdout: "upgraded"
+
+        assert_equal app.path("bin/rake").read, <<CODE
+#!/usr/bin/env ruby
+#{Spring::Client::Binstub::LOADER.strip}
+require 'bundler/setup'
+load Gem.bin_path('rake', 'rake')
+CODE
+
+    assert_equal app.path("bin/rails").read, <<CODE
+#!/usr/bin/env ruby
+#{Spring::Client::Binstub::LOADER.strip}
+APP_PATH = File.expand_path('../../config/application',  __FILE__)
+require_relative '../config/boot'
+require 'rails/commands'
+CODE
+      end
+
+      test "after fork callback" do
+        File.write(app.spring_config, "Spring.after_fork { puts '!callback!' }")
+        assert_success "bin/rails runner 'puts 2'", stdout: "!callback!\n2"
+      end
+
+      test "global config file evaluated" do
+        File.write("#{app.user_home}/.spring.rb", "Spring.after_fork { puts '!callback!' }")
+        assert_success "bin/rails runner 'puts 2'", stdout: "!callback!\n2"
+      end
+
+      test "missing config/application.rb" do
+        app.application_config.delete
+        assert_failure "bin/rake -T", stderr: "unable to find your config/application.rb"
+      end
+
+      test "piping" do
+        assert_success "bin/rake -T | grep db", stdout: "rake db:migrate"
+      end
+
+      test "status" do
+        assert_success "bin/spring status", stdout: "Spring is not running"
+        assert_success "bin/rails runner ''"
+        assert_success "bin/spring status", stdout: "Spring is running"
+      end
+
+      test "runner command sets Rails environment from command-line options" do
+        assert_success "bin/rails runner -e test 'puts Rails.env'", stdout: "test"
+        assert_success "bin/rails runner --environment=test 'puts Rails.env'", stdout: "test"
+      end
+
+      test "forcing rails env via environment variable" do
+        app.env['RAILS_ENV'] = 'test'
+        assert_success "bin/rake -p 'Rails.env'", stdout: "test"
+      end
+
+      test "setting env vars with rake" do
+        File.write(app.path("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 "bin/rake RAILS_ENV=test print_rails_env", stdout: "test"
+        assert_success "bin/rake FOO=bar print_env", stdout: "FOO=bar"
+        assert_success "bin/rake", stdout: "test"
+      end
+
+      test "changing the Gemfile works" do
+        assert_success %(bin/rails runner 'require "sqlite3"')
+
+        File.write(app.gemfile, app.gemfile.read.sub(%{gem 'sqlite3'}, %{# gem 'sqlite3'}))
+        app.await_reload
+
+        assert_failure %(bin/rails runner 'require "sqlite3"'), stderr: "sqlite3"
+      end
+
+      test "changing the Gemfile works when spring calls into itself" do
+        File.write(app.path("script.rb"), <<-CODE)
+          gemfile = Rails.root.join("Gemfile")
+          File.write(gemfile, "\#{gemfile.read}gem 'devise'\\n")
+          Bundler.with_clean_env do
+            system(#{app.env.inspect}, "bundle install")
+          end
+          output = `\#{Rails.root.join('bin/rails')} runner 'require "devise"; puts "done";'`
+          exit output == "done\n"
+        CODE
+
+        assert_success [%(bin/rails runner 'load Rails.root.join("script.rb")'), timeout: 60]
+      end
+
+      test "changing the environment between runs" do
+        File.write(app.application_config, "#{app.application_config.read}\nENV['BAR'] = 'bar'")
+
+        app.env["OMG"] = "1"
+        app.env["FOO"] = "1"
+        app.env["RUBYOPT"] = "-rubygems"
+
+        assert_success %(bin/rails runner 'p ENV["OMG"]'), stdout: "1"
+        assert_success %(bin/rails runner 'p ENV["BAR"]'), stdout: "bar"
+        assert_success %(bin/rails runner 'p ENV.key?("BUNDLE_GEMFILE")'), stdout: "true"
+        assert_success %(bin/rails runner 'p ENV["RUBYOPT"]'), stdout: "bundler"
+
+        app.env["OMG"] = "2"
+        app.env.delete "FOO"
+
+        assert_success %(bin/rails runner 'p ENV["OMG"]'), stdout: "2"
+        assert_success %(bin/rails runner 'p ENV.key?("FOO")'), stdout: "false"
+      end
+
+      test "Kernel.raise remains private" do
+        expr = "p Kernel.private_instance_methods.include?(:raise)"
+        assert_success %(bin/rails runner '#{expr}'), stdout: "true"
+      end
+    end
+  end
+end

data/{test/acceptance/helper.rb → lib/spring/test/application.rb}

@@ -2,43 +2,6 @@ require "spring/env"
 
 module Spring
   module Test
-    class RailsVersion
-      attr_reader :version
-
-      def initialize(string)
-        @version = Gem::Version.new(string)
-      end
-
-      def rails_3?
-        version < Gem::Version.new("4.0.0")
-      end
-      alias needs_testunit? rails_3?
-
-      def test_command
-        needs_testunit? ? 'bin/testunit' : 'bin/rake test'
-      end
-
-      def controller_tests_dir
-        rails_3? ? 'functional' : 'controllers'
-      end
-
-      def bundles_spring?
-        version.segments.take(2) == [4, 1] || version > Gem::Version.new("4.1")
-      end
-
-      def major
-        version.segments[0]
-      end
-
-      def minor
-        version.segments[1]
-      end
-
-      def to_s
-        version.to_s
-      end
-    end
-
     class Application
       DEFAULT_TIMEOUT = ENV['CI'] ? 30 : 10
 
@@ -238,7 +201,7 @@ module Spring
 
       def bundle
         run! "(gem list bundler | grep bundler) || gem install bundler", timeout: nil, retry: 2
-        run! "bundle update --retry=2", timeout: nil
+        run! "bundle check || bundle update --retry=2", timeout: nil
       end
 
       private
@@ -250,95 +213,5 @@ module Spring
         false
       end
     end
-
-    class ApplicationGenerator
-      attr_reader :version_constraint, :version, :application
-
-      def initialize(version_constraint)
-        @version_constraint = version_constraint
-        @version            = RailsVersion.new(version_constraint.split(' ').last)
-        @application        = Application.new(root)
-        @bundled            = false
-      end
-
-      def root
-        "#{TEST_ROOT}/apps/rails-#{version.major}-#{version.minor}-spring-#{Spring::VERSION}"
-      end
-
-      def system(command)
-        if ENV["SPRING_DEBUG"]
-          puts "$ #{command}\n"
-        else
-          command = "(#{command}) > /dev/null"
-        end
-
-        Kernel.system(command) or raise "command failed: #{command}"
-        puts if ENV["SPRING_DEBUG"]
-      end
-
-      # Sporadic SSL errors keep causing test failures so there are anti-SSL workarounds here
-      def generate
-        Bundler.with_clean_env do
-          system("gem list rails --installed --version '#{version_constraint}' || " \
-                   "gem install rails --clear-sources --source http://rubygems.org --version '#{version_constraint}'")
-
-          @version = RailsVersion.new(`ruby -e 'puts Gem::Specification.find_by_name("rails", "#{version_constraint}").version'`.chomp)
-
-          skips = %w(--skip-bundle --skip-javascript --skip-sprockets)
-          skips << "--skip-spring" if version.bundles_spring?
-
-          system("rails _#{version}_ new #{application.root} #{skips.join(' ')}")
-          raise "application generation failed" unless application.exists?
-
-          FileUtils.mkdir_p(application.gem_home)
-          FileUtils.mkdir_p(application.user_home)
-          FileUtils.rm_rf(application.path("test/performance"))
-
-          File.write(application.gemfile, "#{application.gemfile.read}gem 'spring', '#{Spring::VERSION}'\n")
-
-          if version.needs_testunit?
-            File.write(application.gemfile, "#{application.gemfile.read}gem 'spring-commands-testunit'\n")
-          end
-
-          File.write(application.gemfile, application.gemfile.read.sub("https://rubygems.org", "http://rubygems.org"))
-
-          if application.path("bin").exist?
-            FileUtils.cp_r(application.path("bin"), application.path("bin_original"))
-          end
-        end
-
-        install_spring
-
-        application.run! "bundle exec rails g scaffold post title:string"
-        application.run! "bundle exec rake db:migrate db:test:clone"
-      end
-
-      def generate_if_missing
-        generate unless application.exists?
-      end
-
-      def install_spring
-        return if @installed
-
-        system("gem build spring.gemspec 2>&1")
-        application.run! "gem install ../../../spring-#{Spring::VERSION}.gem", timeout: nil
-
-        application.bundle
-
-        FileUtils.rm_rf application.path("bin")
-
-        if application.path("bin_original").exist?
-          FileUtils.cp_r application.path("bin_original"), application.path("bin")
-        end
-
-        application.run! "#{application.spring} binstub --all"
-        @installed = true
-      end
-
-      def copy_to(path)
-        system("rm -rf #{path}")
-        system("cp -r #{application.root} #{path}")
-      end
-    end
   end
 end

data/lib/spring/test/application_generator.rb

@@ -0,0 +1,121 @@
+module Spring
+  module Test
+    class ApplicationGenerator
+      attr_reader :version_constraint, :version, :application
+
+      def initialize(version_constraint)
+        @version_constraint = version_constraint
+        @version            = RailsVersion.new(version_constraint.split(' ').last)
+        @application        = Application.new(root)
+        @bundled            = false
+      end
+
+      def test_root
+        Pathname.new Spring::Test.root
+      end
+
+      def root
+        test_root.join("apps/rails-#{version.major}-#{version.minor}-spring-#{Spring::VERSION}")
+      end
+
+      def system(command)
+        if ENV["SPRING_DEBUG"]
+          puts "$ #{command}\n"
+        else
+          command = "(#{command}) > /dev/null"
+        end
+
+        Kernel.system(command) or raise "command failed: #{command}"
+        puts if ENV["SPRING_DEBUG"]
+      end
+
+      def generate
+        Bundler.with_clean_env { generate_files }
+        install_spring
+        generate_scaffold
+      end
+
+      # Sporadic SSL errors keep causing test failures so there are anti-SSL workarounds here
+      def generate_files
+        system("gem list '^rails$' --installed --version '#{version_constraint}' || " \
+                 "gem install rails --clear-sources --source http://rubygems.org --version '#{version_constraint}'")
+
+        @version = RailsVersion.new(`ruby -e 'puts Gem::Specification.find_by_name("rails", "#{version_constraint}").version'`.chomp)
+
+        skips = %w(--skip-bundle --skip-javascript --skip-sprockets)
+        skips << "--skip-spring" if version.bundles_spring?
+
+        system("rails _#{version}_ new #{application.root} #{skips.join(' ')}")
+        raise "application generation failed" unless application.exists?
+
+        FileUtils.mkdir_p(application.gem_home)
+        FileUtils.mkdir_p(application.user_home)
+        FileUtils.rm_rf(application.path("test/performance"))
+
+        File.write(application.gemfile, "#{application.gemfile.read}gem 'spring', '#{Spring::VERSION}'\n")
+
+        if version.needs_testunit?
+          File.write(application.gemfile, "#{application.gemfile.read}gem 'spring-commands-testunit'\n")
+        end
+
+        File.write(application.gemfile, application.gemfile.read.sub("https://rubygems.org", "http://rubygems.org"))
+
+        if application.path("bin").exist?
+          FileUtils.cp_r(application.path("bin"), application.path("bin_original"))
+        end
+      end
+
+      def generate_if_missing
+        generate unless application.exists?
+      end
+
+      def install_spring
+        return if @installed
+
+        build_and_install_gems
+
+        application.bundle
+
+        FileUtils.rm_rf application.path("bin")
+
+        if application.path("bin_original").exist?
+          FileUtils.cp_r application.path("bin_original"), application.path("bin")
+        end
+
+        application.run! "#{application.spring} binstub --all"
+        @installed = true
+      end
+
+      def manually_built_gems
+        %w(spring)
+      end
+
+      def build_and_install_gems
+        manually_built_gems.each do |name|
+          spec = Gem::Specification.find_by_name(name)
+
+          FileUtils.cd(spec.gem_dir) do
+            FileUtils.rm(Dir.glob("#{name}-*.gem"))
+            system("gem build #{name}.gemspec 2>&1")
+          end
+
+          application.run! "gem install #{spec.gem_dir}/#{name}-*.gem", timeout: nil
+        end
+      end
+
+      def copy_to(path)
+        system("rm -rf #{path}")
+        system("cp -r #{application.root} #{path}")
+      end
+
+      def generate_scaffold
+        application.run! "bundle exec rails g scaffold post title:string"
+        application.run! "bundle exec rake db:migrate db:test:clone"
+      end
+
+      def gemspec(name)
+        "#{Gem::Specification.find_by_name(name).gem_dir}/#{name}.gemspec"
+      end
+    end
+  end
+end

data/lib/spring/test/rails_version.rb

@@ -0,0 +1,40 @@
+module Spring
+  module Test
+    class RailsVersion
+      attr_reader :version
+
+      def initialize(string)
+        @version = Gem::Version.new(string)
+      end
+
+      def rails_3?
+        version < Gem::Version.new("4.0.0")
+      end
+      alias needs_testunit? rails_3?
+
+      def test_command
+        needs_testunit? ? 'bin/testunit' : 'bin/rake test'
+      end
+
+      def controller_tests_dir
+        rails_3? ? 'functional' : 'controllers'
+      end
+
+      def bundles_spring?
+        version.segments.take(2) == [4, 1] || version > Gem::Version.new("4.1")
+      end
+
+      def major
+        version.segments[0]
+      end
+
+      def minor
+        version.segments[1]
+      end
+
+      def to_s
+        version.to_s
+      end
+    end
+  end
+end