Roman2K-rails-test-serving 0.1.4 → 0.1.4.1

data/README.mdown

@@ -0,0 +1,79 @@
+# RailsTestServing
+
+Tired of waiting 10 seconds before your tests run? `RailsTestServing` can make them run almost instantly. This library is described more thoroughly in its [introduction  article](http://roman.flucti.com/a-test-server-for-rails-applications).
+
+## Usage
+
+1.  Install the gem:
+
+        gem install Roman2K-rails-test-serving -s http://gems.github.com
+
+2.  Insert the following lines at the very top of `test/test_helper.rb`:
+
+        require 'rubygems'
+        require 'rails_test_serving'
+        RailsTestServing.boot
+
+3.  Append the following line to `~/.bash_profile`:
+
+        export RUBYLIB=".:test:$RUBYLIB"
+
+    If you get loading errors during the next steps:
+    * Move the `RUBYLIB` line from `~/.bash_profile` to `~/.bash_login` instead.
+    * If you are using TextMate, you may try to apply [this (hopefully temporary) fix](http://roman.flucti.com/textmate-fix-for-relative-require-test_helper).
+
+4.  Start the server:
+
+        cd <project-dir>
+        ruby test/test_helper.rb --serve
+
+5.  Run tests as you usually do:
+
+        ruby test/unit/account_test.rb
+        ruby test/unit/account_test.rb -n /balance/
+
+    As a consequence, they work in RubyMate too (⌘R in TextMate).
+
+6.  Have a lot a models and/or mixins? You can reduce reloading time to almost nothing by using `RailsTestServing` in combination with [RailsDevelopmentBoost](https://github.com/Roman2K/rails-dev-boost). Since was originally intended to speed up web-browsing in development mode, be sure to read the note in the `README` for how to enable it in test mode.
+
+**Note:** if the server is not started, tests fall back to running the usual way.
+
+## Options
+
+An option hash can be specified for `RailsTestServing` to use, by defining `$test_server_options` right before `require 'rails_test_serving'`. It must be a hash with symbol keys. Currently available options are:
+
+*   `reload`: An array of regular expressions (or any object responding to `===`) matching the name of the files that should be forced to reload right after the regular constant cleanup. Note that the constants these files have defined are kept around before being re-`require`'d.
+
+Example `test_helper.rb` head:
+
+    require 'rubygems'
+
+    $test_server_options = { :reload => [/blueprint/] }
+    require 'rails_test_serving'
+    RailsTestServing.boot
+
+    # ...remainder here...
+
+When running tests from the command line, you can bypass the server, forcing tests to be run locally, by passing the `--local` flag. For example:
+
+    ruby test/unit/account_test.rb --local
+
+## Caveats
+
+*   Tested working with Rails 2.1.2 up to 2.2.2. Compatibility with versions of Rails out of that range is not guaranteed.
+*   There might exist some quirks: search for "TODO" in the source. I can bear them but contributions are welcome.
+*   Some unit tests are left to be written.
+
+## Credits
+
+Code:
+
+*   [Roman Le Négrate](http://roman.flucti.com), a.k.a. Roman2K ([contact](mailto:roman.lenegrate@gmail.com))
+*   [Jack Chen](http://github.com/chendo), a.k.a. chendo
+
+Feedback:
+
+*   Justin Ko
+*   [Dr Nic Williams](http://drnicwilliams.com)
+
+Released under the MIT license: see the `LICENSE` file.

data/Rakefile

@@ -1,6 +1,6 @@
 require 'echoe'
 
-Echoe.new('rails-test-serving', '0.1.4') do |p|
+Echoe.new('rails-test-serving', '0.1.4.1') do |p|
   p.description     = "Makes unit tests of a Rails application run instantly"
   p.url             = "https://github.com/Roman2K/rails-test-serving"
   p.author          = "Roman Le Négrate"

data/lib/rails_test_serving/bootstrap.rb

@@ -0,0 +1,58 @@
+module RailsTestServing
+  module Bootstrap
+    SOCKET_PATH = ['tmp', 'sockets', 'test_server.sock']
+
+    def boot(argv=ARGV)
+      if argv.delete('--serve')
+        start_server
+      elsif !argv.delete('--local')
+        Client.run_tests
+      end
+    end
+
+    def service_uri
+      @service_uri ||= begin
+        # Determine RAILS_ROOT
+        root, max_depth = Pathname('.'), Pathname.pwd.expand_path.to_s.split(File::SEPARATOR).size
+        until root.join('config', 'boot.rb').file?
+          root = root.parent
+          if root.to_s.split(File::SEPARATOR).size >= max_depth
+            raise "RAILS_ROOT could not be determined"
+          end
+        end
+        root = root.cleanpath
+
+        # Adjust load path
+        $: << root.to_s << root.join('test').to_s
+
+        # Ensure socket directory exists
+        path = root.join(*SOCKET_PATH)
+        path.dirname.mkpath
+
+        # URI
+        "drbunix:#{path}"
+      end
+    end
+
+    def options
+      @options ||= begin
+        options = $test_server_options || {}
+        options[:reload] ||= []
+        options
+      end
+    end
+
+    def active?
+      @active
+    end
+
+  private
+
+    def start_server
+      @active = true
+      Server.start
+    ensure
+      @active = false
+    end
+  end
+end

data/lib/rails_test_serving/cleaner.rb

@@ -0,0 +1,95 @@
+module RailsTestServing
+  class Cleaner
+    include ConstantManagement
+
+    PAUSE = 0.01
+    TESTCASE_CLASS_NAMES =  %w( Test::Unit::TestCase
+                                ActiveSupport::TestCase
+                                ActionView::TestCase
+                                ActionController::TestCase
+                                ActionController::IntegrationTest
+                                ActionMailer::TestCase )
+
+    def initialize
+      start_worker
+    end
+
+    def clean_up_around
+      check_worker_health
+      sleep PAUSE while @working
+      begin
+        reload_app
+        yield
+      ensure
+        @working = true
+        sleep PAUSE until @worker.stop?
+        @worker.wakeup
+      end
+    end
+
+  private
+
+    def start_worker
+      @worker = Thread.new do
+        Thread.abort_on_exception = true
+        loop do
+          Thread.stop
+          begin
+            clean_up_app
+            remove_tests
+          ensure
+            @working = false
+          end
+        end
+      end
+      @working = false
+    end
+
+    def check_worker_health
+      unless @worker.alive?
+        $stderr.puts "cleaning thread died, restarting"
+        start_worker
+      end
+    end
+
+    def clean_up_app
+      ActionController::Dispatcher.new(StringIO.new).cleanup_application
+      if defined?(Fixtures) && Fixtures.respond_to?(:reset_cache)
+        Fixtures.reset_cache
+      end
+
+      # Reload files that match :reload here instead of in reload_app since the
+      # :reload option is intended to target files that don't change between two
+      # consecutive runs (an external library for example). That way, they are
+      # reloaded in the background instead of slowing down the next run.
+      reload_specified_source_files
+    end
+
+    def remove_tests
+      TESTCASE_CLASS_NAMES.each do |name|
+        next unless klass = constantize(name)
+        remove_constants(*subclasses_of(klass).map { |c| c.to_s }.grep(/Test$/) - TESTCASE_CLASS_NAMES)
+      end
+    end
+
+    def reload_app
+      ActionController::Dispatcher.new(StringIO.new).reload_application
+    end
+
+    def reload_specified_source_files
+      to_reload =
+        $".select do |path|
+          RailsTestServing.options[:reload].any? do |matcher|
+            matcher === path
+          end
+        end
+
+      # Force a reload by removing matched files from $"
+      $".replace($" - to_reload)
+
+      to_reload.each do |file|
+        require file
+      end
+    end
+  end
+end

data/lib/rails_test_serving/client.rb

@@ -0,0 +1,53 @@
+module RailsTestServing
+  module Client
+    extend self
+
+    # Setting this variable to true inhibits #run_tests.
+    @@disabled = false
+
+    def disable
+      @@disabled = true
+      yield
+    ensure
+      @@disabled = false
+    end
+
+    def tests_on_exit
+      !Test::Unit.run?
+    end
+
+    def tests_on_exit=(yes)
+      Test::Unit.run = !yes
+    end
+
+    def run_tests
+      return if @@disabled
+      run_tests!
+    end
+
+  private
+
+    def run_tests!
+      handle_process_lifecycle do
+        server = DRbObject.new_with_uri(RailsTestServing.service_uri)
+        begin
+          puts(server.run($0, ARGV))
+        rescue DRb::DRbConnError
+          raise ServerUnavailable
+        end
+      end
+    end
+
+    def handle_process_lifecycle
+      Client.tests_on_exit = false
+      begin
+        yield
+      rescue ServerUnavailable, InvalidArgumentPattern
+        Client.tests_on_exit = true
+      else
+        # TODO exit with a status code reflecting the result of the tests
+        exit 0
+      end
+    end
+  end
+end

data/lib/rails_test_serving/constant_management.rb

@@ -0,0 +1,31 @@
+module RailsTestServing
+  module ConstantManagement
+    extend self
+
+    def legit?(const)
+      !const.to_s.empty? && constantize(const) == const
+    end
+
+    def constantize(name)
+      eval("#{name} if defined? #{name}", TOPLEVEL_BINDING)
+    end
+
+    def constantize!(name)
+      name.to_s.split('::').inject(Object) { |namespace, short| namespace.const_get(short) }
+    end
+
+    # ActiveSupport's Module#remove_class doesn't behave quite the way I would expect it to.
+    def remove_constants(*names)
+      names.map do |name|
+        namespace, short = name.to_s =~ /^(.+)::(.+?)$/ ? [$1, $2] : ['Object', name]
+        constantize!(namespace).module_eval { remove_const(short) if const_defined?(short) }
+      end
+    end
+
+    def subclasses_of(parent, options={})
+      children = []
+      ObjectSpace.each_object(Class) { |klass| children << klass if klass < parent && (!options[:legit] || legit?(klass)) }
+      children
+    end
+  end
+end

data/lib/rails_test_serving/server.rb

@@ -0,0 +1,131 @@
+module RailsTestServing
+  class Server
+    GUARD = Mutex.new
+    PREPARATION_GUARD = Mutex.new
+
+    def self.start
+      server = Server.new
+      DRb.start_service(RailsTestServing.service_uri, server)
+      Thread.new { server.prepare }
+      DRb.thread.join
+    end
+
+    include Utilities
+
+    def run(file, argv)
+      GUARD.synchronize do
+        prepare
+        perform_run(file, argv)
+      end
+    end
+  
+    def prepare
+      PREPARATION_GUARD.synchronize do
+        @prepared ||= begin
+          ENV['RAILS_ENV'] = 'test'
+          log "** Test server starting [##{$$}]..." do
+            enable_dependency_tracking
+            start_cleaner
+            load_framework
+          end
+          install_signal_traps
+          true
+        end
+      end
+    end
+    
+  private
+
+    def enable_dependency_tracking
+      require 'config/boot'
+
+      Rails::Configuration.class_eval do
+        unless method_defined? :cache_classes
+          raise "#{self.class} out of sync with current Rails version"
+        end
+
+        def cache_classes
+          false
+        end
+      end
+    end
+
+    def start_cleaner
+      @cleaner = Cleaner.new
+    end
+
+    def load_framework
+      Client.disable do
+        $: << 'test'
+        require 'test_helper'
+      end
+    end
+
+    def install_signal_traps
+      log " - CTRL+C: Stop the server\n"
+      trap(:INT) do
+        GUARD.synchronize do
+          log "** Stopping the server..." do
+            DRb.thread.raise Interrupt, "stop"
+          end
+        end
+      end
+
+      log " - CTRL+Z: Reset database column information cache\n"
+      trap(:TSTP) do
+        GUARD.synchronize do
+          log "** Resetting database column information cache..." do
+            ActiveRecord::Base.instance_eval { subclasses }.each { |c| c.reset_column_information }
+          end
+        end
+      end
+
+      log " - CTRL+`: Reset lazy-loaded constants\n"
+      trap(:QUIT) do
+        GUARD.synchronize do
+          log "** Resetting lazy-loaded constants..." do
+            (defined?(ActiveSupport::Dependencies) ? ActiveSupport::Dependencies : Dependencies).clear
+          end
+        end
+      end
+    end
+
+    def perform_run(file, argv)
+      sanitize_arguments!(file, argv)
+      log ">> " + [shorten_path(file), *argv].join(' ') do
+        capture_test_result(file, argv)
+      end
+    end
+
+    def sanitize_arguments!(file, argv)
+      if file =~ /^-/
+        # No file was specified for loading, only options. It's the case with
+        # Autotest.
+        raise InvalidArgumentPattern
+      end
+
+      # Filter out the junk that TextMate seems to inject into ARGV when running
+      # focused tests.
+      while a = find_index_by_pattern(argv, /^\[/) and z = find_index_by_pattern(argv[a..-1], /\]$/)
+        argv[a..a+z] = []
+      end
+    end
+
+    def capture_test_result(file, argv)
+      result = []
+      @cleaner.clean_up_around do
+        result << capture_standard_stream('err') do
+          result << capture_standard_stream('out') do
+            result << capture_testrunner_result do
+              fix_objectspace_collector do
+                Client.disable { load(file) }
+                Test::Unit::AutoRunner.run(false, nil, argv)
+              end
+            end
+          end
+        end
+      end
+      result.reverse.join
+    end
+  end
+end

data/lib/rails_test_serving/utilities.rb

@@ -0,0 +1,102 @@
+module RailsTestServing
+  module Utilities
+    def log(message, stream=$stdout)
+      print = lambda do |str|
+        stream.print(str)
+        stream.flush
+      end
+
+      print[message]
+      if block_given?
+        result = nil
+        elapsed = Benchmark.realtime do
+          result = yield
+        end
+        print[" (%d ms)\n" % (elapsed * 1000)]
+        result
+      end
+    end
+
+    def capture_standard_stream(name)
+      eval("old, $std#{name} = $std#{name}, StringIO.new")
+      begin
+        yield
+        return eval("$std#{name}").string
+      ensure
+        eval("$std#{name} = old")
+      end
+    end
+
+    def capture_testrunner_result
+      set_default_testrunner_stream(io = StringIO.new) { yield }
+      io.string
+    end
+
+    # The default output stream of TestRunner is STDOUT which cannot be captured
+    # and, as a consequence, neither can TestRunner output when not instantiated
+    # explicitely. The following method can change the default output stream
+    # argument so that it can be set to a stream that can be captured instead.
+    def set_default_testrunner_stream(io)
+      require 'test/unit/ui/console/testrunner'
+
+      Test::Unit::UI::Console::TestRunner.class_eval do
+        alias_method :old_initialize, :initialize
+        def initialize(suite, output_level, io=Thread.current["test_runner_io"])
+          old_initialize(suite, output_level, io)
+        end
+      end
+      Thread.current["test_runner_io"] = io
+
+      begin
+        return yield
+      ensure
+        Thread.current["test_runner_io"] = nil
+        Test::Unit::UI::Console::TestRunner.class_eval do
+          alias_method :initialize, :old_initialize
+          remove_method :old_initialize
+        end
+      end
+    end
+
+    # The stock ObjectSpace collector collects every single class that inherits
+    # from Test::Unit, including those which have just been unassigned from
+    # their constant and not yet garbage collected. This method fixes that
+    # behaviour by filtering out these soon-to-be-garbage-collected classes.
+    def fix_objectspace_collector
+      require 'test/unit/collector/objectspace'
+
+      Test::Unit::Collector::ObjectSpace.class_eval do
+        alias_method :old_collect, :collect
+        def collect(name)
+          tests = []
+          ConstantManagement.subclasses_of(Test::Unit::TestCase, :legit => true).each { |klass| add_suite(tests, klass.suite) }
+          suite = Test::Unit::TestSuite.new(name)
+          sort(tests).each { |t| suite << t }
+          suite
+        end
+      end
+
+      begin
+        return yield
+      ensure
+        Test::Unit::Collector::ObjectSpace.class_eval do
+          alias_method :collect, :old_collect
+          remove_method :old_collect
+        end
+      end
+    end
+
+    def shorten_path(path)
+      shortenable, base = File.expand_path(path), File.expand_path(Dir.pwd)
+      attempt = shortenable.sub(/^#{Regexp.escape base + File::SEPARATOR}/, '')
+      attempt.length < path.length ? attempt : path
+    end
+
+    def find_index_by_pattern(enumerable, pattern)
+      enumerable.each_with_index do |element, index|
+        return index if pattern === element
+      end
+      nil
+    end
+  end
+end

data/rails-test-serving.gemspec

@@ -2,15 +2,15 @@
 
 Gem::Specification.new do |s|
   s.name = %q{rails-test-serving}
-  s.version = "0.1.4"
+  s.version = "0.1.4.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
   s.authors = ["Roman Le N\303\251grate"]
-  s.date = %q{2009-02-08}
+  s.date = %q{2009-03-12}
   s.description = %q{Makes unit tests of a Rails application run instantly}
   s.email = %q{roman.lenegrate@gmail.com}
-  s.extra_rdoc_files = ["lib/rails_test_serving.rb", "LICENSE", "README.rdoc"]
-  s.files = ["lib/rails_test_serving.rb", "LICENSE", "Rakefile", "README.rdoc", "test/rails_test_serving_test.rb", "Manifest", "rails-test-serving.gemspec", "test/rails_test_serving/bootstrap_test.rb", "test/rails_test_serving/cleaner_test.rb", "test/rails_test_serving/client_test.rb", "test/rails_test_serving/constant_management_test.rb", "test/rails_test_serving/server_test.rb", "test/rails_test_serving/utilities_test.rb", "test/test_helper.rb"]
+  s.extra_rdoc_files = ["lib/rails_test_serving/bootstrap.rb", "lib/rails_test_serving/cleaner.rb", "lib/rails_test_serving/client.rb", "lib/rails_test_serving/constant_management.rb", "lib/rails_test_serving/server.rb", "lib/rails_test_serving/utilities.rb", "lib/rails_test_serving.rb", "LICENSE", "README.mdown"]
+  s.files = ["lib/rails_test_serving/bootstrap.rb", "lib/rails_test_serving/cleaner.rb", "lib/rails_test_serving/client.rb", "lib/rails_test_serving/constant_management.rb", "lib/rails_test_serving/server.rb", "lib/rails_test_serving/utilities.rb", "lib/rails_test_serving.rb", "LICENSE", "Manifest", "Rakefile", "README.mdown", "test/rails_test_serving/bootstrap_test.rb", "test/rails_test_serving/cleaner_test.rb", "test/rails_test_serving/client_test.rb", "test/rails_test_serving/constant_management_test.rb", "test/rails_test_serving/server_test.rb", "test/rails_test_serving/utilities_test.rb", "test/test_helper.rb", "rails-test-serving.gemspec"]
   s.has_rdoc = true
   s.homepage = %q{https://github.com/Roman2K/rails-test-serving}
   s.rdoc_options = ["--main", "README.mdown", "--inline-source", "--line-numbers", "--charset", "UTF-8"]

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: Roman2K-rails-test-serving
 version: !ruby/object:Gem::Version 
-  version: 0.1.4
+  version: 0.1.4.1
 platform: ruby
 authors: 
 - "Roman Le N\xC3\xA9grate"
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-02-08 00:00:00 -08:00
+date: 2009-03-12 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -20,17 +20,27 @@ executables: []
 extensions: []
 
 extra_rdoc_files: 
+- lib/rails_test_serving/bootstrap.rb
+- lib/rails_test_serving/cleaner.rb
+- lib/rails_test_serving/client.rb
+- lib/rails_test_serving/constant_management.rb
+- lib/rails_test_serving/server.rb
+- lib/rails_test_serving/utilities.rb
 - lib/rails_test_serving.rb
 - LICENSE
-- README.rdoc
+- README.mdown
 files: 
+- lib/rails_test_serving/bootstrap.rb
+- lib/rails_test_serving/cleaner.rb
+- lib/rails_test_serving/client.rb
+- lib/rails_test_serving/constant_management.rb
+- lib/rails_test_serving/server.rb
+- lib/rails_test_serving/utilities.rb
 - lib/rails_test_serving.rb
 - LICENSE
-- Rakefile
-- README.rdoc
-- test/rails_test_serving_test.rb
 - Manifest
-- rails-test-serving.gemspec
+- Rakefile
+- README.mdown
 - test/rails_test_serving/bootstrap_test.rb
 - test/rails_test_serving/cleaner_test.rb
 - test/rails_test_serving/client_test.rb
@@ -38,6 +48,7 @@ files:
 - test/rails_test_serving/server_test.rb
 - test/rails_test_serving/utilities_test.rb
 - test/test_helper.rb
+- rails-test-serving.gemspec
 has_rdoc: true
 homepage: https://github.com/Roman2K/rails-test-serving
 post_install_message: