rails-test-serving 0.1.4.2

data/LICENSE

@@ -0,0 +1,7 @@
+Copyright (c) 2008-2009 Roman Le Négrate
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Manifest

@@ -0,0 +1,18 @@
+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

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

@@ -0,0 +1,11 @@
+require 'echoe'
+
+Echoe.new('rails-test-serving', '0.1.4.2') 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"
+  p.email           = "roman.lenegrate@gmail.com"
+  p.ignore_pattern  = "*.gemspec"
+  p.development_dependencies = []
+  p.rdoc_options    = %w(--main README.mdown --inline-source --line-numbers --charset UTF-8)
+end

data/lib/rails_test_serving.rb

@@ -0,0 +1,22 @@
+require 'pathname'
+require 'thread'
+require 'test/unit'
+require 'drb/unix'
+require 'stringio'
+require 'benchmark'
+
+module RailsTestServing
+  class InvalidArgumentPattern < ArgumentError
+  end
+  class ServerUnavailable < StandardError
+  end
+
+  autoload :Bootstrap,  'rails_test_serving/bootstrap'
+  autoload :Server,     'rails_test_serving/server'
+  autoload :Client,     'rails_test_serving/client'
+  autoload :Cleaner,    'rails_test_serving/cleaner'
+  autoload :ConstantManagement, 'rails_test_serving/constant_management'
+  autoload :Utilities,  'rails_test_serving/utilities'
+
+  extend Bootstrap
+end

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,103 @@
+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
+      if ActionController::Dispatcher.respond_to?(:cleanup_application)
+        ActionController::Dispatcher.cleanup_application
+      else
+        ActionController::Dispatcher.new(StringIO.new).cleanup_application
+      end
+      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
+      if ActionController::Dispatcher.respond_to?(:reload_application)
+        ActionController::Dispatcher.reload_application
+      else
+        ActionController::Dispatcher.new(StringIO.new).reload_application
+      end
+    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

@@ -0,0 +1,32 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{rails-test-serving}
+  s.version = "0.1.4.2"
+
+  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-04-20}
+  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/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"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{rails-test-serving}
+  s.rubygems_version = %q{1.3.2}
+  s.summary = %q{Makes unit tests of a Rails application run instantly}
+  s.test_files = ["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"]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

data/test/rails_test_serving/bootstrap_test.rb

@@ -0,0 +1,78 @@
+require 'test_helper'
+
+class RailsTestServing::BootstrapTest < Test::Unit::TestCase
+  def setup
+    @boot = Object.new.extend RailsTestServing::Bootstrap
+  end
+
+  def test_service_uri
+    Pathname.stubs(:pwd).returns(Pathname("/foo/bar"))
+
+    # RAILS_ROOT is the current directory
+    setup_service_uri_test do
+      FileTest.expects(:file?).with("config/boot.rb").returns true
+      FileUtils.expects(:mkpath).with("tmp/sockets")
+      assert_equal "drbunix:tmp/sockets/test_server.sock", @boot.service_uri
+    end
+
+    # RAILS_ROOT is the parent directory
+    setup_service_uri_test do
+      FileTest.stubs(:file?).with("config/boot.rb").returns false
+      FileTest.stubs(:file?).with("../config/boot.rb").returns true
+      FileUtils.expects(:mkpath).with("../tmp/sockets")
+      assert_equal "drbunix:../tmp/sockets/test_server.sock", @boot.service_uri
+    end
+
+    # RAILS_ROOT cannot be determined
+    setup_service_uri_test do
+      FileTest.expects(:file?).with("config/boot.rb").returns false
+      FileTest.expects(:file?).with("../config/boot.rb").returns false
+      FileTest.expects(:file?).with("../../config/boot.rb").returns false
+      FileTest.expects(:file?).with("../../../config/boot.rb").never
+      FileUtils.expects(:mkpath).never
+      assert_raise(RuntimeError) { @boot.service_uri }
+    end
+  end
+
+  def test_boot
+    argv = []
+    RailsTestServing::Client.expects(:run_tests)
+    @boot.boot(argv)
+
+    argv = ['--local']
+    RailsTestServing::Client.expects(:run_tests).never
+    @boot.boot(argv)
+    assert_equal [], argv
+
+    argv = ["--serve"]
+    @boot.expects(:start_server)
+    @boot.boot(argv)
+    assert_equal [], argv
+  end
+
+  def test_options
+    @boot.instance_variable_set("@options", nil)
+    $test_server_options = nil
+    assert_equal({:reload => []}, @boot.options)
+
+    @boot.instance_variable_set("@options", nil)
+    $test_server_options = {:foo => :bar}
+    assert_equal({:foo => :bar, :reload => []}, @boot.options)
+
+    @boot.instance_variable_set("@options", nil)
+    $test_server_options = {:foo => :bar, :reload => [//]}
+    assert_equal({:foo => :bar, :reload => [//]}, @boot.options)
+  end
+
+private
+
+  def setup_service_uri_test
+    old_load_path = $:.dup
+    begin
+      return yield
+    ensure
+      @boot.instance_variable_set("@service_uri", nil)
+      $:.replace(old_load_path)
+    end
+  end
+end

data/test/rails_test_serving/cleaner_test.rb

@@ -0,0 +1,42 @@
+require 'test_helper'
+
+class RailsTestServing::CleanerTest < Test::Unit::TestCase
+  include RailsTestServing
+
+# private
+
+  def test_reload_specified_source_files
+    Cleaner.any_instance.stubs(:start_worker)
+
+    # Empty :reload option
+    preserve_features do
+      $".replace ["foo.rb"]
+      RailsTestServing.stubs(:options).returns({:reload => []})
+
+      Cleaner.any_instance.expects(:require).never
+      Cleaner.new.instance_eval { reload_specified_source_files }
+      assert_equal ["foo.rb"], $"
+    end
+
+    # :reload option contains regular expressions
+    preserve_features do
+      $".replace ["foo.rb", "bar.rb"]
+      RailsTestServing.stubs(:options).returns({:reload => [/foo/]})
+
+      Cleaner.any_instance.expects(:require).with("foo.rb").once
+      Cleaner.new.instance_eval { reload_specified_source_files }
+      assert_equal ["bar.rb"], $"
+    end
+  end
+
+private
+
+  def preserve_features
+    old = $".dup
+    begin
+      return yield
+    ensure
+      $".replace(old)
+    end
+  end
+end

data/test/rails_test_serving/client_test.rb

@@ -0,0 +1,17 @@
+require 'test_helper'
+
+class RailsTestServing::ClientTest < Test::Unit::TestCase
+  def setup
+    @client = Object.new.extend RailsTestServing::Client
+  end
+
+  def test_run_tests
+    @client.expects(:run_tests!)
+    @client.run_tests
+
+    @client.disable do
+      @client.expects(:run_tests!).never
+      @client.run_tests
+    end
+  end
+end

data/test/rails_test_serving/constant_management_test.rb

@@ -0,0 +1,57 @@
+require 'test_helper'
+
+class RailsTestServing::ConstantManagementTest < Test::Unit::TestCase
+  include RailsTestServing::ConstantManagement
+  NS = self
+
+  Foo = :foo
+  NamedFoo = Module.new
+  Namespace = Module.new
+
+  class A; end
+  class B < A; end
+  class C < B; end
+
+  def test_legit
+    assert legit?(NamedFoo)
+
+    assert !legit?("Inexistent")
+
+    fake = stub(:to_s => NamedFoo.to_s)
+    assert_equal NamedFoo.to_s, "#{fake}"   # sanity check
+    assert !legit?(fake)
+  end
+
+  def test_constantize
+    assert_equal :foo, constantize("#{NS}::Foo")
+    assert_equal nil,  constantize("#{NS}::Bar")
+  end
+
+  def test_constantize!
+    assert_equal :foo, constantize!("#{NS}::Foo")
+    assert_raise(NameError) { constantize!("#{NS}::Bar") }
+  end
+
+  def test_remove_constants
+    mod_A = Module.new
+    Namespace.const_set(:A, mod_A)
+    assert eval("defined? #{NS}::Namespace::A")  # sanity check
+
+    removed = remove_constants("#{NS}::Namespace::A")
+    assert_equal [mod_A], removed
+    assert !eval("defined? #{NS}::Namespace::A")
+
+    removed = remove_constants("#{NS}::Namespace::A")
+    assert_equal [nil], removed
+  end
+
+  def test_subclasses_of
+    assert_equal [B, C],  subclasses_of(A).sort_by { |c| c.name }
+    assert_equal [C],     subclasses_of(B)
+    assert_equal [],      subclasses_of(C)
+
+    self.stubs(:legit?).with(B).returns true
+    self.stubs(:legit?).with(C).returns false
+    assert_equal [B], subclasses_of(A, :legit => true)
+  end
+end

data/test/rails_test_serving/server_test.rb

@@ -0,0 +1,75 @@
+require 'test_helper'
+
+class RailsTestServing::ServerTest < Test::Unit::TestCase
+
+# private
+
+  def test_perform_run
+    server = stub_server
+    file, argv = "test.rb", ["-n", "/pat/"]
+
+    server.stubs(:sanitize_arguments!)
+    server.stubs(:log).with(">> test.rb -n /pat/").yields.returns("result").once
+    server.stubs(:capture_test_result).with(file, argv)
+
+    result = server.instance_eval { perform_run(file, argv) }
+    assert_equal "result", result
+  end
+
+  def test_sanitize_arguments
+    server = stub_server
+    sanitize = lambda { |*args| server.instance_eval { sanitize_arguments! *args } }
+
+    # valid
+    file, argv = "test.rb", ["--name=test_create"]
+    sanitize.call file, argv
+
+    assert_equal "test.rb", file
+    assert_equal ["--name=test_create"], argv
+
+    # TextMate junk
+    junk = ["[test_create,", "nil,", "nil]"]
+
+    # a)  at the beginning
+    file, argv = "test.rb", junk + ["foo"]
+    sanitize.call file, argv
+
+    assert_equal "test.rb", file
+    assert_equal ["foo"], argv
+
+    # b)  in between normal arguments
+    file, argv = "test.rb", ["foo"] + junk + ["bar"]
+    sanitize.call file, argv
+
+    assert_equal "test.rb", file
+    assert_equal ["foo", "bar"], argv
+
+    # invalid arguments
+    assert_raise RailsTestServing::InvalidArgumentPattern do
+      sanitize.call "-e", ["code"]
+    end
+  end
+
+  def test_capture_test_result
+    server = stub_server
+    cleaner = server.instance_variable_set("@cleaner", stub)
+
+    cleaner.stubs(:clean_up_around).yields
+    server.stubs(:capture_standard_stream).with('err').yields.returns "stderr"
+    server.stubs(:capture_standard_stream).with('out').yields.returns "stdout"
+    server.stubs(:capture_testrunner_result).yields.returns "result"
+    server.stubs(:fix_objectspace_collector).yields
+
+    server.stubs(:load).with("file")
+    Test::Unit::AutoRunner.expects(:run).with(false, nil, "argv")
+
+    result = server.instance_eval { capture_test_result("file", "argv") }
+    assert_equal "stderrstdoutresult", result
+  end
+
+private
+
+  def stub_server
+    RailsTestServing::Server.new
+  end
+end

data/test/rails_test_serving/utilities_test.rb

@@ -0,0 +1,50 @@
+require 'test_helper'
+
+class RailsTestServing::UtilitiesTest < Test::Unit::TestCase
+  def setup
+    @utils = Object.new.extend RailsTestServing::Utilities
+  end
+
+  def test_log
+    # Blockless form
+    stream = StringIO.new
+    result = @utils.instance_eval { log("message", stream) }
+    assert_equal "message", stream.string
+    assert_equal nil, result
+
+    # Block form
+    stream = StringIO.new
+    Benchmark.stubs(:realtime).yields.returns 1
+    yielded = []
+    result = @utils.instance_eval { log("message", stream) { yielded << true; "result" } }
+    assert_equal "message (1000 ms)\n", stream.string
+    assert_equal [true], yielded
+    assert_equal "result", result
+  end
+
+  def test_capture_standard_stream
+    assert_equal STDOUT, $stdout  # sanity check
+
+    captured = @utils.instance_eval { capture_standard_stream('out') { print "test" } }
+
+    assert_equal "test", captured
+    assert_equal STDOUT, $stdout
+  end
+
+  def test_capture_testrunner_result
+    captured = @utils.instance_eval do
+      capture_testrunner_result { Thread.current["test_runner_io"].print "test" }
+    end
+    assert_equal "test", captured
+  end
+
+  def test_shorten_path
+    Dir.stubs(:pwd).returns '/base'
+
+    assert_equal 'test.rb', @utils.shorten_path('test.rb')
+    assert_equal 'test.rb', @utils.shorten_path('/base/test.rb')
+    assert_equal 'test.rb', @utils.shorten_path('/base/./test.rb')
+    assert_equal '/other-base/test.rb', @utils.shorten_path('/other-base/test.rb')
+    assert_equal '/other-base/test.rb', @utils.shorten_path('/other-base/././test.rb')
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,8 @@
+require 'rubygems'
+
+require 'test/unit'
+require 'mocha'
+Mocha::Configuration.prevent :stubbing_non_existent_method
+Mocha::Configuration.warn_when :stubbing_method_unnecessarily
+
+require 'rails_test_serving'

metadata

@@ -0,0 +1,92 @@
+--- !ruby/object:Gem::Specification 
+name: rails-test-serving
+version: !ruby/object:Gem::Version 
+  version: 0.1.4.2
+platform: ruby
+authors: 
+- "Roman Le N\xC3\xA9grate"
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-04-20 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: Makes unit tests of a Rails application run instantly
+email: roman.lenegrate@gmail.com
+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.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
+- 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
+has_rdoc: true
+homepage: https://github.com/Roman2K/rails-test-serving
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.mdown
+- --inline-source
+- --line-numbers
+- --charset
+- UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "1.2"
+  version: 
+requirements: []
+
+rubyforge_project: rails-test-serving
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Makes unit tests of a Rails application run instantly
+test_files: 
+- 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